1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lightsail
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/lightsail/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	"math"
20	"strings"
21)
22
23type awsAwsjson11_deserializeOpAllocateStaticIp struct {
24}
25
26func (*awsAwsjson11_deserializeOpAllocateStaticIp) ID() string {
27	return "OperationDeserializer"
28}
29
30func (m *awsAwsjson11_deserializeOpAllocateStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32) {
33	out, metadata, err = next.HandleDeserialize(ctx, in)
34	if err != nil {
35		return out, metadata, err
36	}
37
38	response, ok := out.RawResponse.(*smithyhttp.Response)
39	if !ok {
40		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
41	}
42
43	if response.StatusCode < 200 || response.StatusCode >= 300 {
44		return out, metadata, awsAwsjson11_deserializeOpErrorAllocateStaticIp(response, &metadata)
45	}
46	output := &AllocateStaticIpOutput{}
47	out.Result = output
48
49	var buff [1024]byte
50	ringBuffer := smithyio.NewRingBuffer(buff[:])
51
52	body := io.TeeReader(response.Body, ringBuffer)
53	decoder := json.NewDecoder(body)
54	decoder.UseNumber()
55	var shape interface{}
56	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
57		var snapshot bytes.Buffer
58		io.Copy(&snapshot, ringBuffer)
59		err = &smithy.DeserializationError{
60			Err:      fmt.Errorf("failed to decode response body, %w", err),
61			Snapshot: snapshot.Bytes(),
62		}
63		return out, metadata, err
64	}
65
66	err = awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(&output, shape)
67	if err != nil {
68		var snapshot bytes.Buffer
69		io.Copy(&snapshot, ringBuffer)
70		err = &smithy.DeserializationError{
71			Err:      fmt.Errorf("failed to decode response body, %w", err),
72			Snapshot: snapshot.Bytes(),
73		}
74		return out, metadata, err
75	}
76
77	return out, metadata, err
78}
79
80func awsAwsjson11_deserializeOpErrorAllocateStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
81	var errorBuffer bytes.Buffer
82	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
83		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
84	}
85	errorBody := bytes.NewReader(errorBuffer.Bytes())
86
87	errorCode := "UnknownError"
88	errorMessage := errorCode
89
90	code := response.Header.Get("X-Amzn-ErrorType")
91	if len(code) != 0 {
92		errorCode = restjson.SanitizeErrorCode(code)
93	}
94
95	var buff [1024]byte
96	ringBuffer := smithyio.NewRingBuffer(buff[:])
97
98	body := io.TeeReader(errorBody, ringBuffer)
99	decoder := json.NewDecoder(body)
100	decoder.UseNumber()
101	code, message, err := restjson.GetErrorInfo(decoder)
102	if err != nil {
103		var snapshot bytes.Buffer
104		io.Copy(&snapshot, ringBuffer)
105		err = &smithy.DeserializationError{
106			Err:      fmt.Errorf("failed to decode response body, %w", err),
107			Snapshot: snapshot.Bytes(),
108		}
109		return err
110	}
111
112	errorBody.Seek(0, io.SeekStart)
113	if len(code) != 0 {
114		errorCode = restjson.SanitizeErrorCode(code)
115	}
116	if len(message) != 0 {
117		errorMessage = message
118	}
119
120	switch {
121	case strings.EqualFold("AccessDeniedException", errorCode):
122		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
123
124	case strings.EqualFold("AccountSetupInProgressException", errorCode):
125		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
126
127	case strings.EqualFold("InvalidInputException", errorCode):
128		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
129
130	case strings.EqualFold("NotFoundException", errorCode):
131		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
132
133	case strings.EqualFold("OperationFailureException", errorCode):
134		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
135
136	case strings.EqualFold("ServiceException", errorCode):
137		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
138
139	case strings.EqualFold("UnauthenticatedException", errorCode):
140		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
141
142	default:
143		genericError := &smithy.GenericAPIError{
144			Code:    errorCode,
145			Message: errorMessage,
146		}
147		return genericError
148
149	}
150}
151
152type awsAwsjson11_deserializeOpAttachCertificateToDistribution struct {
153}
154
155func (*awsAwsjson11_deserializeOpAttachCertificateToDistribution) ID() string {
156	return "OperationDeserializer"
157}
158
159func (m *awsAwsjson11_deserializeOpAttachCertificateToDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
160	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
161) {
162	out, metadata, err = next.HandleDeserialize(ctx, in)
163	if err != nil {
164		return out, metadata, err
165	}
166
167	response, ok := out.RawResponse.(*smithyhttp.Response)
168	if !ok {
169		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
170	}
171
172	if response.StatusCode < 200 || response.StatusCode >= 300 {
173		return out, metadata, awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response, &metadata)
174	}
175	output := &AttachCertificateToDistributionOutput{}
176	out.Result = output
177
178	var buff [1024]byte
179	ringBuffer := smithyio.NewRingBuffer(buff[:])
180
181	body := io.TeeReader(response.Body, ringBuffer)
182	decoder := json.NewDecoder(body)
183	decoder.UseNumber()
184	var shape interface{}
185	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
186		var snapshot bytes.Buffer
187		io.Copy(&snapshot, ringBuffer)
188		err = &smithy.DeserializationError{
189			Err:      fmt.Errorf("failed to decode response body, %w", err),
190			Snapshot: snapshot.Bytes(),
191		}
192		return out, metadata, err
193	}
194
195	err = awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(&output, shape)
196	if err != nil {
197		var snapshot bytes.Buffer
198		io.Copy(&snapshot, ringBuffer)
199		err = &smithy.DeserializationError{
200			Err:      fmt.Errorf("failed to decode response body, %w", err),
201			Snapshot: snapshot.Bytes(),
202		}
203		return out, metadata, err
204	}
205
206	return out, metadata, err
207}
208
209func awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
210	var errorBuffer bytes.Buffer
211	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
212		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
213	}
214	errorBody := bytes.NewReader(errorBuffer.Bytes())
215
216	errorCode := "UnknownError"
217	errorMessage := errorCode
218
219	code := response.Header.Get("X-Amzn-ErrorType")
220	if len(code) != 0 {
221		errorCode = restjson.SanitizeErrorCode(code)
222	}
223
224	var buff [1024]byte
225	ringBuffer := smithyio.NewRingBuffer(buff[:])
226
227	body := io.TeeReader(errorBody, ringBuffer)
228	decoder := json.NewDecoder(body)
229	decoder.UseNumber()
230	code, message, err := restjson.GetErrorInfo(decoder)
231	if err != nil {
232		var snapshot bytes.Buffer
233		io.Copy(&snapshot, ringBuffer)
234		err = &smithy.DeserializationError{
235			Err:      fmt.Errorf("failed to decode response body, %w", err),
236			Snapshot: snapshot.Bytes(),
237		}
238		return err
239	}
240
241	errorBody.Seek(0, io.SeekStart)
242	if len(code) != 0 {
243		errorCode = restjson.SanitizeErrorCode(code)
244	}
245	if len(message) != 0 {
246		errorMessage = message
247	}
248
249	switch {
250	case strings.EqualFold("AccessDeniedException", errorCode):
251		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
252
253	case strings.EqualFold("InvalidInputException", errorCode):
254		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
255
256	case strings.EqualFold("NotFoundException", errorCode):
257		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
258
259	case strings.EqualFold("OperationFailureException", errorCode):
260		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
261
262	case strings.EqualFold("ServiceException", errorCode):
263		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
264
265	case strings.EqualFold("UnauthenticatedException", errorCode):
266		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
267
268	default:
269		genericError := &smithy.GenericAPIError{
270			Code:    errorCode,
271			Message: errorMessage,
272		}
273		return genericError
274
275	}
276}
277
278type awsAwsjson11_deserializeOpAttachDisk struct {
279}
280
281func (*awsAwsjson11_deserializeOpAttachDisk) ID() string {
282	return "OperationDeserializer"
283}
284
285func (m *awsAwsjson11_deserializeOpAttachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
286	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
287) {
288	out, metadata, err = next.HandleDeserialize(ctx, in)
289	if err != nil {
290		return out, metadata, err
291	}
292
293	response, ok := out.RawResponse.(*smithyhttp.Response)
294	if !ok {
295		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
296	}
297
298	if response.StatusCode < 200 || response.StatusCode >= 300 {
299		return out, metadata, awsAwsjson11_deserializeOpErrorAttachDisk(response, &metadata)
300	}
301	output := &AttachDiskOutput{}
302	out.Result = output
303
304	var buff [1024]byte
305	ringBuffer := smithyio.NewRingBuffer(buff[:])
306
307	body := io.TeeReader(response.Body, ringBuffer)
308	decoder := json.NewDecoder(body)
309	decoder.UseNumber()
310	var shape interface{}
311	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
312		var snapshot bytes.Buffer
313		io.Copy(&snapshot, ringBuffer)
314		err = &smithy.DeserializationError{
315			Err:      fmt.Errorf("failed to decode response body, %w", err),
316			Snapshot: snapshot.Bytes(),
317		}
318		return out, metadata, err
319	}
320
321	err = awsAwsjson11_deserializeOpDocumentAttachDiskOutput(&output, shape)
322	if err != nil {
323		var snapshot bytes.Buffer
324		io.Copy(&snapshot, ringBuffer)
325		err = &smithy.DeserializationError{
326			Err:      fmt.Errorf("failed to decode response body, %w", err),
327			Snapshot: snapshot.Bytes(),
328		}
329		return out, metadata, err
330	}
331
332	return out, metadata, err
333}
334
335func awsAwsjson11_deserializeOpErrorAttachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
336	var errorBuffer bytes.Buffer
337	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
338		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
339	}
340	errorBody := bytes.NewReader(errorBuffer.Bytes())
341
342	errorCode := "UnknownError"
343	errorMessage := errorCode
344
345	code := response.Header.Get("X-Amzn-ErrorType")
346	if len(code) != 0 {
347		errorCode = restjson.SanitizeErrorCode(code)
348	}
349
350	var buff [1024]byte
351	ringBuffer := smithyio.NewRingBuffer(buff[:])
352
353	body := io.TeeReader(errorBody, ringBuffer)
354	decoder := json.NewDecoder(body)
355	decoder.UseNumber()
356	code, message, err := restjson.GetErrorInfo(decoder)
357	if err != nil {
358		var snapshot bytes.Buffer
359		io.Copy(&snapshot, ringBuffer)
360		err = &smithy.DeserializationError{
361			Err:      fmt.Errorf("failed to decode response body, %w", err),
362			Snapshot: snapshot.Bytes(),
363		}
364		return err
365	}
366
367	errorBody.Seek(0, io.SeekStart)
368	if len(code) != 0 {
369		errorCode = restjson.SanitizeErrorCode(code)
370	}
371	if len(message) != 0 {
372		errorMessage = message
373	}
374
375	switch {
376	case strings.EqualFold("AccessDeniedException", errorCode):
377		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
378
379	case strings.EqualFold("AccountSetupInProgressException", errorCode):
380		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
381
382	case strings.EqualFold("InvalidInputException", errorCode):
383		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
384
385	case strings.EqualFold("NotFoundException", errorCode):
386		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
387
388	case strings.EqualFold("OperationFailureException", errorCode):
389		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
390
391	case strings.EqualFold("ServiceException", errorCode):
392		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
393
394	case strings.EqualFold("UnauthenticatedException", errorCode):
395		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
396
397	default:
398		genericError := &smithy.GenericAPIError{
399			Code:    errorCode,
400			Message: errorMessage,
401		}
402		return genericError
403
404	}
405}
406
407type awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer struct {
408}
409
410func (*awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) ID() string {
411	return "OperationDeserializer"
412}
413
414func (m *awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
415	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
416) {
417	out, metadata, err = next.HandleDeserialize(ctx, in)
418	if err != nil {
419		return out, metadata, err
420	}
421
422	response, ok := out.RawResponse.(*smithyhttp.Response)
423	if !ok {
424		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
425	}
426
427	if response.StatusCode < 200 || response.StatusCode >= 300 {
428		return out, metadata, awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response, &metadata)
429	}
430	output := &AttachInstancesToLoadBalancerOutput{}
431	out.Result = output
432
433	var buff [1024]byte
434	ringBuffer := smithyio.NewRingBuffer(buff[:])
435
436	body := io.TeeReader(response.Body, ringBuffer)
437	decoder := json.NewDecoder(body)
438	decoder.UseNumber()
439	var shape interface{}
440	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
441		var snapshot bytes.Buffer
442		io.Copy(&snapshot, ringBuffer)
443		err = &smithy.DeserializationError{
444			Err:      fmt.Errorf("failed to decode response body, %w", err),
445			Snapshot: snapshot.Bytes(),
446		}
447		return out, metadata, err
448	}
449
450	err = awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(&output, shape)
451	if err != nil {
452		var snapshot bytes.Buffer
453		io.Copy(&snapshot, ringBuffer)
454		err = &smithy.DeserializationError{
455			Err:      fmt.Errorf("failed to decode response body, %w", err),
456			Snapshot: snapshot.Bytes(),
457		}
458		return out, metadata, err
459	}
460
461	return out, metadata, err
462}
463
464func awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
465	var errorBuffer bytes.Buffer
466	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
467		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
468	}
469	errorBody := bytes.NewReader(errorBuffer.Bytes())
470
471	errorCode := "UnknownError"
472	errorMessage := errorCode
473
474	code := response.Header.Get("X-Amzn-ErrorType")
475	if len(code) != 0 {
476		errorCode = restjson.SanitizeErrorCode(code)
477	}
478
479	var buff [1024]byte
480	ringBuffer := smithyio.NewRingBuffer(buff[:])
481
482	body := io.TeeReader(errorBody, ringBuffer)
483	decoder := json.NewDecoder(body)
484	decoder.UseNumber()
485	code, message, err := restjson.GetErrorInfo(decoder)
486	if err != nil {
487		var snapshot bytes.Buffer
488		io.Copy(&snapshot, ringBuffer)
489		err = &smithy.DeserializationError{
490			Err:      fmt.Errorf("failed to decode response body, %w", err),
491			Snapshot: snapshot.Bytes(),
492		}
493		return err
494	}
495
496	errorBody.Seek(0, io.SeekStart)
497	if len(code) != 0 {
498		errorCode = restjson.SanitizeErrorCode(code)
499	}
500	if len(message) != 0 {
501		errorMessage = message
502	}
503
504	switch {
505	case strings.EqualFold("AccessDeniedException", errorCode):
506		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
507
508	case strings.EqualFold("AccountSetupInProgressException", errorCode):
509		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
510
511	case strings.EqualFold("InvalidInputException", errorCode):
512		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
513
514	case strings.EqualFold("NotFoundException", errorCode):
515		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
516
517	case strings.EqualFold("OperationFailureException", errorCode):
518		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
519
520	case strings.EqualFold("ServiceException", errorCode):
521		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
522
523	case strings.EqualFold("UnauthenticatedException", errorCode):
524		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
525
526	default:
527		genericError := &smithy.GenericAPIError{
528			Code:    errorCode,
529			Message: errorMessage,
530		}
531		return genericError
532
533	}
534}
535
536type awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate struct {
537}
538
539func (*awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) ID() string {
540	return "OperationDeserializer"
541}
542
543func (m *awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
544	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
545) {
546	out, metadata, err = next.HandleDeserialize(ctx, in)
547	if err != nil {
548		return out, metadata, err
549	}
550
551	response, ok := out.RawResponse.(*smithyhttp.Response)
552	if !ok {
553		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
554	}
555
556	if response.StatusCode < 200 || response.StatusCode >= 300 {
557		return out, metadata, awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response, &metadata)
558	}
559	output := &AttachLoadBalancerTlsCertificateOutput{}
560	out.Result = output
561
562	var buff [1024]byte
563	ringBuffer := smithyio.NewRingBuffer(buff[:])
564
565	body := io.TeeReader(response.Body, ringBuffer)
566	decoder := json.NewDecoder(body)
567	decoder.UseNumber()
568	var shape interface{}
569	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
570		var snapshot bytes.Buffer
571		io.Copy(&snapshot, ringBuffer)
572		err = &smithy.DeserializationError{
573			Err:      fmt.Errorf("failed to decode response body, %w", err),
574			Snapshot: snapshot.Bytes(),
575		}
576		return out, metadata, err
577	}
578
579	err = awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(&output, shape)
580	if err != nil {
581		var snapshot bytes.Buffer
582		io.Copy(&snapshot, ringBuffer)
583		err = &smithy.DeserializationError{
584			Err:      fmt.Errorf("failed to decode response body, %w", err),
585			Snapshot: snapshot.Bytes(),
586		}
587		return out, metadata, err
588	}
589
590	return out, metadata, err
591}
592
593func awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
594	var errorBuffer bytes.Buffer
595	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
596		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
597	}
598	errorBody := bytes.NewReader(errorBuffer.Bytes())
599
600	errorCode := "UnknownError"
601	errorMessage := errorCode
602
603	code := response.Header.Get("X-Amzn-ErrorType")
604	if len(code) != 0 {
605		errorCode = restjson.SanitizeErrorCode(code)
606	}
607
608	var buff [1024]byte
609	ringBuffer := smithyio.NewRingBuffer(buff[:])
610
611	body := io.TeeReader(errorBody, ringBuffer)
612	decoder := json.NewDecoder(body)
613	decoder.UseNumber()
614	code, message, err := restjson.GetErrorInfo(decoder)
615	if err != nil {
616		var snapshot bytes.Buffer
617		io.Copy(&snapshot, ringBuffer)
618		err = &smithy.DeserializationError{
619			Err:      fmt.Errorf("failed to decode response body, %w", err),
620			Snapshot: snapshot.Bytes(),
621		}
622		return err
623	}
624
625	errorBody.Seek(0, io.SeekStart)
626	if len(code) != 0 {
627		errorCode = restjson.SanitizeErrorCode(code)
628	}
629	if len(message) != 0 {
630		errorMessage = message
631	}
632
633	switch {
634	case strings.EqualFold("AccessDeniedException", errorCode):
635		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
636
637	case strings.EqualFold("AccountSetupInProgressException", errorCode):
638		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
639
640	case strings.EqualFold("InvalidInputException", errorCode):
641		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
642
643	case strings.EqualFold("NotFoundException", errorCode):
644		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
645
646	case strings.EqualFold("OperationFailureException", errorCode):
647		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
648
649	case strings.EqualFold("ServiceException", errorCode):
650		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
651
652	case strings.EqualFold("UnauthenticatedException", errorCode):
653		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
654
655	default:
656		genericError := &smithy.GenericAPIError{
657			Code:    errorCode,
658			Message: errorMessage,
659		}
660		return genericError
661
662	}
663}
664
665type awsAwsjson11_deserializeOpAttachStaticIp struct {
666}
667
668func (*awsAwsjson11_deserializeOpAttachStaticIp) ID() string {
669	return "OperationDeserializer"
670}
671
672func (m *awsAwsjson11_deserializeOpAttachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
673	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
674) {
675	out, metadata, err = next.HandleDeserialize(ctx, in)
676	if err != nil {
677		return out, metadata, err
678	}
679
680	response, ok := out.RawResponse.(*smithyhttp.Response)
681	if !ok {
682		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
683	}
684
685	if response.StatusCode < 200 || response.StatusCode >= 300 {
686		return out, metadata, awsAwsjson11_deserializeOpErrorAttachStaticIp(response, &metadata)
687	}
688	output := &AttachStaticIpOutput{}
689	out.Result = output
690
691	var buff [1024]byte
692	ringBuffer := smithyio.NewRingBuffer(buff[:])
693
694	body := io.TeeReader(response.Body, ringBuffer)
695	decoder := json.NewDecoder(body)
696	decoder.UseNumber()
697	var shape interface{}
698	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
699		var snapshot bytes.Buffer
700		io.Copy(&snapshot, ringBuffer)
701		err = &smithy.DeserializationError{
702			Err:      fmt.Errorf("failed to decode response body, %w", err),
703			Snapshot: snapshot.Bytes(),
704		}
705		return out, metadata, err
706	}
707
708	err = awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(&output, shape)
709	if err != nil {
710		var snapshot bytes.Buffer
711		io.Copy(&snapshot, ringBuffer)
712		err = &smithy.DeserializationError{
713			Err:      fmt.Errorf("failed to decode response body, %w", err),
714			Snapshot: snapshot.Bytes(),
715		}
716		return out, metadata, err
717	}
718
719	return out, metadata, err
720}
721
722func awsAwsjson11_deserializeOpErrorAttachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
723	var errorBuffer bytes.Buffer
724	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
725		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
726	}
727	errorBody := bytes.NewReader(errorBuffer.Bytes())
728
729	errorCode := "UnknownError"
730	errorMessage := errorCode
731
732	code := response.Header.Get("X-Amzn-ErrorType")
733	if len(code) != 0 {
734		errorCode = restjson.SanitizeErrorCode(code)
735	}
736
737	var buff [1024]byte
738	ringBuffer := smithyio.NewRingBuffer(buff[:])
739
740	body := io.TeeReader(errorBody, ringBuffer)
741	decoder := json.NewDecoder(body)
742	decoder.UseNumber()
743	code, message, err := restjson.GetErrorInfo(decoder)
744	if err != nil {
745		var snapshot bytes.Buffer
746		io.Copy(&snapshot, ringBuffer)
747		err = &smithy.DeserializationError{
748			Err:      fmt.Errorf("failed to decode response body, %w", err),
749			Snapshot: snapshot.Bytes(),
750		}
751		return err
752	}
753
754	errorBody.Seek(0, io.SeekStart)
755	if len(code) != 0 {
756		errorCode = restjson.SanitizeErrorCode(code)
757	}
758	if len(message) != 0 {
759		errorMessage = message
760	}
761
762	switch {
763	case strings.EqualFold("AccessDeniedException", errorCode):
764		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
765
766	case strings.EqualFold("AccountSetupInProgressException", errorCode):
767		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
768
769	case strings.EqualFold("InvalidInputException", errorCode):
770		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
771
772	case strings.EqualFold("NotFoundException", errorCode):
773		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
774
775	case strings.EqualFold("OperationFailureException", errorCode):
776		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
777
778	case strings.EqualFold("ServiceException", errorCode):
779		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
780
781	case strings.EqualFold("UnauthenticatedException", errorCode):
782		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
783
784	default:
785		genericError := &smithy.GenericAPIError{
786			Code:    errorCode,
787			Message: errorMessage,
788		}
789		return genericError
790
791	}
792}
793
794type awsAwsjson11_deserializeOpCloseInstancePublicPorts struct {
795}
796
797func (*awsAwsjson11_deserializeOpCloseInstancePublicPorts) ID() string {
798	return "OperationDeserializer"
799}
800
801func (m *awsAwsjson11_deserializeOpCloseInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
802	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
803) {
804	out, metadata, err = next.HandleDeserialize(ctx, in)
805	if err != nil {
806		return out, metadata, err
807	}
808
809	response, ok := out.RawResponse.(*smithyhttp.Response)
810	if !ok {
811		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
812	}
813
814	if response.StatusCode < 200 || response.StatusCode >= 300 {
815		return out, metadata, awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response, &metadata)
816	}
817	output := &CloseInstancePublicPortsOutput{}
818	out.Result = output
819
820	var buff [1024]byte
821	ringBuffer := smithyio.NewRingBuffer(buff[:])
822
823	body := io.TeeReader(response.Body, ringBuffer)
824	decoder := json.NewDecoder(body)
825	decoder.UseNumber()
826	var shape interface{}
827	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
828		var snapshot bytes.Buffer
829		io.Copy(&snapshot, ringBuffer)
830		err = &smithy.DeserializationError{
831			Err:      fmt.Errorf("failed to decode response body, %w", err),
832			Snapshot: snapshot.Bytes(),
833		}
834		return out, metadata, err
835	}
836
837	err = awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(&output, shape)
838	if err != nil {
839		var snapshot bytes.Buffer
840		io.Copy(&snapshot, ringBuffer)
841		err = &smithy.DeserializationError{
842			Err:      fmt.Errorf("failed to decode response body, %w", err),
843			Snapshot: snapshot.Bytes(),
844		}
845		return out, metadata, err
846	}
847
848	return out, metadata, err
849}
850
851func awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
852	var errorBuffer bytes.Buffer
853	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
854		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
855	}
856	errorBody := bytes.NewReader(errorBuffer.Bytes())
857
858	errorCode := "UnknownError"
859	errorMessage := errorCode
860
861	code := response.Header.Get("X-Amzn-ErrorType")
862	if len(code) != 0 {
863		errorCode = restjson.SanitizeErrorCode(code)
864	}
865
866	var buff [1024]byte
867	ringBuffer := smithyio.NewRingBuffer(buff[:])
868
869	body := io.TeeReader(errorBody, ringBuffer)
870	decoder := json.NewDecoder(body)
871	decoder.UseNumber()
872	code, message, err := restjson.GetErrorInfo(decoder)
873	if err != nil {
874		var snapshot bytes.Buffer
875		io.Copy(&snapshot, ringBuffer)
876		err = &smithy.DeserializationError{
877			Err:      fmt.Errorf("failed to decode response body, %w", err),
878			Snapshot: snapshot.Bytes(),
879		}
880		return err
881	}
882
883	errorBody.Seek(0, io.SeekStart)
884	if len(code) != 0 {
885		errorCode = restjson.SanitizeErrorCode(code)
886	}
887	if len(message) != 0 {
888		errorMessage = message
889	}
890
891	switch {
892	case strings.EqualFold("AccessDeniedException", errorCode):
893		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
894
895	case strings.EqualFold("AccountSetupInProgressException", errorCode):
896		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
897
898	case strings.EqualFold("InvalidInputException", errorCode):
899		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
900
901	case strings.EqualFold("NotFoundException", errorCode):
902		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
903
904	case strings.EqualFold("OperationFailureException", errorCode):
905		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
906
907	case strings.EqualFold("ServiceException", errorCode):
908		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
909
910	case strings.EqualFold("UnauthenticatedException", errorCode):
911		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
912
913	default:
914		genericError := &smithy.GenericAPIError{
915			Code:    errorCode,
916			Message: errorMessage,
917		}
918		return genericError
919
920	}
921}
922
923type awsAwsjson11_deserializeOpCopySnapshot struct {
924}
925
926func (*awsAwsjson11_deserializeOpCopySnapshot) ID() string {
927	return "OperationDeserializer"
928}
929
930func (m *awsAwsjson11_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
931	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
932) {
933	out, metadata, err = next.HandleDeserialize(ctx, in)
934	if err != nil {
935		return out, metadata, err
936	}
937
938	response, ok := out.RawResponse.(*smithyhttp.Response)
939	if !ok {
940		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
941	}
942
943	if response.StatusCode < 200 || response.StatusCode >= 300 {
944		return out, metadata, awsAwsjson11_deserializeOpErrorCopySnapshot(response, &metadata)
945	}
946	output := &CopySnapshotOutput{}
947	out.Result = output
948
949	var buff [1024]byte
950	ringBuffer := smithyio.NewRingBuffer(buff[:])
951
952	body := io.TeeReader(response.Body, ringBuffer)
953	decoder := json.NewDecoder(body)
954	decoder.UseNumber()
955	var shape interface{}
956	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
957		var snapshot bytes.Buffer
958		io.Copy(&snapshot, ringBuffer)
959		err = &smithy.DeserializationError{
960			Err:      fmt.Errorf("failed to decode response body, %w", err),
961			Snapshot: snapshot.Bytes(),
962		}
963		return out, metadata, err
964	}
965
966	err = awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(&output, shape)
967	if err != nil {
968		var snapshot bytes.Buffer
969		io.Copy(&snapshot, ringBuffer)
970		err = &smithy.DeserializationError{
971			Err:      fmt.Errorf("failed to decode response body, %w", err),
972			Snapshot: snapshot.Bytes(),
973		}
974		return out, metadata, err
975	}
976
977	return out, metadata, err
978}
979
980func awsAwsjson11_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
981	var errorBuffer bytes.Buffer
982	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
983		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
984	}
985	errorBody := bytes.NewReader(errorBuffer.Bytes())
986
987	errorCode := "UnknownError"
988	errorMessage := errorCode
989
990	code := response.Header.Get("X-Amzn-ErrorType")
991	if len(code) != 0 {
992		errorCode = restjson.SanitizeErrorCode(code)
993	}
994
995	var buff [1024]byte
996	ringBuffer := smithyio.NewRingBuffer(buff[:])
997
998	body := io.TeeReader(errorBody, ringBuffer)
999	decoder := json.NewDecoder(body)
1000	decoder.UseNumber()
1001	code, message, err := restjson.GetErrorInfo(decoder)
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 err
1010	}
1011
1012	errorBody.Seek(0, io.SeekStart)
1013	if len(code) != 0 {
1014		errorCode = restjson.SanitizeErrorCode(code)
1015	}
1016	if len(message) != 0 {
1017		errorMessage = message
1018	}
1019
1020	switch {
1021	case strings.EqualFold("AccessDeniedException", errorCode):
1022		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1023
1024	case strings.EqualFold("AccountSetupInProgressException", errorCode):
1025		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1026
1027	case strings.EqualFold("InvalidInputException", errorCode):
1028		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1029
1030	case strings.EqualFold("NotFoundException", errorCode):
1031		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1032
1033	case strings.EqualFold("OperationFailureException", errorCode):
1034		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1035
1036	case strings.EqualFold("ServiceException", errorCode):
1037		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1038
1039	case strings.EqualFold("UnauthenticatedException", errorCode):
1040		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1041
1042	default:
1043		genericError := &smithy.GenericAPIError{
1044			Code:    errorCode,
1045			Message: errorMessage,
1046		}
1047		return genericError
1048
1049	}
1050}
1051
1052type awsAwsjson11_deserializeOpCreateBucket struct {
1053}
1054
1055func (*awsAwsjson11_deserializeOpCreateBucket) ID() string {
1056	return "OperationDeserializer"
1057}
1058
1059func (m *awsAwsjson11_deserializeOpCreateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1060	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	out, metadata, err = next.HandleDeserialize(ctx, in)
1063	if err != nil {
1064		return out, metadata, err
1065	}
1066
1067	response, ok := out.RawResponse.(*smithyhttp.Response)
1068	if !ok {
1069		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1070	}
1071
1072	if response.StatusCode < 200 || response.StatusCode >= 300 {
1073		return out, metadata, awsAwsjson11_deserializeOpErrorCreateBucket(response, &metadata)
1074	}
1075	output := &CreateBucketOutput{}
1076	out.Result = output
1077
1078	var buff [1024]byte
1079	ringBuffer := smithyio.NewRingBuffer(buff[:])
1080
1081	body := io.TeeReader(response.Body, ringBuffer)
1082	decoder := json.NewDecoder(body)
1083	decoder.UseNumber()
1084	var shape interface{}
1085	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1086		var snapshot bytes.Buffer
1087		io.Copy(&snapshot, ringBuffer)
1088		err = &smithy.DeserializationError{
1089			Err:      fmt.Errorf("failed to decode response body, %w", err),
1090			Snapshot: snapshot.Bytes(),
1091		}
1092		return out, metadata, err
1093	}
1094
1095	err = awsAwsjson11_deserializeOpDocumentCreateBucketOutput(&output, shape)
1096	if err != nil {
1097		var snapshot bytes.Buffer
1098		io.Copy(&snapshot, ringBuffer)
1099		err = &smithy.DeserializationError{
1100			Err:      fmt.Errorf("failed to decode response body, %w", err),
1101			Snapshot: snapshot.Bytes(),
1102		}
1103		return out, metadata, err
1104	}
1105
1106	return out, metadata, err
1107}
1108
1109func awsAwsjson11_deserializeOpErrorCreateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1110	var errorBuffer bytes.Buffer
1111	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1112		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1113	}
1114	errorBody := bytes.NewReader(errorBuffer.Bytes())
1115
1116	errorCode := "UnknownError"
1117	errorMessage := errorCode
1118
1119	code := response.Header.Get("X-Amzn-ErrorType")
1120	if len(code) != 0 {
1121		errorCode = restjson.SanitizeErrorCode(code)
1122	}
1123
1124	var buff [1024]byte
1125	ringBuffer := smithyio.NewRingBuffer(buff[:])
1126
1127	body := io.TeeReader(errorBody, ringBuffer)
1128	decoder := json.NewDecoder(body)
1129	decoder.UseNumber()
1130	code, message, err := restjson.GetErrorInfo(decoder)
1131	if err != nil {
1132		var snapshot bytes.Buffer
1133		io.Copy(&snapshot, ringBuffer)
1134		err = &smithy.DeserializationError{
1135			Err:      fmt.Errorf("failed to decode response body, %w", err),
1136			Snapshot: snapshot.Bytes(),
1137		}
1138		return err
1139	}
1140
1141	errorBody.Seek(0, io.SeekStart)
1142	if len(code) != 0 {
1143		errorCode = restjson.SanitizeErrorCode(code)
1144	}
1145	if len(message) != 0 {
1146		errorMessage = message
1147	}
1148
1149	switch {
1150	case strings.EqualFold("AccessDeniedException", errorCode):
1151		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1152
1153	case strings.EqualFold("InvalidInputException", errorCode):
1154		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1155
1156	case strings.EqualFold("ServiceException", errorCode):
1157		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1158
1159	case strings.EqualFold("UnauthenticatedException", errorCode):
1160		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1161
1162	default:
1163		genericError := &smithy.GenericAPIError{
1164			Code:    errorCode,
1165			Message: errorMessage,
1166		}
1167		return genericError
1168
1169	}
1170}
1171
1172type awsAwsjson11_deserializeOpCreateBucketAccessKey struct {
1173}
1174
1175func (*awsAwsjson11_deserializeOpCreateBucketAccessKey) ID() string {
1176	return "OperationDeserializer"
1177}
1178
1179func (m *awsAwsjson11_deserializeOpCreateBucketAccessKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1180	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1181) {
1182	out, metadata, err = next.HandleDeserialize(ctx, in)
1183	if err != nil {
1184		return out, metadata, err
1185	}
1186
1187	response, ok := out.RawResponse.(*smithyhttp.Response)
1188	if !ok {
1189		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1190	}
1191
1192	if response.StatusCode < 200 || response.StatusCode >= 300 {
1193		return out, metadata, awsAwsjson11_deserializeOpErrorCreateBucketAccessKey(response, &metadata)
1194	}
1195	output := &CreateBucketAccessKeyOutput{}
1196	out.Result = output
1197
1198	var buff [1024]byte
1199	ringBuffer := smithyio.NewRingBuffer(buff[:])
1200
1201	body := io.TeeReader(response.Body, ringBuffer)
1202	decoder := json.NewDecoder(body)
1203	decoder.UseNumber()
1204	var shape interface{}
1205	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1206		var snapshot bytes.Buffer
1207		io.Copy(&snapshot, ringBuffer)
1208		err = &smithy.DeserializationError{
1209			Err:      fmt.Errorf("failed to decode response body, %w", err),
1210			Snapshot: snapshot.Bytes(),
1211		}
1212		return out, metadata, err
1213	}
1214
1215	err = awsAwsjson11_deserializeOpDocumentCreateBucketAccessKeyOutput(&output, shape)
1216	if err != nil {
1217		var snapshot bytes.Buffer
1218		io.Copy(&snapshot, ringBuffer)
1219		err = &smithy.DeserializationError{
1220			Err:      fmt.Errorf("failed to decode response body, %w", err),
1221			Snapshot: snapshot.Bytes(),
1222		}
1223		return out, metadata, err
1224	}
1225
1226	return out, metadata, err
1227}
1228
1229func awsAwsjson11_deserializeOpErrorCreateBucketAccessKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1230	var errorBuffer bytes.Buffer
1231	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1232		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1233	}
1234	errorBody := bytes.NewReader(errorBuffer.Bytes())
1235
1236	errorCode := "UnknownError"
1237	errorMessage := errorCode
1238
1239	code := response.Header.Get("X-Amzn-ErrorType")
1240	if len(code) != 0 {
1241		errorCode = restjson.SanitizeErrorCode(code)
1242	}
1243
1244	var buff [1024]byte
1245	ringBuffer := smithyio.NewRingBuffer(buff[:])
1246
1247	body := io.TeeReader(errorBody, ringBuffer)
1248	decoder := json.NewDecoder(body)
1249	decoder.UseNumber()
1250	code, message, err := restjson.GetErrorInfo(decoder)
1251	if err != nil {
1252		var snapshot bytes.Buffer
1253		io.Copy(&snapshot, ringBuffer)
1254		err = &smithy.DeserializationError{
1255			Err:      fmt.Errorf("failed to decode response body, %w", err),
1256			Snapshot: snapshot.Bytes(),
1257		}
1258		return err
1259	}
1260
1261	errorBody.Seek(0, io.SeekStart)
1262	if len(code) != 0 {
1263		errorCode = restjson.SanitizeErrorCode(code)
1264	}
1265	if len(message) != 0 {
1266		errorMessage = message
1267	}
1268
1269	switch {
1270	case strings.EqualFold("AccessDeniedException", errorCode):
1271		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1272
1273	case strings.EqualFold("InvalidInputException", errorCode):
1274		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1275
1276	case strings.EqualFold("NotFoundException", errorCode):
1277		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1278
1279	case strings.EqualFold("ServiceException", errorCode):
1280		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1281
1282	case strings.EqualFold("UnauthenticatedException", errorCode):
1283		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1284
1285	default:
1286		genericError := &smithy.GenericAPIError{
1287			Code:    errorCode,
1288			Message: errorMessage,
1289		}
1290		return genericError
1291
1292	}
1293}
1294
1295type awsAwsjson11_deserializeOpCreateCertificate struct {
1296}
1297
1298func (*awsAwsjson11_deserializeOpCreateCertificate) ID() string {
1299	return "OperationDeserializer"
1300}
1301
1302func (m *awsAwsjson11_deserializeOpCreateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1303	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1304) {
1305	out, metadata, err = next.HandleDeserialize(ctx, in)
1306	if err != nil {
1307		return out, metadata, err
1308	}
1309
1310	response, ok := out.RawResponse.(*smithyhttp.Response)
1311	if !ok {
1312		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1313	}
1314
1315	if response.StatusCode < 200 || response.StatusCode >= 300 {
1316		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCertificate(response, &metadata)
1317	}
1318	output := &CreateCertificateOutput{}
1319	out.Result = output
1320
1321	var buff [1024]byte
1322	ringBuffer := smithyio.NewRingBuffer(buff[:])
1323
1324	body := io.TeeReader(response.Body, ringBuffer)
1325	decoder := json.NewDecoder(body)
1326	decoder.UseNumber()
1327	var shape interface{}
1328	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1329		var snapshot bytes.Buffer
1330		io.Copy(&snapshot, ringBuffer)
1331		err = &smithy.DeserializationError{
1332			Err:      fmt.Errorf("failed to decode response body, %w", err),
1333			Snapshot: snapshot.Bytes(),
1334		}
1335		return out, metadata, err
1336	}
1337
1338	err = awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(&output, shape)
1339	if err != nil {
1340		var snapshot bytes.Buffer
1341		io.Copy(&snapshot, ringBuffer)
1342		err = &smithy.DeserializationError{
1343			Err:      fmt.Errorf("failed to decode response body, %w", err),
1344			Snapshot: snapshot.Bytes(),
1345		}
1346		return out, metadata, err
1347	}
1348
1349	return out, metadata, err
1350}
1351
1352func awsAwsjson11_deserializeOpErrorCreateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1353	var errorBuffer bytes.Buffer
1354	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1355		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1356	}
1357	errorBody := bytes.NewReader(errorBuffer.Bytes())
1358
1359	errorCode := "UnknownError"
1360	errorMessage := errorCode
1361
1362	code := response.Header.Get("X-Amzn-ErrorType")
1363	if len(code) != 0 {
1364		errorCode = restjson.SanitizeErrorCode(code)
1365	}
1366
1367	var buff [1024]byte
1368	ringBuffer := smithyio.NewRingBuffer(buff[:])
1369
1370	body := io.TeeReader(errorBody, ringBuffer)
1371	decoder := json.NewDecoder(body)
1372	decoder.UseNumber()
1373	code, message, err := restjson.GetErrorInfo(decoder)
1374	if err != nil {
1375		var snapshot bytes.Buffer
1376		io.Copy(&snapshot, ringBuffer)
1377		err = &smithy.DeserializationError{
1378			Err:      fmt.Errorf("failed to decode response body, %w", err),
1379			Snapshot: snapshot.Bytes(),
1380		}
1381		return err
1382	}
1383
1384	errorBody.Seek(0, io.SeekStart)
1385	if len(code) != 0 {
1386		errorCode = restjson.SanitizeErrorCode(code)
1387	}
1388	if len(message) != 0 {
1389		errorMessage = message
1390	}
1391
1392	switch {
1393	case strings.EqualFold("AccessDeniedException", errorCode):
1394		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1395
1396	case strings.EqualFold("InvalidInputException", errorCode):
1397		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1398
1399	case strings.EqualFold("NotFoundException", errorCode):
1400		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1401
1402	case strings.EqualFold("ServiceException", errorCode):
1403		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1404
1405	case strings.EqualFold("UnauthenticatedException", errorCode):
1406		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1407
1408	default:
1409		genericError := &smithy.GenericAPIError{
1410			Code:    errorCode,
1411			Message: errorMessage,
1412		}
1413		return genericError
1414
1415	}
1416}
1417
1418type awsAwsjson11_deserializeOpCreateCloudFormationStack struct {
1419}
1420
1421func (*awsAwsjson11_deserializeOpCreateCloudFormationStack) ID() string {
1422	return "OperationDeserializer"
1423}
1424
1425func (m *awsAwsjson11_deserializeOpCreateCloudFormationStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1426	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1427) {
1428	out, metadata, err = next.HandleDeserialize(ctx, in)
1429	if err != nil {
1430		return out, metadata, err
1431	}
1432
1433	response, ok := out.RawResponse.(*smithyhttp.Response)
1434	if !ok {
1435		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1436	}
1437
1438	if response.StatusCode < 200 || response.StatusCode >= 300 {
1439		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response, &metadata)
1440	}
1441	output := &CreateCloudFormationStackOutput{}
1442	out.Result = output
1443
1444	var buff [1024]byte
1445	ringBuffer := smithyio.NewRingBuffer(buff[:])
1446
1447	body := io.TeeReader(response.Body, ringBuffer)
1448	decoder := json.NewDecoder(body)
1449	decoder.UseNumber()
1450	var shape interface{}
1451	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1452		var snapshot bytes.Buffer
1453		io.Copy(&snapshot, ringBuffer)
1454		err = &smithy.DeserializationError{
1455			Err:      fmt.Errorf("failed to decode response body, %w", err),
1456			Snapshot: snapshot.Bytes(),
1457		}
1458		return out, metadata, err
1459	}
1460
1461	err = awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(&output, shape)
1462	if err != nil {
1463		var snapshot bytes.Buffer
1464		io.Copy(&snapshot, ringBuffer)
1465		err = &smithy.DeserializationError{
1466			Err:      fmt.Errorf("failed to decode response body, %w", err),
1467			Snapshot: snapshot.Bytes(),
1468		}
1469		return out, metadata, err
1470	}
1471
1472	return out, metadata, err
1473}
1474
1475func awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1476	var errorBuffer bytes.Buffer
1477	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1478		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1479	}
1480	errorBody := bytes.NewReader(errorBuffer.Bytes())
1481
1482	errorCode := "UnknownError"
1483	errorMessage := errorCode
1484
1485	code := response.Header.Get("X-Amzn-ErrorType")
1486	if len(code) != 0 {
1487		errorCode = restjson.SanitizeErrorCode(code)
1488	}
1489
1490	var buff [1024]byte
1491	ringBuffer := smithyio.NewRingBuffer(buff[:])
1492
1493	body := io.TeeReader(errorBody, ringBuffer)
1494	decoder := json.NewDecoder(body)
1495	decoder.UseNumber()
1496	code, message, err := restjson.GetErrorInfo(decoder)
1497	if err != nil {
1498		var snapshot bytes.Buffer
1499		io.Copy(&snapshot, ringBuffer)
1500		err = &smithy.DeserializationError{
1501			Err:      fmt.Errorf("failed to decode response body, %w", err),
1502			Snapshot: snapshot.Bytes(),
1503		}
1504		return err
1505	}
1506
1507	errorBody.Seek(0, io.SeekStart)
1508	if len(code) != 0 {
1509		errorCode = restjson.SanitizeErrorCode(code)
1510	}
1511	if len(message) != 0 {
1512		errorMessage = message
1513	}
1514
1515	switch {
1516	case strings.EqualFold("AccessDeniedException", errorCode):
1517		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1518
1519	case strings.EqualFold("AccountSetupInProgressException", errorCode):
1520		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1521
1522	case strings.EqualFold("InvalidInputException", errorCode):
1523		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1524
1525	case strings.EqualFold("NotFoundException", errorCode):
1526		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1527
1528	case strings.EqualFold("OperationFailureException", errorCode):
1529		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1530
1531	case strings.EqualFold("ServiceException", errorCode):
1532		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1533
1534	case strings.EqualFold("UnauthenticatedException", errorCode):
1535		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1536
1537	default:
1538		genericError := &smithy.GenericAPIError{
1539			Code:    errorCode,
1540			Message: errorMessage,
1541		}
1542		return genericError
1543
1544	}
1545}
1546
1547type awsAwsjson11_deserializeOpCreateContactMethod struct {
1548}
1549
1550func (*awsAwsjson11_deserializeOpCreateContactMethod) ID() string {
1551	return "OperationDeserializer"
1552}
1553
1554func (m *awsAwsjson11_deserializeOpCreateContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1555	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1556) {
1557	out, metadata, err = next.HandleDeserialize(ctx, in)
1558	if err != nil {
1559		return out, metadata, err
1560	}
1561
1562	response, ok := out.RawResponse.(*smithyhttp.Response)
1563	if !ok {
1564		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1565	}
1566
1567	if response.StatusCode < 200 || response.StatusCode >= 300 {
1568		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContactMethod(response, &metadata)
1569	}
1570	output := &CreateContactMethodOutput{}
1571	out.Result = output
1572
1573	var buff [1024]byte
1574	ringBuffer := smithyio.NewRingBuffer(buff[:])
1575
1576	body := io.TeeReader(response.Body, ringBuffer)
1577	decoder := json.NewDecoder(body)
1578	decoder.UseNumber()
1579	var shape interface{}
1580	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1581		var snapshot bytes.Buffer
1582		io.Copy(&snapshot, ringBuffer)
1583		err = &smithy.DeserializationError{
1584			Err:      fmt.Errorf("failed to decode response body, %w", err),
1585			Snapshot: snapshot.Bytes(),
1586		}
1587		return out, metadata, err
1588	}
1589
1590	err = awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(&output, shape)
1591	if err != nil {
1592		var snapshot bytes.Buffer
1593		io.Copy(&snapshot, ringBuffer)
1594		err = &smithy.DeserializationError{
1595			Err:      fmt.Errorf("failed to decode response body, %w", err),
1596			Snapshot: snapshot.Bytes(),
1597		}
1598		return out, metadata, err
1599	}
1600
1601	return out, metadata, err
1602}
1603
1604func awsAwsjson11_deserializeOpErrorCreateContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1605	var errorBuffer bytes.Buffer
1606	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1607		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1608	}
1609	errorBody := bytes.NewReader(errorBuffer.Bytes())
1610
1611	errorCode := "UnknownError"
1612	errorMessage := errorCode
1613
1614	code := response.Header.Get("X-Amzn-ErrorType")
1615	if len(code) != 0 {
1616		errorCode = restjson.SanitizeErrorCode(code)
1617	}
1618
1619	var buff [1024]byte
1620	ringBuffer := smithyio.NewRingBuffer(buff[:])
1621
1622	body := io.TeeReader(errorBody, ringBuffer)
1623	decoder := json.NewDecoder(body)
1624	decoder.UseNumber()
1625	code, message, err := restjson.GetErrorInfo(decoder)
1626	if err != nil {
1627		var snapshot bytes.Buffer
1628		io.Copy(&snapshot, ringBuffer)
1629		err = &smithy.DeserializationError{
1630			Err:      fmt.Errorf("failed to decode response body, %w", err),
1631			Snapshot: snapshot.Bytes(),
1632		}
1633		return err
1634	}
1635
1636	errorBody.Seek(0, io.SeekStart)
1637	if len(code) != 0 {
1638		errorCode = restjson.SanitizeErrorCode(code)
1639	}
1640	if len(message) != 0 {
1641		errorMessage = message
1642	}
1643
1644	switch {
1645	case strings.EqualFold("AccessDeniedException", errorCode):
1646		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1647
1648	case strings.EqualFold("InvalidInputException", errorCode):
1649		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1650
1651	case strings.EqualFold("NotFoundException", errorCode):
1652		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1653
1654	case strings.EqualFold("OperationFailureException", errorCode):
1655		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1656
1657	case strings.EqualFold("ServiceException", errorCode):
1658		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1659
1660	case strings.EqualFold("UnauthenticatedException", errorCode):
1661		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1662
1663	default:
1664		genericError := &smithy.GenericAPIError{
1665			Code:    errorCode,
1666			Message: errorMessage,
1667		}
1668		return genericError
1669
1670	}
1671}
1672
1673type awsAwsjson11_deserializeOpCreateContainerService struct {
1674}
1675
1676func (*awsAwsjson11_deserializeOpCreateContainerService) ID() string {
1677	return "OperationDeserializer"
1678}
1679
1680func (m *awsAwsjson11_deserializeOpCreateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1681	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	out, metadata, err = next.HandleDeserialize(ctx, in)
1684	if err != nil {
1685		return out, metadata, err
1686	}
1687
1688	response, ok := out.RawResponse.(*smithyhttp.Response)
1689	if !ok {
1690		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1691	}
1692
1693	if response.StatusCode < 200 || response.StatusCode >= 300 {
1694		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerService(response, &metadata)
1695	}
1696	output := &CreateContainerServiceOutput{}
1697	out.Result = output
1698
1699	var buff [1024]byte
1700	ringBuffer := smithyio.NewRingBuffer(buff[:])
1701
1702	body := io.TeeReader(response.Body, ringBuffer)
1703	decoder := json.NewDecoder(body)
1704	decoder.UseNumber()
1705	var shape interface{}
1706	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1707		var snapshot bytes.Buffer
1708		io.Copy(&snapshot, ringBuffer)
1709		err = &smithy.DeserializationError{
1710			Err:      fmt.Errorf("failed to decode response body, %w", err),
1711			Snapshot: snapshot.Bytes(),
1712		}
1713		return out, metadata, err
1714	}
1715
1716	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(&output, shape)
1717	if err != nil {
1718		var snapshot bytes.Buffer
1719		io.Copy(&snapshot, ringBuffer)
1720		err = &smithy.DeserializationError{
1721			Err:      fmt.Errorf("failed to decode response body, %w", err),
1722			Snapshot: snapshot.Bytes(),
1723		}
1724		return out, metadata, err
1725	}
1726
1727	return out, metadata, err
1728}
1729
1730func awsAwsjson11_deserializeOpErrorCreateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1731	var errorBuffer bytes.Buffer
1732	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1733		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1734	}
1735	errorBody := bytes.NewReader(errorBuffer.Bytes())
1736
1737	errorCode := "UnknownError"
1738	errorMessage := errorCode
1739
1740	code := response.Header.Get("X-Amzn-ErrorType")
1741	if len(code) != 0 {
1742		errorCode = restjson.SanitizeErrorCode(code)
1743	}
1744
1745	var buff [1024]byte
1746	ringBuffer := smithyio.NewRingBuffer(buff[:])
1747
1748	body := io.TeeReader(errorBody, ringBuffer)
1749	decoder := json.NewDecoder(body)
1750	decoder.UseNumber()
1751	code, message, err := restjson.GetErrorInfo(decoder)
1752	if err != nil {
1753		var snapshot bytes.Buffer
1754		io.Copy(&snapshot, ringBuffer)
1755		err = &smithy.DeserializationError{
1756			Err:      fmt.Errorf("failed to decode response body, %w", err),
1757			Snapshot: snapshot.Bytes(),
1758		}
1759		return err
1760	}
1761
1762	errorBody.Seek(0, io.SeekStart)
1763	if len(code) != 0 {
1764		errorCode = restjson.SanitizeErrorCode(code)
1765	}
1766	if len(message) != 0 {
1767		errorMessage = message
1768	}
1769
1770	switch {
1771	case strings.EqualFold("AccessDeniedException", errorCode):
1772		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1773
1774	case strings.EqualFold("InvalidInputException", errorCode):
1775		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1776
1777	case strings.EqualFold("NotFoundException", errorCode):
1778		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1779
1780	case strings.EqualFold("ServiceException", errorCode):
1781		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1782
1783	case strings.EqualFold("UnauthenticatedException", errorCode):
1784		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1785
1786	default:
1787		genericError := &smithy.GenericAPIError{
1788			Code:    errorCode,
1789			Message: errorMessage,
1790		}
1791		return genericError
1792
1793	}
1794}
1795
1796type awsAwsjson11_deserializeOpCreateContainerServiceDeployment struct {
1797}
1798
1799func (*awsAwsjson11_deserializeOpCreateContainerServiceDeployment) ID() string {
1800	return "OperationDeserializer"
1801}
1802
1803func (m *awsAwsjson11_deserializeOpCreateContainerServiceDeployment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1804	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1805) {
1806	out, metadata, err = next.HandleDeserialize(ctx, in)
1807	if err != nil {
1808		return out, metadata, err
1809	}
1810
1811	response, ok := out.RawResponse.(*smithyhttp.Response)
1812	if !ok {
1813		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1814	}
1815
1816	if response.StatusCode < 200 || response.StatusCode >= 300 {
1817		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response, &metadata)
1818	}
1819	output := &CreateContainerServiceDeploymentOutput{}
1820	out.Result = output
1821
1822	var buff [1024]byte
1823	ringBuffer := smithyio.NewRingBuffer(buff[:])
1824
1825	body := io.TeeReader(response.Body, ringBuffer)
1826	decoder := json.NewDecoder(body)
1827	decoder.UseNumber()
1828	var shape interface{}
1829	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1830		var snapshot bytes.Buffer
1831		io.Copy(&snapshot, ringBuffer)
1832		err = &smithy.DeserializationError{
1833			Err:      fmt.Errorf("failed to decode response body, %w", err),
1834			Snapshot: snapshot.Bytes(),
1835		}
1836		return out, metadata, err
1837	}
1838
1839	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(&output, shape)
1840	if err != nil {
1841		var snapshot bytes.Buffer
1842		io.Copy(&snapshot, ringBuffer)
1843		err = &smithy.DeserializationError{
1844			Err:      fmt.Errorf("failed to decode response body, %w", err),
1845			Snapshot: snapshot.Bytes(),
1846		}
1847		return out, metadata, err
1848	}
1849
1850	return out, metadata, err
1851}
1852
1853func awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1854	var errorBuffer bytes.Buffer
1855	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1856		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1857	}
1858	errorBody := bytes.NewReader(errorBuffer.Bytes())
1859
1860	errorCode := "UnknownError"
1861	errorMessage := errorCode
1862
1863	code := response.Header.Get("X-Amzn-ErrorType")
1864	if len(code) != 0 {
1865		errorCode = restjson.SanitizeErrorCode(code)
1866	}
1867
1868	var buff [1024]byte
1869	ringBuffer := smithyio.NewRingBuffer(buff[:])
1870
1871	body := io.TeeReader(errorBody, ringBuffer)
1872	decoder := json.NewDecoder(body)
1873	decoder.UseNumber()
1874	code, message, err := restjson.GetErrorInfo(decoder)
1875	if err != nil {
1876		var snapshot bytes.Buffer
1877		io.Copy(&snapshot, ringBuffer)
1878		err = &smithy.DeserializationError{
1879			Err:      fmt.Errorf("failed to decode response body, %w", err),
1880			Snapshot: snapshot.Bytes(),
1881		}
1882		return err
1883	}
1884
1885	errorBody.Seek(0, io.SeekStart)
1886	if len(code) != 0 {
1887		errorCode = restjson.SanitizeErrorCode(code)
1888	}
1889	if len(message) != 0 {
1890		errorMessage = message
1891	}
1892
1893	switch {
1894	case strings.EqualFold("AccessDeniedException", errorCode):
1895		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1896
1897	case strings.EqualFold("InvalidInputException", errorCode):
1898		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1899
1900	case strings.EqualFold("NotFoundException", errorCode):
1901		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1902
1903	case strings.EqualFold("ServiceException", errorCode):
1904		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1905
1906	case strings.EqualFold("UnauthenticatedException", errorCode):
1907		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1908
1909	default:
1910		genericError := &smithy.GenericAPIError{
1911			Code:    errorCode,
1912			Message: errorMessage,
1913		}
1914		return genericError
1915
1916	}
1917}
1918
1919type awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin struct {
1920}
1921
1922func (*awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) ID() string {
1923	return "OperationDeserializer"
1924}
1925
1926func (m *awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1927	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1928) {
1929	out, metadata, err = next.HandleDeserialize(ctx, in)
1930	if err != nil {
1931		return out, metadata, err
1932	}
1933
1934	response, ok := out.RawResponse.(*smithyhttp.Response)
1935	if !ok {
1936		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1937	}
1938
1939	if response.StatusCode < 200 || response.StatusCode >= 300 {
1940		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response, &metadata)
1941	}
1942	output := &CreateContainerServiceRegistryLoginOutput{}
1943	out.Result = output
1944
1945	var buff [1024]byte
1946	ringBuffer := smithyio.NewRingBuffer(buff[:])
1947
1948	body := io.TeeReader(response.Body, ringBuffer)
1949	decoder := json.NewDecoder(body)
1950	decoder.UseNumber()
1951	var shape interface{}
1952	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1953		var snapshot bytes.Buffer
1954		io.Copy(&snapshot, ringBuffer)
1955		err = &smithy.DeserializationError{
1956			Err:      fmt.Errorf("failed to decode response body, %w", err),
1957			Snapshot: snapshot.Bytes(),
1958		}
1959		return out, metadata, err
1960	}
1961
1962	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(&output, shape)
1963	if err != nil {
1964		var snapshot bytes.Buffer
1965		io.Copy(&snapshot, ringBuffer)
1966		err = &smithy.DeserializationError{
1967			Err:      fmt.Errorf("failed to decode response body, %w", err),
1968			Snapshot: snapshot.Bytes(),
1969		}
1970		return out, metadata, err
1971	}
1972
1973	return out, metadata, err
1974}
1975
1976func awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1977	var errorBuffer bytes.Buffer
1978	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1979		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1980	}
1981	errorBody := bytes.NewReader(errorBuffer.Bytes())
1982
1983	errorCode := "UnknownError"
1984	errorMessage := errorCode
1985
1986	code := response.Header.Get("X-Amzn-ErrorType")
1987	if len(code) != 0 {
1988		errorCode = restjson.SanitizeErrorCode(code)
1989	}
1990
1991	var buff [1024]byte
1992	ringBuffer := smithyio.NewRingBuffer(buff[:])
1993
1994	body := io.TeeReader(errorBody, ringBuffer)
1995	decoder := json.NewDecoder(body)
1996	decoder.UseNumber()
1997	code, message, err := restjson.GetErrorInfo(decoder)
1998	if err != nil {
1999		var snapshot bytes.Buffer
2000		io.Copy(&snapshot, ringBuffer)
2001		err = &smithy.DeserializationError{
2002			Err:      fmt.Errorf("failed to decode response body, %w", err),
2003			Snapshot: snapshot.Bytes(),
2004		}
2005		return err
2006	}
2007
2008	errorBody.Seek(0, io.SeekStart)
2009	if len(code) != 0 {
2010		errorCode = restjson.SanitizeErrorCode(code)
2011	}
2012	if len(message) != 0 {
2013		errorMessage = message
2014	}
2015
2016	switch {
2017	case strings.EqualFold("AccessDeniedException", errorCode):
2018		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2019
2020	case strings.EqualFold("InvalidInputException", errorCode):
2021		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2022
2023	case strings.EqualFold("NotFoundException", errorCode):
2024		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2025
2026	case strings.EqualFold("ServiceException", errorCode):
2027		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2028
2029	case strings.EqualFold("UnauthenticatedException", errorCode):
2030		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2031
2032	default:
2033		genericError := &smithy.GenericAPIError{
2034			Code:    errorCode,
2035			Message: errorMessage,
2036		}
2037		return genericError
2038
2039	}
2040}
2041
2042type awsAwsjson11_deserializeOpCreateDisk struct {
2043}
2044
2045func (*awsAwsjson11_deserializeOpCreateDisk) ID() string {
2046	return "OperationDeserializer"
2047}
2048
2049func (m *awsAwsjson11_deserializeOpCreateDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2050	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2051) {
2052	out, metadata, err = next.HandleDeserialize(ctx, in)
2053	if err != nil {
2054		return out, metadata, err
2055	}
2056
2057	response, ok := out.RawResponse.(*smithyhttp.Response)
2058	if !ok {
2059		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2060	}
2061
2062	if response.StatusCode < 200 || response.StatusCode >= 300 {
2063		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDisk(response, &metadata)
2064	}
2065	output := &CreateDiskOutput{}
2066	out.Result = output
2067
2068	var buff [1024]byte
2069	ringBuffer := smithyio.NewRingBuffer(buff[:])
2070
2071	body := io.TeeReader(response.Body, ringBuffer)
2072	decoder := json.NewDecoder(body)
2073	decoder.UseNumber()
2074	var shape interface{}
2075	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2076		var snapshot bytes.Buffer
2077		io.Copy(&snapshot, ringBuffer)
2078		err = &smithy.DeserializationError{
2079			Err:      fmt.Errorf("failed to decode response body, %w", err),
2080			Snapshot: snapshot.Bytes(),
2081		}
2082		return out, metadata, err
2083	}
2084
2085	err = awsAwsjson11_deserializeOpDocumentCreateDiskOutput(&output, shape)
2086	if err != nil {
2087		var snapshot bytes.Buffer
2088		io.Copy(&snapshot, ringBuffer)
2089		err = &smithy.DeserializationError{
2090			Err:      fmt.Errorf("failed to decode response body, %w", err),
2091			Snapshot: snapshot.Bytes(),
2092		}
2093		return out, metadata, err
2094	}
2095
2096	return out, metadata, err
2097}
2098
2099func awsAwsjson11_deserializeOpErrorCreateDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2100	var errorBuffer bytes.Buffer
2101	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2102		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2103	}
2104	errorBody := bytes.NewReader(errorBuffer.Bytes())
2105
2106	errorCode := "UnknownError"
2107	errorMessage := errorCode
2108
2109	code := response.Header.Get("X-Amzn-ErrorType")
2110	if len(code) != 0 {
2111		errorCode = restjson.SanitizeErrorCode(code)
2112	}
2113
2114	var buff [1024]byte
2115	ringBuffer := smithyio.NewRingBuffer(buff[:])
2116
2117	body := io.TeeReader(errorBody, ringBuffer)
2118	decoder := json.NewDecoder(body)
2119	decoder.UseNumber()
2120	code, message, err := restjson.GetErrorInfo(decoder)
2121	if err != nil {
2122		var snapshot bytes.Buffer
2123		io.Copy(&snapshot, ringBuffer)
2124		err = &smithy.DeserializationError{
2125			Err:      fmt.Errorf("failed to decode response body, %w", err),
2126			Snapshot: snapshot.Bytes(),
2127		}
2128		return err
2129	}
2130
2131	errorBody.Seek(0, io.SeekStart)
2132	if len(code) != 0 {
2133		errorCode = restjson.SanitizeErrorCode(code)
2134	}
2135	if len(message) != 0 {
2136		errorMessage = message
2137	}
2138
2139	switch {
2140	case strings.EqualFold("AccessDeniedException", errorCode):
2141		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2142
2143	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2144		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2145
2146	case strings.EqualFold("InvalidInputException", errorCode):
2147		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2148
2149	case strings.EqualFold("NotFoundException", errorCode):
2150		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2151
2152	case strings.EqualFold("OperationFailureException", errorCode):
2153		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2154
2155	case strings.EqualFold("ServiceException", errorCode):
2156		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2157
2158	case strings.EqualFold("UnauthenticatedException", errorCode):
2159		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2160
2161	default:
2162		genericError := &smithy.GenericAPIError{
2163			Code:    errorCode,
2164			Message: errorMessage,
2165		}
2166		return genericError
2167
2168	}
2169}
2170
2171type awsAwsjson11_deserializeOpCreateDiskFromSnapshot struct {
2172}
2173
2174func (*awsAwsjson11_deserializeOpCreateDiskFromSnapshot) ID() string {
2175	return "OperationDeserializer"
2176}
2177
2178func (m *awsAwsjson11_deserializeOpCreateDiskFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2179	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2180) {
2181	out, metadata, err = next.HandleDeserialize(ctx, in)
2182	if err != nil {
2183		return out, metadata, err
2184	}
2185
2186	response, ok := out.RawResponse.(*smithyhttp.Response)
2187	if !ok {
2188		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2189	}
2190
2191	if response.StatusCode < 200 || response.StatusCode >= 300 {
2192		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response, &metadata)
2193	}
2194	output := &CreateDiskFromSnapshotOutput{}
2195	out.Result = output
2196
2197	var buff [1024]byte
2198	ringBuffer := smithyio.NewRingBuffer(buff[:])
2199
2200	body := io.TeeReader(response.Body, ringBuffer)
2201	decoder := json.NewDecoder(body)
2202	decoder.UseNumber()
2203	var shape interface{}
2204	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2205		var snapshot bytes.Buffer
2206		io.Copy(&snapshot, ringBuffer)
2207		err = &smithy.DeserializationError{
2208			Err:      fmt.Errorf("failed to decode response body, %w", err),
2209			Snapshot: snapshot.Bytes(),
2210		}
2211		return out, metadata, err
2212	}
2213
2214	err = awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(&output, shape)
2215	if err != nil {
2216		var snapshot bytes.Buffer
2217		io.Copy(&snapshot, ringBuffer)
2218		err = &smithy.DeserializationError{
2219			Err:      fmt.Errorf("failed to decode response body, %w", err),
2220			Snapshot: snapshot.Bytes(),
2221		}
2222		return out, metadata, err
2223	}
2224
2225	return out, metadata, err
2226}
2227
2228func awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2229	var errorBuffer bytes.Buffer
2230	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2231		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2232	}
2233	errorBody := bytes.NewReader(errorBuffer.Bytes())
2234
2235	errorCode := "UnknownError"
2236	errorMessage := errorCode
2237
2238	code := response.Header.Get("X-Amzn-ErrorType")
2239	if len(code) != 0 {
2240		errorCode = restjson.SanitizeErrorCode(code)
2241	}
2242
2243	var buff [1024]byte
2244	ringBuffer := smithyio.NewRingBuffer(buff[:])
2245
2246	body := io.TeeReader(errorBody, ringBuffer)
2247	decoder := json.NewDecoder(body)
2248	decoder.UseNumber()
2249	code, message, err := restjson.GetErrorInfo(decoder)
2250	if err != nil {
2251		var snapshot bytes.Buffer
2252		io.Copy(&snapshot, ringBuffer)
2253		err = &smithy.DeserializationError{
2254			Err:      fmt.Errorf("failed to decode response body, %w", err),
2255			Snapshot: snapshot.Bytes(),
2256		}
2257		return err
2258	}
2259
2260	errorBody.Seek(0, io.SeekStart)
2261	if len(code) != 0 {
2262		errorCode = restjson.SanitizeErrorCode(code)
2263	}
2264	if len(message) != 0 {
2265		errorMessage = message
2266	}
2267
2268	switch {
2269	case strings.EqualFold("AccessDeniedException", errorCode):
2270		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2271
2272	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2273		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2274
2275	case strings.EqualFold("InvalidInputException", errorCode):
2276		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2277
2278	case strings.EqualFold("NotFoundException", errorCode):
2279		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2280
2281	case strings.EqualFold("OperationFailureException", errorCode):
2282		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2283
2284	case strings.EqualFold("ServiceException", errorCode):
2285		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2286
2287	case strings.EqualFold("UnauthenticatedException", errorCode):
2288		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2289
2290	default:
2291		genericError := &smithy.GenericAPIError{
2292			Code:    errorCode,
2293			Message: errorMessage,
2294		}
2295		return genericError
2296
2297	}
2298}
2299
2300type awsAwsjson11_deserializeOpCreateDiskSnapshot struct {
2301}
2302
2303func (*awsAwsjson11_deserializeOpCreateDiskSnapshot) ID() string {
2304	return "OperationDeserializer"
2305}
2306
2307func (m *awsAwsjson11_deserializeOpCreateDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2308	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2309) {
2310	out, metadata, err = next.HandleDeserialize(ctx, in)
2311	if err != nil {
2312		return out, metadata, err
2313	}
2314
2315	response, ok := out.RawResponse.(*smithyhttp.Response)
2316	if !ok {
2317		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2318	}
2319
2320	if response.StatusCode < 200 || response.StatusCode >= 300 {
2321		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response, &metadata)
2322	}
2323	output := &CreateDiskSnapshotOutput{}
2324	out.Result = output
2325
2326	var buff [1024]byte
2327	ringBuffer := smithyio.NewRingBuffer(buff[:])
2328
2329	body := io.TeeReader(response.Body, ringBuffer)
2330	decoder := json.NewDecoder(body)
2331	decoder.UseNumber()
2332	var shape interface{}
2333	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2334		var snapshot bytes.Buffer
2335		io.Copy(&snapshot, ringBuffer)
2336		err = &smithy.DeserializationError{
2337			Err:      fmt.Errorf("failed to decode response body, %w", err),
2338			Snapshot: snapshot.Bytes(),
2339		}
2340		return out, metadata, err
2341	}
2342
2343	err = awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(&output, shape)
2344	if err != nil {
2345		var snapshot bytes.Buffer
2346		io.Copy(&snapshot, ringBuffer)
2347		err = &smithy.DeserializationError{
2348			Err:      fmt.Errorf("failed to decode response body, %w", err),
2349			Snapshot: snapshot.Bytes(),
2350		}
2351		return out, metadata, err
2352	}
2353
2354	return out, metadata, err
2355}
2356
2357func awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2358	var errorBuffer bytes.Buffer
2359	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2360		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2361	}
2362	errorBody := bytes.NewReader(errorBuffer.Bytes())
2363
2364	errorCode := "UnknownError"
2365	errorMessage := errorCode
2366
2367	code := response.Header.Get("X-Amzn-ErrorType")
2368	if len(code) != 0 {
2369		errorCode = restjson.SanitizeErrorCode(code)
2370	}
2371
2372	var buff [1024]byte
2373	ringBuffer := smithyio.NewRingBuffer(buff[:])
2374
2375	body := io.TeeReader(errorBody, ringBuffer)
2376	decoder := json.NewDecoder(body)
2377	decoder.UseNumber()
2378	code, message, err := restjson.GetErrorInfo(decoder)
2379	if err != nil {
2380		var snapshot bytes.Buffer
2381		io.Copy(&snapshot, ringBuffer)
2382		err = &smithy.DeserializationError{
2383			Err:      fmt.Errorf("failed to decode response body, %w", err),
2384			Snapshot: snapshot.Bytes(),
2385		}
2386		return err
2387	}
2388
2389	errorBody.Seek(0, io.SeekStart)
2390	if len(code) != 0 {
2391		errorCode = restjson.SanitizeErrorCode(code)
2392	}
2393	if len(message) != 0 {
2394		errorMessage = message
2395	}
2396
2397	switch {
2398	case strings.EqualFold("AccessDeniedException", errorCode):
2399		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2400
2401	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2402		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2403
2404	case strings.EqualFold("InvalidInputException", errorCode):
2405		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2406
2407	case strings.EqualFold("NotFoundException", errorCode):
2408		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2409
2410	case strings.EqualFold("OperationFailureException", errorCode):
2411		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2412
2413	case strings.EqualFold("ServiceException", errorCode):
2414		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2415
2416	case strings.EqualFold("UnauthenticatedException", errorCode):
2417		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2418
2419	default:
2420		genericError := &smithy.GenericAPIError{
2421			Code:    errorCode,
2422			Message: errorMessage,
2423		}
2424		return genericError
2425
2426	}
2427}
2428
2429type awsAwsjson11_deserializeOpCreateDistribution struct {
2430}
2431
2432func (*awsAwsjson11_deserializeOpCreateDistribution) ID() string {
2433	return "OperationDeserializer"
2434}
2435
2436func (m *awsAwsjson11_deserializeOpCreateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2437	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2438) {
2439	out, metadata, err = next.HandleDeserialize(ctx, in)
2440	if err != nil {
2441		return out, metadata, err
2442	}
2443
2444	response, ok := out.RawResponse.(*smithyhttp.Response)
2445	if !ok {
2446		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2447	}
2448
2449	if response.StatusCode < 200 || response.StatusCode >= 300 {
2450		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDistribution(response, &metadata)
2451	}
2452	output := &CreateDistributionOutput{}
2453	out.Result = output
2454
2455	var buff [1024]byte
2456	ringBuffer := smithyio.NewRingBuffer(buff[:])
2457
2458	body := io.TeeReader(response.Body, ringBuffer)
2459	decoder := json.NewDecoder(body)
2460	decoder.UseNumber()
2461	var shape interface{}
2462	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2463		var snapshot bytes.Buffer
2464		io.Copy(&snapshot, ringBuffer)
2465		err = &smithy.DeserializationError{
2466			Err:      fmt.Errorf("failed to decode response body, %w", err),
2467			Snapshot: snapshot.Bytes(),
2468		}
2469		return out, metadata, err
2470	}
2471
2472	err = awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(&output, shape)
2473	if err != nil {
2474		var snapshot bytes.Buffer
2475		io.Copy(&snapshot, ringBuffer)
2476		err = &smithy.DeserializationError{
2477			Err:      fmt.Errorf("failed to decode response body, %w", err),
2478			Snapshot: snapshot.Bytes(),
2479		}
2480		return out, metadata, err
2481	}
2482
2483	return out, metadata, err
2484}
2485
2486func awsAwsjson11_deserializeOpErrorCreateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2487	var errorBuffer bytes.Buffer
2488	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2489		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2490	}
2491	errorBody := bytes.NewReader(errorBuffer.Bytes())
2492
2493	errorCode := "UnknownError"
2494	errorMessage := errorCode
2495
2496	code := response.Header.Get("X-Amzn-ErrorType")
2497	if len(code) != 0 {
2498		errorCode = restjson.SanitizeErrorCode(code)
2499	}
2500
2501	var buff [1024]byte
2502	ringBuffer := smithyio.NewRingBuffer(buff[:])
2503
2504	body := io.TeeReader(errorBody, ringBuffer)
2505	decoder := json.NewDecoder(body)
2506	decoder.UseNumber()
2507	code, message, err := restjson.GetErrorInfo(decoder)
2508	if err != nil {
2509		var snapshot bytes.Buffer
2510		io.Copy(&snapshot, ringBuffer)
2511		err = &smithy.DeserializationError{
2512			Err:      fmt.Errorf("failed to decode response body, %w", err),
2513			Snapshot: snapshot.Bytes(),
2514		}
2515		return err
2516	}
2517
2518	errorBody.Seek(0, io.SeekStart)
2519	if len(code) != 0 {
2520		errorCode = restjson.SanitizeErrorCode(code)
2521	}
2522	if len(message) != 0 {
2523		errorMessage = message
2524	}
2525
2526	switch {
2527	case strings.EqualFold("AccessDeniedException", errorCode):
2528		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2529
2530	case strings.EqualFold("InvalidInputException", errorCode):
2531		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2532
2533	case strings.EqualFold("NotFoundException", errorCode):
2534		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2535
2536	case strings.EqualFold("OperationFailureException", errorCode):
2537		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2538
2539	case strings.EqualFold("ServiceException", errorCode):
2540		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2541
2542	case strings.EqualFold("UnauthenticatedException", errorCode):
2543		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2544
2545	default:
2546		genericError := &smithy.GenericAPIError{
2547			Code:    errorCode,
2548			Message: errorMessage,
2549		}
2550		return genericError
2551
2552	}
2553}
2554
2555type awsAwsjson11_deserializeOpCreateDomain struct {
2556}
2557
2558func (*awsAwsjson11_deserializeOpCreateDomain) ID() string {
2559	return "OperationDeserializer"
2560}
2561
2562func (m *awsAwsjson11_deserializeOpCreateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2563	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2564) {
2565	out, metadata, err = next.HandleDeserialize(ctx, in)
2566	if err != nil {
2567		return out, metadata, err
2568	}
2569
2570	response, ok := out.RawResponse.(*smithyhttp.Response)
2571	if !ok {
2572		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2573	}
2574
2575	if response.StatusCode < 200 || response.StatusCode >= 300 {
2576		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomain(response, &metadata)
2577	}
2578	output := &CreateDomainOutput{}
2579	out.Result = output
2580
2581	var buff [1024]byte
2582	ringBuffer := smithyio.NewRingBuffer(buff[:])
2583
2584	body := io.TeeReader(response.Body, ringBuffer)
2585	decoder := json.NewDecoder(body)
2586	decoder.UseNumber()
2587	var shape interface{}
2588	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2589		var snapshot bytes.Buffer
2590		io.Copy(&snapshot, ringBuffer)
2591		err = &smithy.DeserializationError{
2592			Err:      fmt.Errorf("failed to decode response body, %w", err),
2593			Snapshot: snapshot.Bytes(),
2594		}
2595		return out, metadata, err
2596	}
2597
2598	err = awsAwsjson11_deserializeOpDocumentCreateDomainOutput(&output, shape)
2599	if err != nil {
2600		var snapshot bytes.Buffer
2601		io.Copy(&snapshot, ringBuffer)
2602		err = &smithy.DeserializationError{
2603			Err:      fmt.Errorf("failed to decode response body, %w", err),
2604			Snapshot: snapshot.Bytes(),
2605		}
2606		return out, metadata, err
2607	}
2608
2609	return out, metadata, err
2610}
2611
2612func awsAwsjson11_deserializeOpErrorCreateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2613	var errorBuffer bytes.Buffer
2614	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2615		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2616	}
2617	errorBody := bytes.NewReader(errorBuffer.Bytes())
2618
2619	errorCode := "UnknownError"
2620	errorMessage := errorCode
2621
2622	code := response.Header.Get("X-Amzn-ErrorType")
2623	if len(code) != 0 {
2624		errorCode = restjson.SanitizeErrorCode(code)
2625	}
2626
2627	var buff [1024]byte
2628	ringBuffer := smithyio.NewRingBuffer(buff[:])
2629
2630	body := io.TeeReader(errorBody, ringBuffer)
2631	decoder := json.NewDecoder(body)
2632	decoder.UseNumber()
2633	code, message, err := restjson.GetErrorInfo(decoder)
2634	if err != nil {
2635		var snapshot bytes.Buffer
2636		io.Copy(&snapshot, ringBuffer)
2637		err = &smithy.DeserializationError{
2638			Err:      fmt.Errorf("failed to decode response body, %w", err),
2639			Snapshot: snapshot.Bytes(),
2640		}
2641		return err
2642	}
2643
2644	errorBody.Seek(0, io.SeekStart)
2645	if len(code) != 0 {
2646		errorCode = restjson.SanitizeErrorCode(code)
2647	}
2648	if len(message) != 0 {
2649		errorMessage = message
2650	}
2651
2652	switch {
2653	case strings.EqualFold("AccessDeniedException", errorCode):
2654		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2655
2656	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2657		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2658
2659	case strings.EqualFold("InvalidInputException", errorCode):
2660		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2661
2662	case strings.EqualFold("NotFoundException", errorCode):
2663		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2664
2665	case strings.EqualFold("OperationFailureException", errorCode):
2666		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2667
2668	case strings.EqualFold("ServiceException", errorCode):
2669		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2670
2671	case strings.EqualFold("UnauthenticatedException", errorCode):
2672		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2673
2674	default:
2675		genericError := &smithy.GenericAPIError{
2676			Code:    errorCode,
2677			Message: errorMessage,
2678		}
2679		return genericError
2680
2681	}
2682}
2683
2684type awsAwsjson11_deserializeOpCreateDomainEntry struct {
2685}
2686
2687func (*awsAwsjson11_deserializeOpCreateDomainEntry) ID() string {
2688	return "OperationDeserializer"
2689}
2690
2691func (m *awsAwsjson11_deserializeOpCreateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2692	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2693) {
2694	out, metadata, err = next.HandleDeserialize(ctx, in)
2695	if err != nil {
2696		return out, metadata, err
2697	}
2698
2699	response, ok := out.RawResponse.(*smithyhttp.Response)
2700	if !ok {
2701		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2702	}
2703
2704	if response.StatusCode < 200 || response.StatusCode >= 300 {
2705		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomainEntry(response, &metadata)
2706	}
2707	output := &CreateDomainEntryOutput{}
2708	out.Result = output
2709
2710	var buff [1024]byte
2711	ringBuffer := smithyio.NewRingBuffer(buff[:])
2712
2713	body := io.TeeReader(response.Body, ringBuffer)
2714	decoder := json.NewDecoder(body)
2715	decoder.UseNumber()
2716	var shape interface{}
2717	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2718		var snapshot bytes.Buffer
2719		io.Copy(&snapshot, ringBuffer)
2720		err = &smithy.DeserializationError{
2721			Err:      fmt.Errorf("failed to decode response body, %w", err),
2722			Snapshot: snapshot.Bytes(),
2723		}
2724		return out, metadata, err
2725	}
2726
2727	err = awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(&output, shape)
2728	if err != nil {
2729		var snapshot bytes.Buffer
2730		io.Copy(&snapshot, ringBuffer)
2731		err = &smithy.DeserializationError{
2732			Err:      fmt.Errorf("failed to decode response body, %w", err),
2733			Snapshot: snapshot.Bytes(),
2734		}
2735		return out, metadata, err
2736	}
2737
2738	return out, metadata, err
2739}
2740
2741func awsAwsjson11_deserializeOpErrorCreateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2742	var errorBuffer bytes.Buffer
2743	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2744		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2745	}
2746	errorBody := bytes.NewReader(errorBuffer.Bytes())
2747
2748	errorCode := "UnknownError"
2749	errorMessage := errorCode
2750
2751	code := response.Header.Get("X-Amzn-ErrorType")
2752	if len(code) != 0 {
2753		errorCode = restjson.SanitizeErrorCode(code)
2754	}
2755
2756	var buff [1024]byte
2757	ringBuffer := smithyio.NewRingBuffer(buff[:])
2758
2759	body := io.TeeReader(errorBody, ringBuffer)
2760	decoder := json.NewDecoder(body)
2761	decoder.UseNumber()
2762	code, message, err := restjson.GetErrorInfo(decoder)
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 err
2771	}
2772
2773	errorBody.Seek(0, io.SeekStart)
2774	if len(code) != 0 {
2775		errorCode = restjson.SanitizeErrorCode(code)
2776	}
2777	if len(message) != 0 {
2778		errorMessage = message
2779	}
2780
2781	switch {
2782	case strings.EqualFold("AccessDeniedException", errorCode):
2783		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2784
2785	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2786		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2787
2788	case strings.EqualFold("InvalidInputException", errorCode):
2789		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2790
2791	case strings.EqualFold("NotFoundException", errorCode):
2792		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2793
2794	case strings.EqualFold("OperationFailureException", errorCode):
2795		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2796
2797	case strings.EqualFold("ServiceException", errorCode):
2798		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2799
2800	case strings.EqualFold("UnauthenticatedException", errorCode):
2801		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2802
2803	default:
2804		genericError := &smithy.GenericAPIError{
2805			Code:    errorCode,
2806			Message: errorMessage,
2807		}
2808		return genericError
2809
2810	}
2811}
2812
2813type awsAwsjson11_deserializeOpCreateInstances struct {
2814}
2815
2816func (*awsAwsjson11_deserializeOpCreateInstances) ID() string {
2817	return "OperationDeserializer"
2818}
2819
2820func (m *awsAwsjson11_deserializeOpCreateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2821	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2822) {
2823	out, metadata, err = next.HandleDeserialize(ctx, in)
2824	if err != nil {
2825		return out, metadata, err
2826	}
2827
2828	response, ok := out.RawResponse.(*smithyhttp.Response)
2829	if !ok {
2830		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2831	}
2832
2833	if response.StatusCode < 200 || response.StatusCode >= 300 {
2834		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstances(response, &metadata)
2835	}
2836	output := &CreateInstancesOutput{}
2837	out.Result = output
2838
2839	var buff [1024]byte
2840	ringBuffer := smithyio.NewRingBuffer(buff[:])
2841
2842	body := io.TeeReader(response.Body, ringBuffer)
2843	decoder := json.NewDecoder(body)
2844	decoder.UseNumber()
2845	var shape interface{}
2846	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2847		var snapshot bytes.Buffer
2848		io.Copy(&snapshot, ringBuffer)
2849		err = &smithy.DeserializationError{
2850			Err:      fmt.Errorf("failed to decode response body, %w", err),
2851			Snapshot: snapshot.Bytes(),
2852		}
2853		return out, metadata, err
2854	}
2855
2856	err = awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(&output, shape)
2857	if err != nil {
2858		var snapshot bytes.Buffer
2859		io.Copy(&snapshot, ringBuffer)
2860		err = &smithy.DeserializationError{
2861			Err:      fmt.Errorf("failed to decode response body, %w", err),
2862			Snapshot: snapshot.Bytes(),
2863		}
2864		return out, metadata, err
2865	}
2866
2867	return out, metadata, err
2868}
2869
2870func awsAwsjson11_deserializeOpErrorCreateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2871	var errorBuffer bytes.Buffer
2872	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2873		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2874	}
2875	errorBody := bytes.NewReader(errorBuffer.Bytes())
2876
2877	errorCode := "UnknownError"
2878	errorMessage := errorCode
2879
2880	code := response.Header.Get("X-Amzn-ErrorType")
2881	if len(code) != 0 {
2882		errorCode = restjson.SanitizeErrorCode(code)
2883	}
2884
2885	var buff [1024]byte
2886	ringBuffer := smithyio.NewRingBuffer(buff[:])
2887
2888	body := io.TeeReader(errorBody, ringBuffer)
2889	decoder := json.NewDecoder(body)
2890	decoder.UseNumber()
2891	code, message, err := restjson.GetErrorInfo(decoder)
2892	if err != nil {
2893		var snapshot bytes.Buffer
2894		io.Copy(&snapshot, ringBuffer)
2895		err = &smithy.DeserializationError{
2896			Err:      fmt.Errorf("failed to decode response body, %w", err),
2897			Snapshot: snapshot.Bytes(),
2898		}
2899		return err
2900	}
2901
2902	errorBody.Seek(0, io.SeekStart)
2903	if len(code) != 0 {
2904		errorCode = restjson.SanitizeErrorCode(code)
2905	}
2906	if len(message) != 0 {
2907		errorMessage = message
2908	}
2909
2910	switch {
2911	case strings.EqualFold("AccessDeniedException", errorCode):
2912		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2913
2914	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2915		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2916
2917	case strings.EqualFold("InvalidInputException", errorCode):
2918		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2919
2920	case strings.EqualFold("NotFoundException", errorCode):
2921		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2922
2923	case strings.EqualFold("OperationFailureException", errorCode):
2924		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2925
2926	case strings.EqualFold("ServiceException", errorCode):
2927		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2928
2929	case strings.EqualFold("UnauthenticatedException", errorCode):
2930		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2931
2932	default:
2933		genericError := &smithy.GenericAPIError{
2934			Code:    errorCode,
2935			Message: errorMessage,
2936		}
2937		return genericError
2938
2939	}
2940}
2941
2942type awsAwsjson11_deserializeOpCreateInstancesFromSnapshot struct {
2943}
2944
2945func (*awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) ID() string {
2946	return "OperationDeserializer"
2947}
2948
2949func (m *awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2950	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2951) {
2952	out, metadata, err = next.HandleDeserialize(ctx, in)
2953	if err != nil {
2954		return out, metadata, err
2955	}
2956
2957	response, ok := out.RawResponse.(*smithyhttp.Response)
2958	if !ok {
2959		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2960	}
2961
2962	if response.StatusCode < 200 || response.StatusCode >= 300 {
2963		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response, &metadata)
2964	}
2965	output := &CreateInstancesFromSnapshotOutput{}
2966	out.Result = output
2967
2968	var buff [1024]byte
2969	ringBuffer := smithyio.NewRingBuffer(buff[:])
2970
2971	body := io.TeeReader(response.Body, ringBuffer)
2972	decoder := json.NewDecoder(body)
2973	decoder.UseNumber()
2974	var shape interface{}
2975	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2976		var snapshot bytes.Buffer
2977		io.Copy(&snapshot, ringBuffer)
2978		err = &smithy.DeserializationError{
2979			Err:      fmt.Errorf("failed to decode response body, %w", err),
2980			Snapshot: snapshot.Bytes(),
2981		}
2982		return out, metadata, err
2983	}
2984
2985	err = awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(&output, shape)
2986	if err != nil {
2987		var snapshot bytes.Buffer
2988		io.Copy(&snapshot, ringBuffer)
2989		err = &smithy.DeserializationError{
2990			Err:      fmt.Errorf("failed to decode response body, %w", err),
2991			Snapshot: snapshot.Bytes(),
2992		}
2993		return out, metadata, err
2994	}
2995
2996	return out, metadata, err
2997}
2998
2999func awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3000	var errorBuffer bytes.Buffer
3001	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3002		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3003	}
3004	errorBody := bytes.NewReader(errorBuffer.Bytes())
3005
3006	errorCode := "UnknownError"
3007	errorMessage := errorCode
3008
3009	code := response.Header.Get("X-Amzn-ErrorType")
3010	if len(code) != 0 {
3011		errorCode = restjson.SanitizeErrorCode(code)
3012	}
3013
3014	var buff [1024]byte
3015	ringBuffer := smithyio.NewRingBuffer(buff[:])
3016
3017	body := io.TeeReader(errorBody, ringBuffer)
3018	decoder := json.NewDecoder(body)
3019	decoder.UseNumber()
3020	code, message, err := restjson.GetErrorInfo(decoder)
3021	if err != nil {
3022		var snapshot bytes.Buffer
3023		io.Copy(&snapshot, ringBuffer)
3024		err = &smithy.DeserializationError{
3025			Err:      fmt.Errorf("failed to decode response body, %w", err),
3026			Snapshot: snapshot.Bytes(),
3027		}
3028		return err
3029	}
3030
3031	errorBody.Seek(0, io.SeekStart)
3032	if len(code) != 0 {
3033		errorCode = restjson.SanitizeErrorCode(code)
3034	}
3035	if len(message) != 0 {
3036		errorMessage = message
3037	}
3038
3039	switch {
3040	case strings.EqualFold("AccessDeniedException", errorCode):
3041		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3042
3043	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3044		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3045
3046	case strings.EqualFold("InvalidInputException", errorCode):
3047		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3048
3049	case strings.EqualFold("NotFoundException", errorCode):
3050		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3051
3052	case strings.EqualFold("OperationFailureException", errorCode):
3053		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3054
3055	case strings.EqualFold("ServiceException", errorCode):
3056		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3057
3058	case strings.EqualFold("UnauthenticatedException", errorCode):
3059		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3060
3061	default:
3062		genericError := &smithy.GenericAPIError{
3063			Code:    errorCode,
3064			Message: errorMessage,
3065		}
3066		return genericError
3067
3068	}
3069}
3070
3071type awsAwsjson11_deserializeOpCreateInstanceSnapshot struct {
3072}
3073
3074func (*awsAwsjson11_deserializeOpCreateInstanceSnapshot) ID() string {
3075	return "OperationDeserializer"
3076}
3077
3078func (m *awsAwsjson11_deserializeOpCreateInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3079	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3080) {
3081	out, metadata, err = next.HandleDeserialize(ctx, in)
3082	if err != nil {
3083		return out, metadata, err
3084	}
3085
3086	response, ok := out.RawResponse.(*smithyhttp.Response)
3087	if !ok {
3088		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3089	}
3090
3091	if response.StatusCode < 200 || response.StatusCode >= 300 {
3092		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response, &metadata)
3093	}
3094	output := &CreateInstanceSnapshotOutput{}
3095	out.Result = output
3096
3097	var buff [1024]byte
3098	ringBuffer := smithyio.NewRingBuffer(buff[:])
3099
3100	body := io.TeeReader(response.Body, ringBuffer)
3101	decoder := json.NewDecoder(body)
3102	decoder.UseNumber()
3103	var shape interface{}
3104	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3105		var snapshot bytes.Buffer
3106		io.Copy(&snapshot, ringBuffer)
3107		err = &smithy.DeserializationError{
3108			Err:      fmt.Errorf("failed to decode response body, %w", err),
3109			Snapshot: snapshot.Bytes(),
3110		}
3111		return out, metadata, err
3112	}
3113
3114	err = awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(&output, shape)
3115	if err != nil {
3116		var snapshot bytes.Buffer
3117		io.Copy(&snapshot, ringBuffer)
3118		err = &smithy.DeserializationError{
3119			Err:      fmt.Errorf("failed to decode response body, %w", err),
3120			Snapshot: snapshot.Bytes(),
3121		}
3122		return out, metadata, err
3123	}
3124
3125	return out, metadata, err
3126}
3127
3128func awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3129	var errorBuffer bytes.Buffer
3130	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3131		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3132	}
3133	errorBody := bytes.NewReader(errorBuffer.Bytes())
3134
3135	errorCode := "UnknownError"
3136	errorMessage := errorCode
3137
3138	code := response.Header.Get("X-Amzn-ErrorType")
3139	if len(code) != 0 {
3140		errorCode = restjson.SanitizeErrorCode(code)
3141	}
3142
3143	var buff [1024]byte
3144	ringBuffer := smithyio.NewRingBuffer(buff[:])
3145
3146	body := io.TeeReader(errorBody, ringBuffer)
3147	decoder := json.NewDecoder(body)
3148	decoder.UseNumber()
3149	code, message, err := restjson.GetErrorInfo(decoder)
3150	if err != nil {
3151		var snapshot bytes.Buffer
3152		io.Copy(&snapshot, ringBuffer)
3153		err = &smithy.DeserializationError{
3154			Err:      fmt.Errorf("failed to decode response body, %w", err),
3155			Snapshot: snapshot.Bytes(),
3156		}
3157		return err
3158	}
3159
3160	errorBody.Seek(0, io.SeekStart)
3161	if len(code) != 0 {
3162		errorCode = restjson.SanitizeErrorCode(code)
3163	}
3164	if len(message) != 0 {
3165		errorMessage = message
3166	}
3167
3168	switch {
3169	case strings.EqualFold("AccessDeniedException", errorCode):
3170		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3171
3172	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3173		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3174
3175	case strings.EqualFold("InvalidInputException", errorCode):
3176		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3177
3178	case strings.EqualFold("NotFoundException", errorCode):
3179		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3180
3181	case strings.EqualFold("OperationFailureException", errorCode):
3182		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3183
3184	case strings.EqualFold("ServiceException", errorCode):
3185		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3186
3187	case strings.EqualFold("UnauthenticatedException", errorCode):
3188		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3189
3190	default:
3191		genericError := &smithy.GenericAPIError{
3192			Code:    errorCode,
3193			Message: errorMessage,
3194		}
3195		return genericError
3196
3197	}
3198}
3199
3200type awsAwsjson11_deserializeOpCreateKeyPair struct {
3201}
3202
3203func (*awsAwsjson11_deserializeOpCreateKeyPair) ID() string {
3204	return "OperationDeserializer"
3205}
3206
3207func (m *awsAwsjson11_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3208	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3209) {
3210	out, metadata, err = next.HandleDeserialize(ctx, in)
3211	if err != nil {
3212		return out, metadata, err
3213	}
3214
3215	response, ok := out.RawResponse.(*smithyhttp.Response)
3216	if !ok {
3217		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3218	}
3219
3220	if response.StatusCode < 200 || response.StatusCode >= 300 {
3221		return out, metadata, awsAwsjson11_deserializeOpErrorCreateKeyPair(response, &metadata)
3222	}
3223	output := &CreateKeyPairOutput{}
3224	out.Result = output
3225
3226	var buff [1024]byte
3227	ringBuffer := smithyio.NewRingBuffer(buff[:])
3228
3229	body := io.TeeReader(response.Body, ringBuffer)
3230	decoder := json.NewDecoder(body)
3231	decoder.UseNumber()
3232	var shape interface{}
3233	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3234		var snapshot bytes.Buffer
3235		io.Copy(&snapshot, ringBuffer)
3236		err = &smithy.DeserializationError{
3237			Err:      fmt.Errorf("failed to decode response body, %w", err),
3238			Snapshot: snapshot.Bytes(),
3239		}
3240		return out, metadata, err
3241	}
3242
3243	err = awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(&output, shape)
3244	if err != nil {
3245		var snapshot bytes.Buffer
3246		io.Copy(&snapshot, ringBuffer)
3247		err = &smithy.DeserializationError{
3248			Err:      fmt.Errorf("failed to decode response body, %w", err),
3249			Snapshot: snapshot.Bytes(),
3250		}
3251		return out, metadata, err
3252	}
3253
3254	return out, metadata, err
3255}
3256
3257func awsAwsjson11_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3258	var errorBuffer bytes.Buffer
3259	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3260		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3261	}
3262	errorBody := bytes.NewReader(errorBuffer.Bytes())
3263
3264	errorCode := "UnknownError"
3265	errorMessage := errorCode
3266
3267	code := response.Header.Get("X-Amzn-ErrorType")
3268	if len(code) != 0 {
3269		errorCode = restjson.SanitizeErrorCode(code)
3270	}
3271
3272	var buff [1024]byte
3273	ringBuffer := smithyio.NewRingBuffer(buff[:])
3274
3275	body := io.TeeReader(errorBody, ringBuffer)
3276	decoder := json.NewDecoder(body)
3277	decoder.UseNumber()
3278	code, message, err := restjson.GetErrorInfo(decoder)
3279	if err != nil {
3280		var snapshot bytes.Buffer
3281		io.Copy(&snapshot, ringBuffer)
3282		err = &smithy.DeserializationError{
3283			Err:      fmt.Errorf("failed to decode response body, %w", err),
3284			Snapshot: snapshot.Bytes(),
3285		}
3286		return err
3287	}
3288
3289	errorBody.Seek(0, io.SeekStart)
3290	if len(code) != 0 {
3291		errorCode = restjson.SanitizeErrorCode(code)
3292	}
3293	if len(message) != 0 {
3294		errorMessage = message
3295	}
3296
3297	switch {
3298	case strings.EqualFold("AccessDeniedException", errorCode):
3299		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3300
3301	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3302		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3303
3304	case strings.EqualFold("InvalidInputException", errorCode):
3305		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3306
3307	case strings.EqualFold("NotFoundException", errorCode):
3308		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3309
3310	case strings.EqualFold("OperationFailureException", errorCode):
3311		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3312
3313	case strings.EqualFold("ServiceException", errorCode):
3314		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3315
3316	case strings.EqualFold("UnauthenticatedException", errorCode):
3317		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3318
3319	default:
3320		genericError := &smithy.GenericAPIError{
3321			Code:    errorCode,
3322			Message: errorMessage,
3323		}
3324		return genericError
3325
3326	}
3327}
3328
3329type awsAwsjson11_deserializeOpCreateLoadBalancer struct {
3330}
3331
3332func (*awsAwsjson11_deserializeOpCreateLoadBalancer) ID() string {
3333	return "OperationDeserializer"
3334}
3335
3336func (m *awsAwsjson11_deserializeOpCreateLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3337	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3338) {
3339	out, metadata, err = next.HandleDeserialize(ctx, in)
3340	if err != nil {
3341		return out, metadata, err
3342	}
3343
3344	response, ok := out.RawResponse.(*smithyhttp.Response)
3345	if !ok {
3346		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3347	}
3348
3349	if response.StatusCode < 200 || response.StatusCode >= 300 {
3350		return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response, &metadata)
3351	}
3352	output := &CreateLoadBalancerOutput{}
3353	out.Result = output
3354
3355	var buff [1024]byte
3356	ringBuffer := smithyio.NewRingBuffer(buff[:])
3357
3358	body := io.TeeReader(response.Body, ringBuffer)
3359	decoder := json.NewDecoder(body)
3360	decoder.UseNumber()
3361	var shape interface{}
3362	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
3370	}
3371
3372	err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(&output, shape)
3373	if err != nil {
3374		var snapshot bytes.Buffer
3375		io.Copy(&snapshot, ringBuffer)
3376		err = &smithy.DeserializationError{
3377			Err:      fmt.Errorf("failed to decode response body, %w", err),
3378			Snapshot: snapshot.Bytes(),
3379		}
3380		return out, metadata, err
3381	}
3382
3383	return out, metadata, err
3384}
3385
3386func awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3387	var errorBuffer bytes.Buffer
3388	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3389		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3390	}
3391	errorBody := bytes.NewReader(errorBuffer.Bytes())
3392
3393	errorCode := "UnknownError"
3394	errorMessage := errorCode
3395
3396	code := response.Header.Get("X-Amzn-ErrorType")
3397	if len(code) != 0 {
3398		errorCode = restjson.SanitizeErrorCode(code)
3399	}
3400
3401	var buff [1024]byte
3402	ringBuffer := smithyio.NewRingBuffer(buff[:])
3403
3404	body := io.TeeReader(errorBody, ringBuffer)
3405	decoder := json.NewDecoder(body)
3406	decoder.UseNumber()
3407	code, message, err := restjson.GetErrorInfo(decoder)
3408	if err != nil {
3409		var snapshot bytes.Buffer
3410		io.Copy(&snapshot, ringBuffer)
3411		err = &smithy.DeserializationError{
3412			Err:      fmt.Errorf("failed to decode response body, %w", err),
3413			Snapshot: snapshot.Bytes(),
3414		}
3415		return err
3416	}
3417
3418	errorBody.Seek(0, io.SeekStart)
3419	if len(code) != 0 {
3420		errorCode = restjson.SanitizeErrorCode(code)
3421	}
3422	if len(message) != 0 {
3423		errorMessage = message
3424	}
3425
3426	switch {
3427	case strings.EqualFold("AccessDeniedException", errorCode):
3428		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3429
3430	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3431		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3432
3433	case strings.EqualFold("InvalidInputException", errorCode):
3434		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3435
3436	case strings.EqualFold("NotFoundException", errorCode):
3437		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3438
3439	case strings.EqualFold("OperationFailureException", errorCode):
3440		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3441
3442	case strings.EqualFold("ServiceException", errorCode):
3443		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3444
3445	case strings.EqualFold("UnauthenticatedException", errorCode):
3446		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3447
3448	default:
3449		genericError := &smithy.GenericAPIError{
3450			Code:    errorCode,
3451			Message: errorMessage,
3452		}
3453		return genericError
3454
3455	}
3456}
3457
3458type awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate struct {
3459}
3460
3461func (*awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) ID() string {
3462	return "OperationDeserializer"
3463}
3464
3465func (m *awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3466	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3467) {
3468	out, metadata, err = next.HandleDeserialize(ctx, in)
3469	if err != nil {
3470		return out, metadata, err
3471	}
3472
3473	response, ok := out.RawResponse.(*smithyhttp.Response)
3474	if !ok {
3475		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3476	}
3477
3478	if response.StatusCode < 200 || response.StatusCode >= 300 {
3479		return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response, &metadata)
3480	}
3481	output := &CreateLoadBalancerTlsCertificateOutput{}
3482	out.Result = output
3483
3484	var buff [1024]byte
3485	ringBuffer := smithyio.NewRingBuffer(buff[:])
3486
3487	body := io.TeeReader(response.Body, ringBuffer)
3488	decoder := json.NewDecoder(body)
3489	decoder.UseNumber()
3490	var shape interface{}
3491	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3492		var snapshot bytes.Buffer
3493		io.Copy(&snapshot, ringBuffer)
3494		err = &smithy.DeserializationError{
3495			Err:      fmt.Errorf("failed to decode response body, %w", err),
3496			Snapshot: snapshot.Bytes(),
3497		}
3498		return out, metadata, err
3499	}
3500
3501	err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(&output, shape)
3502	if err != nil {
3503		var snapshot bytes.Buffer
3504		io.Copy(&snapshot, ringBuffer)
3505		err = &smithy.DeserializationError{
3506			Err:      fmt.Errorf("failed to decode response body, %w", err),
3507			Snapshot: snapshot.Bytes(),
3508		}
3509		return out, metadata, err
3510	}
3511
3512	return out, metadata, err
3513}
3514
3515func awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3516	var errorBuffer bytes.Buffer
3517	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3518		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3519	}
3520	errorBody := bytes.NewReader(errorBuffer.Bytes())
3521
3522	errorCode := "UnknownError"
3523	errorMessage := errorCode
3524
3525	code := response.Header.Get("X-Amzn-ErrorType")
3526	if len(code) != 0 {
3527		errorCode = restjson.SanitizeErrorCode(code)
3528	}
3529
3530	var buff [1024]byte
3531	ringBuffer := smithyio.NewRingBuffer(buff[:])
3532
3533	body := io.TeeReader(errorBody, ringBuffer)
3534	decoder := json.NewDecoder(body)
3535	decoder.UseNumber()
3536	code, message, err := restjson.GetErrorInfo(decoder)
3537	if err != nil {
3538		var snapshot bytes.Buffer
3539		io.Copy(&snapshot, ringBuffer)
3540		err = &smithy.DeserializationError{
3541			Err:      fmt.Errorf("failed to decode response body, %w", err),
3542			Snapshot: snapshot.Bytes(),
3543		}
3544		return err
3545	}
3546
3547	errorBody.Seek(0, io.SeekStart)
3548	if len(code) != 0 {
3549		errorCode = restjson.SanitizeErrorCode(code)
3550	}
3551	if len(message) != 0 {
3552		errorMessage = message
3553	}
3554
3555	switch {
3556	case strings.EqualFold("AccessDeniedException", errorCode):
3557		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3558
3559	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3560		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3561
3562	case strings.EqualFold("InvalidInputException", errorCode):
3563		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3564
3565	case strings.EqualFold("NotFoundException", errorCode):
3566		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3567
3568	case strings.EqualFold("OperationFailureException", errorCode):
3569		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3570
3571	case strings.EqualFold("ServiceException", errorCode):
3572		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3573
3574	case strings.EqualFold("UnauthenticatedException", errorCode):
3575		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3576
3577	default:
3578		genericError := &smithy.GenericAPIError{
3579			Code:    errorCode,
3580			Message: errorMessage,
3581		}
3582		return genericError
3583
3584	}
3585}
3586
3587type awsAwsjson11_deserializeOpCreateRelationalDatabase struct {
3588}
3589
3590func (*awsAwsjson11_deserializeOpCreateRelationalDatabase) ID() string {
3591	return "OperationDeserializer"
3592}
3593
3594func (m *awsAwsjson11_deserializeOpCreateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3595	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3596) {
3597	out, metadata, err = next.HandleDeserialize(ctx, in)
3598	if err != nil {
3599		return out, metadata, err
3600	}
3601
3602	response, ok := out.RawResponse.(*smithyhttp.Response)
3603	if !ok {
3604		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3605	}
3606
3607	if response.StatusCode < 200 || response.StatusCode >= 300 {
3608		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response, &metadata)
3609	}
3610	output := &CreateRelationalDatabaseOutput{}
3611	out.Result = output
3612
3613	var buff [1024]byte
3614	ringBuffer := smithyio.NewRingBuffer(buff[:])
3615
3616	body := io.TeeReader(response.Body, ringBuffer)
3617	decoder := json.NewDecoder(body)
3618	decoder.UseNumber()
3619	var shape interface{}
3620	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3621		var snapshot bytes.Buffer
3622		io.Copy(&snapshot, ringBuffer)
3623		err = &smithy.DeserializationError{
3624			Err:      fmt.Errorf("failed to decode response body, %w", err),
3625			Snapshot: snapshot.Bytes(),
3626		}
3627		return out, metadata, err
3628	}
3629
3630	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(&output, shape)
3631	if err != nil {
3632		var snapshot bytes.Buffer
3633		io.Copy(&snapshot, ringBuffer)
3634		err = &smithy.DeserializationError{
3635			Err:      fmt.Errorf("failed to decode response body, %w", err),
3636			Snapshot: snapshot.Bytes(),
3637		}
3638		return out, metadata, err
3639	}
3640
3641	return out, metadata, err
3642}
3643
3644func awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3645	var errorBuffer bytes.Buffer
3646	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3647		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3648	}
3649	errorBody := bytes.NewReader(errorBuffer.Bytes())
3650
3651	errorCode := "UnknownError"
3652	errorMessage := errorCode
3653
3654	code := response.Header.Get("X-Amzn-ErrorType")
3655	if len(code) != 0 {
3656		errorCode = restjson.SanitizeErrorCode(code)
3657	}
3658
3659	var buff [1024]byte
3660	ringBuffer := smithyio.NewRingBuffer(buff[:])
3661
3662	body := io.TeeReader(errorBody, ringBuffer)
3663	decoder := json.NewDecoder(body)
3664	decoder.UseNumber()
3665	code, message, err := restjson.GetErrorInfo(decoder)
3666	if err != nil {
3667		var snapshot bytes.Buffer
3668		io.Copy(&snapshot, ringBuffer)
3669		err = &smithy.DeserializationError{
3670			Err:      fmt.Errorf("failed to decode response body, %w", err),
3671			Snapshot: snapshot.Bytes(),
3672		}
3673		return err
3674	}
3675
3676	errorBody.Seek(0, io.SeekStart)
3677	if len(code) != 0 {
3678		errorCode = restjson.SanitizeErrorCode(code)
3679	}
3680	if len(message) != 0 {
3681		errorMessage = message
3682	}
3683
3684	switch {
3685	case strings.EqualFold("AccessDeniedException", errorCode):
3686		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3687
3688	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3689		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3690
3691	case strings.EqualFold("InvalidInputException", errorCode):
3692		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3693
3694	case strings.EqualFold("NotFoundException", errorCode):
3695		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3696
3697	case strings.EqualFold("OperationFailureException", errorCode):
3698		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3699
3700	case strings.EqualFold("ServiceException", errorCode):
3701		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3702
3703	case strings.EqualFold("UnauthenticatedException", errorCode):
3704		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3705
3706	default:
3707		genericError := &smithy.GenericAPIError{
3708			Code:    errorCode,
3709			Message: errorMessage,
3710		}
3711		return genericError
3712
3713	}
3714}
3715
3716type awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot struct {
3717}
3718
3719func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) ID() string {
3720	return "OperationDeserializer"
3721}
3722
3723func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3724	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3725) {
3726	out, metadata, err = next.HandleDeserialize(ctx, in)
3727	if err != nil {
3728		return out, metadata, err
3729	}
3730
3731	response, ok := out.RawResponse.(*smithyhttp.Response)
3732	if !ok {
3733		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3734	}
3735
3736	if response.StatusCode < 200 || response.StatusCode >= 300 {
3737		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response, &metadata)
3738	}
3739	output := &CreateRelationalDatabaseFromSnapshotOutput{}
3740	out.Result = output
3741
3742	var buff [1024]byte
3743	ringBuffer := smithyio.NewRingBuffer(buff[:])
3744
3745	body := io.TeeReader(response.Body, ringBuffer)
3746	decoder := json.NewDecoder(body)
3747	decoder.UseNumber()
3748	var shape interface{}
3749	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3750		var snapshot bytes.Buffer
3751		io.Copy(&snapshot, ringBuffer)
3752		err = &smithy.DeserializationError{
3753			Err:      fmt.Errorf("failed to decode response body, %w", err),
3754			Snapshot: snapshot.Bytes(),
3755		}
3756		return out, metadata, err
3757	}
3758
3759	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(&output, shape)
3760	if err != nil {
3761		var snapshot bytes.Buffer
3762		io.Copy(&snapshot, ringBuffer)
3763		err = &smithy.DeserializationError{
3764			Err:      fmt.Errorf("failed to decode response body, %w", err),
3765			Snapshot: snapshot.Bytes(),
3766		}
3767		return out, metadata, err
3768	}
3769
3770	return out, metadata, err
3771}
3772
3773func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3774	var errorBuffer bytes.Buffer
3775	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3776		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3777	}
3778	errorBody := bytes.NewReader(errorBuffer.Bytes())
3779
3780	errorCode := "UnknownError"
3781	errorMessage := errorCode
3782
3783	code := response.Header.Get("X-Amzn-ErrorType")
3784	if len(code) != 0 {
3785		errorCode = restjson.SanitizeErrorCode(code)
3786	}
3787
3788	var buff [1024]byte
3789	ringBuffer := smithyio.NewRingBuffer(buff[:])
3790
3791	body := io.TeeReader(errorBody, ringBuffer)
3792	decoder := json.NewDecoder(body)
3793	decoder.UseNumber()
3794	code, message, err := restjson.GetErrorInfo(decoder)
3795	if err != nil {
3796		var snapshot bytes.Buffer
3797		io.Copy(&snapshot, ringBuffer)
3798		err = &smithy.DeserializationError{
3799			Err:      fmt.Errorf("failed to decode response body, %w", err),
3800			Snapshot: snapshot.Bytes(),
3801		}
3802		return err
3803	}
3804
3805	errorBody.Seek(0, io.SeekStart)
3806	if len(code) != 0 {
3807		errorCode = restjson.SanitizeErrorCode(code)
3808	}
3809	if len(message) != 0 {
3810		errorMessage = message
3811	}
3812
3813	switch {
3814	case strings.EqualFold("AccessDeniedException", errorCode):
3815		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3816
3817	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3818		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3819
3820	case strings.EqualFold("InvalidInputException", errorCode):
3821		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3822
3823	case strings.EqualFold("NotFoundException", errorCode):
3824		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3825
3826	case strings.EqualFold("OperationFailureException", errorCode):
3827		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3828
3829	case strings.EqualFold("ServiceException", errorCode):
3830		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3831
3832	case strings.EqualFold("UnauthenticatedException", errorCode):
3833		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3834
3835	default:
3836		genericError := &smithy.GenericAPIError{
3837			Code:    errorCode,
3838			Message: errorMessage,
3839		}
3840		return genericError
3841
3842	}
3843}
3844
3845type awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot struct {
3846}
3847
3848func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) ID() string {
3849	return "OperationDeserializer"
3850}
3851
3852func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3853	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3854) {
3855	out, metadata, err = next.HandleDeserialize(ctx, in)
3856	if err != nil {
3857		return out, metadata, err
3858	}
3859
3860	response, ok := out.RawResponse.(*smithyhttp.Response)
3861	if !ok {
3862		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3863	}
3864
3865	if response.StatusCode < 200 || response.StatusCode >= 300 {
3866		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response, &metadata)
3867	}
3868	output := &CreateRelationalDatabaseSnapshotOutput{}
3869	out.Result = output
3870
3871	var buff [1024]byte
3872	ringBuffer := smithyio.NewRingBuffer(buff[:])
3873
3874	body := io.TeeReader(response.Body, ringBuffer)
3875	decoder := json.NewDecoder(body)
3876	decoder.UseNumber()
3877	var shape interface{}
3878	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3879		var snapshot bytes.Buffer
3880		io.Copy(&snapshot, ringBuffer)
3881		err = &smithy.DeserializationError{
3882			Err:      fmt.Errorf("failed to decode response body, %w", err),
3883			Snapshot: snapshot.Bytes(),
3884		}
3885		return out, metadata, err
3886	}
3887
3888	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(&output, shape)
3889	if err != nil {
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	return out, metadata, err
3900}
3901
3902func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3903	var errorBuffer bytes.Buffer
3904	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3905		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3906	}
3907	errorBody := bytes.NewReader(errorBuffer.Bytes())
3908
3909	errorCode := "UnknownError"
3910	errorMessage := errorCode
3911
3912	code := response.Header.Get("X-Amzn-ErrorType")
3913	if len(code) != 0 {
3914		errorCode = restjson.SanitizeErrorCode(code)
3915	}
3916
3917	var buff [1024]byte
3918	ringBuffer := smithyio.NewRingBuffer(buff[:])
3919
3920	body := io.TeeReader(errorBody, ringBuffer)
3921	decoder := json.NewDecoder(body)
3922	decoder.UseNumber()
3923	code, message, err := restjson.GetErrorInfo(decoder)
3924	if err != nil {
3925		var snapshot bytes.Buffer
3926		io.Copy(&snapshot, ringBuffer)
3927		err = &smithy.DeserializationError{
3928			Err:      fmt.Errorf("failed to decode response body, %w", err),
3929			Snapshot: snapshot.Bytes(),
3930		}
3931		return err
3932	}
3933
3934	errorBody.Seek(0, io.SeekStart)
3935	if len(code) != 0 {
3936		errorCode = restjson.SanitizeErrorCode(code)
3937	}
3938	if len(message) != 0 {
3939		errorMessage = message
3940	}
3941
3942	switch {
3943	case strings.EqualFold("AccessDeniedException", errorCode):
3944		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3945
3946	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3947		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3948
3949	case strings.EqualFold("InvalidInputException", errorCode):
3950		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3951
3952	case strings.EqualFold("NotFoundException", errorCode):
3953		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3954
3955	case strings.EqualFold("OperationFailureException", errorCode):
3956		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3957
3958	case strings.EqualFold("ServiceException", errorCode):
3959		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3960
3961	case strings.EqualFold("UnauthenticatedException", errorCode):
3962		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3963
3964	default:
3965		genericError := &smithy.GenericAPIError{
3966			Code:    errorCode,
3967			Message: errorMessage,
3968		}
3969		return genericError
3970
3971	}
3972}
3973
3974type awsAwsjson11_deserializeOpDeleteAlarm struct {
3975}
3976
3977func (*awsAwsjson11_deserializeOpDeleteAlarm) ID() string {
3978	return "OperationDeserializer"
3979}
3980
3981func (m *awsAwsjson11_deserializeOpDeleteAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3982	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3983) {
3984	out, metadata, err = next.HandleDeserialize(ctx, in)
3985	if err != nil {
3986		return out, metadata, err
3987	}
3988
3989	response, ok := out.RawResponse.(*smithyhttp.Response)
3990	if !ok {
3991		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3992	}
3993
3994	if response.StatusCode < 200 || response.StatusCode >= 300 {
3995		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAlarm(response, &metadata)
3996	}
3997	output := &DeleteAlarmOutput{}
3998	out.Result = output
3999
4000	var buff [1024]byte
4001	ringBuffer := smithyio.NewRingBuffer(buff[:])
4002
4003	body := io.TeeReader(response.Body, ringBuffer)
4004	decoder := json.NewDecoder(body)
4005	decoder.UseNumber()
4006	var shape interface{}
4007	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4008		var snapshot bytes.Buffer
4009		io.Copy(&snapshot, ringBuffer)
4010		err = &smithy.DeserializationError{
4011			Err:      fmt.Errorf("failed to decode response body, %w", err),
4012			Snapshot: snapshot.Bytes(),
4013		}
4014		return out, metadata, err
4015	}
4016
4017	err = awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(&output, shape)
4018	if err != nil {
4019		var snapshot bytes.Buffer
4020		io.Copy(&snapshot, ringBuffer)
4021		err = &smithy.DeserializationError{
4022			Err:      fmt.Errorf("failed to decode response body, %w", err),
4023			Snapshot: snapshot.Bytes(),
4024		}
4025		return out, metadata, err
4026	}
4027
4028	return out, metadata, err
4029}
4030
4031func awsAwsjson11_deserializeOpErrorDeleteAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4032	var errorBuffer bytes.Buffer
4033	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4034		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4035	}
4036	errorBody := bytes.NewReader(errorBuffer.Bytes())
4037
4038	errorCode := "UnknownError"
4039	errorMessage := errorCode
4040
4041	code := response.Header.Get("X-Amzn-ErrorType")
4042	if len(code) != 0 {
4043		errorCode = restjson.SanitizeErrorCode(code)
4044	}
4045
4046	var buff [1024]byte
4047	ringBuffer := smithyio.NewRingBuffer(buff[:])
4048
4049	body := io.TeeReader(errorBody, ringBuffer)
4050	decoder := json.NewDecoder(body)
4051	decoder.UseNumber()
4052	code, message, err := restjson.GetErrorInfo(decoder)
4053	if err != nil {
4054		var snapshot bytes.Buffer
4055		io.Copy(&snapshot, ringBuffer)
4056		err = &smithy.DeserializationError{
4057			Err:      fmt.Errorf("failed to decode response body, %w", err),
4058			Snapshot: snapshot.Bytes(),
4059		}
4060		return err
4061	}
4062
4063	errorBody.Seek(0, io.SeekStart)
4064	if len(code) != 0 {
4065		errorCode = restjson.SanitizeErrorCode(code)
4066	}
4067	if len(message) != 0 {
4068		errorMessage = message
4069	}
4070
4071	switch {
4072	case strings.EqualFold("AccessDeniedException", errorCode):
4073		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4074
4075	case strings.EqualFold("InvalidInputException", errorCode):
4076		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4077
4078	case strings.EqualFold("NotFoundException", errorCode):
4079		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4080
4081	case strings.EqualFold("OperationFailureException", errorCode):
4082		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4083
4084	case strings.EqualFold("ServiceException", errorCode):
4085		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4086
4087	case strings.EqualFold("UnauthenticatedException", errorCode):
4088		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4089
4090	default:
4091		genericError := &smithy.GenericAPIError{
4092			Code:    errorCode,
4093			Message: errorMessage,
4094		}
4095		return genericError
4096
4097	}
4098}
4099
4100type awsAwsjson11_deserializeOpDeleteAutoSnapshot struct {
4101}
4102
4103func (*awsAwsjson11_deserializeOpDeleteAutoSnapshot) ID() string {
4104	return "OperationDeserializer"
4105}
4106
4107func (m *awsAwsjson11_deserializeOpDeleteAutoSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4108	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4109) {
4110	out, metadata, err = next.HandleDeserialize(ctx, in)
4111	if err != nil {
4112		return out, metadata, err
4113	}
4114
4115	response, ok := out.RawResponse.(*smithyhttp.Response)
4116	if !ok {
4117		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4118	}
4119
4120	if response.StatusCode < 200 || response.StatusCode >= 300 {
4121		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response, &metadata)
4122	}
4123	output := &DeleteAutoSnapshotOutput{}
4124	out.Result = output
4125
4126	var buff [1024]byte
4127	ringBuffer := smithyio.NewRingBuffer(buff[:])
4128
4129	body := io.TeeReader(response.Body, ringBuffer)
4130	decoder := json.NewDecoder(body)
4131	decoder.UseNumber()
4132	var shape interface{}
4133	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4134		var snapshot bytes.Buffer
4135		io.Copy(&snapshot, ringBuffer)
4136		err = &smithy.DeserializationError{
4137			Err:      fmt.Errorf("failed to decode response body, %w", err),
4138			Snapshot: snapshot.Bytes(),
4139		}
4140		return out, metadata, err
4141	}
4142
4143	err = awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(&output, shape)
4144	if err != nil {
4145		var snapshot bytes.Buffer
4146		io.Copy(&snapshot, ringBuffer)
4147		err = &smithy.DeserializationError{
4148			Err:      fmt.Errorf("failed to decode response body, %w", err),
4149			Snapshot: snapshot.Bytes(),
4150		}
4151		return out, metadata, err
4152	}
4153
4154	return out, metadata, err
4155}
4156
4157func awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4158	var errorBuffer bytes.Buffer
4159	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4160		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4161	}
4162	errorBody := bytes.NewReader(errorBuffer.Bytes())
4163
4164	errorCode := "UnknownError"
4165	errorMessage := errorCode
4166
4167	code := response.Header.Get("X-Amzn-ErrorType")
4168	if len(code) != 0 {
4169		errorCode = restjson.SanitizeErrorCode(code)
4170	}
4171
4172	var buff [1024]byte
4173	ringBuffer := smithyio.NewRingBuffer(buff[:])
4174
4175	body := io.TeeReader(errorBody, ringBuffer)
4176	decoder := json.NewDecoder(body)
4177	decoder.UseNumber()
4178	code, message, err := restjson.GetErrorInfo(decoder)
4179	if err != nil {
4180		var snapshot bytes.Buffer
4181		io.Copy(&snapshot, ringBuffer)
4182		err = &smithy.DeserializationError{
4183			Err:      fmt.Errorf("failed to decode response body, %w", err),
4184			Snapshot: snapshot.Bytes(),
4185		}
4186		return err
4187	}
4188
4189	errorBody.Seek(0, io.SeekStart)
4190	if len(code) != 0 {
4191		errorCode = restjson.SanitizeErrorCode(code)
4192	}
4193	if len(message) != 0 {
4194		errorMessage = message
4195	}
4196
4197	switch {
4198	case strings.EqualFold("AccessDeniedException", errorCode):
4199		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4200
4201	case strings.EqualFold("InvalidInputException", errorCode):
4202		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4203
4204	case strings.EqualFold("NotFoundException", errorCode):
4205		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4206
4207	case strings.EqualFold("OperationFailureException", errorCode):
4208		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4209
4210	case strings.EqualFold("ServiceException", errorCode):
4211		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4212
4213	case strings.EqualFold("UnauthenticatedException", errorCode):
4214		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4215
4216	default:
4217		genericError := &smithy.GenericAPIError{
4218			Code:    errorCode,
4219			Message: errorMessage,
4220		}
4221		return genericError
4222
4223	}
4224}
4225
4226type awsAwsjson11_deserializeOpDeleteBucket struct {
4227}
4228
4229func (*awsAwsjson11_deserializeOpDeleteBucket) ID() string {
4230	return "OperationDeserializer"
4231}
4232
4233func (m *awsAwsjson11_deserializeOpDeleteBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4234	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4235) {
4236	out, metadata, err = next.HandleDeserialize(ctx, in)
4237	if err != nil {
4238		return out, metadata, err
4239	}
4240
4241	response, ok := out.RawResponse.(*smithyhttp.Response)
4242	if !ok {
4243		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4244	}
4245
4246	if response.StatusCode < 200 || response.StatusCode >= 300 {
4247		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteBucket(response, &metadata)
4248	}
4249	output := &DeleteBucketOutput{}
4250	out.Result = output
4251
4252	var buff [1024]byte
4253	ringBuffer := smithyio.NewRingBuffer(buff[:])
4254
4255	body := io.TeeReader(response.Body, ringBuffer)
4256	decoder := json.NewDecoder(body)
4257	decoder.UseNumber()
4258	var shape interface{}
4259	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4260		var snapshot bytes.Buffer
4261		io.Copy(&snapshot, ringBuffer)
4262		err = &smithy.DeserializationError{
4263			Err:      fmt.Errorf("failed to decode response body, %w", err),
4264			Snapshot: snapshot.Bytes(),
4265		}
4266		return out, metadata, err
4267	}
4268
4269	err = awsAwsjson11_deserializeOpDocumentDeleteBucketOutput(&output, shape)
4270	if err != nil {
4271		var snapshot bytes.Buffer
4272		io.Copy(&snapshot, ringBuffer)
4273		err = &smithy.DeserializationError{
4274			Err:      fmt.Errorf("failed to decode response body, %w", err),
4275			Snapshot: snapshot.Bytes(),
4276		}
4277		return out, metadata, err
4278	}
4279
4280	return out, metadata, err
4281}
4282
4283func awsAwsjson11_deserializeOpErrorDeleteBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4284	var errorBuffer bytes.Buffer
4285	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4286		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4287	}
4288	errorBody := bytes.NewReader(errorBuffer.Bytes())
4289
4290	errorCode := "UnknownError"
4291	errorMessage := errorCode
4292
4293	code := response.Header.Get("X-Amzn-ErrorType")
4294	if len(code) != 0 {
4295		errorCode = restjson.SanitizeErrorCode(code)
4296	}
4297
4298	var buff [1024]byte
4299	ringBuffer := smithyio.NewRingBuffer(buff[:])
4300
4301	body := io.TeeReader(errorBody, ringBuffer)
4302	decoder := json.NewDecoder(body)
4303	decoder.UseNumber()
4304	code, message, err := restjson.GetErrorInfo(decoder)
4305	if err != nil {
4306		var snapshot bytes.Buffer
4307		io.Copy(&snapshot, ringBuffer)
4308		err = &smithy.DeserializationError{
4309			Err:      fmt.Errorf("failed to decode response body, %w", err),
4310			Snapshot: snapshot.Bytes(),
4311		}
4312		return err
4313	}
4314
4315	errorBody.Seek(0, io.SeekStart)
4316	if len(code) != 0 {
4317		errorCode = restjson.SanitizeErrorCode(code)
4318	}
4319	if len(message) != 0 {
4320		errorMessage = message
4321	}
4322
4323	switch {
4324	case strings.EqualFold("AccessDeniedException", errorCode):
4325		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4326
4327	case strings.EqualFold("InvalidInputException", errorCode):
4328		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4329
4330	case strings.EqualFold("NotFoundException", errorCode):
4331		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4332
4333	case strings.EqualFold("ServiceException", errorCode):
4334		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4335
4336	case strings.EqualFold("UnauthenticatedException", errorCode):
4337		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4338
4339	default:
4340		genericError := &smithy.GenericAPIError{
4341			Code:    errorCode,
4342			Message: errorMessage,
4343		}
4344		return genericError
4345
4346	}
4347}
4348
4349type awsAwsjson11_deserializeOpDeleteBucketAccessKey struct {
4350}
4351
4352func (*awsAwsjson11_deserializeOpDeleteBucketAccessKey) ID() string {
4353	return "OperationDeserializer"
4354}
4355
4356func (m *awsAwsjson11_deserializeOpDeleteBucketAccessKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4357	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4358) {
4359	out, metadata, err = next.HandleDeserialize(ctx, in)
4360	if err != nil {
4361		return out, metadata, err
4362	}
4363
4364	response, ok := out.RawResponse.(*smithyhttp.Response)
4365	if !ok {
4366		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4367	}
4368
4369	if response.StatusCode < 200 || response.StatusCode >= 300 {
4370		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteBucketAccessKey(response, &metadata)
4371	}
4372	output := &DeleteBucketAccessKeyOutput{}
4373	out.Result = output
4374
4375	var buff [1024]byte
4376	ringBuffer := smithyio.NewRingBuffer(buff[:])
4377
4378	body := io.TeeReader(response.Body, ringBuffer)
4379	decoder := json.NewDecoder(body)
4380	decoder.UseNumber()
4381	var shape interface{}
4382	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4383		var snapshot bytes.Buffer
4384		io.Copy(&snapshot, ringBuffer)
4385		err = &smithy.DeserializationError{
4386			Err:      fmt.Errorf("failed to decode response body, %w", err),
4387			Snapshot: snapshot.Bytes(),
4388		}
4389		return out, metadata, err
4390	}
4391
4392	err = awsAwsjson11_deserializeOpDocumentDeleteBucketAccessKeyOutput(&output, shape)
4393	if err != nil {
4394		var snapshot bytes.Buffer
4395		io.Copy(&snapshot, ringBuffer)
4396		err = &smithy.DeserializationError{
4397			Err:      fmt.Errorf("failed to decode response body, %w", err),
4398			Snapshot: snapshot.Bytes(),
4399		}
4400		return out, metadata, err
4401	}
4402
4403	return out, metadata, err
4404}
4405
4406func awsAwsjson11_deserializeOpErrorDeleteBucketAccessKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4407	var errorBuffer bytes.Buffer
4408	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4409		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4410	}
4411	errorBody := bytes.NewReader(errorBuffer.Bytes())
4412
4413	errorCode := "UnknownError"
4414	errorMessage := errorCode
4415
4416	code := response.Header.Get("X-Amzn-ErrorType")
4417	if len(code) != 0 {
4418		errorCode = restjson.SanitizeErrorCode(code)
4419	}
4420
4421	var buff [1024]byte
4422	ringBuffer := smithyio.NewRingBuffer(buff[:])
4423
4424	body := io.TeeReader(errorBody, ringBuffer)
4425	decoder := json.NewDecoder(body)
4426	decoder.UseNumber()
4427	code, message, err := restjson.GetErrorInfo(decoder)
4428	if err != nil {
4429		var snapshot bytes.Buffer
4430		io.Copy(&snapshot, ringBuffer)
4431		err = &smithy.DeserializationError{
4432			Err:      fmt.Errorf("failed to decode response body, %w", err),
4433			Snapshot: snapshot.Bytes(),
4434		}
4435		return err
4436	}
4437
4438	errorBody.Seek(0, io.SeekStart)
4439	if len(code) != 0 {
4440		errorCode = restjson.SanitizeErrorCode(code)
4441	}
4442	if len(message) != 0 {
4443		errorMessage = message
4444	}
4445
4446	switch {
4447	case strings.EqualFold("AccessDeniedException", errorCode):
4448		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4449
4450	case strings.EqualFold("InvalidInputException", errorCode):
4451		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4452
4453	case strings.EqualFold("NotFoundException", errorCode):
4454		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4455
4456	case strings.EqualFold("ServiceException", errorCode):
4457		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4458
4459	case strings.EqualFold("UnauthenticatedException", errorCode):
4460		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4461
4462	default:
4463		genericError := &smithy.GenericAPIError{
4464			Code:    errorCode,
4465			Message: errorMessage,
4466		}
4467		return genericError
4468
4469	}
4470}
4471
4472type awsAwsjson11_deserializeOpDeleteCertificate struct {
4473}
4474
4475func (*awsAwsjson11_deserializeOpDeleteCertificate) ID() string {
4476	return "OperationDeserializer"
4477}
4478
4479func (m *awsAwsjson11_deserializeOpDeleteCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4480	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4481) {
4482	out, metadata, err = next.HandleDeserialize(ctx, in)
4483	if err != nil {
4484		return out, metadata, err
4485	}
4486
4487	response, ok := out.RawResponse.(*smithyhttp.Response)
4488	if !ok {
4489		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4490	}
4491
4492	if response.StatusCode < 200 || response.StatusCode >= 300 {
4493		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCertificate(response, &metadata)
4494	}
4495	output := &DeleteCertificateOutput{}
4496	out.Result = output
4497
4498	var buff [1024]byte
4499	ringBuffer := smithyio.NewRingBuffer(buff[:])
4500
4501	body := io.TeeReader(response.Body, ringBuffer)
4502	decoder := json.NewDecoder(body)
4503	decoder.UseNumber()
4504	var shape interface{}
4505	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4506		var snapshot bytes.Buffer
4507		io.Copy(&snapshot, ringBuffer)
4508		err = &smithy.DeserializationError{
4509			Err:      fmt.Errorf("failed to decode response body, %w", err),
4510			Snapshot: snapshot.Bytes(),
4511		}
4512		return out, metadata, err
4513	}
4514
4515	err = awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(&output, shape)
4516	if err != nil {
4517		var snapshot bytes.Buffer
4518		io.Copy(&snapshot, ringBuffer)
4519		err = &smithy.DeserializationError{
4520			Err:      fmt.Errorf("failed to decode response body, %w", err),
4521			Snapshot: snapshot.Bytes(),
4522		}
4523		return out, metadata, err
4524	}
4525
4526	return out, metadata, err
4527}
4528
4529func awsAwsjson11_deserializeOpErrorDeleteCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4530	var errorBuffer bytes.Buffer
4531	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4532		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4533	}
4534	errorBody := bytes.NewReader(errorBuffer.Bytes())
4535
4536	errorCode := "UnknownError"
4537	errorMessage := errorCode
4538
4539	code := response.Header.Get("X-Amzn-ErrorType")
4540	if len(code) != 0 {
4541		errorCode = restjson.SanitizeErrorCode(code)
4542	}
4543
4544	var buff [1024]byte
4545	ringBuffer := smithyio.NewRingBuffer(buff[:])
4546
4547	body := io.TeeReader(errorBody, ringBuffer)
4548	decoder := json.NewDecoder(body)
4549	decoder.UseNumber()
4550	code, message, err := restjson.GetErrorInfo(decoder)
4551	if err != nil {
4552		var snapshot bytes.Buffer
4553		io.Copy(&snapshot, ringBuffer)
4554		err = &smithy.DeserializationError{
4555			Err:      fmt.Errorf("failed to decode response body, %w", err),
4556			Snapshot: snapshot.Bytes(),
4557		}
4558		return err
4559	}
4560
4561	errorBody.Seek(0, io.SeekStart)
4562	if len(code) != 0 {
4563		errorCode = restjson.SanitizeErrorCode(code)
4564	}
4565	if len(message) != 0 {
4566		errorMessage = message
4567	}
4568
4569	switch {
4570	case strings.EqualFold("AccessDeniedException", errorCode):
4571		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4572
4573	case strings.EqualFold("InvalidInputException", errorCode):
4574		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4575
4576	case strings.EqualFold("NotFoundException", errorCode):
4577		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4578
4579	case strings.EqualFold("ServiceException", errorCode):
4580		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4581
4582	case strings.EqualFold("UnauthenticatedException", errorCode):
4583		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4584
4585	default:
4586		genericError := &smithy.GenericAPIError{
4587			Code:    errorCode,
4588			Message: errorMessage,
4589		}
4590		return genericError
4591
4592	}
4593}
4594
4595type awsAwsjson11_deserializeOpDeleteContactMethod struct {
4596}
4597
4598func (*awsAwsjson11_deserializeOpDeleteContactMethod) ID() string {
4599	return "OperationDeserializer"
4600}
4601
4602func (m *awsAwsjson11_deserializeOpDeleteContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4603	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4604) {
4605	out, metadata, err = next.HandleDeserialize(ctx, in)
4606	if err != nil {
4607		return out, metadata, err
4608	}
4609
4610	response, ok := out.RawResponse.(*smithyhttp.Response)
4611	if !ok {
4612		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4613	}
4614
4615	if response.StatusCode < 200 || response.StatusCode >= 300 {
4616		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContactMethod(response, &metadata)
4617	}
4618	output := &DeleteContactMethodOutput{}
4619	out.Result = output
4620
4621	var buff [1024]byte
4622	ringBuffer := smithyio.NewRingBuffer(buff[:])
4623
4624	body := io.TeeReader(response.Body, ringBuffer)
4625	decoder := json.NewDecoder(body)
4626	decoder.UseNumber()
4627	var shape interface{}
4628	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4629		var snapshot bytes.Buffer
4630		io.Copy(&snapshot, ringBuffer)
4631		err = &smithy.DeserializationError{
4632			Err:      fmt.Errorf("failed to decode response body, %w", err),
4633			Snapshot: snapshot.Bytes(),
4634		}
4635		return out, metadata, err
4636	}
4637
4638	err = awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(&output, shape)
4639	if err != nil {
4640		var snapshot bytes.Buffer
4641		io.Copy(&snapshot, ringBuffer)
4642		err = &smithy.DeserializationError{
4643			Err:      fmt.Errorf("failed to decode response body, %w", err),
4644			Snapshot: snapshot.Bytes(),
4645		}
4646		return out, metadata, err
4647	}
4648
4649	return out, metadata, err
4650}
4651
4652func awsAwsjson11_deserializeOpErrorDeleteContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4653	var errorBuffer bytes.Buffer
4654	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4655		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4656	}
4657	errorBody := bytes.NewReader(errorBuffer.Bytes())
4658
4659	errorCode := "UnknownError"
4660	errorMessage := errorCode
4661
4662	code := response.Header.Get("X-Amzn-ErrorType")
4663	if len(code) != 0 {
4664		errorCode = restjson.SanitizeErrorCode(code)
4665	}
4666
4667	var buff [1024]byte
4668	ringBuffer := smithyio.NewRingBuffer(buff[:])
4669
4670	body := io.TeeReader(errorBody, ringBuffer)
4671	decoder := json.NewDecoder(body)
4672	decoder.UseNumber()
4673	code, message, err := restjson.GetErrorInfo(decoder)
4674	if err != nil {
4675		var snapshot bytes.Buffer
4676		io.Copy(&snapshot, ringBuffer)
4677		err = &smithy.DeserializationError{
4678			Err:      fmt.Errorf("failed to decode response body, %w", err),
4679			Snapshot: snapshot.Bytes(),
4680		}
4681		return err
4682	}
4683
4684	errorBody.Seek(0, io.SeekStart)
4685	if len(code) != 0 {
4686		errorCode = restjson.SanitizeErrorCode(code)
4687	}
4688	if len(message) != 0 {
4689		errorMessage = message
4690	}
4691
4692	switch {
4693	case strings.EqualFold("AccessDeniedException", errorCode):
4694		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4695
4696	case strings.EqualFold("InvalidInputException", errorCode):
4697		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4698
4699	case strings.EqualFold("NotFoundException", errorCode):
4700		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4701
4702	case strings.EqualFold("OperationFailureException", errorCode):
4703		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4704
4705	case strings.EqualFold("ServiceException", errorCode):
4706		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4707
4708	case strings.EqualFold("UnauthenticatedException", errorCode):
4709		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4710
4711	default:
4712		genericError := &smithy.GenericAPIError{
4713			Code:    errorCode,
4714			Message: errorMessage,
4715		}
4716		return genericError
4717
4718	}
4719}
4720
4721type awsAwsjson11_deserializeOpDeleteContainerImage struct {
4722}
4723
4724func (*awsAwsjson11_deserializeOpDeleteContainerImage) ID() string {
4725	return "OperationDeserializer"
4726}
4727
4728func (m *awsAwsjson11_deserializeOpDeleteContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4729	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4730) {
4731	out, metadata, err = next.HandleDeserialize(ctx, in)
4732	if err != nil {
4733		return out, metadata, err
4734	}
4735
4736	response, ok := out.RawResponse.(*smithyhttp.Response)
4737	if !ok {
4738		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4739	}
4740
4741	if response.StatusCode < 200 || response.StatusCode >= 300 {
4742		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerImage(response, &metadata)
4743	}
4744	output := &DeleteContainerImageOutput{}
4745	out.Result = output
4746
4747	var buff [1024]byte
4748	ringBuffer := smithyio.NewRingBuffer(buff[:])
4749
4750	body := io.TeeReader(response.Body, ringBuffer)
4751	decoder := json.NewDecoder(body)
4752	decoder.UseNumber()
4753	var shape interface{}
4754	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4755		var snapshot bytes.Buffer
4756		io.Copy(&snapshot, ringBuffer)
4757		err = &smithy.DeserializationError{
4758			Err:      fmt.Errorf("failed to decode response body, %w", err),
4759			Snapshot: snapshot.Bytes(),
4760		}
4761		return out, metadata, err
4762	}
4763
4764	err = awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(&output, shape)
4765	if err != nil {
4766		var snapshot bytes.Buffer
4767		io.Copy(&snapshot, ringBuffer)
4768		err = &smithy.DeserializationError{
4769			Err:      fmt.Errorf("failed to decode response body, %w", err),
4770			Snapshot: snapshot.Bytes(),
4771		}
4772		return out, metadata, err
4773	}
4774
4775	return out, metadata, err
4776}
4777
4778func awsAwsjson11_deserializeOpErrorDeleteContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4779	var errorBuffer bytes.Buffer
4780	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4781		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4782	}
4783	errorBody := bytes.NewReader(errorBuffer.Bytes())
4784
4785	errorCode := "UnknownError"
4786	errorMessage := errorCode
4787
4788	code := response.Header.Get("X-Amzn-ErrorType")
4789	if len(code) != 0 {
4790		errorCode = restjson.SanitizeErrorCode(code)
4791	}
4792
4793	var buff [1024]byte
4794	ringBuffer := smithyio.NewRingBuffer(buff[:])
4795
4796	body := io.TeeReader(errorBody, ringBuffer)
4797	decoder := json.NewDecoder(body)
4798	decoder.UseNumber()
4799	code, message, err := restjson.GetErrorInfo(decoder)
4800	if err != nil {
4801		var snapshot bytes.Buffer
4802		io.Copy(&snapshot, ringBuffer)
4803		err = &smithy.DeserializationError{
4804			Err:      fmt.Errorf("failed to decode response body, %w", err),
4805			Snapshot: snapshot.Bytes(),
4806		}
4807		return err
4808	}
4809
4810	errorBody.Seek(0, io.SeekStart)
4811	if len(code) != 0 {
4812		errorCode = restjson.SanitizeErrorCode(code)
4813	}
4814	if len(message) != 0 {
4815		errorMessage = message
4816	}
4817
4818	switch {
4819	case strings.EqualFold("AccessDeniedException", errorCode):
4820		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4821
4822	case strings.EqualFold("InvalidInputException", errorCode):
4823		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4824
4825	case strings.EqualFold("NotFoundException", errorCode):
4826		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4827
4828	case strings.EqualFold("ServiceException", errorCode):
4829		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4830
4831	case strings.EqualFold("UnauthenticatedException", errorCode):
4832		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4833
4834	default:
4835		genericError := &smithy.GenericAPIError{
4836			Code:    errorCode,
4837			Message: errorMessage,
4838		}
4839		return genericError
4840
4841	}
4842}
4843
4844type awsAwsjson11_deserializeOpDeleteContainerService struct {
4845}
4846
4847func (*awsAwsjson11_deserializeOpDeleteContainerService) ID() string {
4848	return "OperationDeserializer"
4849}
4850
4851func (m *awsAwsjson11_deserializeOpDeleteContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4852	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4853) {
4854	out, metadata, err = next.HandleDeserialize(ctx, in)
4855	if err != nil {
4856		return out, metadata, err
4857	}
4858
4859	response, ok := out.RawResponse.(*smithyhttp.Response)
4860	if !ok {
4861		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4862	}
4863
4864	if response.StatusCode < 200 || response.StatusCode >= 300 {
4865		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerService(response, &metadata)
4866	}
4867	output := &DeleteContainerServiceOutput{}
4868	out.Result = output
4869
4870	var buff [1024]byte
4871	ringBuffer := smithyio.NewRingBuffer(buff[:])
4872
4873	body := io.TeeReader(response.Body, ringBuffer)
4874	decoder := json.NewDecoder(body)
4875	decoder.UseNumber()
4876	var shape interface{}
4877	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4878		var snapshot bytes.Buffer
4879		io.Copy(&snapshot, ringBuffer)
4880		err = &smithy.DeserializationError{
4881			Err:      fmt.Errorf("failed to decode response body, %w", err),
4882			Snapshot: snapshot.Bytes(),
4883		}
4884		return out, metadata, err
4885	}
4886
4887	err = awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(&output, shape)
4888	if err != nil {
4889		var snapshot bytes.Buffer
4890		io.Copy(&snapshot, ringBuffer)
4891		err = &smithy.DeserializationError{
4892			Err:      fmt.Errorf("failed to decode response body, %w", err),
4893			Snapshot: snapshot.Bytes(),
4894		}
4895		return out, metadata, err
4896	}
4897
4898	return out, metadata, err
4899}
4900
4901func awsAwsjson11_deserializeOpErrorDeleteContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4902	var errorBuffer bytes.Buffer
4903	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4904		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4905	}
4906	errorBody := bytes.NewReader(errorBuffer.Bytes())
4907
4908	errorCode := "UnknownError"
4909	errorMessage := errorCode
4910
4911	code := response.Header.Get("X-Amzn-ErrorType")
4912	if len(code) != 0 {
4913		errorCode = restjson.SanitizeErrorCode(code)
4914	}
4915
4916	var buff [1024]byte
4917	ringBuffer := smithyio.NewRingBuffer(buff[:])
4918
4919	body := io.TeeReader(errorBody, ringBuffer)
4920	decoder := json.NewDecoder(body)
4921	decoder.UseNumber()
4922	code, message, err := restjson.GetErrorInfo(decoder)
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 err
4931	}
4932
4933	errorBody.Seek(0, io.SeekStart)
4934	if len(code) != 0 {
4935		errorCode = restjson.SanitizeErrorCode(code)
4936	}
4937	if len(message) != 0 {
4938		errorMessage = message
4939	}
4940
4941	switch {
4942	case strings.EqualFold("AccessDeniedException", errorCode):
4943		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4944
4945	case strings.EqualFold("InvalidInputException", errorCode):
4946		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4947
4948	case strings.EqualFold("NotFoundException", errorCode):
4949		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4950
4951	case strings.EqualFold("ServiceException", errorCode):
4952		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4953
4954	case strings.EqualFold("UnauthenticatedException", errorCode):
4955		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4956
4957	default:
4958		genericError := &smithy.GenericAPIError{
4959			Code:    errorCode,
4960			Message: errorMessage,
4961		}
4962		return genericError
4963
4964	}
4965}
4966
4967type awsAwsjson11_deserializeOpDeleteDisk struct {
4968}
4969
4970func (*awsAwsjson11_deserializeOpDeleteDisk) ID() string {
4971	return "OperationDeserializer"
4972}
4973
4974func (m *awsAwsjson11_deserializeOpDeleteDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4975	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4976) {
4977	out, metadata, err = next.HandleDeserialize(ctx, in)
4978	if err != nil {
4979		return out, metadata, err
4980	}
4981
4982	response, ok := out.RawResponse.(*smithyhttp.Response)
4983	if !ok {
4984		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4985	}
4986
4987	if response.StatusCode < 200 || response.StatusCode >= 300 {
4988		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDisk(response, &metadata)
4989	}
4990	output := &DeleteDiskOutput{}
4991	out.Result = output
4992
4993	var buff [1024]byte
4994	ringBuffer := smithyio.NewRingBuffer(buff[:])
4995
4996	body := io.TeeReader(response.Body, ringBuffer)
4997	decoder := json.NewDecoder(body)
4998	decoder.UseNumber()
4999	var shape interface{}
5000	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5001		var snapshot bytes.Buffer
5002		io.Copy(&snapshot, ringBuffer)
5003		err = &smithy.DeserializationError{
5004			Err:      fmt.Errorf("failed to decode response body, %w", err),
5005			Snapshot: snapshot.Bytes(),
5006		}
5007		return out, metadata, err
5008	}
5009
5010	err = awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(&output, shape)
5011	if err != nil {
5012		var snapshot bytes.Buffer
5013		io.Copy(&snapshot, ringBuffer)
5014		err = &smithy.DeserializationError{
5015			Err:      fmt.Errorf("failed to decode response body, %w", err),
5016			Snapshot: snapshot.Bytes(),
5017		}
5018		return out, metadata, err
5019	}
5020
5021	return out, metadata, err
5022}
5023
5024func awsAwsjson11_deserializeOpErrorDeleteDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5025	var errorBuffer bytes.Buffer
5026	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5027		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5028	}
5029	errorBody := bytes.NewReader(errorBuffer.Bytes())
5030
5031	errorCode := "UnknownError"
5032	errorMessage := errorCode
5033
5034	code := response.Header.Get("X-Amzn-ErrorType")
5035	if len(code) != 0 {
5036		errorCode = restjson.SanitizeErrorCode(code)
5037	}
5038
5039	var buff [1024]byte
5040	ringBuffer := smithyio.NewRingBuffer(buff[:])
5041
5042	body := io.TeeReader(errorBody, ringBuffer)
5043	decoder := json.NewDecoder(body)
5044	decoder.UseNumber()
5045	code, message, err := restjson.GetErrorInfo(decoder)
5046	if err != nil {
5047		var snapshot bytes.Buffer
5048		io.Copy(&snapshot, ringBuffer)
5049		err = &smithy.DeserializationError{
5050			Err:      fmt.Errorf("failed to decode response body, %w", err),
5051			Snapshot: snapshot.Bytes(),
5052		}
5053		return err
5054	}
5055
5056	errorBody.Seek(0, io.SeekStart)
5057	if len(code) != 0 {
5058		errorCode = restjson.SanitizeErrorCode(code)
5059	}
5060	if len(message) != 0 {
5061		errorMessage = message
5062	}
5063
5064	switch {
5065	case strings.EqualFold("AccessDeniedException", errorCode):
5066		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5067
5068	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5069		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5070
5071	case strings.EqualFold("InvalidInputException", errorCode):
5072		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5073
5074	case strings.EqualFold("NotFoundException", errorCode):
5075		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5076
5077	case strings.EqualFold("OperationFailureException", errorCode):
5078		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5079
5080	case strings.EqualFold("ServiceException", errorCode):
5081		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5082
5083	case strings.EqualFold("UnauthenticatedException", errorCode):
5084		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5085
5086	default:
5087		genericError := &smithy.GenericAPIError{
5088			Code:    errorCode,
5089			Message: errorMessage,
5090		}
5091		return genericError
5092
5093	}
5094}
5095
5096type awsAwsjson11_deserializeOpDeleteDiskSnapshot struct {
5097}
5098
5099func (*awsAwsjson11_deserializeOpDeleteDiskSnapshot) ID() string {
5100	return "OperationDeserializer"
5101}
5102
5103func (m *awsAwsjson11_deserializeOpDeleteDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5104	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5105) {
5106	out, metadata, err = next.HandleDeserialize(ctx, in)
5107	if err != nil {
5108		return out, metadata, err
5109	}
5110
5111	response, ok := out.RawResponse.(*smithyhttp.Response)
5112	if !ok {
5113		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5114	}
5115
5116	if response.StatusCode < 200 || response.StatusCode >= 300 {
5117		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response, &metadata)
5118	}
5119	output := &DeleteDiskSnapshotOutput{}
5120	out.Result = output
5121
5122	var buff [1024]byte
5123	ringBuffer := smithyio.NewRingBuffer(buff[:])
5124
5125	body := io.TeeReader(response.Body, ringBuffer)
5126	decoder := json.NewDecoder(body)
5127	decoder.UseNumber()
5128	var shape interface{}
5129	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5130		var snapshot bytes.Buffer
5131		io.Copy(&snapshot, ringBuffer)
5132		err = &smithy.DeserializationError{
5133			Err:      fmt.Errorf("failed to decode response body, %w", err),
5134			Snapshot: snapshot.Bytes(),
5135		}
5136		return out, metadata, err
5137	}
5138
5139	err = awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(&output, shape)
5140	if err != nil {
5141		var snapshot bytes.Buffer
5142		io.Copy(&snapshot, ringBuffer)
5143		err = &smithy.DeserializationError{
5144			Err:      fmt.Errorf("failed to decode response body, %w", err),
5145			Snapshot: snapshot.Bytes(),
5146		}
5147		return out, metadata, err
5148	}
5149
5150	return out, metadata, err
5151}
5152
5153func awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5154	var errorBuffer bytes.Buffer
5155	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5156		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5157	}
5158	errorBody := bytes.NewReader(errorBuffer.Bytes())
5159
5160	errorCode := "UnknownError"
5161	errorMessage := errorCode
5162
5163	code := response.Header.Get("X-Amzn-ErrorType")
5164	if len(code) != 0 {
5165		errorCode = restjson.SanitizeErrorCode(code)
5166	}
5167
5168	var buff [1024]byte
5169	ringBuffer := smithyio.NewRingBuffer(buff[:])
5170
5171	body := io.TeeReader(errorBody, ringBuffer)
5172	decoder := json.NewDecoder(body)
5173	decoder.UseNumber()
5174	code, message, err := restjson.GetErrorInfo(decoder)
5175	if err != nil {
5176		var snapshot bytes.Buffer
5177		io.Copy(&snapshot, ringBuffer)
5178		err = &smithy.DeserializationError{
5179			Err:      fmt.Errorf("failed to decode response body, %w", err),
5180			Snapshot: snapshot.Bytes(),
5181		}
5182		return err
5183	}
5184
5185	errorBody.Seek(0, io.SeekStart)
5186	if len(code) != 0 {
5187		errorCode = restjson.SanitizeErrorCode(code)
5188	}
5189	if len(message) != 0 {
5190		errorMessage = message
5191	}
5192
5193	switch {
5194	case strings.EqualFold("AccessDeniedException", errorCode):
5195		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5196
5197	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5198		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5199
5200	case strings.EqualFold("InvalidInputException", errorCode):
5201		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5202
5203	case strings.EqualFold("NotFoundException", errorCode):
5204		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5205
5206	case strings.EqualFold("OperationFailureException", errorCode):
5207		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5208
5209	case strings.EqualFold("ServiceException", errorCode):
5210		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5211
5212	case strings.EqualFold("UnauthenticatedException", errorCode):
5213		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5214
5215	default:
5216		genericError := &smithy.GenericAPIError{
5217			Code:    errorCode,
5218			Message: errorMessage,
5219		}
5220		return genericError
5221
5222	}
5223}
5224
5225type awsAwsjson11_deserializeOpDeleteDistribution struct {
5226}
5227
5228func (*awsAwsjson11_deserializeOpDeleteDistribution) ID() string {
5229	return "OperationDeserializer"
5230}
5231
5232func (m *awsAwsjson11_deserializeOpDeleteDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5233	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5234) {
5235	out, metadata, err = next.HandleDeserialize(ctx, in)
5236	if err != nil {
5237		return out, metadata, err
5238	}
5239
5240	response, ok := out.RawResponse.(*smithyhttp.Response)
5241	if !ok {
5242		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5243	}
5244
5245	if response.StatusCode < 200 || response.StatusCode >= 300 {
5246		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDistribution(response, &metadata)
5247	}
5248	output := &DeleteDistributionOutput{}
5249	out.Result = output
5250
5251	var buff [1024]byte
5252	ringBuffer := smithyio.NewRingBuffer(buff[:])
5253
5254	body := io.TeeReader(response.Body, ringBuffer)
5255	decoder := json.NewDecoder(body)
5256	decoder.UseNumber()
5257	var shape interface{}
5258	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5259		var snapshot bytes.Buffer
5260		io.Copy(&snapshot, ringBuffer)
5261		err = &smithy.DeserializationError{
5262			Err:      fmt.Errorf("failed to decode response body, %w", err),
5263			Snapshot: snapshot.Bytes(),
5264		}
5265		return out, metadata, err
5266	}
5267
5268	err = awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(&output, shape)
5269	if err != nil {
5270		var snapshot bytes.Buffer
5271		io.Copy(&snapshot, ringBuffer)
5272		err = &smithy.DeserializationError{
5273			Err:      fmt.Errorf("failed to decode response body, %w", err),
5274			Snapshot: snapshot.Bytes(),
5275		}
5276		return out, metadata, err
5277	}
5278
5279	return out, metadata, err
5280}
5281
5282func awsAwsjson11_deserializeOpErrorDeleteDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5283	var errorBuffer bytes.Buffer
5284	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5285		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5286	}
5287	errorBody := bytes.NewReader(errorBuffer.Bytes())
5288
5289	errorCode := "UnknownError"
5290	errorMessage := errorCode
5291
5292	code := response.Header.Get("X-Amzn-ErrorType")
5293	if len(code) != 0 {
5294		errorCode = restjson.SanitizeErrorCode(code)
5295	}
5296
5297	var buff [1024]byte
5298	ringBuffer := smithyio.NewRingBuffer(buff[:])
5299
5300	body := io.TeeReader(errorBody, ringBuffer)
5301	decoder := json.NewDecoder(body)
5302	decoder.UseNumber()
5303	code, message, err := restjson.GetErrorInfo(decoder)
5304	if err != nil {
5305		var snapshot bytes.Buffer
5306		io.Copy(&snapshot, ringBuffer)
5307		err = &smithy.DeserializationError{
5308			Err:      fmt.Errorf("failed to decode response body, %w", err),
5309			Snapshot: snapshot.Bytes(),
5310		}
5311		return err
5312	}
5313
5314	errorBody.Seek(0, io.SeekStart)
5315	if len(code) != 0 {
5316		errorCode = restjson.SanitizeErrorCode(code)
5317	}
5318	if len(message) != 0 {
5319		errorMessage = message
5320	}
5321
5322	switch {
5323	case strings.EqualFold("AccessDeniedException", errorCode):
5324		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5325
5326	case strings.EqualFold("InvalidInputException", errorCode):
5327		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5328
5329	case strings.EqualFold("NotFoundException", errorCode):
5330		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5331
5332	case strings.EqualFold("OperationFailureException", errorCode):
5333		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5334
5335	case strings.EqualFold("ServiceException", errorCode):
5336		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5337
5338	case strings.EqualFold("UnauthenticatedException", errorCode):
5339		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5340
5341	default:
5342		genericError := &smithy.GenericAPIError{
5343			Code:    errorCode,
5344			Message: errorMessage,
5345		}
5346		return genericError
5347
5348	}
5349}
5350
5351type awsAwsjson11_deserializeOpDeleteDomain struct {
5352}
5353
5354func (*awsAwsjson11_deserializeOpDeleteDomain) ID() string {
5355	return "OperationDeserializer"
5356}
5357
5358func (m *awsAwsjson11_deserializeOpDeleteDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5359	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5360) {
5361	out, metadata, err = next.HandleDeserialize(ctx, in)
5362	if err != nil {
5363		return out, metadata, err
5364	}
5365
5366	response, ok := out.RawResponse.(*smithyhttp.Response)
5367	if !ok {
5368		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5369	}
5370
5371	if response.StatusCode < 200 || response.StatusCode >= 300 {
5372		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomain(response, &metadata)
5373	}
5374	output := &DeleteDomainOutput{}
5375	out.Result = output
5376
5377	var buff [1024]byte
5378	ringBuffer := smithyio.NewRingBuffer(buff[:])
5379
5380	body := io.TeeReader(response.Body, ringBuffer)
5381	decoder := json.NewDecoder(body)
5382	decoder.UseNumber()
5383	var shape interface{}
5384	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5385		var snapshot bytes.Buffer
5386		io.Copy(&snapshot, ringBuffer)
5387		err = &smithy.DeserializationError{
5388			Err:      fmt.Errorf("failed to decode response body, %w", err),
5389			Snapshot: snapshot.Bytes(),
5390		}
5391		return out, metadata, err
5392	}
5393
5394	err = awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(&output, shape)
5395	if err != nil {
5396		var snapshot bytes.Buffer
5397		io.Copy(&snapshot, ringBuffer)
5398		err = &smithy.DeserializationError{
5399			Err:      fmt.Errorf("failed to decode response body, %w", err),
5400			Snapshot: snapshot.Bytes(),
5401		}
5402		return out, metadata, err
5403	}
5404
5405	return out, metadata, err
5406}
5407
5408func awsAwsjson11_deserializeOpErrorDeleteDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5409	var errorBuffer bytes.Buffer
5410	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5411		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5412	}
5413	errorBody := bytes.NewReader(errorBuffer.Bytes())
5414
5415	errorCode := "UnknownError"
5416	errorMessage := errorCode
5417
5418	code := response.Header.Get("X-Amzn-ErrorType")
5419	if len(code) != 0 {
5420		errorCode = restjson.SanitizeErrorCode(code)
5421	}
5422
5423	var buff [1024]byte
5424	ringBuffer := smithyio.NewRingBuffer(buff[:])
5425
5426	body := io.TeeReader(errorBody, ringBuffer)
5427	decoder := json.NewDecoder(body)
5428	decoder.UseNumber()
5429	code, message, err := restjson.GetErrorInfo(decoder)
5430	if err != nil {
5431		var snapshot bytes.Buffer
5432		io.Copy(&snapshot, ringBuffer)
5433		err = &smithy.DeserializationError{
5434			Err:      fmt.Errorf("failed to decode response body, %w", err),
5435			Snapshot: snapshot.Bytes(),
5436		}
5437		return err
5438	}
5439
5440	errorBody.Seek(0, io.SeekStart)
5441	if len(code) != 0 {
5442		errorCode = restjson.SanitizeErrorCode(code)
5443	}
5444	if len(message) != 0 {
5445		errorMessage = message
5446	}
5447
5448	switch {
5449	case strings.EqualFold("AccessDeniedException", errorCode):
5450		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5451
5452	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5453		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5454
5455	case strings.EqualFold("InvalidInputException", errorCode):
5456		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5457
5458	case strings.EqualFold("NotFoundException", errorCode):
5459		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5460
5461	case strings.EqualFold("OperationFailureException", errorCode):
5462		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5463
5464	case strings.EqualFold("ServiceException", errorCode):
5465		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5466
5467	case strings.EqualFold("UnauthenticatedException", errorCode):
5468		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5469
5470	default:
5471		genericError := &smithy.GenericAPIError{
5472			Code:    errorCode,
5473			Message: errorMessage,
5474		}
5475		return genericError
5476
5477	}
5478}
5479
5480type awsAwsjson11_deserializeOpDeleteDomainEntry struct {
5481}
5482
5483func (*awsAwsjson11_deserializeOpDeleteDomainEntry) ID() string {
5484	return "OperationDeserializer"
5485}
5486
5487func (m *awsAwsjson11_deserializeOpDeleteDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5488	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5489) {
5490	out, metadata, err = next.HandleDeserialize(ctx, in)
5491	if err != nil {
5492		return out, metadata, err
5493	}
5494
5495	response, ok := out.RawResponse.(*smithyhttp.Response)
5496	if !ok {
5497		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5498	}
5499
5500	if response.StatusCode < 200 || response.StatusCode >= 300 {
5501		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response, &metadata)
5502	}
5503	output := &DeleteDomainEntryOutput{}
5504	out.Result = output
5505
5506	var buff [1024]byte
5507	ringBuffer := smithyio.NewRingBuffer(buff[:])
5508
5509	body := io.TeeReader(response.Body, ringBuffer)
5510	decoder := json.NewDecoder(body)
5511	decoder.UseNumber()
5512	var shape interface{}
5513	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5514		var snapshot bytes.Buffer
5515		io.Copy(&snapshot, ringBuffer)
5516		err = &smithy.DeserializationError{
5517			Err:      fmt.Errorf("failed to decode response body, %w", err),
5518			Snapshot: snapshot.Bytes(),
5519		}
5520		return out, metadata, err
5521	}
5522
5523	err = awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(&output, shape)
5524	if err != nil {
5525		var snapshot bytes.Buffer
5526		io.Copy(&snapshot, ringBuffer)
5527		err = &smithy.DeserializationError{
5528			Err:      fmt.Errorf("failed to decode response body, %w", err),
5529			Snapshot: snapshot.Bytes(),
5530		}
5531		return out, metadata, err
5532	}
5533
5534	return out, metadata, err
5535}
5536
5537func awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5538	var errorBuffer bytes.Buffer
5539	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5540		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5541	}
5542	errorBody := bytes.NewReader(errorBuffer.Bytes())
5543
5544	errorCode := "UnknownError"
5545	errorMessage := errorCode
5546
5547	code := response.Header.Get("X-Amzn-ErrorType")
5548	if len(code) != 0 {
5549		errorCode = restjson.SanitizeErrorCode(code)
5550	}
5551
5552	var buff [1024]byte
5553	ringBuffer := smithyio.NewRingBuffer(buff[:])
5554
5555	body := io.TeeReader(errorBody, ringBuffer)
5556	decoder := json.NewDecoder(body)
5557	decoder.UseNumber()
5558	code, message, err := restjson.GetErrorInfo(decoder)
5559	if err != nil {
5560		var snapshot bytes.Buffer
5561		io.Copy(&snapshot, ringBuffer)
5562		err = &smithy.DeserializationError{
5563			Err:      fmt.Errorf("failed to decode response body, %w", err),
5564			Snapshot: snapshot.Bytes(),
5565		}
5566		return err
5567	}
5568
5569	errorBody.Seek(0, io.SeekStart)
5570	if len(code) != 0 {
5571		errorCode = restjson.SanitizeErrorCode(code)
5572	}
5573	if len(message) != 0 {
5574		errorMessage = message
5575	}
5576
5577	switch {
5578	case strings.EqualFold("AccessDeniedException", errorCode):
5579		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5580
5581	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5582		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5583
5584	case strings.EqualFold("InvalidInputException", errorCode):
5585		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5586
5587	case strings.EqualFold("NotFoundException", errorCode):
5588		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5589
5590	case strings.EqualFold("OperationFailureException", errorCode):
5591		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5592
5593	case strings.EqualFold("ServiceException", errorCode):
5594		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5595
5596	case strings.EqualFold("UnauthenticatedException", errorCode):
5597		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5598
5599	default:
5600		genericError := &smithy.GenericAPIError{
5601			Code:    errorCode,
5602			Message: errorMessage,
5603		}
5604		return genericError
5605
5606	}
5607}
5608
5609type awsAwsjson11_deserializeOpDeleteInstance struct {
5610}
5611
5612func (*awsAwsjson11_deserializeOpDeleteInstance) ID() string {
5613	return "OperationDeserializer"
5614}
5615
5616func (m *awsAwsjson11_deserializeOpDeleteInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5617	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5618) {
5619	out, metadata, err = next.HandleDeserialize(ctx, in)
5620	if err != nil {
5621		return out, metadata, err
5622	}
5623
5624	response, ok := out.RawResponse.(*smithyhttp.Response)
5625	if !ok {
5626		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5627	}
5628
5629	if response.StatusCode < 200 || response.StatusCode >= 300 {
5630		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstance(response, &metadata)
5631	}
5632	output := &DeleteInstanceOutput{}
5633	out.Result = output
5634
5635	var buff [1024]byte
5636	ringBuffer := smithyio.NewRingBuffer(buff[:])
5637
5638	body := io.TeeReader(response.Body, ringBuffer)
5639	decoder := json.NewDecoder(body)
5640	decoder.UseNumber()
5641	var shape interface{}
5642	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
5650	}
5651
5652	err = awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(&output, shape)
5653	if err != nil {
5654		var snapshot bytes.Buffer
5655		io.Copy(&snapshot, ringBuffer)
5656		err = &smithy.DeserializationError{
5657			Err:      fmt.Errorf("failed to decode response body, %w", err),
5658			Snapshot: snapshot.Bytes(),
5659		}
5660		return out, metadata, err
5661	}
5662
5663	return out, metadata, err
5664}
5665
5666func awsAwsjson11_deserializeOpErrorDeleteInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5667	var errorBuffer bytes.Buffer
5668	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5669		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5670	}
5671	errorBody := bytes.NewReader(errorBuffer.Bytes())
5672
5673	errorCode := "UnknownError"
5674	errorMessage := errorCode
5675
5676	code := response.Header.Get("X-Amzn-ErrorType")
5677	if len(code) != 0 {
5678		errorCode = restjson.SanitizeErrorCode(code)
5679	}
5680
5681	var buff [1024]byte
5682	ringBuffer := smithyio.NewRingBuffer(buff[:])
5683
5684	body := io.TeeReader(errorBody, ringBuffer)
5685	decoder := json.NewDecoder(body)
5686	decoder.UseNumber()
5687	code, message, err := restjson.GetErrorInfo(decoder)
5688	if err != nil {
5689		var snapshot bytes.Buffer
5690		io.Copy(&snapshot, ringBuffer)
5691		err = &smithy.DeserializationError{
5692			Err:      fmt.Errorf("failed to decode response body, %w", err),
5693			Snapshot: snapshot.Bytes(),
5694		}
5695		return err
5696	}
5697
5698	errorBody.Seek(0, io.SeekStart)
5699	if len(code) != 0 {
5700		errorCode = restjson.SanitizeErrorCode(code)
5701	}
5702	if len(message) != 0 {
5703		errorMessage = message
5704	}
5705
5706	switch {
5707	case strings.EqualFold("AccessDeniedException", errorCode):
5708		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5709
5710	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5711		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5712
5713	case strings.EqualFold("InvalidInputException", errorCode):
5714		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5715
5716	case strings.EqualFold("NotFoundException", errorCode):
5717		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5718
5719	case strings.EqualFold("OperationFailureException", errorCode):
5720		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5721
5722	case strings.EqualFold("ServiceException", errorCode):
5723		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5724
5725	case strings.EqualFold("UnauthenticatedException", errorCode):
5726		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5727
5728	default:
5729		genericError := &smithy.GenericAPIError{
5730			Code:    errorCode,
5731			Message: errorMessage,
5732		}
5733		return genericError
5734
5735	}
5736}
5737
5738type awsAwsjson11_deserializeOpDeleteInstanceSnapshot struct {
5739}
5740
5741func (*awsAwsjson11_deserializeOpDeleteInstanceSnapshot) ID() string {
5742	return "OperationDeserializer"
5743}
5744
5745func (m *awsAwsjson11_deserializeOpDeleteInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5746	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5747) {
5748	out, metadata, err = next.HandleDeserialize(ctx, in)
5749	if err != nil {
5750		return out, metadata, err
5751	}
5752
5753	response, ok := out.RawResponse.(*smithyhttp.Response)
5754	if !ok {
5755		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5756	}
5757
5758	if response.StatusCode < 200 || response.StatusCode >= 300 {
5759		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response, &metadata)
5760	}
5761	output := &DeleteInstanceSnapshotOutput{}
5762	out.Result = output
5763
5764	var buff [1024]byte
5765	ringBuffer := smithyio.NewRingBuffer(buff[:])
5766
5767	body := io.TeeReader(response.Body, ringBuffer)
5768	decoder := json.NewDecoder(body)
5769	decoder.UseNumber()
5770	var shape interface{}
5771	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5772		var snapshot bytes.Buffer
5773		io.Copy(&snapshot, ringBuffer)
5774		err = &smithy.DeserializationError{
5775			Err:      fmt.Errorf("failed to decode response body, %w", err),
5776			Snapshot: snapshot.Bytes(),
5777		}
5778		return out, metadata, err
5779	}
5780
5781	err = awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(&output, shape)
5782	if err != nil {
5783		var snapshot bytes.Buffer
5784		io.Copy(&snapshot, ringBuffer)
5785		err = &smithy.DeserializationError{
5786			Err:      fmt.Errorf("failed to decode response body, %w", err),
5787			Snapshot: snapshot.Bytes(),
5788		}
5789		return out, metadata, err
5790	}
5791
5792	return out, metadata, err
5793}
5794
5795func awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5796	var errorBuffer bytes.Buffer
5797	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5798		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5799	}
5800	errorBody := bytes.NewReader(errorBuffer.Bytes())
5801
5802	errorCode := "UnknownError"
5803	errorMessage := errorCode
5804
5805	code := response.Header.Get("X-Amzn-ErrorType")
5806	if len(code) != 0 {
5807		errorCode = restjson.SanitizeErrorCode(code)
5808	}
5809
5810	var buff [1024]byte
5811	ringBuffer := smithyio.NewRingBuffer(buff[:])
5812
5813	body := io.TeeReader(errorBody, ringBuffer)
5814	decoder := json.NewDecoder(body)
5815	decoder.UseNumber()
5816	code, message, err := restjson.GetErrorInfo(decoder)
5817	if err != nil {
5818		var snapshot bytes.Buffer
5819		io.Copy(&snapshot, ringBuffer)
5820		err = &smithy.DeserializationError{
5821			Err:      fmt.Errorf("failed to decode response body, %w", err),
5822			Snapshot: snapshot.Bytes(),
5823		}
5824		return err
5825	}
5826
5827	errorBody.Seek(0, io.SeekStart)
5828	if len(code) != 0 {
5829		errorCode = restjson.SanitizeErrorCode(code)
5830	}
5831	if len(message) != 0 {
5832		errorMessage = message
5833	}
5834
5835	switch {
5836	case strings.EqualFold("AccessDeniedException", errorCode):
5837		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5838
5839	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5840		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5841
5842	case strings.EqualFold("InvalidInputException", errorCode):
5843		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5844
5845	case strings.EqualFold("NotFoundException", errorCode):
5846		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5847
5848	case strings.EqualFold("OperationFailureException", errorCode):
5849		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5850
5851	case strings.EqualFold("ServiceException", errorCode):
5852		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5853
5854	case strings.EqualFold("UnauthenticatedException", errorCode):
5855		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5856
5857	default:
5858		genericError := &smithy.GenericAPIError{
5859			Code:    errorCode,
5860			Message: errorMessage,
5861		}
5862		return genericError
5863
5864	}
5865}
5866
5867type awsAwsjson11_deserializeOpDeleteKeyPair struct {
5868}
5869
5870func (*awsAwsjson11_deserializeOpDeleteKeyPair) ID() string {
5871	return "OperationDeserializer"
5872}
5873
5874func (m *awsAwsjson11_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5875	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5876) {
5877	out, metadata, err = next.HandleDeserialize(ctx, in)
5878	if err != nil {
5879		return out, metadata, err
5880	}
5881
5882	response, ok := out.RawResponse.(*smithyhttp.Response)
5883	if !ok {
5884		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5885	}
5886
5887	if response.StatusCode < 200 || response.StatusCode >= 300 {
5888		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKeyPair(response, &metadata)
5889	}
5890	output := &DeleteKeyPairOutput{}
5891	out.Result = output
5892
5893	var buff [1024]byte
5894	ringBuffer := smithyio.NewRingBuffer(buff[:])
5895
5896	body := io.TeeReader(response.Body, ringBuffer)
5897	decoder := json.NewDecoder(body)
5898	decoder.UseNumber()
5899	var shape interface{}
5900	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5901		var snapshot bytes.Buffer
5902		io.Copy(&snapshot, ringBuffer)
5903		err = &smithy.DeserializationError{
5904			Err:      fmt.Errorf("failed to decode response body, %w", err),
5905			Snapshot: snapshot.Bytes(),
5906		}
5907		return out, metadata, err
5908	}
5909
5910	err = awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(&output, shape)
5911	if err != nil {
5912		var snapshot bytes.Buffer
5913		io.Copy(&snapshot, ringBuffer)
5914		err = &smithy.DeserializationError{
5915			Err:      fmt.Errorf("failed to decode response body, %w", err),
5916			Snapshot: snapshot.Bytes(),
5917		}
5918		return out, metadata, err
5919	}
5920
5921	return out, metadata, err
5922}
5923
5924func awsAwsjson11_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5925	var errorBuffer bytes.Buffer
5926	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5927		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5928	}
5929	errorBody := bytes.NewReader(errorBuffer.Bytes())
5930
5931	errorCode := "UnknownError"
5932	errorMessage := errorCode
5933
5934	code := response.Header.Get("X-Amzn-ErrorType")
5935	if len(code) != 0 {
5936		errorCode = restjson.SanitizeErrorCode(code)
5937	}
5938
5939	var buff [1024]byte
5940	ringBuffer := smithyio.NewRingBuffer(buff[:])
5941
5942	body := io.TeeReader(errorBody, ringBuffer)
5943	decoder := json.NewDecoder(body)
5944	decoder.UseNumber()
5945	code, message, err := restjson.GetErrorInfo(decoder)
5946	if err != nil {
5947		var snapshot bytes.Buffer
5948		io.Copy(&snapshot, ringBuffer)
5949		err = &smithy.DeserializationError{
5950			Err:      fmt.Errorf("failed to decode response body, %w", err),
5951			Snapshot: snapshot.Bytes(),
5952		}
5953		return err
5954	}
5955
5956	errorBody.Seek(0, io.SeekStart)
5957	if len(code) != 0 {
5958		errorCode = restjson.SanitizeErrorCode(code)
5959	}
5960	if len(message) != 0 {
5961		errorMessage = message
5962	}
5963
5964	switch {
5965	case strings.EqualFold("AccessDeniedException", errorCode):
5966		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5967
5968	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5969		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5970
5971	case strings.EqualFold("InvalidInputException", errorCode):
5972		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5973
5974	case strings.EqualFold("NotFoundException", errorCode):
5975		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5976
5977	case strings.EqualFold("OperationFailureException", errorCode):
5978		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5979
5980	case strings.EqualFold("ServiceException", errorCode):
5981		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5982
5983	case strings.EqualFold("UnauthenticatedException", errorCode):
5984		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5985
5986	default:
5987		genericError := &smithy.GenericAPIError{
5988			Code:    errorCode,
5989			Message: errorMessage,
5990		}
5991		return genericError
5992
5993	}
5994}
5995
5996type awsAwsjson11_deserializeOpDeleteKnownHostKeys struct {
5997}
5998
5999func (*awsAwsjson11_deserializeOpDeleteKnownHostKeys) ID() string {
6000	return "OperationDeserializer"
6001}
6002
6003func (m *awsAwsjson11_deserializeOpDeleteKnownHostKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6004	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6005) {
6006	out, metadata, err = next.HandleDeserialize(ctx, in)
6007	if err != nil {
6008		return out, metadata, err
6009	}
6010
6011	response, ok := out.RawResponse.(*smithyhttp.Response)
6012	if !ok {
6013		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6014	}
6015
6016	if response.StatusCode < 200 || response.StatusCode >= 300 {
6017		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response, &metadata)
6018	}
6019	output := &DeleteKnownHostKeysOutput{}
6020	out.Result = output
6021
6022	var buff [1024]byte
6023	ringBuffer := smithyio.NewRingBuffer(buff[:])
6024
6025	body := io.TeeReader(response.Body, ringBuffer)
6026	decoder := json.NewDecoder(body)
6027	decoder.UseNumber()
6028	var shape interface{}
6029	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6030		var snapshot bytes.Buffer
6031		io.Copy(&snapshot, ringBuffer)
6032		err = &smithy.DeserializationError{
6033			Err:      fmt.Errorf("failed to decode response body, %w", err),
6034			Snapshot: snapshot.Bytes(),
6035		}
6036		return out, metadata, err
6037	}
6038
6039	err = awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(&output, shape)
6040	if err != nil {
6041		var snapshot bytes.Buffer
6042		io.Copy(&snapshot, ringBuffer)
6043		err = &smithy.DeserializationError{
6044			Err:      fmt.Errorf("failed to decode response body, %w", err),
6045			Snapshot: snapshot.Bytes(),
6046		}
6047		return out, metadata, err
6048	}
6049
6050	return out, metadata, err
6051}
6052
6053func awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6054	var errorBuffer bytes.Buffer
6055	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6056		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6057	}
6058	errorBody := bytes.NewReader(errorBuffer.Bytes())
6059
6060	errorCode := "UnknownError"
6061	errorMessage := errorCode
6062
6063	code := response.Header.Get("X-Amzn-ErrorType")
6064	if len(code) != 0 {
6065		errorCode = restjson.SanitizeErrorCode(code)
6066	}
6067
6068	var buff [1024]byte
6069	ringBuffer := smithyio.NewRingBuffer(buff[:])
6070
6071	body := io.TeeReader(errorBody, ringBuffer)
6072	decoder := json.NewDecoder(body)
6073	decoder.UseNumber()
6074	code, message, err := restjson.GetErrorInfo(decoder)
6075	if err != nil {
6076		var snapshot bytes.Buffer
6077		io.Copy(&snapshot, ringBuffer)
6078		err = &smithy.DeserializationError{
6079			Err:      fmt.Errorf("failed to decode response body, %w", err),
6080			Snapshot: snapshot.Bytes(),
6081		}
6082		return err
6083	}
6084
6085	errorBody.Seek(0, io.SeekStart)
6086	if len(code) != 0 {
6087		errorCode = restjson.SanitizeErrorCode(code)
6088	}
6089	if len(message) != 0 {
6090		errorMessage = message
6091	}
6092
6093	switch {
6094	case strings.EqualFold("AccessDeniedException", errorCode):
6095		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6096
6097	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6098		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6099
6100	case strings.EqualFold("InvalidInputException", errorCode):
6101		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6102
6103	case strings.EqualFold("NotFoundException", errorCode):
6104		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6105
6106	case strings.EqualFold("OperationFailureException", errorCode):
6107		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6108
6109	case strings.EqualFold("ServiceException", errorCode):
6110		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6111
6112	case strings.EqualFold("UnauthenticatedException", errorCode):
6113		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6114
6115	default:
6116		genericError := &smithy.GenericAPIError{
6117			Code:    errorCode,
6118			Message: errorMessage,
6119		}
6120		return genericError
6121
6122	}
6123}
6124
6125type awsAwsjson11_deserializeOpDeleteLoadBalancer struct {
6126}
6127
6128func (*awsAwsjson11_deserializeOpDeleteLoadBalancer) ID() string {
6129	return "OperationDeserializer"
6130}
6131
6132func (m *awsAwsjson11_deserializeOpDeleteLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6133	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6134) {
6135	out, metadata, err = next.HandleDeserialize(ctx, in)
6136	if err != nil {
6137		return out, metadata, err
6138	}
6139
6140	response, ok := out.RawResponse.(*smithyhttp.Response)
6141	if !ok {
6142		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6143	}
6144
6145	if response.StatusCode < 200 || response.StatusCode >= 300 {
6146		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response, &metadata)
6147	}
6148	output := &DeleteLoadBalancerOutput{}
6149	out.Result = output
6150
6151	var buff [1024]byte
6152	ringBuffer := smithyio.NewRingBuffer(buff[:])
6153
6154	body := io.TeeReader(response.Body, ringBuffer)
6155	decoder := json.NewDecoder(body)
6156	decoder.UseNumber()
6157	var shape interface{}
6158	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6159		var snapshot bytes.Buffer
6160		io.Copy(&snapshot, ringBuffer)
6161		err = &smithy.DeserializationError{
6162			Err:      fmt.Errorf("failed to decode response body, %w", err),
6163			Snapshot: snapshot.Bytes(),
6164		}
6165		return out, metadata, err
6166	}
6167
6168	err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(&output, shape)
6169	if err != nil {
6170		var snapshot bytes.Buffer
6171		io.Copy(&snapshot, ringBuffer)
6172		err = &smithy.DeserializationError{
6173			Err:      fmt.Errorf("failed to decode response body, %w", err),
6174			Snapshot: snapshot.Bytes(),
6175		}
6176		return out, metadata, err
6177	}
6178
6179	return out, metadata, err
6180}
6181
6182func awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6183	var errorBuffer bytes.Buffer
6184	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6185		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6186	}
6187	errorBody := bytes.NewReader(errorBuffer.Bytes())
6188
6189	errorCode := "UnknownError"
6190	errorMessage := errorCode
6191
6192	code := response.Header.Get("X-Amzn-ErrorType")
6193	if len(code) != 0 {
6194		errorCode = restjson.SanitizeErrorCode(code)
6195	}
6196
6197	var buff [1024]byte
6198	ringBuffer := smithyio.NewRingBuffer(buff[:])
6199
6200	body := io.TeeReader(errorBody, ringBuffer)
6201	decoder := json.NewDecoder(body)
6202	decoder.UseNumber()
6203	code, message, err := restjson.GetErrorInfo(decoder)
6204	if err != nil {
6205		var snapshot bytes.Buffer
6206		io.Copy(&snapshot, ringBuffer)
6207		err = &smithy.DeserializationError{
6208			Err:      fmt.Errorf("failed to decode response body, %w", err),
6209			Snapshot: snapshot.Bytes(),
6210		}
6211		return err
6212	}
6213
6214	errorBody.Seek(0, io.SeekStart)
6215	if len(code) != 0 {
6216		errorCode = restjson.SanitizeErrorCode(code)
6217	}
6218	if len(message) != 0 {
6219		errorMessage = message
6220	}
6221
6222	switch {
6223	case strings.EqualFold("AccessDeniedException", errorCode):
6224		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6225
6226	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6227		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6228
6229	case strings.EqualFold("InvalidInputException", errorCode):
6230		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6231
6232	case strings.EqualFold("NotFoundException", errorCode):
6233		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6234
6235	case strings.EqualFold("OperationFailureException", errorCode):
6236		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6237
6238	case strings.EqualFold("ServiceException", errorCode):
6239		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6240
6241	case strings.EqualFold("UnauthenticatedException", errorCode):
6242		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6243
6244	default:
6245		genericError := &smithy.GenericAPIError{
6246			Code:    errorCode,
6247			Message: errorMessage,
6248		}
6249		return genericError
6250
6251	}
6252}
6253
6254type awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate struct {
6255}
6256
6257func (*awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) ID() string {
6258	return "OperationDeserializer"
6259}
6260
6261func (m *awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6262	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6263) {
6264	out, metadata, err = next.HandleDeserialize(ctx, in)
6265	if err != nil {
6266		return out, metadata, err
6267	}
6268
6269	response, ok := out.RawResponse.(*smithyhttp.Response)
6270	if !ok {
6271		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6272	}
6273
6274	if response.StatusCode < 200 || response.StatusCode >= 300 {
6275		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response, &metadata)
6276	}
6277	output := &DeleteLoadBalancerTlsCertificateOutput{}
6278	out.Result = output
6279
6280	var buff [1024]byte
6281	ringBuffer := smithyio.NewRingBuffer(buff[:])
6282
6283	body := io.TeeReader(response.Body, ringBuffer)
6284	decoder := json.NewDecoder(body)
6285	decoder.UseNumber()
6286	var shape interface{}
6287	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6288		var snapshot bytes.Buffer
6289		io.Copy(&snapshot, ringBuffer)
6290		err = &smithy.DeserializationError{
6291			Err:      fmt.Errorf("failed to decode response body, %w", err),
6292			Snapshot: snapshot.Bytes(),
6293		}
6294		return out, metadata, err
6295	}
6296
6297	err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(&output, shape)
6298	if err != nil {
6299		var snapshot bytes.Buffer
6300		io.Copy(&snapshot, ringBuffer)
6301		err = &smithy.DeserializationError{
6302			Err:      fmt.Errorf("failed to decode response body, %w", err),
6303			Snapshot: snapshot.Bytes(),
6304		}
6305		return out, metadata, err
6306	}
6307
6308	return out, metadata, err
6309}
6310
6311func awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6312	var errorBuffer bytes.Buffer
6313	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6314		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6315	}
6316	errorBody := bytes.NewReader(errorBuffer.Bytes())
6317
6318	errorCode := "UnknownError"
6319	errorMessage := errorCode
6320
6321	code := response.Header.Get("X-Amzn-ErrorType")
6322	if len(code) != 0 {
6323		errorCode = restjson.SanitizeErrorCode(code)
6324	}
6325
6326	var buff [1024]byte
6327	ringBuffer := smithyio.NewRingBuffer(buff[:])
6328
6329	body := io.TeeReader(errorBody, ringBuffer)
6330	decoder := json.NewDecoder(body)
6331	decoder.UseNumber()
6332	code, message, err := restjson.GetErrorInfo(decoder)
6333	if err != nil {
6334		var snapshot bytes.Buffer
6335		io.Copy(&snapshot, ringBuffer)
6336		err = &smithy.DeserializationError{
6337			Err:      fmt.Errorf("failed to decode response body, %w", err),
6338			Snapshot: snapshot.Bytes(),
6339		}
6340		return err
6341	}
6342
6343	errorBody.Seek(0, io.SeekStart)
6344	if len(code) != 0 {
6345		errorCode = restjson.SanitizeErrorCode(code)
6346	}
6347	if len(message) != 0 {
6348		errorMessage = message
6349	}
6350
6351	switch {
6352	case strings.EqualFold("AccessDeniedException", errorCode):
6353		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6354
6355	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6356		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6357
6358	case strings.EqualFold("InvalidInputException", errorCode):
6359		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6360
6361	case strings.EqualFold("NotFoundException", errorCode):
6362		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6363
6364	case strings.EqualFold("OperationFailureException", errorCode):
6365		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6366
6367	case strings.EqualFold("ServiceException", errorCode):
6368		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6369
6370	case strings.EqualFold("UnauthenticatedException", errorCode):
6371		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6372
6373	default:
6374		genericError := &smithy.GenericAPIError{
6375			Code:    errorCode,
6376			Message: errorMessage,
6377		}
6378		return genericError
6379
6380	}
6381}
6382
6383type awsAwsjson11_deserializeOpDeleteRelationalDatabase struct {
6384}
6385
6386func (*awsAwsjson11_deserializeOpDeleteRelationalDatabase) ID() string {
6387	return "OperationDeserializer"
6388}
6389
6390func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6391	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6392) {
6393	out, metadata, err = next.HandleDeserialize(ctx, in)
6394	if err != nil {
6395		return out, metadata, err
6396	}
6397
6398	response, ok := out.RawResponse.(*smithyhttp.Response)
6399	if !ok {
6400		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6401	}
6402
6403	if response.StatusCode < 200 || response.StatusCode >= 300 {
6404		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response, &metadata)
6405	}
6406	output := &DeleteRelationalDatabaseOutput{}
6407	out.Result = output
6408
6409	var buff [1024]byte
6410	ringBuffer := smithyio.NewRingBuffer(buff[:])
6411
6412	body := io.TeeReader(response.Body, ringBuffer)
6413	decoder := json.NewDecoder(body)
6414	decoder.UseNumber()
6415	var shape interface{}
6416	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6417		var snapshot bytes.Buffer
6418		io.Copy(&snapshot, ringBuffer)
6419		err = &smithy.DeserializationError{
6420			Err:      fmt.Errorf("failed to decode response body, %w", err),
6421			Snapshot: snapshot.Bytes(),
6422		}
6423		return out, metadata, err
6424	}
6425
6426	err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(&output, shape)
6427	if err != nil {
6428		var snapshot bytes.Buffer
6429		io.Copy(&snapshot, ringBuffer)
6430		err = &smithy.DeserializationError{
6431			Err:      fmt.Errorf("failed to decode response body, %w", err),
6432			Snapshot: snapshot.Bytes(),
6433		}
6434		return out, metadata, err
6435	}
6436
6437	return out, metadata, err
6438}
6439
6440func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6441	var errorBuffer bytes.Buffer
6442	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6443		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6444	}
6445	errorBody := bytes.NewReader(errorBuffer.Bytes())
6446
6447	errorCode := "UnknownError"
6448	errorMessage := errorCode
6449
6450	code := response.Header.Get("X-Amzn-ErrorType")
6451	if len(code) != 0 {
6452		errorCode = restjson.SanitizeErrorCode(code)
6453	}
6454
6455	var buff [1024]byte
6456	ringBuffer := smithyio.NewRingBuffer(buff[:])
6457
6458	body := io.TeeReader(errorBody, ringBuffer)
6459	decoder := json.NewDecoder(body)
6460	decoder.UseNumber()
6461	code, message, err := restjson.GetErrorInfo(decoder)
6462	if err != nil {
6463		var snapshot bytes.Buffer
6464		io.Copy(&snapshot, ringBuffer)
6465		err = &smithy.DeserializationError{
6466			Err:      fmt.Errorf("failed to decode response body, %w", err),
6467			Snapshot: snapshot.Bytes(),
6468		}
6469		return err
6470	}
6471
6472	errorBody.Seek(0, io.SeekStart)
6473	if len(code) != 0 {
6474		errorCode = restjson.SanitizeErrorCode(code)
6475	}
6476	if len(message) != 0 {
6477		errorMessage = message
6478	}
6479
6480	switch {
6481	case strings.EqualFold("AccessDeniedException", errorCode):
6482		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6483
6484	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6485		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6486
6487	case strings.EqualFold("InvalidInputException", errorCode):
6488		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6489
6490	case strings.EqualFold("NotFoundException", errorCode):
6491		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6492
6493	case strings.EqualFold("OperationFailureException", errorCode):
6494		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6495
6496	case strings.EqualFold("ServiceException", errorCode):
6497		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6498
6499	case strings.EqualFold("UnauthenticatedException", errorCode):
6500		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6501
6502	default:
6503		genericError := &smithy.GenericAPIError{
6504			Code:    errorCode,
6505			Message: errorMessage,
6506		}
6507		return genericError
6508
6509	}
6510}
6511
6512type awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot struct {
6513}
6514
6515func (*awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) ID() string {
6516	return "OperationDeserializer"
6517}
6518
6519func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6520	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6521) {
6522	out, metadata, err = next.HandleDeserialize(ctx, in)
6523	if err != nil {
6524		return out, metadata, err
6525	}
6526
6527	response, ok := out.RawResponse.(*smithyhttp.Response)
6528	if !ok {
6529		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6530	}
6531
6532	if response.StatusCode < 200 || response.StatusCode >= 300 {
6533		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response, &metadata)
6534	}
6535	output := &DeleteRelationalDatabaseSnapshotOutput{}
6536	out.Result = output
6537
6538	var buff [1024]byte
6539	ringBuffer := smithyio.NewRingBuffer(buff[:])
6540
6541	body := io.TeeReader(response.Body, ringBuffer)
6542	decoder := json.NewDecoder(body)
6543	decoder.UseNumber()
6544	var shape interface{}
6545	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6546		var snapshot bytes.Buffer
6547		io.Copy(&snapshot, ringBuffer)
6548		err = &smithy.DeserializationError{
6549			Err:      fmt.Errorf("failed to decode response body, %w", err),
6550			Snapshot: snapshot.Bytes(),
6551		}
6552		return out, metadata, err
6553	}
6554
6555	err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(&output, shape)
6556	if err != nil {
6557		var snapshot bytes.Buffer
6558		io.Copy(&snapshot, ringBuffer)
6559		err = &smithy.DeserializationError{
6560			Err:      fmt.Errorf("failed to decode response body, %w", err),
6561			Snapshot: snapshot.Bytes(),
6562		}
6563		return out, metadata, err
6564	}
6565
6566	return out, metadata, err
6567}
6568
6569func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6570	var errorBuffer bytes.Buffer
6571	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6572		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6573	}
6574	errorBody := bytes.NewReader(errorBuffer.Bytes())
6575
6576	errorCode := "UnknownError"
6577	errorMessage := errorCode
6578
6579	code := response.Header.Get("X-Amzn-ErrorType")
6580	if len(code) != 0 {
6581		errorCode = restjson.SanitizeErrorCode(code)
6582	}
6583
6584	var buff [1024]byte
6585	ringBuffer := smithyio.NewRingBuffer(buff[:])
6586
6587	body := io.TeeReader(errorBody, ringBuffer)
6588	decoder := json.NewDecoder(body)
6589	decoder.UseNumber()
6590	code, message, err := restjson.GetErrorInfo(decoder)
6591	if err != nil {
6592		var snapshot bytes.Buffer
6593		io.Copy(&snapshot, ringBuffer)
6594		err = &smithy.DeserializationError{
6595			Err:      fmt.Errorf("failed to decode response body, %w", err),
6596			Snapshot: snapshot.Bytes(),
6597		}
6598		return err
6599	}
6600
6601	errorBody.Seek(0, io.SeekStart)
6602	if len(code) != 0 {
6603		errorCode = restjson.SanitizeErrorCode(code)
6604	}
6605	if len(message) != 0 {
6606		errorMessage = message
6607	}
6608
6609	switch {
6610	case strings.EqualFold("AccessDeniedException", errorCode):
6611		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6612
6613	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6614		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6615
6616	case strings.EqualFold("InvalidInputException", errorCode):
6617		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6618
6619	case strings.EqualFold("NotFoundException", errorCode):
6620		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6621
6622	case strings.EqualFold("OperationFailureException", errorCode):
6623		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6624
6625	case strings.EqualFold("ServiceException", errorCode):
6626		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6627
6628	case strings.EqualFold("UnauthenticatedException", errorCode):
6629		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6630
6631	default:
6632		genericError := &smithy.GenericAPIError{
6633			Code:    errorCode,
6634			Message: errorMessage,
6635		}
6636		return genericError
6637
6638	}
6639}
6640
6641type awsAwsjson11_deserializeOpDetachCertificateFromDistribution struct {
6642}
6643
6644func (*awsAwsjson11_deserializeOpDetachCertificateFromDistribution) ID() string {
6645	return "OperationDeserializer"
6646}
6647
6648func (m *awsAwsjson11_deserializeOpDetachCertificateFromDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6649	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6650) {
6651	out, metadata, err = next.HandleDeserialize(ctx, in)
6652	if err != nil {
6653		return out, metadata, err
6654	}
6655
6656	response, ok := out.RawResponse.(*smithyhttp.Response)
6657	if !ok {
6658		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6659	}
6660
6661	if response.StatusCode < 200 || response.StatusCode >= 300 {
6662		return out, metadata, awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response, &metadata)
6663	}
6664	output := &DetachCertificateFromDistributionOutput{}
6665	out.Result = output
6666
6667	var buff [1024]byte
6668	ringBuffer := smithyio.NewRingBuffer(buff[:])
6669
6670	body := io.TeeReader(response.Body, ringBuffer)
6671	decoder := json.NewDecoder(body)
6672	decoder.UseNumber()
6673	var shape interface{}
6674	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6675		var snapshot bytes.Buffer
6676		io.Copy(&snapshot, ringBuffer)
6677		err = &smithy.DeserializationError{
6678			Err:      fmt.Errorf("failed to decode response body, %w", err),
6679			Snapshot: snapshot.Bytes(),
6680		}
6681		return out, metadata, err
6682	}
6683
6684	err = awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(&output, shape)
6685	if err != nil {
6686		var snapshot bytes.Buffer
6687		io.Copy(&snapshot, ringBuffer)
6688		err = &smithy.DeserializationError{
6689			Err:      fmt.Errorf("failed to decode response body, %w", err),
6690			Snapshot: snapshot.Bytes(),
6691		}
6692		return out, metadata, err
6693	}
6694
6695	return out, metadata, err
6696}
6697
6698func awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6699	var errorBuffer bytes.Buffer
6700	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6701		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6702	}
6703	errorBody := bytes.NewReader(errorBuffer.Bytes())
6704
6705	errorCode := "UnknownError"
6706	errorMessage := errorCode
6707
6708	code := response.Header.Get("X-Amzn-ErrorType")
6709	if len(code) != 0 {
6710		errorCode = restjson.SanitizeErrorCode(code)
6711	}
6712
6713	var buff [1024]byte
6714	ringBuffer := smithyio.NewRingBuffer(buff[:])
6715
6716	body := io.TeeReader(errorBody, ringBuffer)
6717	decoder := json.NewDecoder(body)
6718	decoder.UseNumber()
6719	code, message, err := restjson.GetErrorInfo(decoder)
6720	if err != nil {
6721		var snapshot bytes.Buffer
6722		io.Copy(&snapshot, ringBuffer)
6723		err = &smithy.DeserializationError{
6724			Err:      fmt.Errorf("failed to decode response body, %w", err),
6725			Snapshot: snapshot.Bytes(),
6726		}
6727		return err
6728	}
6729
6730	errorBody.Seek(0, io.SeekStart)
6731	if len(code) != 0 {
6732		errorCode = restjson.SanitizeErrorCode(code)
6733	}
6734	if len(message) != 0 {
6735		errorMessage = message
6736	}
6737
6738	switch {
6739	case strings.EqualFold("AccessDeniedException", errorCode):
6740		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6741
6742	case strings.EqualFold("InvalidInputException", errorCode):
6743		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6744
6745	case strings.EqualFold("NotFoundException", errorCode):
6746		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6747
6748	case strings.EqualFold("OperationFailureException", errorCode):
6749		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6750
6751	case strings.EqualFold("ServiceException", errorCode):
6752		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6753
6754	case strings.EqualFold("UnauthenticatedException", errorCode):
6755		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6756
6757	default:
6758		genericError := &smithy.GenericAPIError{
6759			Code:    errorCode,
6760			Message: errorMessage,
6761		}
6762		return genericError
6763
6764	}
6765}
6766
6767type awsAwsjson11_deserializeOpDetachDisk struct {
6768}
6769
6770func (*awsAwsjson11_deserializeOpDetachDisk) ID() string {
6771	return "OperationDeserializer"
6772}
6773
6774func (m *awsAwsjson11_deserializeOpDetachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6775	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6776) {
6777	out, metadata, err = next.HandleDeserialize(ctx, in)
6778	if err != nil {
6779		return out, metadata, err
6780	}
6781
6782	response, ok := out.RawResponse.(*smithyhttp.Response)
6783	if !ok {
6784		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6785	}
6786
6787	if response.StatusCode < 200 || response.StatusCode >= 300 {
6788		return out, metadata, awsAwsjson11_deserializeOpErrorDetachDisk(response, &metadata)
6789	}
6790	output := &DetachDiskOutput{}
6791	out.Result = output
6792
6793	var buff [1024]byte
6794	ringBuffer := smithyio.NewRingBuffer(buff[:])
6795
6796	body := io.TeeReader(response.Body, ringBuffer)
6797	decoder := json.NewDecoder(body)
6798	decoder.UseNumber()
6799	var shape interface{}
6800	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6801		var snapshot bytes.Buffer
6802		io.Copy(&snapshot, ringBuffer)
6803		err = &smithy.DeserializationError{
6804			Err:      fmt.Errorf("failed to decode response body, %w", err),
6805			Snapshot: snapshot.Bytes(),
6806		}
6807		return out, metadata, err
6808	}
6809
6810	err = awsAwsjson11_deserializeOpDocumentDetachDiskOutput(&output, shape)
6811	if err != nil {
6812		var snapshot bytes.Buffer
6813		io.Copy(&snapshot, ringBuffer)
6814		err = &smithy.DeserializationError{
6815			Err:      fmt.Errorf("failed to decode response body, %w", err),
6816			Snapshot: snapshot.Bytes(),
6817		}
6818		return out, metadata, err
6819	}
6820
6821	return out, metadata, err
6822}
6823
6824func awsAwsjson11_deserializeOpErrorDetachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6825	var errorBuffer bytes.Buffer
6826	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6827		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6828	}
6829	errorBody := bytes.NewReader(errorBuffer.Bytes())
6830
6831	errorCode := "UnknownError"
6832	errorMessage := errorCode
6833
6834	code := response.Header.Get("X-Amzn-ErrorType")
6835	if len(code) != 0 {
6836		errorCode = restjson.SanitizeErrorCode(code)
6837	}
6838
6839	var buff [1024]byte
6840	ringBuffer := smithyio.NewRingBuffer(buff[:])
6841
6842	body := io.TeeReader(errorBody, ringBuffer)
6843	decoder := json.NewDecoder(body)
6844	decoder.UseNumber()
6845	code, message, err := restjson.GetErrorInfo(decoder)
6846	if err != nil {
6847		var snapshot bytes.Buffer
6848		io.Copy(&snapshot, ringBuffer)
6849		err = &smithy.DeserializationError{
6850			Err:      fmt.Errorf("failed to decode response body, %w", err),
6851			Snapshot: snapshot.Bytes(),
6852		}
6853		return err
6854	}
6855
6856	errorBody.Seek(0, io.SeekStart)
6857	if len(code) != 0 {
6858		errorCode = restjson.SanitizeErrorCode(code)
6859	}
6860	if len(message) != 0 {
6861		errorMessage = message
6862	}
6863
6864	switch {
6865	case strings.EqualFold("AccessDeniedException", errorCode):
6866		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6867
6868	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6869		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6870
6871	case strings.EqualFold("InvalidInputException", errorCode):
6872		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6873
6874	case strings.EqualFold("NotFoundException", errorCode):
6875		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6876
6877	case strings.EqualFold("OperationFailureException", errorCode):
6878		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6879
6880	case strings.EqualFold("ServiceException", errorCode):
6881		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6882
6883	case strings.EqualFold("UnauthenticatedException", errorCode):
6884		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6885
6886	default:
6887		genericError := &smithy.GenericAPIError{
6888			Code:    errorCode,
6889			Message: errorMessage,
6890		}
6891		return genericError
6892
6893	}
6894}
6895
6896type awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer struct {
6897}
6898
6899func (*awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) ID() string {
6900	return "OperationDeserializer"
6901}
6902
6903func (m *awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6904	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6905) {
6906	out, metadata, err = next.HandleDeserialize(ctx, in)
6907	if err != nil {
6908		return out, metadata, err
6909	}
6910
6911	response, ok := out.RawResponse.(*smithyhttp.Response)
6912	if !ok {
6913		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6914	}
6915
6916	if response.StatusCode < 200 || response.StatusCode >= 300 {
6917		return out, metadata, awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response, &metadata)
6918	}
6919	output := &DetachInstancesFromLoadBalancerOutput{}
6920	out.Result = output
6921
6922	var buff [1024]byte
6923	ringBuffer := smithyio.NewRingBuffer(buff[:])
6924
6925	body := io.TeeReader(response.Body, ringBuffer)
6926	decoder := json.NewDecoder(body)
6927	decoder.UseNumber()
6928	var shape interface{}
6929	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6930		var snapshot bytes.Buffer
6931		io.Copy(&snapshot, ringBuffer)
6932		err = &smithy.DeserializationError{
6933			Err:      fmt.Errorf("failed to decode response body, %w", err),
6934			Snapshot: snapshot.Bytes(),
6935		}
6936		return out, metadata, err
6937	}
6938
6939	err = awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(&output, shape)
6940	if err != nil {
6941		var snapshot bytes.Buffer
6942		io.Copy(&snapshot, ringBuffer)
6943		err = &smithy.DeserializationError{
6944			Err:      fmt.Errorf("failed to decode response body, %w", err),
6945			Snapshot: snapshot.Bytes(),
6946		}
6947		return out, metadata, err
6948	}
6949
6950	return out, metadata, err
6951}
6952
6953func awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6954	var errorBuffer bytes.Buffer
6955	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6956		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6957	}
6958	errorBody := bytes.NewReader(errorBuffer.Bytes())
6959
6960	errorCode := "UnknownError"
6961	errorMessage := errorCode
6962
6963	code := response.Header.Get("X-Amzn-ErrorType")
6964	if len(code) != 0 {
6965		errorCode = restjson.SanitizeErrorCode(code)
6966	}
6967
6968	var buff [1024]byte
6969	ringBuffer := smithyio.NewRingBuffer(buff[:])
6970
6971	body := io.TeeReader(errorBody, ringBuffer)
6972	decoder := json.NewDecoder(body)
6973	decoder.UseNumber()
6974	code, message, err := restjson.GetErrorInfo(decoder)
6975	if err != nil {
6976		var snapshot bytes.Buffer
6977		io.Copy(&snapshot, ringBuffer)
6978		err = &smithy.DeserializationError{
6979			Err:      fmt.Errorf("failed to decode response body, %w", err),
6980			Snapshot: snapshot.Bytes(),
6981		}
6982		return err
6983	}
6984
6985	errorBody.Seek(0, io.SeekStart)
6986	if len(code) != 0 {
6987		errorCode = restjson.SanitizeErrorCode(code)
6988	}
6989	if len(message) != 0 {
6990		errorMessage = message
6991	}
6992
6993	switch {
6994	case strings.EqualFold("AccessDeniedException", errorCode):
6995		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6996
6997	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6998		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6999
7000	case strings.EqualFold("InvalidInputException", errorCode):
7001		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7002
7003	case strings.EqualFold("NotFoundException", errorCode):
7004		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7005
7006	case strings.EqualFold("OperationFailureException", errorCode):
7007		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7008
7009	case strings.EqualFold("ServiceException", errorCode):
7010		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7011
7012	case strings.EqualFold("UnauthenticatedException", errorCode):
7013		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7014
7015	default:
7016		genericError := &smithy.GenericAPIError{
7017			Code:    errorCode,
7018			Message: errorMessage,
7019		}
7020		return genericError
7021
7022	}
7023}
7024
7025type awsAwsjson11_deserializeOpDetachStaticIp struct {
7026}
7027
7028func (*awsAwsjson11_deserializeOpDetachStaticIp) ID() string {
7029	return "OperationDeserializer"
7030}
7031
7032func (m *awsAwsjson11_deserializeOpDetachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7033	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7034) {
7035	out, metadata, err = next.HandleDeserialize(ctx, in)
7036	if err != nil {
7037		return out, metadata, err
7038	}
7039
7040	response, ok := out.RawResponse.(*smithyhttp.Response)
7041	if !ok {
7042		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7043	}
7044
7045	if response.StatusCode < 200 || response.StatusCode >= 300 {
7046		return out, metadata, awsAwsjson11_deserializeOpErrorDetachStaticIp(response, &metadata)
7047	}
7048	output := &DetachStaticIpOutput{}
7049	out.Result = output
7050
7051	var buff [1024]byte
7052	ringBuffer := smithyio.NewRingBuffer(buff[:])
7053
7054	body := io.TeeReader(response.Body, ringBuffer)
7055	decoder := json.NewDecoder(body)
7056	decoder.UseNumber()
7057	var shape interface{}
7058	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7059		var snapshot bytes.Buffer
7060		io.Copy(&snapshot, ringBuffer)
7061		err = &smithy.DeserializationError{
7062			Err:      fmt.Errorf("failed to decode response body, %w", err),
7063			Snapshot: snapshot.Bytes(),
7064		}
7065		return out, metadata, err
7066	}
7067
7068	err = awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(&output, shape)
7069	if err != nil {
7070		var snapshot bytes.Buffer
7071		io.Copy(&snapshot, ringBuffer)
7072		err = &smithy.DeserializationError{
7073			Err:      fmt.Errorf("failed to decode response body, %w", err),
7074			Snapshot: snapshot.Bytes(),
7075		}
7076		return out, metadata, err
7077	}
7078
7079	return out, metadata, err
7080}
7081
7082func awsAwsjson11_deserializeOpErrorDetachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7083	var errorBuffer bytes.Buffer
7084	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7085		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7086	}
7087	errorBody := bytes.NewReader(errorBuffer.Bytes())
7088
7089	errorCode := "UnknownError"
7090	errorMessage := errorCode
7091
7092	code := response.Header.Get("X-Amzn-ErrorType")
7093	if len(code) != 0 {
7094		errorCode = restjson.SanitizeErrorCode(code)
7095	}
7096
7097	var buff [1024]byte
7098	ringBuffer := smithyio.NewRingBuffer(buff[:])
7099
7100	body := io.TeeReader(errorBody, ringBuffer)
7101	decoder := json.NewDecoder(body)
7102	decoder.UseNumber()
7103	code, message, err := restjson.GetErrorInfo(decoder)
7104	if err != nil {
7105		var snapshot bytes.Buffer
7106		io.Copy(&snapshot, ringBuffer)
7107		err = &smithy.DeserializationError{
7108			Err:      fmt.Errorf("failed to decode response body, %w", err),
7109			Snapshot: snapshot.Bytes(),
7110		}
7111		return err
7112	}
7113
7114	errorBody.Seek(0, io.SeekStart)
7115	if len(code) != 0 {
7116		errorCode = restjson.SanitizeErrorCode(code)
7117	}
7118	if len(message) != 0 {
7119		errorMessage = message
7120	}
7121
7122	switch {
7123	case strings.EqualFold("AccessDeniedException", errorCode):
7124		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7125
7126	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7127		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7128
7129	case strings.EqualFold("InvalidInputException", errorCode):
7130		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7131
7132	case strings.EqualFold("NotFoundException", errorCode):
7133		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7134
7135	case strings.EqualFold("OperationFailureException", errorCode):
7136		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7137
7138	case strings.EqualFold("ServiceException", errorCode):
7139		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7140
7141	case strings.EqualFold("UnauthenticatedException", errorCode):
7142		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7143
7144	default:
7145		genericError := &smithy.GenericAPIError{
7146			Code:    errorCode,
7147			Message: errorMessage,
7148		}
7149		return genericError
7150
7151	}
7152}
7153
7154type awsAwsjson11_deserializeOpDisableAddOn struct {
7155}
7156
7157func (*awsAwsjson11_deserializeOpDisableAddOn) ID() string {
7158	return "OperationDeserializer"
7159}
7160
7161func (m *awsAwsjson11_deserializeOpDisableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7162	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7163) {
7164	out, metadata, err = next.HandleDeserialize(ctx, in)
7165	if err != nil {
7166		return out, metadata, err
7167	}
7168
7169	response, ok := out.RawResponse.(*smithyhttp.Response)
7170	if !ok {
7171		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7172	}
7173
7174	if response.StatusCode < 200 || response.StatusCode >= 300 {
7175		return out, metadata, awsAwsjson11_deserializeOpErrorDisableAddOn(response, &metadata)
7176	}
7177	output := &DisableAddOnOutput{}
7178	out.Result = output
7179
7180	var buff [1024]byte
7181	ringBuffer := smithyio.NewRingBuffer(buff[:])
7182
7183	body := io.TeeReader(response.Body, ringBuffer)
7184	decoder := json.NewDecoder(body)
7185	decoder.UseNumber()
7186	var shape interface{}
7187	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7188		var snapshot bytes.Buffer
7189		io.Copy(&snapshot, ringBuffer)
7190		err = &smithy.DeserializationError{
7191			Err:      fmt.Errorf("failed to decode response body, %w", err),
7192			Snapshot: snapshot.Bytes(),
7193		}
7194		return out, metadata, err
7195	}
7196
7197	err = awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(&output, shape)
7198	if err != nil {
7199		var snapshot bytes.Buffer
7200		io.Copy(&snapshot, ringBuffer)
7201		err = &smithy.DeserializationError{
7202			Err:      fmt.Errorf("failed to decode response body, %w", err),
7203			Snapshot: snapshot.Bytes(),
7204		}
7205		return out, metadata, err
7206	}
7207
7208	return out, metadata, err
7209}
7210
7211func awsAwsjson11_deserializeOpErrorDisableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7212	var errorBuffer bytes.Buffer
7213	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7214		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7215	}
7216	errorBody := bytes.NewReader(errorBuffer.Bytes())
7217
7218	errorCode := "UnknownError"
7219	errorMessage := errorCode
7220
7221	code := response.Header.Get("X-Amzn-ErrorType")
7222	if len(code) != 0 {
7223		errorCode = restjson.SanitizeErrorCode(code)
7224	}
7225
7226	var buff [1024]byte
7227	ringBuffer := smithyio.NewRingBuffer(buff[:])
7228
7229	body := io.TeeReader(errorBody, ringBuffer)
7230	decoder := json.NewDecoder(body)
7231	decoder.UseNumber()
7232	code, message, err := restjson.GetErrorInfo(decoder)
7233	if err != nil {
7234		var snapshot bytes.Buffer
7235		io.Copy(&snapshot, ringBuffer)
7236		err = &smithy.DeserializationError{
7237			Err:      fmt.Errorf("failed to decode response body, %w", err),
7238			Snapshot: snapshot.Bytes(),
7239		}
7240		return err
7241	}
7242
7243	errorBody.Seek(0, io.SeekStart)
7244	if len(code) != 0 {
7245		errorCode = restjson.SanitizeErrorCode(code)
7246	}
7247	if len(message) != 0 {
7248		errorMessage = message
7249	}
7250
7251	switch {
7252	case strings.EqualFold("AccessDeniedException", errorCode):
7253		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7254
7255	case strings.EqualFold("InvalidInputException", errorCode):
7256		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7257
7258	case strings.EqualFold("NotFoundException", errorCode):
7259		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7260
7261	case strings.EqualFold("OperationFailureException", errorCode):
7262		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7263
7264	case strings.EqualFold("ServiceException", errorCode):
7265		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7266
7267	case strings.EqualFold("UnauthenticatedException", errorCode):
7268		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7269
7270	default:
7271		genericError := &smithy.GenericAPIError{
7272			Code:    errorCode,
7273			Message: errorMessage,
7274		}
7275		return genericError
7276
7277	}
7278}
7279
7280type awsAwsjson11_deserializeOpDownloadDefaultKeyPair struct {
7281}
7282
7283func (*awsAwsjson11_deserializeOpDownloadDefaultKeyPair) ID() string {
7284	return "OperationDeserializer"
7285}
7286
7287func (m *awsAwsjson11_deserializeOpDownloadDefaultKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7288	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7289) {
7290	out, metadata, err = next.HandleDeserialize(ctx, in)
7291	if err != nil {
7292		return out, metadata, err
7293	}
7294
7295	response, ok := out.RawResponse.(*smithyhttp.Response)
7296	if !ok {
7297		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7298	}
7299
7300	if response.StatusCode < 200 || response.StatusCode >= 300 {
7301		return out, metadata, awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response, &metadata)
7302	}
7303	output := &DownloadDefaultKeyPairOutput{}
7304	out.Result = output
7305
7306	var buff [1024]byte
7307	ringBuffer := smithyio.NewRingBuffer(buff[:])
7308
7309	body := io.TeeReader(response.Body, ringBuffer)
7310	decoder := json.NewDecoder(body)
7311	decoder.UseNumber()
7312	var shape interface{}
7313	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7314		var snapshot bytes.Buffer
7315		io.Copy(&snapshot, ringBuffer)
7316		err = &smithy.DeserializationError{
7317			Err:      fmt.Errorf("failed to decode response body, %w", err),
7318			Snapshot: snapshot.Bytes(),
7319		}
7320		return out, metadata, err
7321	}
7322
7323	err = awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(&output, shape)
7324	if err != nil {
7325		var snapshot bytes.Buffer
7326		io.Copy(&snapshot, ringBuffer)
7327		err = &smithy.DeserializationError{
7328			Err:      fmt.Errorf("failed to decode response body, %w", err),
7329			Snapshot: snapshot.Bytes(),
7330		}
7331		return out, metadata, err
7332	}
7333
7334	return out, metadata, err
7335}
7336
7337func awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7338	var errorBuffer bytes.Buffer
7339	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7340		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7341	}
7342	errorBody := bytes.NewReader(errorBuffer.Bytes())
7343
7344	errorCode := "UnknownError"
7345	errorMessage := errorCode
7346
7347	code := response.Header.Get("X-Amzn-ErrorType")
7348	if len(code) != 0 {
7349		errorCode = restjson.SanitizeErrorCode(code)
7350	}
7351
7352	var buff [1024]byte
7353	ringBuffer := smithyio.NewRingBuffer(buff[:])
7354
7355	body := io.TeeReader(errorBody, ringBuffer)
7356	decoder := json.NewDecoder(body)
7357	decoder.UseNumber()
7358	code, message, err := restjson.GetErrorInfo(decoder)
7359	if err != nil {
7360		var snapshot bytes.Buffer
7361		io.Copy(&snapshot, ringBuffer)
7362		err = &smithy.DeserializationError{
7363			Err:      fmt.Errorf("failed to decode response body, %w", err),
7364			Snapshot: snapshot.Bytes(),
7365		}
7366		return err
7367	}
7368
7369	errorBody.Seek(0, io.SeekStart)
7370	if len(code) != 0 {
7371		errorCode = restjson.SanitizeErrorCode(code)
7372	}
7373	if len(message) != 0 {
7374		errorMessage = message
7375	}
7376
7377	switch {
7378	case strings.EqualFold("AccessDeniedException", errorCode):
7379		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7380
7381	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7382		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7383
7384	case strings.EqualFold("InvalidInputException", errorCode):
7385		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7386
7387	case strings.EqualFold("NotFoundException", errorCode):
7388		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7389
7390	case strings.EqualFold("OperationFailureException", errorCode):
7391		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7392
7393	case strings.EqualFold("ServiceException", errorCode):
7394		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7395
7396	case strings.EqualFold("UnauthenticatedException", errorCode):
7397		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7398
7399	default:
7400		genericError := &smithy.GenericAPIError{
7401			Code:    errorCode,
7402			Message: errorMessage,
7403		}
7404		return genericError
7405
7406	}
7407}
7408
7409type awsAwsjson11_deserializeOpEnableAddOn struct {
7410}
7411
7412func (*awsAwsjson11_deserializeOpEnableAddOn) ID() string {
7413	return "OperationDeserializer"
7414}
7415
7416func (m *awsAwsjson11_deserializeOpEnableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7417	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7418) {
7419	out, metadata, err = next.HandleDeserialize(ctx, in)
7420	if err != nil {
7421		return out, metadata, err
7422	}
7423
7424	response, ok := out.RawResponse.(*smithyhttp.Response)
7425	if !ok {
7426		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7427	}
7428
7429	if response.StatusCode < 200 || response.StatusCode >= 300 {
7430		return out, metadata, awsAwsjson11_deserializeOpErrorEnableAddOn(response, &metadata)
7431	}
7432	output := &EnableAddOnOutput{}
7433	out.Result = output
7434
7435	var buff [1024]byte
7436	ringBuffer := smithyio.NewRingBuffer(buff[:])
7437
7438	body := io.TeeReader(response.Body, ringBuffer)
7439	decoder := json.NewDecoder(body)
7440	decoder.UseNumber()
7441	var shape interface{}
7442	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7443		var snapshot bytes.Buffer
7444		io.Copy(&snapshot, ringBuffer)
7445		err = &smithy.DeserializationError{
7446			Err:      fmt.Errorf("failed to decode response body, %w", err),
7447			Snapshot: snapshot.Bytes(),
7448		}
7449		return out, metadata, err
7450	}
7451
7452	err = awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(&output, shape)
7453	if err != nil {
7454		var snapshot bytes.Buffer
7455		io.Copy(&snapshot, ringBuffer)
7456		err = &smithy.DeserializationError{
7457			Err:      fmt.Errorf("failed to decode response body, %w", err),
7458			Snapshot: snapshot.Bytes(),
7459		}
7460		return out, metadata, err
7461	}
7462
7463	return out, metadata, err
7464}
7465
7466func awsAwsjson11_deserializeOpErrorEnableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7467	var errorBuffer bytes.Buffer
7468	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7469		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7470	}
7471	errorBody := bytes.NewReader(errorBuffer.Bytes())
7472
7473	errorCode := "UnknownError"
7474	errorMessage := errorCode
7475
7476	code := response.Header.Get("X-Amzn-ErrorType")
7477	if len(code) != 0 {
7478		errorCode = restjson.SanitizeErrorCode(code)
7479	}
7480
7481	var buff [1024]byte
7482	ringBuffer := smithyio.NewRingBuffer(buff[:])
7483
7484	body := io.TeeReader(errorBody, ringBuffer)
7485	decoder := json.NewDecoder(body)
7486	decoder.UseNumber()
7487	code, message, err := restjson.GetErrorInfo(decoder)
7488	if err != nil {
7489		var snapshot bytes.Buffer
7490		io.Copy(&snapshot, ringBuffer)
7491		err = &smithy.DeserializationError{
7492			Err:      fmt.Errorf("failed to decode response body, %w", err),
7493			Snapshot: snapshot.Bytes(),
7494		}
7495		return err
7496	}
7497
7498	errorBody.Seek(0, io.SeekStart)
7499	if len(code) != 0 {
7500		errorCode = restjson.SanitizeErrorCode(code)
7501	}
7502	if len(message) != 0 {
7503		errorMessage = message
7504	}
7505
7506	switch {
7507	case strings.EqualFold("AccessDeniedException", errorCode):
7508		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7509
7510	case strings.EqualFold("InvalidInputException", errorCode):
7511		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7512
7513	case strings.EqualFold("NotFoundException", errorCode):
7514		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7515
7516	case strings.EqualFold("OperationFailureException", errorCode):
7517		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7518
7519	case strings.EqualFold("ServiceException", errorCode):
7520		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7521
7522	case strings.EqualFold("UnauthenticatedException", errorCode):
7523		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7524
7525	default:
7526		genericError := &smithy.GenericAPIError{
7527			Code:    errorCode,
7528			Message: errorMessage,
7529		}
7530		return genericError
7531
7532	}
7533}
7534
7535type awsAwsjson11_deserializeOpExportSnapshot struct {
7536}
7537
7538func (*awsAwsjson11_deserializeOpExportSnapshot) ID() string {
7539	return "OperationDeserializer"
7540}
7541
7542func (m *awsAwsjson11_deserializeOpExportSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7543	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7544) {
7545	out, metadata, err = next.HandleDeserialize(ctx, in)
7546	if err != nil {
7547		return out, metadata, err
7548	}
7549
7550	response, ok := out.RawResponse.(*smithyhttp.Response)
7551	if !ok {
7552		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7553	}
7554
7555	if response.StatusCode < 200 || response.StatusCode >= 300 {
7556		return out, metadata, awsAwsjson11_deserializeOpErrorExportSnapshot(response, &metadata)
7557	}
7558	output := &ExportSnapshotOutput{}
7559	out.Result = output
7560
7561	var buff [1024]byte
7562	ringBuffer := smithyio.NewRingBuffer(buff[:])
7563
7564	body := io.TeeReader(response.Body, ringBuffer)
7565	decoder := json.NewDecoder(body)
7566	decoder.UseNumber()
7567	var shape interface{}
7568	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7569		var snapshot bytes.Buffer
7570		io.Copy(&snapshot, ringBuffer)
7571		err = &smithy.DeserializationError{
7572			Err:      fmt.Errorf("failed to decode response body, %w", err),
7573			Snapshot: snapshot.Bytes(),
7574		}
7575		return out, metadata, err
7576	}
7577
7578	err = awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(&output, shape)
7579	if err != nil {
7580		var snapshot bytes.Buffer
7581		io.Copy(&snapshot, ringBuffer)
7582		err = &smithy.DeserializationError{
7583			Err:      fmt.Errorf("failed to decode response body, %w", err),
7584			Snapshot: snapshot.Bytes(),
7585		}
7586		return out, metadata, err
7587	}
7588
7589	return out, metadata, err
7590}
7591
7592func awsAwsjson11_deserializeOpErrorExportSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7593	var errorBuffer bytes.Buffer
7594	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7595		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7596	}
7597	errorBody := bytes.NewReader(errorBuffer.Bytes())
7598
7599	errorCode := "UnknownError"
7600	errorMessage := errorCode
7601
7602	code := response.Header.Get("X-Amzn-ErrorType")
7603	if len(code) != 0 {
7604		errorCode = restjson.SanitizeErrorCode(code)
7605	}
7606
7607	var buff [1024]byte
7608	ringBuffer := smithyio.NewRingBuffer(buff[:])
7609
7610	body := io.TeeReader(errorBody, ringBuffer)
7611	decoder := json.NewDecoder(body)
7612	decoder.UseNumber()
7613	code, message, err := restjson.GetErrorInfo(decoder)
7614	if err != nil {
7615		var snapshot bytes.Buffer
7616		io.Copy(&snapshot, ringBuffer)
7617		err = &smithy.DeserializationError{
7618			Err:      fmt.Errorf("failed to decode response body, %w", err),
7619			Snapshot: snapshot.Bytes(),
7620		}
7621		return err
7622	}
7623
7624	errorBody.Seek(0, io.SeekStart)
7625	if len(code) != 0 {
7626		errorCode = restjson.SanitizeErrorCode(code)
7627	}
7628	if len(message) != 0 {
7629		errorMessage = message
7630	}
7631
7632	switch {
7633	case strings.EqualFold("AccessDeniedException", errorCode):
7634		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7635
7636	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7637		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7638
7639	case strings.EqualFold("InvalidInputException", errorCode):
7640		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7641
7642	case strings.EqualFold("NotFoundException", errorCode):
7643		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7644
7645	case strings.EqualFold("OperationFailureException", errorCode):
7646		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7647
7648	case strings.EqualFold("ServiceException", errorCode):
7649		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7650
7651	case strings.EqualFold("UnauthenticatedException", errorCode):
7652		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7653
7654	default:
7655		genericError := &smithy.GenericAPIError{
7656			Code:    errorCode,
7657			Message: errorMessage,
7658		}
7659		return genericError
7660
7661	}
7662}
7663
7664type awsAwsjson11_deserializeOpGetActiveNames struct {
7665}
7666
7667func (*awsAwsjson11_deserializeOpGetActiveNames) ID() string {
7668	return "OperationDeserializer"
7669}
7670
7671func (m *awsAwsjson11_deserializeOpGetActiveNames) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7672	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7673) {
7674	out, metadata, err = next.HandleDeserialize(ctx, in)
7675	if err != nil {
7676		return out, metadata, err
7677	}
7678
7679	response, ok := out.RawResponse.(*smithyhttp.Response)
7680	if !ok {
7681		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7682	}
7683
7684	if response.StatusCode < 200 || response.StatusCode >= 300 {
7685		return out, metadata, awsAwsjson11_deserializeOpErrorGetActiveNames(response, &metadata)
7686	}
7687	output := &GetActiveNamesOutput{}
7688	out.Result = output
7689
7690	var buff [1024]byte
7691	ringBuffer := smithyio.NewRingBuffer(buff[:])
7692
7693	body := io.TeeReader(response.Body, ringBuffer)
7694	decoder := json.NewDecoder(body)
7695	decoder.UseNumber()
7696	var shape interface{}
7697	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7698		var snapshot bytes.Buffer
7699		io.Copy(&snapshot, ringBuffer)
7700		err = &smithy.DeserializationError{
7701			Err:      fmt.Errorf("failed to decode response body, %w", err),
7702			Snapshot: snapshot.Bytes(),
7703		}
7704		return out, metadata, err
7705	}
7706
7707	err = awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(&output, shape)
7708	if err != nil {
7709		var snapshot bytes.Buffer
7710		io.Copy(&snapshot, ringBuffer)
7711		err = &smithy.DeserializationError{
7712			Err:      fmt.Errorf("failed to decode response body, %w", err),
7713			Snapshot: snapshot.Bytes(),
7714		}
7715		return out, metadata, err
7716	}
7717
7718	return out, metadata, err
7719}
7720
7721func awsAwsjson11_deserializeOpErrorGetActiveNames(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7722	var errorBuffer bytes.Buffer
7723	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7724		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7725	}
7726	errorBody := bytes.NewReader(errorBuffer.Bytes())
7727
7728	errorCode := "UnknownError"
7729	errorMessage := errorCode
7730
7731	code := response.Header.Get("X-Amzn-ErrorType")
7732	if len(code) != 0 {
7733		errorCode = restjson.SanitizeErrorCode(code)
7734	}
7735
7736	var buff [1024]byte
7737	ringBuffer := smithyio.NewRingBuffer(buff[:])
7738
7739	body := io.TeeReader(errorBody, ringBuffer)
7740	decoder := json.NewDecoder(body)
7741	decoder.UseNumber()
7742	code, message, err := restjson.GetErrorInfo(decoder)
7743	if err != nil {
7744		var snapshot bytes.Buffer
7745		io.Copy(&snapshot, ringBuffer)
7746		err = &smithy.DeserializationError{
7747			Err:      fmt.Errorf("failed to decode response body, %w", err),
7748			Snapshot: snapshot.Bytes(),
7749		}
7750		return err
7751	}
7752
7753	errorBody.Seek(0, io.SeekStart)
7754	if len(code) != 0 {
7755		errorCode = restjson.SanitizeErrorCode(code)
7756	}
7757	if len(message) != 0 {
7758		errorMessage = message
7759	}
7760
7761	switch {
7762	case strings.EqualFold("AccessDeniedException", errorCode):
7763		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7764
7765	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7766		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7767
7768	case strings.EqualFold("InvalidInputException", errorCode):
7769		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7770
7771	case strings.EqualFold("NotFoundException", errorCode):
7772		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7773
7774	case strings.EqualFold("OperationFailureException", errorCode):
7775		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7776
7777	case strings.EqualFold("ServiceException", errorCode):
7778		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7779
7780	case strings.EqualFold("UnauthenticatedException", errorCode):
7781		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7782
7783	default:
7784		genericError := &smithy.GenericAPIError{
7785			Code:    errorCode,
7786			Message: errorMessage,
7787		}
7788		return genericError
7789
7790	}
7791}
7792
7793type awsAwsjson11_deserializeOpGetAlarms struct {
7794}
7795
7796func (*awsAwsjson11_deserializeOpGetAlarms) ID() string {
7797	return "OperationDeserializer"
7798}
7799
7800func (m *awsAwsjson11_deserializeOpGetAlarms) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7801	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7802) {
7803	out, metadata, err = next.HandleDeserialize(ctx, in)
7804	if err != nil {
7805		return out, metadata, err
7806	}
7807
7808	response, ok := out.RawResponse.(*smithyhttp.Response)
7809	if !ok {
7810		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7811	}
7812
7813	if response.StatusCode < 200 || response.StatusCode >= 300 {
7814		return out, metadata, awsAwsjson11_deserializeOpErrorGetAlarms(response, &metadata)
7815	}
7816	output := &GetAlarmsOutput{}
7817	out.Result = output
7818
7819	var buff [1024]byte
7820	ringBuffer := smithyio.NewRingBuffer(buff[:])
7821
7822	body := io.TeeReader(response.Body, ringBuffer)
7823	decoder := json.NewDecoder(body)
7824	decoder.UseNumber()
7825	var shape interface{}
7826	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7827		var snapshot bytes.Buffer
7828		io.Copy(&snapshot, ringBuffer)
7829		err = &smithy.DeserializationError{
7830			Err:      fmt.Errorf("failed to decode response body, %w", err),
7831			Snapshot: snapshot.Bytes(),
7832		}
7833		return out, metadata, err
7834	}
7835
7836	err = awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(&output, shape)
7837	if err != nil {
7838		var snapshot bytes.Buffer
7839		io.Copy(&snapshot, ringBuffer)
7840		err = &smithy.DeserializationError{
7841			Err:      fmt.Errorf("failed to decode response body, %w", err),
7842			Snapshot: snapshot.Bytes(),
7843		}
7844		return out, metadata, err
7845	}
7846
7847	return out, metadata, err
7848}
7849
7850func awsAwsjson11_deserializeOpErrorGetAlarms(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7851	var errorBuffer bytes.Buffer
7852	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7853		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7854	}
7855	errorBody := bytes.NewReader(errorBuffer.Bytes())
7856
7857	errorCode := "UnknownError"
7858	errorMessage := errorCode
7859
7860	code := response.Header.Get("X-Amzn-ErrorType")
7861	if len(code) != 0 {
7862		errorCode = restjson.SanitizeErrorCode(code)
7863	}
7864
7865	var buff [1024]byte
7866	ringBuffer := smithyio.NewRingBuffer(buff[:])
7867
7868	body := io.TeeReader(errorBody, ringBuffer)
7869	decoder := json.NewDecoder(body)
7870	decoder.UseNumber()
7871	code, message, err := restjson.GetErrorInfo(decoder)
7872	if err != nil {
7873		var snapshot bytes.Buffer
7874		io.Copy(&snapshot, ringBuffer)
7875		err = &smithy.DeserializationError{
7876			Err:      fmt.Errorf("failed to decode response body, %w", err),
7877			Snapshot: snapshot.Bytes(),
7878		}
7879		return err
7880	}
7881
7882	errorBody.Seek(0, io.SeekStart)
7883	if len(code) != 0 {
7884		errorCode = restjson.SanitizeErrorCode(code)
7885	}
7886	if len(message) != 0 {
7887		errorMessage = message
7888	}
7889
7890	switch {
7891	case strings.EqualFold("AccessDeniedException", errorCode):
7892		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7893
7894	case strings.EqualFold("InvalidInputException", errorCode):
7895		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7896
7897	case strings.EqualFold("NotFoundException", errorCode):
7898		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7899
7900	case strings.EqualFold("OperationFailureException", errorCode):
7901		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7902
7903	case strings.EqualFold("ServiceException", errorCode):
7904		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7905
7906	case strings.EqualFold("UnauthenticatedException", errorCode):
7907		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7908
7909	default:
7910		genericError := &smithy.GenericAPIError{
7911			Code:    errorCode,
7912			Message: errorMessage,
7913		}
7914		return genericError
7915
7916	}
7917}
7918
7919type awsAwsjson11_deserializeOpGetAutoSnapshots struct {
7920}
7921
7922func (*awsAwsjson11_deserializeOpGetAutoSnapshots) ID() string {
7923	return "OperationDeserializer"
7924}
7925
7926func (m *awsAwsjson11_deserializeOpGetAutoSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7927	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7928) {
7929	out, metadata, err = next.HandleDeserialize(ctx, in)
7930	if err != nil {
7931		return out, metadata, err
7932	}
7933
7934	response, ok := out.RawResponse.(*smithyhttp.Response)
7935	if !ok {
7936		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7937	}
7938
7939	if response.StatusCode < 200 || response.StatusCode >= 300 {
7940		return out, metadata, awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response, &metadata)
7941	}
7942	output := &GetAutoSnapshotsOutput{}
7943	out.Result = output
7944
7945	var buff [1024]byte
7946	ringBuffer := smithyio.NewRingBuffer(buff[:])
7947
7948	body := io.TeeReader(response.Body, ringBuffer)
7949	decoder := json.NewDecoder(body)
7950	decoder.UseNumber()
7951	var shape interface{}
7952	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7953		var snapshot bytes.Buffer
7954		io.Copy(&snapshot, ringBuffer)
7955		err = &smithy.DeserializationError{
7956			Err:      fmt.Errorf("failed to decode response body, %w", err),
7957			Snapshot: snapshot.Bytes(),
7958		}
7959		return out, metadata, err
7960	}
7961
7962	err = awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(&output, shape)
7963	if err != nil {
7964		var snapshot bytes.Buffer
7965		io.Copy(&snapshot, ringBuffer)
7966		err = &smithy.DeserializationError{
7967			Err:      fmt.Errorf("failed to decode response body, %w", err),
7968			Snapshot: snapshot.Bytes(),
7969		}
7970		return out, metadata, err
7971	}
7972
7973	return out, metadata, err
7974}
7975
7976func awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7977	var errorBuffer bytes.Buffer
7978	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7979		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7980	}
7981	errorBody := bytes.NewReader(errorBuffer.Bytes())
7982
7983	errorCode := "UnknownError"
7984	errorMessage := errorCode
7985
7986	code := response.Header.Get("X-Amzn-ErrorType")
7987	if len(code) != 0 {
7988		errorCode = restjson.SanitizeErrorCode(code)
7989	}
7990
7991	var buff [1024]byte
7992	ringBuffer := smithyio.NewRingBuffer(buff[:])
7993
7994	body := io.TeeReader(errorBody, ringBuffer)
7995	decoder := json.NewDecoder(body)
7996	decoder.UseNumber()
7997	code, message, err := restjson.GetErrorInfo(decoder)
7998	if err != nil {
7999		var snapshot bytes.Buffer
8000		io.Copy(&snapshot, ringBuffer)
8001		err = &smithy.DeserializationError{
8002			Err:      fmt.Errorf("failed to decode response body, %w", err),
8003			Snapshot: snapshot.Bytes(),
8004		}
8005		return err
8006	}
8007
8008	errorBody.Seek(0, io.SeekStart)
8009	if len(code) != 0 {
8010		errorCode = restjson.SanitizeErrorCode(code)
8011	}
8012	if len(message) != 0 {
8013		errorMessage = message
8014	}
8015
8016	switch {
8017	case strings.EqualFold("AccessDeniedException", errorCode):
8018		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8019
8020	case strings.EqualFold("InvalidInputException", errorCode):
8021		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8022
8023	case strings.EqualFold("NotFoundException", errorCode):
8024		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8025
8026	case strings.EqualFold("OperationFailureException", errorCode):
8027		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8028
8029	case strings.EqualFold("ServiceException", errorCode):
8030		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8031
8032	case strings.EqualFold("UnauthenticatedException", errorCode):
8033		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8034
8035	default:
8036		genericError := &smithy.GenericAPIError{
8037			Code:    errorCode,
8038			Message: errorMessage,
8039		}
8040		return genericError
8041
8042	}
8043}
8044
8045type awsAwsjson11_deserializeOpGetBlueprints struct {
8046}
8047
8048func (*awsAwsjson11_deserializeOpGetBlueprints) ID() string {
8049	return "OperationDeserializer"
8050}
8051
8052func (m *awsAwsjson11_deserializeOpGetBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8053	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8054) {
8055	out, metadata, err = next.HandleDeserialize(ctx, in)
8056	if err != nil {
8057		return out, metadata, err
8058	}
8059
8060	response, ok := out.RawResponse.(*smithyhttp.Response)
8061	if !ok {
8062		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8063	}
8064
8065	if response.StatusCode < 200 || response.StatusCode >= 300 {
8066		return out, metadata, awsAwsjson11_deserializeOpErrorGetBlueprints(response, &metadata)
8067	}
8068	output := &GetBlueprintsOutput{}
8069	out.Result = output
8070
8071	var buff [1024]byte
8072	ringBuffer := smithyio.NewRingBuffer(buff[:])
8073
8074	body := io.TeeReader(response.Body, ringBuffer)
8075	decoder := json.NewDecoder(body)
8076	decoder.UseNumber()
8077	var shape interface{}
8078	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8079		var snapshot bytes.Buffer
8080		io.Copy(&snapshot, ringBuffer)
8081		err = &smithy.DeserializationError{
8082			Err:      fmt.Errorf("failed to decode response body, %w", err),
8083			Snapshot: snapshot.Bytes(),
8084		}
8085		return out, metadata, err
8086	}
8087
8088	err = awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(&output, shape)
8089	if err != nil {
8090		var snapshot bytes.Buffer
8091		io.Copy(&snapshot, ringBuffer)
8092		err = &smithy.DeserializationError{
8093			Err:      fmt.Errorf("failed to decode response body, %w", err),
8094			Snapshot: snapshot.Bytes(),
8095		}
8096		return out, metadata, err
8097	}
8098
8099	return out, metadata, err
8100}
8101
8102func awsAwsjson11_deserializeOpErrorGetBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8103	var errorBuffer bytes.Buffer
8104	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8105		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8106	}
8107	errorBody := bytes.NewReader(errorBuffer.Bytes())
8108
8109	errorCode := "UnknownError"
8110	errorMessage := errorCode
8111
8112	code := response.Header.Get("X-Amzn-ErrorType")
8113	if len(code) != 0 {
8114		errorCode = restjson.SanitizeErrorCode(code)
8115	}
8116
8117	var buff [1024]byte
8118	ringBuffer := smithyio.NewRingBuffer(buff[:])
8119
8120	body := io.TeeReader(errorBody, ringBuffer)
8121	decoder := json.NewDecoder(body)
8122	decoder.UseNumber()
8123	code, message, err := restjson.GetErrorInfo(decoder)
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 err
8132	}
8133
8134	errorBody.Seek(0, io.SeekStart)
8135	if len(code) != 0 {
8136		errorCode = restjson.SanitizeErrorCode(code)
8137	}
8138	if len(message) != 0 {
8139		errorMessage = message
8140	}
8141
8142	switch {
8143	case strings.EqualFold("AccessDeniedException", errorCode):
8144		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8145
8146	case strings.EqualFold("AccountSetupInProgressException", errorCode):
8147		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
8148
8149	case strings.EqualFold("InvalidInputException", errorCode):
8150		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8151
8152	case strings.EqualFold("NotFoundException", errorCode):
8153		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8154
8155	case strings.EqualFold("OperationFailureException", errorCode):
8156		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8157
8158	case strings.EqualFold("ServiceException", errorCode):
8159		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8160
8161	case strings.EqualFold("UnauthenticatedException", errorCode):
8162		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8163
8164	default:
8165		genericError := &smithy.GenericAPIError{
8166			Code:    errorCode,
8167			Message: errorMessage,
8168		}
8169		return genericError
8170
8171	}
8172}
8173
8174type awsAwsjson11_deserializeOpGetBucketAccessKeys struct {
8175}
8176
8177func (*awsAwsjson11_deserializeOpGetBucketAccessKeys) ID() string {
8178	return "OperationDeserializer"
8179}
8180
8181func (m *awsAwsjson11_deserializeOpGetBucketAccessKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8182	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8183) {
8184	out, metadata, err = next.HandleDeserialize(ctx, in)
8185	if err != nil {
8186		return out, metadata, err
8187	}
8188
8189	response, ok := out.RawResponse.(*smithyhttp.Response)
8190	if !ok {
8191		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8192	}
8193
8194	if response.StatusCode < 200 || response.StatusCode >= 300 {
8195		return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketAccessKeys(response, &metadata)
8196	}
8197	output := &GetBucketAccessKeysOutput{}
8198	out.Result = output
8199
8200	var buff [1024]byte
8201	ringBuffer := smithyio.NewRingBuffer(buff[:])
8202
8203	body := io.TeeReader(response.Body, ringBuffer)
8204	decoder := json.NewDecoder(body)
8205	decoder.UseNumber()
8206	var shape interface{}
8207	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8208		var snapshot bytes.Buffer
8209		io.Copy(&snapshot, ringBuffer)
8210		err = &smithy.DeserializationError{
8211			Err:      fmt.Errorf("failed to decode response body, %w", err),
8212			Snapshot: snapshot.Bytes(),
8213		}
8214		return out, metadata, err
8215	}
8216
8217	err = awsAwsjson11_deserializeOpDocumentGetBucketAccessKeysOutput(&output, shape)
8218	if err != nil {
8219		var snapshot bytes.Buffer
8220		io.Copy(&snapshot, ringBuffer)
8221		err = &smithy.DeserializationError{
8222			Err:      fmt.Errorf("failed to decode response body, %w", err),
8223			Snapshot: snapshot.Bytes(),
8224		}
8225		return out, metadata, err
8226	}
8227
8228	return out, metadata, err
8229}
8230
8231func awsAwsjson11_deserializeOpErrorGetBucketAccessKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8232	var errorBuffer bytes.Buffer
8233	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8234		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8235	}
8236	errorBody := bytes.NewReader(errorBuffer.Bytes())
8237
8238	errorCode := "UnknownError"
8239	errorMessage := errorCode
8240
8241	code := response.Header.Get("X-Amzn-ErrorType")
8242	if len(code) != 0 {
8243		errorCode = restjson.SanitizeErrorCode(code)
8244	}
8245
8246	var buff [1024]byte
8247	ringBuffer := smithyio.NewRingBuffer(buff[:])
8248
8249	body := io.TeeReader(errorBody, ringBuffer)
8250	decoder := json.NewDecoder(body)
8251	decoder.UseNumber()
8252	code, message, err := restjson.GetErrorInfo(decoder)
8253	if err != nil {
8254		var snapshot bytes.Buffer
8255		io.Copy(&snapshot, ringBuffer)
8256		err = &smithy.DeserializationError{
8257			Err:      fmt.Errorf("failed to decode response body, %w", err),
8258			Snapshot: snapshot.Bytes(),
8259		}
8260		return err
8261	}
8262
8263	errorBody.Seek(0, io.SeekStart)
8264	if len(code) != 0 {
8265		errorCode = restjson.SanitizeErrorCode(code)
8266	}
8267	if len(message) != 0 {
8268		errorMessage = message
8269	}
8270
8271	switch {
8272	case strings.EqualFold("AccessDeniedException", errorCode):
8273		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8274
8275	case strings.EqualFold("InvalidInputException", errorCode):
8276		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8277
8278	case strings.EqualFold("NotFoundException", errorCode):
8279		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8280
8281	case strings.EqualFold("ServiceException", errorCode):
8282		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8283
8284	case strings.EqualFold("UnauthenticatedException", errorCode):
8285		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8286
8287	default:
8288		genericError := &smithy.GenericAPIError{
8289			Code:    errorCode,
8290			Message: errorMessage,
8291		}
8292		return genericError
8293
8294	}
8295}
8296
8297type awsAwsjson11_deserializeOpGetBucketBundles struct {
8298}
8299
8300func (*awsAwsjson11_deserializeOpGetBucketBundles) ID() string {
8301	return "OperationDeserializer"
8302}
8303
8304func (m *awsAwsjson11_deserializeOpGetBucketBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8305	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8306) {
8307	out, metadata, err = next.HandleDeserialize(ctx, in)
8308	if err != nil {
8309		return out, metadata, err
8310	}
8311
8312	response, ok := out.RawResponse.(*smithyhttp.Response)
8313	if !ok {
8314		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8315	}
8316
8317	if response.StatusCode < 200 || response.StatusCode >= 300 {
8318		return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketBundles(response, &metadata)
8319	}
8320	output := &GetBucketBundlesOutput{}
8321	out.Result = output
8322
8323	var buff [1024]byte
8324	ringBuffer := smithyio.NewRingBuffer(buff[:])
8325
8326	body := io.TeeReader(response.Body, ringBuffer)
8327	decoder := json.NewDecoder(body)
8328	decoder.UseNumber()
8329	var shape interface{}
8330	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8331		var snapshot bytes.Buffer
8332		io.Copy(&snapshot, ringBuffer)
8333		err = &smithy.DeserializationError{
8334			Err:      fmt.Errorf("failed to decode response body, %w", err),
8335			Snapshot: snapshot.Bytes(),
8336		}
8337		return out, metadata, err
8338	}
8339
8340	err = awsAwsjson11_deserializeOpDocumentGetBucketBundlesOutput(&output, shape)
8341	if err != nil {
8342		var snapshot bytes.Buffer
8343		io.Copy(&snapshot, ringBuffer)
8344		err = &smithy.DeserializationError{
8345			Err:      fmt.Errorf("failed to decode response body, %w", err),
8346			Snapshot: snapshot.Bytes(),
8347		}
8348		return out, metadata, err
8349	}
8350
8351	return out, metadata, err
8352}
8353
8354func awsAwsjson11_deserializeOpErrorGetBucketBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8355	var errorBuffer bytes.Buffer
8356	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8357		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8358	}
8359	errorBody := bytes.NewReader(errorBuffer.Bytes())
8360
8361	errorCode := "UnknownError"
8362	errorMessage := errorCode
8363
8364	code := response.Header.Get("X-Amzn-ErrorType")
8365	if len(code) != 0 {
8366		errorCode = restjson.SanitizeErrorCode(code)
8367	}
8368
8369	var buff [1024]byte
8370	ringBuffer := smithyio.NewRingBuffer(buff[:])
8371
8372	body := io.TeeReader(errorBody, ringBuffer)
8373	decoder := json.NewDecoder(body)
8374	decoder.UseNumber()
8375	code, message, err := restjson.GetErrorInfo(decoder)
8376	if err != nil {
8377		var snapshot bytes.Buffer
8378		io.Copy(&snapshot, ringBuffer)
8379		err = &smithy.DeserializationError{
8380			Err:      fmt.Errorf("failed to decode response body, %w", err),
8381			Snapshot: snapshot.Bytes(),
8382		}
8383		return err
8384	}
8385
8386	errorBody.Seek(0, io.SeekStart)
8387	if len(code) != 0 {
8388		errorCode = restjson.SanitizeErrorCode(code)
8389	}
8390	if len(message) != 0 {
8391		errorMessage = message
8392	}
8393
8394	switch {
8395	case strings.EqualFold("AccessDeniedException", errorCode):
8396		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8397
8398	case strings.EqualFold("InvalidInputException", errorCode):
8399		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8400
8401	case strings.EqualFold("ServiceException", errorCode):
8402		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8403
8404	case strings.EqualFold("UnauthenticatedException", errorCode):
8405		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8406
8407	default:
8408		genericError := &smithy.GenericAPIError{
8409			Code:    errorCode,
8410			Message: errorMessage,
8411		}
8412		return genericError
8413
8414	}
8415}
8416
8417type awsAwsjson11_deserializeOpGetBucketMetricData struct {
8418}
8419
8420func (*awsAwsjson11_deserializeOpGetBucketMetricData) ID() string {
8421	return "OperationDeserializer"
8422}
8423
8424func (m *awsAwsjson11_deserializeOpGetBucketMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8425	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8426) {
8427	out, metadata, err = next.HandleDeserialize(ctx, in)
8428	if err != nil {
8429		return out, metadata, err
8430	}
8431
8432	response, ok := out.RawResponse.(*smithyhttp.Response)
8433	if !ok {
8434		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8435	}
8436
8437	if response.StatusCode < 200 || response.StatusCode >= 300 {
8438		return out, metadata, awsAwsjson11_deserializeOpErrorGetBucketMetricData(response, &metadata)
8439	}
8440	output := &GetBucketMetricDataOutput{}
8441	out.Result = output
8442
8443	var buff [1024]byte
8444	ringBuffer := smithyio.NewRingBuffer(buff[:])
8445
8446	body := io.TeeReader(response.Body, ringBuffer)
8447	decoder := json.NewDecoder(body)
8448	decoder.UseNumber()
8449	var shape interface{}
8450	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8451		var snapshot bytes.Buffer
8452		io.Copy(&snapshot, ringBuffer)
8453		err = &smithy.DeserializationError{
8454			Err:      fmt.Errorf("failed to decode response body, %w", err),
8455			Snapshot: snapshot.Bytes(),
8456		}
8457		return out, metadata, err
8458	}
8459
8460	err = awsAwsjson11_deserializeOpDocumentGetBucketMetricDataOutput(&output, shape)
8461	if err != nil {
8462		var snapshot bytes.Buffer
8463		io.Copy(&snapshot, ringBuffer)
8464		err = &smithy.DeserializationError{
8465			Err:      fmt.Errorf("failed to decode response body, %w", err),
8466			Snapshot: snapshot.Bytes(),
8467		}
8468		return out, metadata, err
8469	}
8470
8471	return out, metadata, err
8472}
8473
8474func awsAwsjson11_deserializeOpErrorGetBucketMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8475	var errorBuffer bytes.Buffer
8476	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8477		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8478	}
8479	errorBody := bytes.NewReader(errorBuffer.Bytes())
8480
8481	errorCode := "UnknownError"
8482	errorMessage := errorCode
8483
8484	code := response.Header.Get("X-Amzn-ErrorType")
8485	if len(code) != 0 {
8486		errorCode = restjson.SanitizeErrorCode(code)
8487	}
8488
8489	var buff [1024]byte
8490	ringBuffer := smithyio.NewRingBuffer(buff[:])
8491
8492	body := io.TeeReader(errorBody, ringBuffer)
8493	decoder := json.NewDecoder(body)
8494	decoder.UseNumber()
8495	code, message, err := restjson.GetErrorInfo(decoder)
8496	if err != nil {
8497		var snapshot bytes.Buffer
8498		io.Copy(&snapshot, ringBuffer)
8499		err = &smithy.DeserializationError{
8500			Err:      fmt.Errorf("failed to decode response body, %w", err),
8501			Snapshot: snapshot.Bytes(),
8502		}
8503		return err
8504	}
8505
8506	errorBody.Seek(0, io.SeekStart)
8507	if len(code) != 0 {
8508		errorCode = restjson.SanitizeErrorCode(code)
8509	}
8510	if len(message) != 0 {
8511		errorMessage = message
8512	}
8513
8514	switch {
8515	case strings.EqualFold("AccessDeniedException", errorCode):
8516		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8517
8518	case strings.EqualFold("InvalidInputException", errorCode):
8519		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8520
8521	case strings.EqualFold("NotFoundException", errorCode):
8522		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8523
8524	case strings.EqualFold("ServiceException", errorCode):
8525		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8526
8527	case strings.EqualFold("UnauthenticatedException", errorCode):
8528		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8529
8530	default:
8531		genericError := &smithy.GenericAPIError{
8532			Code:    errorCode,
8533			Message: errorMessage,
8534		}
8535		return genericError
8536
8537	}
8538}
8539
8540type awsAwsjson11_deserializeOpGetBuckets struct {
8541}
8542
8543func (*awsAwsjson11_deserializeOpGetBuckets) ID() string {
8544	return "OperationDeserializer"
8545}
8546
8547func (m *awsAwsjson11_deserializeOpGetBuckets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8548	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8549) {
8550	out, metadata, err = next.HandleDeserialize(ctx, in)
8551	if err != nil {
8552		return out, metadata, err
8553	}
8554
8555	response, ok := out.RawResponse.(*smithyhttp.Response)
8556	if !ok {
8557		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8558	}
8559
8560	if response.StatusCode < 200 || response.StatusCode >= 300 {
8561		return out, metadata, awsAwsjson11_deserializeOpErrorGetBuckets(response, &metadata)
8562	}
8563	output := &GetBucketsOutput{}
8564	out.Result = output
8565
8566	var buff [1024]byte
8567	ringBuffer := smithyio.NewRingBuffer(buff[:])
8568
8569	body := io.TeeReader(response.Body, ringBuffer)
8570	decoder := json.NewDecoder(body)
8571	decoder.UseNumber()
8572	var shape interface{}
8573	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8574		var snapshot bytes.Buffer
8575		io.Copy(&snapshot, ringBuffer)
8576		err = &smithy.DeserializationError{
8577			Err:      fmt.Errorf("failed to decode response body, %w", err),
8578			Snapshot: snapshot.Bytes(),
8579		}
8580		return out, metadata, err
8581	}
8582
8583	err = awsAwsjson11_deserializeOpDocumentGetBucketsOutput(&output, shape)
8584	if err != nil {
8585		var snapshot bytes.Buffer
8586		io.Copy(&snapshot, ringBuffer)
8587		err = &smithy.DeserializationError{
8588			Err:      fmt.Errorf("failed to decode response body, %w", err),
8589			Snapshot: snapshot.Bytes(),
8590		}
8591		return out, metadata, err
8592	}
8593
8594	return out, metadata, err
8595}
8596
8597func awsAwsjson11_deserializeOpErrorGetBuckets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8598	var errorBuffer bytes.Buffer
8599	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8600		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8601	}
8602	errorBody := bytes.NewReader(errorBuffer.Bytes())
8603
8604	errorCode := "UnknownError"
8605	errorMessage := errorCode
8606
8607	code := response.Header.Get("X-Amzn-ErrorType")
8608	if len(code) != 0 {
8609		errorCode = restjson.SanitizeErrorCode(code)
8610	}
8611
8612	var buff [1024]byte
8613	ringBuffer := smithyio.NewRingBuffer(buff[:])
8614
8615	body := io.TeeReader(errorBody, ringBuffer)
8616	decoder := json.NewDecoder(body)
8617	decoder.UseNumber()
8618	code, message, err := restjson.GetErrorInfo(decoder)
8619	if err != nil {
8620		var snapshot bytes.Buffer
8621		io.Copy(&snapshot, ringBuffer)
8622		err = &smithy.DeserializationError{
8623			Err:      fmt.Errorf("failed to decode response body, %w", err),
8624			Snapshot: snapshot.Bytes(),
8625		}
8626		return err
8627	}
8628
8629	errorBody.Seek(0, io.SeekStart)
8630	if len(code) != 0 {
8631		errorCode = restjson.SanitizeErrorCode(code)
8632	}
8633	if len(message) != 0 {
8634		errorMessage = message
8635	}
8636
8637	switch {
8638	case strings.EqualFold("AccessDeniedException", errorCode):
8639		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8640
8641	case strings.EqualFold("InvalidInputException", errorCode):
8642		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8643
8644	case strings.EqualFold("NotFoundException", errorCode):
8645		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8646
8647	case strings.EqualFold("ServiceException", errorCode):
8648		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8649
8650	case strings.EqualFold("UnauthenticatedException", errorCode):
8651		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8652
8653	default:
8654		genericError := &smithy.GenericAPIError{
8655			Code:    errorCode,
8656			Message: errorMessage,
8657		}
8658		return genericError
8659
8660	}
8661}
8662
8663type awsAwsjson11_deserializeOpGetBundles struct {
8664}
8665
8666func (*awsAwsjson11_deserializeOpGetBundles) ID() string {
8667	return "OperationDeserializer"
8668}
8669
8670func (m *awsAwsjson11_deserializeOpGetBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8671	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8672) {
8673	out, metadata, err = next.HandleDeserialize(ctx, in)
8674	if err != nil {
8675		return out, metadata, err
8676	}
8677
8678	response, ok := out.RawResponse.(*smithyhttp.Response)
8679	if !ok {
8680		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8681	}
8682
8683	if response.StatusCode < 200 || response.StatusCode >= 300 {
8684		return out, metadata, awsAwsjson11_deserializeOpErrorGetBundles(response, &metadata)
8685	}
8686	output := &GetBundlesOutput{}
8687	out.Result = output
8688
8689	var buff [1024]byte
8690	ringBuffer := smithyio.NewRingBuffer(buff[:])
8691
8692	body := io.TeeReader(response.Body, ringBuffer)
8693	decoder := json.NewDecoder(body)
8694	decoder.UseNumber()
8695	var shape interface{}
8696	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8697		var snapshot bytes.Buffer
8698		io.Copy(&snapshot, ringBuffer)
8699		err = &smithy.DeserializationError{
8700			Err:      fmt.Errorf("failed to decode response body, %w", err),
8701			Snapshot: snapshot.Bytes(),
8702		}
8703		return out, metadata, err
8704	}
8705
8706	err = awsAwsjson11_deserializeOpDocumentGetBundlesOutput(&output, shape)
8707	if err != nil {
8708		var snapshot bytes.Buffer
8709		io.Copy(&snapshot, ringBuffer)
8710		err = &smithy.DeserializationError{
8711			Err:      fmt.Errorf("failed to decode response body, %w", err),
8712			Snapshot: snapshot.Bytes(),
8713		}
8714		return out, metadata, err
8715	}
8716
8717	return out, metadata, err
8718}
8719
8720func awsAwsjson11_deserializeOpErrorGetBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8721	var errorBuffer bytes.Buffer
8722	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8723		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8724	}
8725	errorBody := bytes.NewReader(errorBuffer.Bytes())
8726
8727	errorCode := "UnknownError"
8728	errorMessage := errorCode
8729
8730	code := response.Header.Get("X-Amzn-ErrorType")
8731	if len(code) != 0 {
8732		errorCode = restjson.SanitizeErrorCode(code)
8733	}
8734
8735	var buff [1024]byte
8736	ringBuffer := smithyio.NewRingBuffer(buff[:])
8737
8738	body := io.TeeReader(errorBody, ringBuffer)
8739	decoder := json.NewDecoder(body)
8740	decoder.UseNumber()
8741	code, message, err := restjson.GetErrorInfo(decoder)
8742	if err != nil {
8743		var snapshot bytes.Buffer
8744		io.Copy(&snapshot, ringBuffer)
8745		err = &smithy.DeserializationError{
8746			Err:      fmt.Errorf("failed to decode response body, %w", err),
8747			Snapshot: snapshot.Bytes(),
8748		}
8749		return err
8750	}
8751
8752	errorBody.Seek(0, io.SeekStart)
8753	if len(code) != 0 {
8754		errorCode = restjson.SanitizeErrorCode(code)
8755	}
8756	if len(message) != 0 {
8757		errorMessage = message
8758	}
8759
8760	switch {
8761	case strings.EqualFold("AccessDeniedException", errorCode):
8762		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8763
8764	case strings.EqualFold("AccountSetupInProgressException", errorCode):
8765		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
8766
8767	case strings.EqualFold("InvalidInputException", errorCode):
8768		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8769
8770	case strings.EqualFold("NotFoundException", errorCode):
8771		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8772
8773	case strings.EqualFold("OperationFailureException", errorCode):
8774		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8775
8776	case strings.EqualFold("ServiceException", errorCode):
8777		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8778
8779	case strings.EqualFold("UnauthenticatedException", errorCode):
8780		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8781
8782	default:
8783		genericError := &smithy.GenericAPIError{
8784			Code:    errorCode,
8785			Message: errorMessage,
8786		}
8787		return genericError
8788
8789	}
8790}
8791
8792type awsAwsjson11_deserializeOpGetCertificates struct {
8793}
8794
8795func (*awsAwsjson11_deserializeOpGetCertificates) ID() string {
8796	return "OperationDeserializer"
8797}
8798
8799func (m *awsAwsjson11_deserializeOpGetCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8800	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8801) {
8802	out, metadata, err = next.HandleDeserialize(ctx, in)
8803	if err != nil {
8804		return out, metadata, err
8805	}
8806
8807	response, ok := out.RawResponse.(*smithyhttp.Response)
8808	if !ok {
8809		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8810	}
8811
8812	if response.StatusCode < 200 || response.StatusCode >= 300 {
8813		return out, metadata, awsAwsjson11_deserializeOpErrorGetCertificates(response, &metadata)
8814	}
8815	output := &GetCertificatesOutput{}
8816	out.Result = output
8817
8818	var buff [1024]byte
8819	ringBuffer := smithyio.NewRingBuffer(buff[:])
8820
8821	body := io.TeeReader(response.Body, ringBuffer)
8822	decoder := json.NewDecoder(body)
8823	decoder.UseNumber()
8824	var shape interface{}
8825	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8826		var snapshot bytes.Buffer
8827		io.Copy(&snapshot, ringBuffer)
8828		err = &smithy.DeserializationError{
8829			Err:      fmt.Errorf("failed to decode response body, %w", err),
8830			Snapshot: snapshot.Bytes(),
8831		}
8832		return out, metadata, err
8833	}
8834
8835	err = awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(&output, shape)
8836	if err != nil {
8837		var snapshot bytes.Buffer
8838		io.Copy(&snapshot, ringBuffer)
8839		err = &smithy.DeserializationError{
8840			Err:      fmt.Errorf("failed to decode response body, %w", err),
8841			Snapshot: snapshot.Bytes(),
8842		}
8843		return out, metadata, err
8844	}
8845
8846	return out, metadata, err
8847}
8848
8849func awsAwsjson11_deserializeOpErrorGetCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8850	var errorBuffer bytes.Buffer
8851	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8852		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8853	}
8854	errorBody := bytes.NewReader(errorBuffer.Bytes())
8855
8856	errorCode := "UnknownError"
8857	errorMessage := errorCode
8858
8859	code := response.Header.Get("X-Amzn-ErrorType")
8860	if len(code) != 0 {
8861		errorCode = restjson.SanitizeErrorCode(code)
8862	}
8863
8864	var buff [1024]byte
8865	ringBuffer := smithyio.NewRingBuffer(buff[:])
8866
8867	body := io.TeeReader(errorBody, ringBuffer)
8868	decoder := json.NewDecoder(body)
8869	decoder.UseNumber()
8870	code, message, err := restjson.GetErrorInfo(decoder)
8871	if err != nil {
8872		var snapshot bytes.Buffer
8873		io.Copy(&snapshot, ringBuffer)
8874		err = &smithy.DeserializationError{
8875			Err:      fmt.Errorf("failed to decode response body, %w", err),
8876			Snapshot: snapshot.Bytes(),
8877		}
8878		return err
8879	}
8880
8881	errorBody.Seek(0, io.SeekStart)
8882	if len(code) != 0 {
8883		errorCode = restjson.SanitizeErrorCode(code)
8884	}
8885	if len(message) != 0 {
8886		errorMessage = message
8887	}
8888
8889	switch {
8890	case strings.EqualFold("AccessDeniedException", errorCode):
8891		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8892
8893	case strings.EqualFold("InvalidInputException", errorCode):
8894		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8895
8896	case strings.EqualFold("NotFoundException", errorCode):
8897		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8898
8899	case strings.EqualFold("ServiceException", errorCode):
8900		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8901
8902	case strings.EqualFold("UnauthenticatedException", errorCode):
8903		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8904
8905	default:
8906		genericError := &smithy.GenericAPIError{
8907			Code:    errorCode,
8908			Message: errorMessage,
8909		}
8910		return genericError
8911
8912	}
8913}
8914
8915type awsAwsjson11_deserializeOpGetCloudFormationStackRecords struct {
8916}
8917
8918func (*awsAwsjson11_deserializeOpGetCloudFormationStackRecords) ID() string {
8919	return "OperationDeserializer"
8920}
8921
8922func (m *awsAwsjson11_deserializeOpGetCloudFormationStackRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8923	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8924) {
8925	out, metadata, err = next.HandleDeserialize(ctx, in)
8926	if err != nil {
8927		return out, metadata, err
8928	}
8929
8930	response, ok := out.RawResponse.(*smithyhttp.Response)
8931	if !ok {
8932		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8933	}
8934
8935	if response.StatusCode < 200 || response.StatusCode >= 300 {
8936		return out, metadata, awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response, &metadata)
8937	}
8938	output := &GetCloudFormationStackRecordsOutput{}
8939	out.Result = output
8940
8941	var buff [1024]byte
8942	ringBuffer := smithyio.NewRingBuffer(buff[:])
8943
8944	body := io.TeeReader(response.Body, ringBuffer)
8945	decoder := json.NewDecoder(body)
8946	decoder.UseNumber()
8947	var shape interface{}
8948	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
8956	}
8957
8958	err = awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(&output, shape)
8959	if err != nil {
8960		var snapshot bytes.Buffer
8961		io.Copy(&snapshot, ringBuffer)
8962		err = &smithy.DeserializationError{
8963			Err:      fmt.Errorf("failed to decode response body, %w", err),
8964			Snapshot: snapshot.Bytes(),
8965		}
8966		return out, metadata, err
8967	}
8968
8969	return out, metadata, err
8970}
8971
8972func awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8973	var errorBuffer bytes.Buffer
8974	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8975		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8976	}
8977	errorBody := bytes.NewReader(errorBuffer.Bytes())
8978
8979	errorCode := "UnknownError"
8980	errorMessage := errorCode
8981
8982	code := response.Header.Get("X-Amzn-ErrorType")
8983	if len(code) != 0 {
8984		errorCode = restjson.SanitizeErrorCode(code)
8985	}
8986
8987	var buff [1024]byte
8988	ringBuffer := smithyio.NewRingBuffer(buff[:])
8989
8990	body := io.TeeReader(errorBody, ringBuffer)
8991	decoder := json.NewDecoder(body)
8992	decoder.UseNumber()
8993	code, message, err := restjson.GetErrorInfo(decoder)
8994	if err != nil {
8995		var snapshot bytes.Buffer
8996		io.Copy(&snapshot, ringBuffer)
8997		err = &smithy.DeserializationError{
8998			Err:      fmt.Errorf("failed to decode response body, %w", err),
8999			Snapshot: snapshot.Bytes(),
9000		}
9001		return err
9002	}
9003
9004	errorBody.Seek(0, io.SeekStart)
9005	if len(code) != 0 {
9006		errorCode = restjson.SanitizeErrorCode(code)
9007	}
9008	if len(message) != 0 {
9009		errorMessage = message
9010	}
9011
9012	switch {
9013	case strings.EqualFold("AccessDeniedException", errorCode):
9014		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9015
9016	case strings.EqualFold("AccountSetupInProgressException", errorCode):
9017		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9018
9019	case strings.EqualFold("InvalidInputException", errorCode):
9020		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9021
9022	case strings.EqualFold("NotFoundException", errorCode):
9023		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9024
9025	case strings.EqualFold("OperationFailureException", errorCode):
9026		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9027
9028	case strings.EqualFold("ServiceException", errorCode):
9029		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9030
9031	case strings.EqualFold("UnauthenticatedException", errorCode):
9032		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9033
9034	default:
9035		genericError := &smithy.GenericAPIError{
9036			Code:    errorCode,
9037			Message: errorMessage,
9038		}
9039		return genericError
9040
9041	}
9042}
9043
9044type awsAwsjson11_deserializeOpGetContactMethods struct {
9045}
9046
9047func (*awsAwsjson11_deserializeOpGetContactMethods) ID() string {
9048	return "OperationDeserializer"
9049}
9050
9051func (m *awsAwsjson11_deserializeOpGetContactMethods) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9052	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9053) {
9054	out, metadata, err = next.HandleDeserialize(ctx, in)
9055	if err != nil {
9056		return out, metadata, err
9057	}
9058
9059	response, ok := out.RawResponse.(*smithyhttp.Response)
9060	if !ok {
9061		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9062	}
9063
9064	if response.StatusCode < 200 || response.StatusCode >= 300 {
9065		return out, metadata, awsAwsjson11_deserializeOpErrorGetContactMethods(response, &metadata)
9066	}
9067	output := &GetContactMethodsOutput{}
9068	out.Result = output
9069
9070	var buff [1024]byte
9071	ringBuffer := smithyio.NewRingBuffer(buff[:])
9072
9073	body := io.TeeReader(response.Body, ringBuffer)
9074	decoder := json.NewDecoder(body)
9075	decoder.UseNumber()
9076	var shape interface{}
9077	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9078		var snapshot bytes.Buffer
9079		io.Copy(&snapshot, ringBuffer)
9080		err = &smithy.DeserializationError{
9081			Err:      fmt.Errorf("failed to decode response body, %w", err),
9082			Snapshot: snapshot.Bytes(),
9083		}
9084		return out, metadata, err
9085	}
9086
9087	err = awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(&output, shape)
9088	if err != nil {
9089		var snapshot bytes.Buffer
9090		io.Copy(&snapshot, ringBuffer)
9091		err = &smithy.DeserializationError{
9092			Err:      fmt.Errorf("failed to decode response body, %w", err),
9093			Snapshot: snapshot.Bytes(),
9094		}
9095		return out, metadata, err
9096	}
9097
9098	return out, metadata, err
9099}
9100
9101func awsAwsjson11_deserializeOpErrorGetContactMethods(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9102	var errorBuffer bytes.Buffer
9103	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9104		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9105	}
9106	errorBody := bytes.NewReader(errorBuffer.Bytes())
9107
9108	errorCode := "UnknownError"
9109	errorMessage := errorCode
9110
9111	code := response.Header.Get("X-Amzn-ErrorType")
9112	if len(code) != 0 {
9113		errorCode = restjson.SanitizeErrorCode(code)
9114	}
9115
9116	var buff [1024]byte
9117	ringBuffer := smithyio.NewRingBuffer(buff[:])
9118
9119	body := io.TeeReader(errorBody, ringBuffer)
9120	decoder := json.NewDecoder(body)
9121	decoder.UseNumber()
9122	code, message, err := restjson.GetErrorInfo(decoder)
9123	if err != nil {
9124		var snapshot bytes.Buffer
9125		io.Copy(&snapshot, ringBuffer)
9126		err = &smithy.DeserializationError{
9127			Err:      fmt.Errorf("failed to decode response body, %w", err),
9128			Snapshot: snapshot.Bytes(),
9129		}
9130		return err
9131	}
9132
9133	errorBody.Seek(0, io.SeekStart)
9134	if len(code) != 0 {
9135		errorCode = restjson.SanitizeErrorCode(code)
9136	}
9137	if len(message) != 0 {
9138		errorMessage = message
9139	}
9140
9141	switch {
9142	case strings.EqualFold("AccessDeniedException", errorCode):
9143		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9144
9145	case strings.EqualFold("InvalidInputException", errorCode):
9146		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9147
9148	case strings.EqualFold("NotFoundException", errorCode):
9149		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9150
9151	case strings.EqualFold("OperationFailureException", errorCode):
9152		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9153
9154	case strings.EqualFold("ServiceException", errorCode):
9155		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9156
9157	case strings.EqualFold("UnauthenticatedException", errorCode):
9158		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9159
9160	default:
9161		genericError := &smithy.GenericAPIError{
9162			Code:    errorCode,
9163			Message: errorMessage,
9164		}
9165		return genericError
9166
9167	}
9168}
9169
9170type awsAwsjson11_deserializeOpGetContainerAPIMetadata struct {
9171}
9172
9173func (*awsAwsjson11_deserializeOpGetContainerAPIMetadata) ID() string {
9174	return "OperationDeserializer"
9175}
9176
9177func (m *awsAwsjson11_deserializeOpGetContainerAPIMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9178	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9179) {
9180	out, metadata, err = next.HandleDeserialize(ctx, in)
9181	if err != nil {
9182		return out, metadata, err
9183	}
9184
9185	response, ok := out.RawResponse.(*smithyhttp.Response)
9186	if !ok {
9187		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9188	}
9189
9190	if response.StatusCode < 200 || response.StatusCode >= 300 {
9191		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response, &metadata)
9192	}
9193	output := &GetContainerAPIMetadataOutput{}
9194	out.Result = output
9195
9196	var buff [1024]byte
9197	ringBuffer := smithyio.NewRingBuffer(buff[:])
9198
9199	body := io.TeeReader(response.Body, ringBuffer)
9200	decoder := json.NewDecoder(body)
9201	decoder.UseNumber()
9202	var shape interface{}
9203	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9204		var snapshot bytes.Buffer
9205		io.Copy(&snapshot, ringBuffer)
9206		err = &smithy.DeserializationError{
9207			Err:      fmt.Errorf("failed to decode response body, %w", err),
9208			Snapshot: snapshot.Bytes(),
9209		}
9210		return out, metadata, err
9211	}
9212
9213	err = awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(&output, shape)
9214	if err != nil {
9215		var snapshot bytes.Buffer
9216		io.Copy(&snapshot, ringBuffer)
9217		err = &smithy.DeserializationError{
9218			Err:      fmt.Errorf("failed to decode response body, %w", err),
9219			Snapshot: snapshot.Bytes(),
9220		}
9221		return out, metadata, err
9222	}
9223
9224	return out, metadata, err
9225}
9226
9227func awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9228	var errorBuffer bytes.Buffer
9229	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9230		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9231	}
9232	errorBody := bytes.NewReader(errorBuffer.Bytes())
9233
9234	errorCode := "UnknownError"
9235	errorMessage := errorCode
9236
9237	code := response.Header.Get("X-Amzn-ErrorType")
9238	if len(code) != 0 {
9239		errorCode = restjson.SanitizeErrorCode(code)
9240	}
9241
9242	var buff [1024]byte
9243	ringBuffer := smithyio.NewRingBuffer(buff[:])
9244
9245	body := io.TeeReader(errorBody, ringBuffer)
9246	decoder := json.NewDecoder(body)
9247	decoder.UseNumber()
9248	code, message, err := restjson.GetErrorInfo(decoder)
9249	if err != nil {
9250		var snapshot bytes.Buffer
9251		io.Copy(&snapshot, ringBuffer)
9252		err = &smithy.DeserializationError{
9253			Err:      fmt.Errorf("failed to decode response body, %w", err),
9254			Snapshot: snapshot.Bytes(),
9255		}
9256		return err
9257	}
9258
9259	errorBody.Seek(0, io.SeekStart)
9260	if len(code) != 0 {
9261		errorCode = restjson.SanitizeErrorCode(code)
9262	}
9263	if len(message) != 0 {
9264		errorMessage = message
9265	}
9266
9267	switch {
9268	case strings.EqualFold("AccessDeniedException", errorCode):
9269		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9270
9271	case strings.EqualFold("ServiceException", errorCode):
9272		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9273
9274	case strings.EqualFold("UnauthenticatedException", errorCode):
9275		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9276
9277	default:
9278		genericError := &smithy.GenericAPIError{
9279			Code:    errorCode,
9280			Message: errorMessage,
9281		}
9282		return genericError
9283
9284	}
9285}
9286
9287type awsAwsjson11_deserializeOpGetContainerImages struct {
9288}
9289
9290func (*awsAwsjson11_deserializeOpGetContainerImages) ID() string {
9291	return "OperationDeserializer"
9292}
9293
9294func (m *awsAwsjson11_deserializeOpGetContainerImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9295	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9296) {
9297	out, metadata, err = next.HandleDeserialize(ctx, in)
9298	if err != nil {
9299		return out, metadata, err
9300	}
9301
9302	response, ok := out.RawResponse.(*smithyhttp.Response)
9303	if !ok {
9304		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9305	}
9306
9307	if response.StatusCode < 200 || response.StatusCode >= 300 {
9308		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerImages(response, &metadata)
9309	}
9310	output := &GetContainerImagesOutput{}
9311	out.Result = output
9312
9313	var buff [1024]byte
9314	ringBuffer := smithyio.NewRingBuffer(buff[:])
9315
9316	body := io.TeeReader(response.Body, ringBuffer)
9317	decoder := json.NewDecoder(body)
9318	decoder.UseNumber()
9319	var shape interface{}
9320	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9321		var snapshot bytes.Buffer
9322		io.Copy(&snapshot, ringBuffer)
9323		err = &smithy.DeserializationError{
9324			Err:      fmt.Errorf("failed to decode response body, %w", err),
9325			Snapshot: snapshot.Bytes(),
9326		}
9327		return out, metadata, err
9328	}
9329
9330	err = awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(&output, shape)
9331	if err != nil {
9332		var snapshot bytes.Buffer
9333		io.Copy(&snapshot, ringBuffer)
9334		err = &smithy.DeserializationError{
9335			Err:      fmt.Errorf("failed to decode response body, %w", err),
9336			Snapshot: snapshot.Bytes(),
9337		}
9338		return out, metadata, err
9339	}
9340
9341	return out, metadata, err
9342}
9343
9344func awsAwsjson11_deserializeOpErrorGetContainerImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9345	var errorBuffer bytes.Buffer
9346	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9347		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9348	}
9349	errorBody := bytes.NewReader(errorBuffer.Bytes())
9350
9351	errorCode := "UnknownError"
9352	errorMessage := errorCode
9353
9354	code := response.Header.Get("X-Amzn-ErrorType")
9355	if len(code) != 0 {
9356		errorCode = restjson.SanitizeErrorCode(code)
9357	}
9358
9359	var buff [1024]byte
9360	ringBuffer := smithyio.NewRingBuffer(buff[:])
9361
9362	body := io.TeeReader(errorBody, ringBuffer)
9363	decoder := json.NewDecoder(body)
9364	decoder.UseNumber()
9365	code, message, err := restjson.GetErrorInfo(decoder)
9366	if err != nil {
9367		var snapshot bytes.Buffer
9368		io.Copy(&snapshot, ringBuffer)
9369		err = &smithy.DeserializationError{
9370			Err:      fmt.Errorf("failed to decode response body, %w", err),
9371			Snapshot: snapshot.Bytes(),
9372		}
9373		return err
9374	}
9375
9376	errorBody.Seek(0, io.SeekStart)
9377	if len(code) != 0 {
9378		errorCode = restjson.SanitizeErrorCode(code)
9379	}
9380	if len(message) != 0 {
9381		errorMessage = message
9382	}
9383
9384	switch {
9385	case strings.EqualFold("AccessDeniedException", errorCode):
9386		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9387
9388	case strings.EqualFold("InvalidInputException", errorCode):
9389		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9390
9391	case strings.EqualFold("NotFoundException", errorCode):
9392		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9393
9394	case strings.EqualFold("ServiceException", errorCode):
9395		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9396
9397	case strings.EqualFold("UnauthenticatedException", errorCode):
9398		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9399
9400	default:
9401		genericError := &smithy.GenericAPIError{
9402			Code:    errorCode,
9403			Message: errorMessage,
9404		}
9405		return genericError
9406
9407	}
9408}
9409
9410type awsAwsjson11_deserializeOpGetContainerLog struct {
9411}
9412
9413func (*awsAwsjson11_deserializeOpGetContainerLog) ID() string {
9414	return "OperationDeserializer"
9415}
9416
9417func (m *awsAwsjson11_deserializeOpGetContainerLog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9418	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9419) {
9420	out, metadata, err = next.HandleDeserialize(ctx, in)
9421	if err != nil {
9422		return out, metadata, err
9423	}
9424
9425	response, ok := out.RawResponse.(*smithyhttp.Response)
9426	if !ok {
9427		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9428	}
9429
9430	if response.StatusCode < 200 || response.StatusCode >= 300 {
9431		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerLog(response, &metadata)
9432	}
9433	output := &GetContainerLogOutput{}
9434	out.Result = output
9435
9436	var buff [1024]byte
9437	ringBuffer := smithyio.NewRingBuffer(buff[:])
9438
9439	body := io.TeeReader(response.Body, ringBuffer)
9440	decoder := json.NewDecoder(body)
9441	decoder.UseNumber()
9442	var shape interface{}
9443	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9444		var snapshot bytes.Buffer
9445		io.Copy(&snapshot, ringBuffer)
9446		err = &smithy.DeserializationError{
9447			Err:      fmt.Errorf("failed to decode response body, %w", err),
9448			Snapshot: snapshot.Bytes(),
9449		}
9450		return out, metadata, err
9451	}
9452
9453	err = awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(&output, shape)
9454	if err != nil {
9455		var snapshot bytes.Buffer
9456		io.Copy(&snapshot, ringBuffer)
9457		err = &smithy.DeserializationError{
9458			Err:      fmt.Errorf("failed to decode response body, %w", err),
9459			Snapshot: snapshot.Bytes(),
9460		}
9461		return out, metadata, err
9462	}
9463
9464	return out, metadata, err
9465}
9466
9467func awsAwsjson11_deserializeOpErrorGetContainerLog(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9468	var errorBuffer bytes.Buffer
9469	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9470		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9471	}
9472	errorBody := bytes.NewReader(errorBuffer.Bytes())
9473
9474	errorCode := "UnknownError"
9475	errorMessage := errorCode
9476
9477	code := response.Header.Get("X-Amzn-ErrorType")
9478	if len(code) != 0 {
9479		errorCode = restjson.SanitizeErrorCode(code)
9480	}
9481
9482	var buff [1024]byte
9483	ringBuffer := smithyio.NewRingBuffer(buff[:])
9484
9485	body := io.TeeReader(errorBody, ringBuffer)
9486	decoder := json.NewDecoder(body)
9487	decoder.UseNumber()
9488	code, message, err := restjson.GetErrorInfo(decoder)
9489	if err != nil {
9490		var snapshot bytes.Buffer
9491		io.Copy(&snapshot, ringBuffer)
9492		err = &smithy.DeserializationError{
9493			Err:      fmt.Errorf("failed to decode response body, %w", err),
9494			Snapshot: snapshot.Bytes(),
9495		}
9496		return err
9497	}
9498
9499	errorBody.Seek(0, io.SeekStart)
9500	if len(code) != 0 {
9501		errorCode = restjson.SanitizeErrorCode(code)
9502	}
9503	if len(message) != 0 {
9504		errorMessage = message
9505	}
9506
9507	switch {
9508	case strings.EqualFold("AccessDeniedException", errorCode):
9509		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9510
9511	case strings.EqualFold("InvalidInputException", errorCode):
9512		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9513
9514	case strings.EqualFold("NotFoundException", errorCode):
9515		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9516
9517	case strings.EqualFold("ServiceException", errorCode):
9518		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9519
9520	case strings.EqualFold("UnauthenticatedException", errorCode):
9521		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9522
9523	default:
9524		genericError := &smithy.GenericAPIError{
9525			Code:    errorCode,
9526			Message: errorMessage,
9527		}
9528		return genericError
9529
9530	}
9531}
9532
9533type awsAwsjson11_deserializeOpGetContainerServiceDeployments struct {
9534}
9535
9536func (*awsAwsjson11_deserializeOpGetContainerServiceDeployments) ID() string {
9537	return "OperationDeserializer"
9538}
9539
9540func (m *awsAwsjson11_deserializeOpGetContainerServiceDeployments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9541	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9542) {
9543	out, metadata, err = next.HandleDeserialize(ctx, in)
9544	if err != nil {
9545		return out, metadata, err
9546	}
9547
9548	response, ok := out.RawResponse.(*smithyhttp.Response)
9549	if !ok {
9550		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9551	}
9552
9553	if response.StatusCode < 200 || response.StatusCode >= 300 {
9554		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response, &metadata)
9555	}
9556	output := &GetContainerServiceDeploymentsOutput{}
9557	out.Result = output
9558
9559	var buff [1024]byte
9560	ringBuffer := smithyio.NewRingBuffer(buff[:])
9561
9562	body := io.TeeReader(response.Body, ringBuffer)
9563	decoder := json.NewDecoder(body)
9564	decoder.UseNumber()
9565	var shape interface{}
9566	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9567		var snapshot bytes.Buffer
9568		io.Copy(&snapshot, ringBuffer)
9569		err = &smithy.DeserializationError{
9570			Err:      fmt.Errorf("failed to decode response body, %w", err),
9571			Snapshot: snapshot.Bytes(),
9572		}
9573		return out, metadata, err
9574	}
9575
9576	err = awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(&output, shape)
9577	if err != nil {
9578		var snapshot bytes.Buffer
9579		io.Copy(&snapshot, ringBuffer)
9580		err = &smithy.DeserializationError{
9581			Err:      fmt.Errorf("failed to decode response body, %w", err),
9582			Snapshot: snapshot.Bytes(),
9583		}
9584		return out, metadata, err
9585	}
9586
9587	return out, metadata, err
9588}
9589
9590func awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9591	var errorBuffer bytes.Buffer
9592	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9593		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9594	}
9595	errorBody := bytes.NewReader(errorBuffer.Bytes())
9596
9597	errorCode := "UnknownError"
9598	errorMessage := errorCode
9599
9600	code := response.Header.Get("X-Amzn-ErrorType")
9601	if len(code) != 0 {
9602		errorCode = restjson.SanitizeErrorCode(code)
9603	}
9604
9605	var buff [1024]byte
9606	ringBuffer := smithyio.NewRingBuffer(buff[:])
9607
9608	body := io.TeeReader(errorBody, ringBuffer)
9609	decoder := json.NewDecoder(body)
9610	decoder.UseNumber()
9611	code, message, err := restjson.GetErrorInfo(decoder)
9612	if err != nil {
9613		var snapshot bytes.Buffer
9614		io.Copy(&snapshot, ringBuffer)
9615		err = &smithy.DeserializationError{
9616			Err:      fmt.Errorf("failed to decode response body, %w", err),
9617			Snapshot: snapshot.Bytes(),
9618		}
9619		return err
9620	}
9621
9622	errorBody.Seek(0, io.SeekStart)
9623	if len(code) != 0 {
9624		errorCode = restjson.SanitizeErrorCode(code)
9625	}
9626	if len(message) != 0 {
9627		errorMessage = message
9628	}
9629
9630	switch {
9631	case strings.EqualFold("AccessDeniedException", errorCode):
9632		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9633
9634	case strings.EqualFold("InvalidInputException", errorCode):
9635		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9636
9637	case strings.EqualFold("NotFoundException", errorCode):
9638		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9639
9640	case strings.EqualFold("ServiceException", errorCode):
9641		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9642
9643	case strings.EqualFold("UnauthenticatedException", errorCode):
9644		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9645
9646	default:
9647		genericError := &smithy.GenericAPIError{
9648			Code:    errorCode,
9649			Message: errorMessage,
9650		}
9651		return genericError
9652
9653	}
9654}
9655
9656type awsAwsjson11_deserializeOpGetContainerServiceMetricData struct {
9657}
9658
9659func (*awsAwsjson11_deserializeOpGetContainerServiceMetricData) ID() string {
9660	return "OperationDeserializer"
9661}
9662
9663func (m *awsAwsjson11_deserializeOpGetContainerServiceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9664	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9665) {
9666	out, metadata, err = next.HandleDeserialize(ctx, in)
9667	if err != nil {
9668		return out, metadata, err
9669	}
9670
9671	response, ok := out.RawResponse.(*smithyhttp.Response)
9672	if !ok {
9673		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9674	}
9675
9676	if response.StatusCode < 200 || response.StatusCode >= 300 {
9677		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response, &metadata)
9678	}
9679	output := &GetContainerServiceMetricDataOutput{}
9680	out.Result = output
9681
9682	var buff [1024]byte
9683	ringBuffer := smithyio.NewRingBuffer(buff[:])
9684
9685	body := io.TeeReader(response.Body, ringBuffer)
9686	decoder := json.NewDecoder(body)
9687	decoder.UseNumber()
9688	var shape interface{}
9689	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9690		var snapshot bytes.Buffer
9691		io.Copy(&snapshot, ringBuffer)
9692		err = &smithy.DeserializationError{
9693			Err:      fmt.Errorf("failed to decode response body, %w", err),
9694			Snapshot: snapshot.Bytes(),
9695		}
9696		return out, metadata, err
9697	}
9698
9699	err = awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(&output, shape)
9700	if err != nil {
9701		var snapshot bytes.Buffer
9702		io.Copy(&snapshot, ringBuffer)
9703		err = &smithy.DeserializationError{
9704			Err:      fmt.Errorf("failed to decode response body, %w", err),
9705			Snapshot: snapshot.Bytes(),
9706		}
9707		return out, metadata, err
9708	}
9709
9710	return out, metadata, err
9711}
9712
9713func awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9714	var errorBuffer bytes.Buffer
9715	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9716		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9717	}
9718	errorBody := bytes.NewReader(errorBuffer.Bytes())
9719
9720	errorCode := "UnknownError"
9721	errorMessage := errorCode
9722
9723	code := response.Header.Get("X-Amzn-ErrorType")
9724	if len(code) != 0 {
9725		errorCode = restjson.SanitizeErrorCode(code)
9726	}
9727
9728	var buff [1024]byte
9729	ringBuffer := smithyio.NewRingBuffer(buff[:])
9730
9731	body := io.TeeReader(errorBody, ringBuffer)
9732	decoder := json.NewDecoder(body)
9733	decoder.UseNumber()
9734	code, message, err := restjson.GetErrorInfo(decoder)
9735	if err != nil {
9736		var snapshot bytes.Buffer
9737		io.Copy(&snapshot, ringBuffer)
9738		err = &smithy.DeserializationError{
9739			Err:      fmt.Errorf("failed to decode response body, %w", err),
9740			Snapshot: snapshot.Bytes(),
9741		}
9742		return err
9743	}
9744
9745	errorBody.Seek(0, io.SeekStart)
9746	if len(code) != 0 {
9747		errorCode = restjson.SanitizeErrorCode(code)
9748	}
9749	if len(message) != 0 {
9750		errorMessage = message
9751	}
9752
9753	switch {
9754	case strings.EqualFold("AccessDeniedException", errorCode):
9755		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9756
9757	case strings.EqualFold("InvalidInputException", errorCode):
9758		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9759
9760	case strings.EqualFold("NotFoundException", errorCode):
9761		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9762
9763	case strings.EqualFold("ServiceException", errorCode):
9764		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9765
9766	case strings.EqualFold("UnauthenticatedException", errorCode):
9767		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9768
9769	default:
9770		genericError := &smithy.GenericAPIError{
9771			Code:    errorCode,
9772			Message: errorMessage,
9773		}
9774		return genericError
9775
9776	}
9777}
9778
9779type awsAwsjson11_deserializeOpGetContainerServicePowers struct {
9780}
9781
9782func (*awsAwsjson11_deserializeOpGetContainerServicePowers) ID() string {
9783	return "OperationDeserializer"
9784}
9785
9786func (m *awsAwsjson11_deserializeOpGetContainerServicePowers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9787	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9788) {
9789	out, metadata, err = next.HandleDeserialize(ctx, in)
9790	if err != nil {
9791		return out, metadata, err
9792	}
9793
9794	response, ok := out.RawResponse.(*smithyhttp.Response)
9795	if !ok {
9796		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9797	}
9798
9799	if response.StatusCode < 200 || response.StatusCode >= 300 {
9800		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response, &metadata)
9801	}
9802	output := &GetContainerServicePowersOutput{}
9803	out.Result = output
9804
9805	var buff [1024]byte
9806	ringBuffer := smithyio.NewRingBuffer(buff[:])
9807
9808	body := io.TeeReader(response.Body, ringBuffer)
9809	decoder := json.NewDecoder(body)
9810	decoder.UseNumber()
9811	var shape interface{}
9812	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9813		var snapshot bytes.Buffer
9814		io.Copy(&snapshot, ringBuffer)
9815		err = &smithy.DeserializationError{
9816			Err:      fmt.Errorf("failed to decode response body, %w", err),
9817			Snapshot: snapshot.Bytes(),
9818		}
9819		return out, metadata, err
9820	}
9821
9822	err = awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(&output, shape)
9823	if err != nil {
9824		var snapshot bytes.Buffer
9825		io.Copy(&snapshot, ringBuffer)
9826		err = &smithy.DeserializationError{
9827			Err:      fmt.Errorf("failed to decode response body, %w", err),
9828			Snapshot: snapshot.Bytes(),
9829		}
9830		return out, metadata, err
9831	}
9832
9833	return out, metadata, err
9834}
9835
9836func awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9837	var errorBuffer bytes.Buffer
9838	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9839		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9840	}
9841	errorBody := bytes.NewReader(errorBuffer.Bytes())
9842
9843	errorCode := "UnknownError"
9844	errorMessage := errorCode
9845
9846	code := response.Header.Get("X-Amzn-ErrorType")
9847	if len(code) != 0 {
9848		errorCode = restjson.SanitizeErrorCode(code)
9849	}
9850
9851	var buff [1024]byte
9852	ringBuffer := smithyio.NewRingBuffer(buff[:])
9853
9854	body := io.TeeReader(errorBody, ringBuffer)
9855	decoder := json.NewDecoder(body)
9856	decoder.UseNumber()
9857	code, message, err := restjson.GetErrorInfo(decoder)
9858	if err != nil {
9859		var snapshot bytes.Buffer
9860		io.Copy(&snapshot, ringBuffer)
9861		err = &smithy.DeserializationError{
9862			Err:      fmt.Errorf("failed to decode response body, %w", err),
9863			Snapshot: snapshot.Bytes(),
9864		}
9865		return err
9866	}
9867
9868	errorBody.Seek(0, io.SeekStart)
9869	if len(code) != 0 {
9870		errorCode = restjson.SanitizeErrorCode(code)
9871	}
9872	if len(message) != 0 {
9873		errorMessage = message
9874	}
9875
9876	switch {
9877	case strings.EqualFold("AccessDeniedException", errorCode):
9878		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9879
9880	case strings.EqualFold("InvalidInputException", errorCode):
9881		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9882
9883	case strings.EqualFold("NotFoundException", errorCode):
9884		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9885
9886	case strings.EqualFold("ServiceException", errorCode):
9887		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9888
9889	case strings.EqualFold("UnauthenticatedException", errorCode):
9890		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9891
9892	default:
9893		genericError := &smithy.GenericAPIError{
9894			Code:    errorCode,
9895			Message: errorMessage,
9896		}
9897		return genericError
9898
9899	}
9900}
9901
9902type awsAwsjson11_deserializeOpGetContainerServices struct {
9903}
9904
9905func (*awsAwsjson11_deserializeOpGetContainerServices) ID() string {
9906	return "OperationDeserializer"
9907}
9908
9909func (m *awsAwsjson11_deserializeOpGetContainerServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9910	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9911) {
9912	out, metadata, err = next.HandleDeserialize(ctx, in)
9913	if err != nil {
9914		return out, metadata, err
9915	}
9916
9917	response, ok := out.RawResponse.(*smithyhttp.Response)
9918	if !ok {
9919		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9920	}
9921
9922	if response.StatusCode < 200 || response.StatusCode >= 300 {
9923		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServices(response, &metadata)
9924	}
9925	output := &GetContainerServicesOutput{}
9926	out.Result = output
9927
9928	var buff [1024]byte
9929	ringBuffer := smithyio.NewRingBuffer(buff[:])
9930
9931	body := io.TeeReader(response.Body, ringBuffer)
9932	decoder := json.NewDecoder(body)
9933	decoder.UseNumber()
9934	var shape interface{}
9935	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9936		var snapshot bytes.Buffer
9937		io.Copy(&snapshot, ringBuffer)
9938		err = &smithy.DeserializationError{
9939			Err:      fmt.Errorf("failed to decode response body, %w", err),
9940			Snapshot: snapshot.Bytes(),
9941		}
9942		return out, metadata, err
9943	}
9944
9945	err = awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(&output, shape)
9946	if err != nil {
9947		var snapshot bytes.Buffer
9948		io.Copy(&snapshot, ringBuffer)
9949		err = &smithy.DeserializationError{
9950			Err:      fmt.Errorf("failed to decode response body, %w", err),
9951			Snapshot: snapshot.Bytes(),
9952		}
9953		return out, metadata, err
9954	}
9955
9956	return out, metadata, err
9957}
9958
9959func awsAwsjson11_deserializeOpErrorGetContainerServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9960	var errorBuffer bytes.Buffer
9961	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9962		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9963	}
9964	errorBody := bytes.NewReader(errorBuffer.Bytes())
9965
9966	errorCode := "UnknownError"
9967	errorMessage := errorCode
9968
9969	code := response.Header.Get("X-Amzn-ErrorType")
9970	if len(code) != 0 {
9971		errorCode = restjson.SanitizeErrorCode(code)
9972	}
9973
9974	var buff [1024]byte
9975	ringBuffer := smithyio.NewRingBuffer(buff[:])
9976
9977	body := io.TeeReader(errorBody, ringBuffer)
9978	decoder := json.NewDecoder(body)
9979	decoder.UseNumber()
9980	code, message, err := restjson.GetErrorInfo(decoder)
9981	if err != nil {
9982		var snapshot bytes.Buffer
9983		io.Copy(&snapshot, ringBuffer)
9984		err = &smithy.DeserializationError{
9985			Err:      fmt.Errorf("failed to decode response body, %w", err),
9986			Snapshot: snapshot.Bytes(),
9987		}
9988		return err
9989	}
9990
9991	errorBody.Seek(0, io.SeekStart)
9992	if len(code) != 0 {
9993		errorCode = restjson.SanitizeErrorCode(code)
9994	}
9995	if len(message) != 0 {
9996		errorMessage = message
9997	}
9998
9999	switch {
10000	case strings.EqualFold("AccessDeniedException", errorCode):
10001		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10002
10003	case strings.EqualFold("InvalidInputException", errorCode):
10004		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10005
10006	case strings.EqualFold("NotFoundException", errorCode):
10007		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10008
10009	case strings.EqualFold("ServiceException", errorCode):
10010		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10011
10012	case strings.EqualFold("UnauthenticatedException", errorCode):
10013		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10014
10015	default:
10016		genericError := &smithy.GenericAPIError{
10017			Code:    errorCode,
10018			Message: errorMessage,
10019		}
10020		return genericError
10021
10022	}
10023}
10024
10025type awsAwsjson11_deserializeOpGetDisk struct {
10026}
10027
10028func (*awsAwsjson11_deserializeOpGetDisk) ID() string {
10029	return "OperationDeserializer"
10030}
10031
10032func (m *awsAwsjson11_deserializeOpGetDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10033	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10034) {
10035	out, metadata, err = next.HandleDeserialize(ctx, in)
10036	if err != nil {
10037		return out, metadata, err
10038	}
10039
10040	response, ok := out.RawResponse.(*smithyhttp.Response)
10041	if !ok {
10042		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10043	}
10044
10045	if response.StatusCode < 200 || response.StatusCode >= 300 {
10046		return out, metadata, awsAwsjson11_deserializeOpErrorGetDisk(response, &metadata)
10047	}
10048	output := &GetDiskOutput{}
10049	out.Result = output
10050
10051	var buff [1024]byte
10052	ringBuffer := smithyio.NewRingBuffer(buff[:])
10053
10054	body := io.TeeReader(response.Body, ringBuffer)
10055	decoder := json.NewDecoder(body)
10056	decoder.UseNumber()
10057	var shape interface{}
10058	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10059		var snapshot bytes.Buffer
10060		io.Copy(&snapshot, ringBuffer)
10061		err = &smithy.DeserializationError{
10062			Err:      fmt.Errorf("failed to decode response body, %w", err),
10063			Snapshot: snapshot.Bytes(),
10064		}
10065		return out, metadata, err
10066	}
10067
10068	err = awsAwsjson11_deserializeOpDocumentGetDiskOutput(&output, shape)
10069	if err != nil {
10070		var snapshot bytes.Buffer
10071		io.Copy(&snapshot, ringBuffer)
10072		err = &smithy.DeserializationError{
10073			Err:      fmt.Errorf("failed to decode response body, %w", err),
10074			Snapshot: snapshot.Bytes(),
10075		}
10076		return out, metadata, err
10077	}
10078
10079	return out, metadata, err
10080}
10081
10082func awsAwsjson11_deserializeOpErrorGetDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10083	var errorBuffer bytes.Buffer
10084	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10085		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10086	}
10087	errorBody := bytes.NewReader(errorBuffer.Bytes())
10088
10089	errorCode := "UnknownError"
10090	errorMessage := errorCode
10091
10092	code := response.Header.Get("X-Amzn-ErrorType")
10093	if len(code) != 0 {
10094		errorCode = restjson.SanitizeErrorCode(code)
10095	}
10096
10097	var buff [1024]byte
10098	ringBuffer := smithyio.NewRingBuffer(buff[:])
10099
10100	body := io.TeeReader(errorBody, ringBuffer)
10101	decoder := json.NewDecoder(body)
10102	decoder.UseNumber()
10103	code, message, err := restjson.GetErrorInfo(decoder)
10104	if err != nil {
10105		var snapshot bytes.Buffer
10106		io.Copy(&snapshot, ringBuffer)
10107		err = &smithy.DeserializationError{
10108			Err:      fmt.Errorf("failed to decode response body, %w", err),
10109			Snapshot: snapshot.Bytes(),
10110		}
10111		return err
10112	}
10113
10114	errorBody.Seek(0, io.SeekStart)
10115	if len(code) != 0 {
10116		errorCode = restjson.SanitizeErrorCode(code)
10117	}
10118	if len(message) != 0 {
10119		errorMessage = message
10120	}
10121
10122	switch {
10123	case strings.EqualFold("AccessDeniedException", errorCode):
10124		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10125
10126	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10127		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10128
10129	case strings.EqualFold("InvalidInputException", errorCode):
10130		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10131
10132	case strings.EqualFold("NotFoundException", errorCode):
10133		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10134
10135	case strings.EqualFold("OperationFailureException", errorCode):
10136		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10137
10138	case strings.EqualFold("ServiceException", errorCode):
10139		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10140
10141	case strings.EqualFold("UnauthenticatedException", errorCode):
10142		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10143
10144	default:
10145		genericError := &smithy.GenericAPIError{
10146			Code:    errorCode,
10147			Message: errorMessage,
10148		}
10149		return genericError
10150
10151	}
10152}
10153
10154type awsAwsjson11_deserializeOpGetDisks struct {
10155}
10156
10157func (*awsAwsjson11_deserializeOpGetDisks) ID() string {
10158	return "OperationDeserializer"
10159}
10160
10161func (m *awsAwsjson11_deserializeOpGetDisks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10162	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10163) {
10164	out, metadata, err = next.HandleDeserialize(ctx, in)
10165	if err != nil {
10166		return out, metadata, err
10167	}
10168
10169	response, ok := out.RawResponse.(*smithyhttp.Response)
10170	if !ok {
10171		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10172	}
10173
10174	if response.StatusCode < 200 || response.StatusCode >= 300 {
10175		return out, metadata, awsAwsjson11_deserializeOpErrorGetDisks(response, &metadata)
10176	}
10177	output := &GetDisksOutput{}
10178	out.Result = output
10179
10180	var buff [1024]byte
10181	ringBuffer := smithyio.NewRingBuffer(buff[:])
10182
10183	body := io.TeeReader(response.Body, ringBuffer)
10184	decoder := json.NewDecoder(body)
10185	decoder.UseNumber()
10186	var shape interface{}
10187	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10188		var snapshot bytes.Buffer
10189		io.Copy(&snapshot, ringBuffer)
10190		err = &smithy.DeserializationError{
10191			Err:      fmt.Errorf("failed to decode response body, %w", err),
10192			Snapshot: snapshot.Bytes(),
10193		}
10194		return out, metadata, err
10195	}
10196
10197	err = awsAwsjson11_deserializeOpDocumentGetDisksOutput(&output, shape)
10198	if err != nil {
10199		var snapshot bytes.Buffer
10200		io.Copy(&snapshot, ringBuffer)
10201		err = &smithy.DeserializationError{
10202			Err:      fmt.Errorf("failed to decode response body, %w", err),
10203			Snapshot: snapshot.Bytes(),
10204		}
10205		return out, metadata, err
10206	}
10207
10208	return out, metadata, err
10209}
10210
10211func awsAwsjson11_deserializeOpErrorGetDisks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10212	var errorBuffer bytes.Buffer
10213	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10214		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10215	}
10216	errorBody := bytes.NewReader(errorBuffer.Bytes())
10217
10218	errorCode := "UnknownError"
10219	errorMessage := errorCode
10220
10221	code := response.Header.Get("X-Amzn-ErrorType")
10222	if len(code) != 0 {
10223		errorCode = restjson.SanitizeErrorCode(code)
10224	}
10225
10226	var buff [1024]byte
10227	ringBuffer := smithyio.NewRingBuffer(buff[:])
10228
10229	body := io.TeeReader(errorBody, ringBuffer)
10230	decoder := json.NewDecoder(body)
10231	decoder.UseNumber()
10232	code, message, err := restjson.GetErrorInfo(decoder)
10233	if err != nil {
10234		var snapshot bytes.Buffer
10235		io.Copy(&snapshot, ringBuffer)
10236		err = &smithy.DeserializationError{
10237			Err:      fmt.Errorf("failed to decode response body, %w", err),
10238			Snapshot: snapshot.Bytes(),
10239		}
10240		return err
10241	}
10242
10243	errorBody.Seek(0, io.SeekStart)
10244	if len(code) != 0 {
10245		errorCode = restjson.SanitizeErrorCode(code)
10246	}
10247	if len(message) != 0 {
10248		errorMessage = message
10249	}
10250
10251	switch {
10252	case strings.EqualFold("AccessDeniedException", errorCode):
10253		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10254
10255	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10256		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10257
10258	case strings.EqualFold("InvalidInputException", errorCode):
10259		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10260
10261	case strings.EqualFold("NotFoundException", errorCode):
10262		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10263
10264	case strings.EqualFold("OperationFailureException", errorCode):
10265		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10266
10267	case strings.EqualFold("ServiceException", errorCode):
10268		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10269
10270	case strings.EqualFold("UnauthenticatedException", errorCode):
10271		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10272
10273	default:
10274		genericError := &smithy.GenericAPIError{
10275			Code:    errorCode,
10276			Message: errorMessage,
10277		}
10278		return genericError
10279
10280	}
10281}
10282
10283type awsAwsjson11_deserializeOpGetDiskSnapshot struct {
10284}
10285
10286func (*awsAwsjson11_deserializeOpGetDiskSnapshot) ID() string {
10287	return "OperationDeserializer"
10288}
10289
10290func (m *awsAwsjson11_deserializeOpGetDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10291	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10292) {
10293	out, metadata, err = next.HandleDeserialize(ctx, in)
10294	if err != nil {
10295		return out, metadata, err
10296	}
10297
10298	response, ok := out.RawResponse.(*smithyhttp.Response)
10299	if !ok {
10300		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10301	}
10302
10303	if response.StatusCode < 200 || response.StatusCode >= 300 {
10304		return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response, &metadata)
10305	}
10306	output := &GetDiskSnapshotOutput{}
10307	out.Result = output
10308
10309	var buff [1024]byte
10310	ringBuffer := smithyio.NewRingBuffer(buff[:])
10311
10312	body := io.TeeReader(response.Body, ringBuffer)
10313	decoder := json.NewDecoder(body)
10314	decoder.UseNumber()
10315	var shape interface{}
10316	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10317		var snapshot bytes.Buffer
10318		io.Copy(&snapshot, ringBuffer)
10319		err = &smithy.DeserializationError{
10320			Err:      fmt.Errorf("failed to decode response body, %w", err),
10321			Snapshot: snapshot.Bytes(),
10322		}
10323		return out, metadata, err
10324	}
10325
10326	err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(&output, shape)
10327	if err != nil {
10328		var snapshot bytes.Buffer
10329		io.Copy(&snapshot, ringBuffer)
10330		err = &smithy.DeserializationError{
10331			Err:      fmt.Errorf("failed to decode response body, %w", err),
10332			Snapshot: snapshot.Bytes(),
10333		}
10334		return out, metadata, err
10335	}
10336
10337	return out, metadata, err
10338}
10339
10340func awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10341	var errorBuffer bytes.Buffer
10342	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10343		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10344	}
10345	errorBody := bytes.NewReader(errorBuffer.Bytes())
10346
10347	errorCode := "UnknownError"
10348	errorMessage := errorCode
10349
10350	code := response.Header.Get("X-Amzn-ErrorType")
10351	if len(code) != 0 {
10352		errorCode = restjson.SanitizeErrorCode(code)
10353	}
10354
10355	var buff [1024]byte
10356	ringBuffer := smithyio.NewRingBuffer(buff[:])
10357
10358	body := io.TeeReader(errorBody, ringBuffer)
10359	decoder := json.NewDecoder(body)
10360	decoder.UseNumber()
10361	code, message, err := restjson.GetErrorInfo(decoder)
10362	if err != nil {
10363		var snapshot bytes.Buffer
10364		io.Copy(&snapshot, ringBuffer)
10365		err = &smithy.DeserializationError{
10366			Err:      fmt.Errorf("failed to decode response body, %w", err),
10367			Snapshot: snapshot.Bytes(),
10368		}
10369		return err
10370	}
10371
10372	errorBody.Seek(0, io.SeekStart)
10373	if len(code) != 0 {
10374		errorCode = restjson.SanitizeErrorCode(code)
10375	}
10376	if len(message) != 0 {
10377		errorMessage = message
10378	}
10379
10380	switch {
10381	case strings.EqualFold("AccessDeniedException", errorCode):
10382		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10383
10384	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10385		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10386
10387	case strings.EqualFold("InvalidInputException", errorCode):
10388		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10389
10390	case strings.EqualFold("NotFoundException", errorCode):
10391		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10392
10393	case strings.EqualFold("OperationFailureException", errorCode):
10394		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10395
10396	case strings.EqualFold("ServiceException", errorCode):
10397		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10398
10399	case strings.EqualFold("UnauthenticatedException", errorCode):
10400		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10401
10402	default:
10403		genericError := &smithy.GenericAPIError{
10404			Code:    errorCode,
10405			Message: errorMessage,
10406		}
10407		return genericError
10408
10409	}
10410}
10411
10412type awsAwsjson11_deserializeOpGetDiskSnapshots struct {
10413}
10414
10415func (*awsAwsjson11_deserializeOpGetDiskSnapshots) ID() string {
10416	return "OperationDeserializer"
10417}
10418
10419func (m *awsAwsjson11_deserializeOpGetDiskSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10420	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10421) {
10422	out, metadata, err = next.HandleDeserialize(ctx, in)
10423	if err != nil {
10424		return out, metadata, err
10425	}
10426
10427	response, ok := out.RawResponse.(*smithyhttp.Response)
10428	if !ok {
10429		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10430	}
10431
10432	if response.StatusCode < 200 || response.StatusCode >= 300 {
10433		return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response, &metadata)
10434	}
10435	output := &GetDiskSnapshotsOutput{}
10436	out.Result = output
10437
10438	var buff [1024]byte
10439	ringBuffer := smithyio.NewRingBuffer(buff[:])
10440
10441	body := io.TeeReader(response.Body, ringBuffer)
10442	decoder := json.NewDecoder(body)
10443	decoder.UseNumber()
10444	var shape interface{}
10445	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10446		var snapshot bytes.Buffer
10447		io.Copy(&snapshot, ringBuffer)
10448		err = &smithy.DeserializationError{
10449			Err:      fmt.Errorf("failed to decode response body, %w", err),
10450			Snapshot: snapshot.Bytes(),
10451		}
10452		return out, metadata, err
10453	}
10454
10455	err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(&output, shape)
10456	if err != nil {
10457		var snapshot bytes.Buffer
10458		io.Copy(&snapshot, ringBuffer)
10459		err = &smithy.DeserializationError{
10460			Err:      fmt.Errorf("failed to decode response body, %w", err),
10461			Snapshot: snapshot.Bytes(),
10462		}
10463		return out, metadata, err
10464	}
10465
10466	return out, metadata, err
10467}
10468
10469func awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10470	var errorBuffer bytes.Buffer
10471	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10472		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10473	}
10474	errorBody := bytes.NewReader(errorBuffer.Bytes())
10475
10476	errorCode := "UnknownError"
10477	errorMessage := errorCode
10478
10479	code := response.Header.Get("X-Amzn-ErrorType")
10480	if len(code) != 0 {
10481		errorCode = restjson.SanitizeErrorCode(code)
10482	}
10483
10484	var buff [1024]byte
10485	ringBuffer := smithyio.NewRingBuffer(buff[:])
10486
10487	body := io.TeeReader(errorBody, ringBuffer)
10488	decoder := json.NewDecoder(body)
10489	decoder.UseNumber()
10490	code, message, err := restjson.GetErrorInfo(decoder)
10491	if err != nil {
10492		var snapshot bytes.Buffer
10493		io.Copy(&snapshot, ringBuffer)
10494		err = &smithy.DeserializationError{
10495			Err:      fmt.Errorf("failed to decode response body, %w", err),
10496			Snapshot: snapshot.Bytes(),
10497		}
10498		return err
10499	}
10500
10501	errorBody.Seek(0, io.SeekStart)
10502	if len(code) != 0 {
10503		errorCode = restjson.SanitizeErrorCode(code)
10504	}
10505	if len(message) != 0 {
10506		errorMessage = message
10507	}
10508
10509	switch {
10510	case strings.EqualFold("AccessDeniedException", errorCode):
10511		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10512
10513	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10514		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10515
10516	case strings.EqualFold("InvalidInputException", errorCode):
10517		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10518
10519	case strings.EqualFold("NotFoundException", errorCode):
10520		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10521
10522	case strings.EqualFold("OperationFailureException", errorCode):
10523		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10524
10525	case strings.EqualFold("ServiceException", errorCode):
10526		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10527
10528	case strings.EqualFold("UnauthenticatedException", errorCode):
10529		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10530
10531	default:
10532		genericError := &smithy.GenericAPIError{
10533			Code:    errorCode,
10534			Message: errorMessage,
10535		}
10536		return genericError
10537
10538	}
10539}
10540
10541type awsAwsjson11_deserializeOpGetDistributionBundles struct {
10542}
10543
10544func (*awsAwsjson11_deserializeOpGetDistributionBundles) ID() string {
10545	return "OperationDeserializer"
10546}
10547
10548func (m *awsAwsjson11_deserializeOpGetDistributionBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10549	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10550) {
10551	out, metadata, err = next.HandleDeserialize(ctx, in)
10552	if err != nil {
10553		return out, metadata, err
10554	}
10555
10556	response, ok := out.RawResponse.(*smithyhttp.Response)
10557	if !ok {
10558		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10559	}
10560
10561	if response.StatusCode < 200 || response.StatusCode >= 300 {
10562		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionBundles(response, &metadata)
10563	}
10564	output := &GetDistributionBundlesOutput{}
10565	out.Result = output
10566
10567	var buff [1024]byte
10568	ringBuffer := smithyio.NewRingBuffer(buff[:])
10569
10570	body := io.TeeReader(response.Body, ringBuffer)
10571	decoder := json.NewDecoder(body)
10572	decoder.UseNumber()
10573	var shape interface{}
10574	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10575		var snapshot bytes.Buffer
10576		io.Copy(&snapshot, ringBuffer)
10577		err = &smithy.DeserializationError{
10578			Err:      fmt.Errorf("failed to decode response body, %w", err),
10579			Snapshot: snapshot.Bytes(),
10580		}
10581		return out, metadata, err
10582	}
10583
10584	err = awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(&output, shape)
10585	if err != nil {
10586		var snapshot bytes.Buffer
10587		io.Copy(&snapshot, ringBuffer)
10588		err = &smithy.DeserializationError{
10589			Err:      fmt.Errorf("failed to decode response body, %w", err),
10590			Snapshot: snapshot.Bytes(),
10591		}
10592		return out, metadata, err
10593	}
10594
10595	return out, metadata, err
10596}
10597
10598func awsAwsjson11_deserializeOpErrorGetDistributionBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10599	var errorBuffer bytes.Buffer
10600	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10601		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10602	}
10603	errorBody := bytes.NewReader(errorBuffer.Bytes())
10604
10605	errorCode := "UnknownError"
10606	errorMessage := errorCode
10607
10608	code := response.Header.Get("X-Amzn-ErrorType")
10609	if len(code) != 0 {
10610		errorCode = restjson.SanitizeErrorCode(code)
10611	}
10612
10613	var buff [1024]byte
10614	ringBuffer := smithyio.NewRingBuffer(buff[:])
10615
10616	body := io.TeeReader(errorBody, ringBuffer)
10617	decoder := json.NewDecoder(body)
10618	decoder.UseNumber()
10619	code, message, err := restjson.GetErrorInfo(decoder)
10620	if err != nil {
10621		var snapshot bytes.Buffer
10622		io.Copy(&snapshot, ringBuffer)
10623		err = &smithy.DeserializationError{
10624			Err:      fmt.Errorf("failed to decode response body, %w", err),
10625			Snapshot: snapshot.Bytes(),
10626		}
10627		return err
10628	}
10629
10630	errorBody.Seek(0, io.SeekStart)
10631	if len(code) != 0 {
10632		errorCode = restjson.SanitizeErrorCode(code)
10633	}
10634	if len(message) != 0 {
10635		errorMessage = message
10636	}
10637
10638	switch {
10639	case strings.EqualFold("AccessDeniedException", errorCode):
10640		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10641
10642	case strings.EqualFold("InvalidInputException", errorCode):
10643		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10644
10645	case strings.EqualFold("NotFoundException", errorCode):
10646		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10647
10648	case strings.EqualFold("OperationFailureException", errorCode):
10649		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10650
10651	case strings.EqualFold("ServiceException", errorCode):
10652		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10653
10654	case strings.EqualFold("UnauthenticatedException", errorCode):
10655		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10656
10657	default:
10658		genericError := &smithy.GenericAPIError{
10659			Code:    errorCode,
10660			Message: errorMessage,
10661		}
10662		return genericError
10663
10664	}
10665}
10666
10667type awsAwsjson11_deserializeOpGetDistributionLatestCacheReset struct {
10668}
10669
10670func (*awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) ID() string {
10671	return "OperationDeserializer"
10672}
10673
10674func (m *awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10675	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10676) {
10677	out, metadata, err = next.HandleDeserialize(ctx, in)
10678	if err != nil {
10679		return out, metadata, err
10680	}
10681
10682	response, ok := out.RawResponse.(*smithyhttp.Response)
10683	if !ok {
10684		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10685	}
10686
10687	if response.StatusCode < 200 || response.StatusCode >= 300 {
10688		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response, &metadata)
10689	}
10690	output := &GetDistributionLatestCacheResetOutput{}
10691	out.Result = output
10692
10693	var buff [1024]byte
10694	ringBuffer := smithyio.NewRingBuffer(buff[:])
10695
10696	body := io.TeeReader(response.Body, ringBuffer)
10697	decoder := json.NewDecoder(body)
10698	decoder.UseNumber()
10699	var shape interface{}
10700	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10701		var snapshot bytes.Buffer
10702		io.Copy(&snapshot, ringBuffer)
10703		err = &smithy.DeserializationError{
10704			Err:      fmt.Errorf("failed to decode response body, %w", err),
10705			Snapshot: snapshot.Bytes(),
10706		}
10707		return out, metadata, err
10708	}
10709
10710	err = awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(&output, shape)
10711	if err != nil {
10712		var snapshot bytes.Buffer
10713		io.Copy(&snapshot, ringBuffer)
10714		err = &smithy.DeserializationError{
10715			Err:      fmt.Errorf("failed to decode response body, %w", err),
10716			Snapshot: snapshot.Bytes(),
10717		}
10718		return out, metadata, err
10719	}
10720
10721	return out, metadata, err
10722}
10723
10724func awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10725	var errorBuffer bytes.Buffer
10726	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10727		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10728	}
10729	errorBody := bytes.NewReader(errorBuffer.Bytes())
10730
10731	errorCode := "UnknownError"
10732	errorMessage := errorCode
10733
10734	code := response.Header.Get("X-Amzn-ErrorType")
10735	if len(code) != 0 {
10736		errorCode = restjson.SanitizeErrorCode(code)
10737	}
10738
10739	var buff [1024]byte
10740	ringBuffer := smithyio.NewRingBuffer(buff[:])
10741
10742	body := io.TeeReader(errorBody, ringBuffer)
10743	decoder := json.NewDecoder(body)
10744	decoder.UseNumber()
10745	code, message, err := restjson.GetErrorInfo(decoder)
10746	if err != nil {
10747		var snapshot bytes.Buffer
10748		io.Copy(&snapshot, ringBuffer)
10749		err = &smithy.DeserializationError{
10750			Err:      fmt.Errorf("failed to decode response body, %w", err),
10751			Snapshot: snapshot.Bytes(),
10752		}
10753		return err
10754	}
10755
10756	errorBody.Seek(0, io.SeekStart)
10757	if len(code) != 0 {
10758		errorCode = restjson.SanitizeErrorCode(code)
10759	}
10760	if len(message) != 0 {
10761		errorMessage = message
10762	}
10763
10764	switch {
10765	case strings.EqualFold("AccessDeniedException", errorCode):
10766		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10767
10768	case strings.EqualFold("InvalidInputException", errorCode):
10769		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10770
10771	case strings.EqualFold("NotFoundException", errorCode):
10772		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10773
10774	case strings.EqualFold("OperationFailureException", errorCode):
10775		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10776
10777	case strings.EqualFold("ServiceException", errorCode):
10778		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10779
10780	case strings.EqualFold("UnauthenticatedException", errorCode):
10781		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10782
10783	default:
10784		genericError := &smithy.GenericAPIError{
10785			Code:    errorCode,
10786			Message: errorMessage,
10787		}
10788		return genericError
10789
10790	}
10791}
10792
10793type awsAwsjson11_deserializeOpGetDistributionMetricData struct {
10794}
10795
10796func (*awsAwsjson11_deserializeOpGetDistributionMetricData) ID() string {
10797	return "OperationDeserializer"
10798}
10799
10800func (m *awsAwsjson11_deserializeOpGetDistributionMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10801	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10802) {
10803	out, metadata, err = next.HandleDeserialize(ctx, in)
10804	if err != nil {
10805		return out, metadata, err
10806	}
10807
10808	response, ok := out.RawResponse.(*smithyhttp.Response)
10809	if !ok {
10810		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10811	}
10812
10813	if response.StatusCode < 200 || response.StatusCode >= 300 {
10814		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response, &metadata)
10815	}
10816	output := &GetDistributionMetricDataOutput{}
10817	out.Result = output
10818
10819	var buff [1024]byte
10820	ringBuffer := smithyio.NewRingBuffer(buff[:])
10821
10822	body := io.TeeReader(response.Body, ringBuffer)
10823	decoder := json.NewDecoder(body)
10824	decoder.UseNumber()
10825	var shape interface{}
10826	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10827		var snapshot bytes.Buffer
10828		io.Copy(&snapshot, ringBuffer)
10829		err = &smithy.DeserializationError{
10830			Err:      fmt.Errorf("failed to decode response body, %w", err),
10831			Snapshot: snapshot.Bytes(),
10832		}
10833		return out, metadata, err
10834	}
10835
10836	err = awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(&output, shape)
10837	if err != nil {
10838		var snapshot bytes.Buffer
10839		io.Copy(&snapshot, ringBuffer)
10840		err = &smithy.DeserializationError{
10841			Err:      fmt.Errorf("failed to decode response body, %w", err),
10842			Snapshot: snapshot.Bytes(),
10843		}
10844		return out, metadata, err
10845	}
10846
10847	return out, metadata, err
10848}
10849
10850func awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10851	var errorBuffer bytes.Buffer
10852	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10853		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10854	}
10855	errorBody := bytes.NewReader(errorBuffer.Bytes())
10856
10857	errorCode := "UnknownError"
10858	errorMessage := errorCode
10859
10860	code := response.Header.Get("X-Amzn-ErrorType")
10861	if len(code) != 0 {
10862		errorCode = restjson.SanitizeErrorCode(code)
10863	}
10864
10865	var buff [1024]byte
10866	ringBuffer := smithyio.NewRingBuffer(buff[:])
10867
10868	body := io.TeeReader(errorBody, ringBuffer)
10869	decoder := json.NewDecoder(body)
10870	decoder.UseNumber()
10871	code, message, err := restjson.GetErrorInfo(decoder)
10872	if err != nil {
10873		var snapshot bytes.Buffer
10874		io.Copy(&snapshot, ringBuffer)
10875		err = &smithy.DeserializationError{
10876			Err:      fmt.Errorf("failed to decode response body, %w", err),
10877			Snapshot: snapshot.Bytes(),
10878		}
10879		return err
10880	}
10881
10882	errorBody.Seek(0, io.SeekStart)
10883	if len(code) != 0 {
10884		errorCode = restjson.SanitizeErrorCode(code)
10885	}
10886	if len(message) != 0 {
10887		errorMessage = message
10888	}
10889
10890	switch {
10891	case strings.EqualFold("AccessDeniedException", errorCode):
10892		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10893
10894	case strings.EqualFold("InvalidInputException", errorCode):
10895		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10896
10897	case strings.EqualFold("NotFoundException", errorCode):
10898		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10899
10900	case strings.EqualFold("OperationFailureException", errorCode):
10901		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10902
10903	case strings.EqualFold("ServiceException", errorCode):
10904		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10905
10906	case strings.EqualFold("UnauthenticatedException", errorCode):
10907		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10908
10909	default:
10910		genericError := &smithy.GenericAPIError{
10911			Code:    errorCode,
10912			Message: errorMessage,
10913		}
10914		return genericError
10915
10916	}
10917}
10918
10919type awsAwsjson11_deserializeOpGetDistributions struct {
10920}
10921
10922func (*awsAwsjson11_deserializeOpGetDistributions) ID() string {
10923	return "OperationDeserializer"
10924}
10925
10926func (m *awsAwsjson11_deserializeOpGetDistributions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10927	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10928) {
10929	out, metadata, err = next.HandleDeserialize(ctx, in)
10930	if err != nil {
10931		return out, metadata, err
10932	}
10933
10934	response, ok := out.RawResponse.(*smithyhttp.Response)
10935	if !ok {
10936		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10937	}
10938
10939	if response.StatusCode < 200 || response.StatusCode >= 300 {
10940		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributions(response, &metadata)
10941	}
10942	output := &GetDistributionsOutput{}
10943	out.Result = output
10944
10945	var buff [1024]byte
10946	ringBuffer := smithyio.NewRingBuffer(buff[:])
10947
10948	body := io.TeeReader(response.Body, ringBuffer)
10949	decoder := json.NewDecoder(body)
10950	decoder.UseNumber()
10951	var shape interface{}
10952	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10953		var snapshot bytes.Buffer
10954		io.Copy(&snapshot, ringBuffer)
10955		err = &smithy.DeserializationError{
10956			Err:      fmt.Errorf("failed to decode response body, %w", err),
10957			Snapshot: snapshot.Bytes(),
10958		}
10959		return out, metadata, err
10960	}
10961
10962	err = awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(&output, shape)
10963	if err != nil {
10964		var snapshot bytes.Buffer
10965		io.Copy(&snapshot, ringBuffer)
10966		err = &smithy.DeserializationError{
10967			Err:      fmt.Errorf("failed to decode response body, %w", err),
10968			Snapshot: snapshot.Bytes(),
10969		}
10970		return out, metadata, err
10971	}
10972
10973	return out, metadata, err
10974}
10975
10976func awsAwsjson11_deserializeOpErrorGetDistributions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10977	var errorBuffer bytes.Buffer
10978	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10979		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10980	}
10981	errorBody := bytes.NewReader(errorBuffer.Bytes())
10982
10983	errorCode := "UnknownError"
10984	errorMessage := errorCode
10985
10986	code := response.Header.Get("X-Amzn-ErrorType")
10987	if len(code) != 0 {
10988		errorCode = restjson.SanitizeErrorCode(code)
10989	}
10990
10991	var buff [1024]byte
10992	ringBuffer := smithyio.NewRingBuffer(buff[:])
10993
10994	body := io.TeeReader(errorBody, ringBuffer)
10995	decoder := json.NewDecoder(body)
10996	decoder.UseNumber()
10997	code, message, err := restjson.GetErrorInfo(decoder)
10998	if err != nil {
10999		var snapshot bytes.Buffer
11000		io.Copy(&snapshot, ringBuffer)
11001		err = &smithy.DeserializationError{
11002			Err:      fmt.Errorf("failed to decode response body, %w", err),
11003			Snapshot: snapshot.Bytes(),
11004		}
11005		return err
11006	}
11007
11008	errorBody.Seek(0, io.SeekStart)
11009	if len(code) != 0 {
11010		errorCode = restjson.SanitizeErrorCode(code)
11011	}
11012	if len(message) != 0 {
11013		errorMessage = message
11014	}
11015
11016	switch {
11017	case strings.EqualFold("AccessDeniedException", errorCode):
11018		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11019
11020	case strings.EqualFold("InvalidInputException", errorCode):
11021		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11022
11023	case strings.EqualFold("NotFoundException", errorCode):
11024		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11025
11026	case strings.EqualFold("OperationFailureException", errorCode):
11027		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11028
11029	case strings.EqualFold("ServiceException", errorCode):
11030		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11031
11032	case strings.EqualFold("UnauthenticatedException", errorCode):
11033		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11034
11035	default:
11036		genericError := &smithy.GenericAPIError{
11037			Code:    errorCode,
11038			Message: errorMessage,
11039		}
11040		return genericError
11041
11042	}
11043}
11044
11045type awsAwsjson11_deserializeOpGetDomain struct {
11046}
11047
11048func (*awsAwsjson11_deserializeOpGetDomain) ID() string {
11049	return "OperationDeserializer"
11050}
11051
11052func (m *awsAwsjson11_deserializeOpGetDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11053	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11054) {
11055	out, metadata, err = next.HandleDeserialize(ctx, in)
11056	if err != nil {
11057		return out, metadata, err
11058	}
11059
11060	response, ok := out.RawResponse.(*smithyhttp.Response)
11061	if !ok {
11062		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11063	}
11064
11065	if response.StatusCode < 200 || response.StatusCode >= 300 {
11066		return out, metadata, awsAwsjson11_deserializeOpErrorGetDomain(response, &metadata)
11067	}
11068	output := &GetDomainOutput{}
11069	out.Result = output
11070
11071	var buff [1024]byte
11072	ringBuffer := smithyio.NewRingBuffer(buff[:])
11073
11074	body := io.TeeReader(response.Body, ringBuffer)
11075	decoder := json.NewDecoder(body)
11076	decoder.UseNumber()
11077	var shape interface{}
11078	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11079		var snapshot bytes.Buffer
11080		io.Copy(&snapshot, ringBuffer)
11081		err = &smithy.DeserializationError{
11082			Err:      fmt.Errorf("failed to decode response body, %w", err),
11083			Snapshot: snapshot.Bytes(),
11084		}
11085		return out, metadata, err
11086	}
11087
11088	err = awsAwsjson11_deserializeOpDocumentGetDomainOutput(&output, shape)
11089	if err != nil {
11090		var snapshot bytes.Buffer
11091		io.Copy(&snapshot, ringBuffer)
11092		err = &smithy.DeserializationError{
11093			Err:      fmt.Errorf("failed to decode response body, %w", err),
11094			Snapshot: snapshot.Bytes(),
11095		}
11096		return out, metadata, err
11097	}
11098
11099	return out, metadata, err
11100}
11101
11102func awsAwsjson11_deserializeOpErrorGetDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11103	var errorBuffer bytes.Buffer
11104	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11105		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11106	}
11107	errorBody := bytes.NewReader(errorBuffer.Bytes())
11108
11109	errorCode := "UnknownError"
11110	errorMessage := errorCode
11111
11112	code := response.Header.Get("X-Amzn-ErrorType")
11113	if len(code) != 0 {
11114		errorCode = restjson.SanitizeErrorCode(code)
11115	}
11116
11117	var buff [1024]byte
11118	ringBuffer := smithyio.NewRingBuffer(buff[:])
11119
11120	body := io.TeeReader(errorBody, ringBuffer)
11121	decoder := json.NewDecoder(body)
11122	decoder.UseNumber()
11123	code, message, err := restjson.GetErrorInfo(decoder)
11124	if err != nil {
11125		var snapshot bytes.Buffer
11126		io.Copy(&snapshot, ringBuffer)
11127		err = &smithy.DeserializationError{
11128			Err:      fmt.Errorf("failed to decode response body, %w", err),
11129			Snapshot: snapshot.Bytes(),
11130		}
11131		return err
11132	}
11133
11134	errorBody.Seek(0, io.SeekStart)
11135	if len(code) != 0 {
11136		errorCode = restjson.SanitizeErrorCode(code)
11137	}
11138	if len(message) != 0 {
11139		errorMessage = message
11140	}
11141
11142	switch {
11143	case strings.EqualFold("AccessDeniedException", errorCode):
11144		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11145
11146	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11147		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11148
11149	case strings.EqualFold("InvalidInputException", errorCode):
11150		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11151
11152	case strings.EqualFold("NotFoundException", errorCode):
11153		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11154
11155	case strings.EqualFold("OperationFailureException", errorCode):
11156		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11157
11158	case strings.EqualFold("ServiceException", errorCode):
11159		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11160
11161	case strings.EqualFold("UnauthenticatedException", errorCode):
11162		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11163
11164	default:
11165		genericError := &smithy.GenericAPIError{
11166			Code:    errorCode,
11167			Message: errorMessage,
11168		}
11169		return genericError
11170
11171	}
11172}
11173
11174type awsAwsjson11_deserializeOpGetDomains struct {
11175}
11176
11177func (*awsAwsjson11_deserializeOpGetDomains) ID() string {
11178	return "OperationDeserializer"
11179}
11180
11181func (m *awsAwsjson11_deserializeOpGetDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11182	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11183) {
11184	out, metadata, err = next.HandleDeserialize(ctx, in)
11185	if err != nil {
11186		return out, metadata, err
11187	}
11188
11189	response, ok := out.RawResponse.(*smithyhttp.Response)
11190	if !ok {
11191		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11192	}
11193
11194	if response.StatusCode < 200 || response.StatusCode >= 300 {
11195		return out, metadata, awsAwsjson11_deserializeOpErrorGetDomains(response, &metadata)
11196	}
11197	output := &GetDomainsOutput{}
11198	out.Result = output
11199
11200	var buff [1024]byte
11201	ringBuffer := smithyio.NewRingBuffer(buff[:])
11202
11203	body := io.TeeReader(response.Body, ringBuffer)
11204	decoder := json.NewDecoder(body)
11205	decoder.UseNumber()
11206	var shape interface{}
11207	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11208		var snapshot bytes.Buffer
11209		io.Copy(&snapshot, ringBuffer)
11210		err = &smithy.DeserializationError{
11211			Err:      fmt.Errorf("failed to decode response body, %w", err),
11212			Snapshot: snapshot.Bytes(),
11213		}
11214		return out, metadata, err
11215	}
11216
11217	err = awsAwsjson11_deserializeOpDocumentGetDomainsOutput(&output, shape)
11218	if err != nil {
11219		var snapshot bytes.Buffer
11220		io.Copy(&snapshot, ringBuffer)
11221		err = &smithy.DeserializationError{
11222			Err:      fmt.Errorf("failed to decode response body, %w", err),
11223			Snapshot: snapshot.Bytes(),
11224		}
11225		return out, metadata, err
11226	}
11227
11228	return out, metadata, err
11229}
11230
11231func awsAwsjson11_deserializeOpErrorGetDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11232	var errorBuffer bytes.Buffer
11233	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11234		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11235	}
11236	errorBody := bytes.NewReader(errorBuffer.Bytes())
11237
11238	errorCode := "UnknownError"
11239	errorMessage := errorCode
11240
11241	code := response.Header.Get("X-Amzn-ErrorType")
11242	if len(code) != 0 {
11243		errorCode = restjson.SanitizeErrorCode(code)
11244	}
11245
11246	var buff [1024]byte
11247	ringBuffer := smithyio.NewRingBuffer(buff[:])
11248
11249	body := io.TeeReader(errorBody, ringBuffer)
11250	decoder := json.NewDecoder(body)
11251	decoder.UseNumber()
11252	code, message, err := restjson.GetErrorInfo(decoder)
11253	if err != nil {
11254		var snapshot bytes.Buffer
11255		io.Copy(&snapshot, ringBuffer)
11256		err = &smithy.DeserializationError{
11257			Err:      fmt.Errorf("failed to decode response body, %w", err),
11258			Snapshot: snapshot.Bytes(),
11259		}
11260		return err
11261	}
11262
11263	errorBody.Seek(0, io.SeekStart)
11264	if len(code) != 0 {
11265		errorCode = restjson.SanitizeErrorCode(code)
11266	}
11267	if len(message) != 0 {
11268		errorMessage = message
11269	}
11270
11271	switch {
11272	case strings.EqualFold("AccessDeniedException", errorCode):
11273		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11274
11275	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11276		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11277
11278	case strings.EqualFold("InvalidInputException", errorCode):
11279		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11280
11281	case strings.EqualFold("NotFoundException", errorCode):
11282		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11283
11284	case strings.EqualFold("OperationFailureException", errorCode):
11285		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11286
11287	case strings.EqualFold("ServiceException", errorCode):
11288		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11289
11290	case strings.EqualFold("UnauthenticatedException", errorCode):
11291		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11292
11293	default:
11294		genericError := &smithy.GenericAPIError{
11295			Code:    errorCode,
11296			Message: errorMessage,
11297		}
11298		return genericError
11299
11300	}
11301}
11302
11303type awsAwsjson11_deserializeOpGetExportSnapshotRecords struct {
11304}
11305
11306func (*awsAwsjson11_deserializeOpGetExportSnapshotRecords) ID() string {
11307	return "OperationDeserializer"
11308}
11309
11310func (m *awsAwsjson11_deserializeOpGetExportSnapshotRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11311	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11312) {
11313	out, metadata, err = next.HandleDeserialize(ctx, in)
11314	if err != nil {
11315		return out, metadata, err
11316	}
11317
11318	response, ok := out.RawResponse.(*smithyhttp.Response)
11319	if !ok {
11320		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11321	}
11322
11323	if response.StatusCode < 200 || response.StatusCode >= 300 {
11324		return out, metadata, awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response, &metadata)
11325	}
11326	output := &GetExportSnapshotRecordsOutput{}
11327	out.Result = output
11328
11329	var buff [1024]byte
11330	ringBuffer := smithyio.NewRingBuffer(buff[:])
11331
11332	body := io.TeeReader(response.Body, ringBuffer)
11333	decoder := json.NewDecoder(body)
11334	decoder.UseNumber()
11335	var shape interface{}
11336	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11337		var snapshot bytes.Buffer
11338		io.Copy(&snapshot, ringBuffer)
11339		err = &smithy.DeserializationError{
11340			Err:      fmt.Errorf("failed to decode response body, %w", err),
11341			Snapshot: snapshot.Bytes(),
11342		}
11343		return out, metadata, err
11344	}
11345
11346	err = awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(&output, shape)
11347	if err != nil {
11348		var snapshot bytes.Buffer
11349		io.Copy(&snapshot, ringBuffer)
11350		err = &smithy.DeserializationError{
11351			Err:      fmt.Errorf("failed to decode response body, %w", err),
11352			Snapshot: snapshot.Bytes(),
11353		}
11354		return out, metadata, err
11355	}
11356
11357	return out, metadata, err
11358}
11359
11360func awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11361	var errorBuffer bytes.Buffer
11362	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11363		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11364	}
11365	errorBody := bytes.NewReader(errorBuffer.Bytes())
11366
11367	errorCode := "UnknownError"
11368	errorMessage := errorCode
11369
11370	code := response.Header.Get("X-Amzn-ErrorType")
11371	if len(code) != 0 {
11372		errorCode = restjson.SanitizeErrorCode(code)
11373	}
11374
11375	var buff [1024]byte
11376	ringBuffer := smithyio.NewRingBuffer(buff[:])
11377
11378	body := io.TeeReader(errorBody, ringBuffer)
11379	decoder := json.NewDecoder(body)
11380	decoder.UseNumber()
11381	code, message, err := restjson.GetErrorInfo(decoder)
11382	if err != nil {
11383		var snapshot bytes.Buffer
11384		io.Copy(&snapshot, ringBuffer)
11385		err = &smithy.DeserializationError{
11386			Err:      fmt.Errorf("failed to decode response body, %w", err),
11387			Snapshot: snapshot.Bytes(),
11388		}
11389		return err
11390	}
11391
11392	errorBody.Seek(0, io.SeekStart)
11393	if len(code) != 0 {
11394		errorCode = restjson.SanitizeErrorCode(code)
11395	}
11396	if len(message) != 0 {
11397		errorMessage = message
11398	}
11399
11400	switch {
11401	case strings.EqualFold("AccessDeniedException", errorCode):
11402		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11403
11404	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11405		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11406
11407	case strings.EqualFold("InvalidInputException", errorCode):
11408		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11409
11410	case strings.EqualFold("NotFoundException", errorCode):
11411		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11412
11413	case strings.EqualFold("OperationFailureException", errorCode):
11414		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11415
11416	case strings.EqualFold("ServiceException", errorCode):
11417		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11418
11419	case strings.EqualFold("UnauthenticatedException", errorCode):
11420		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11421
11422	default:
11423		genericError := &smithy.GenericAPIError{
11424			Code:    errorCode,
11425			Message: errorMessage,
11426		}
11427		return genericError
11428
11429	}
11430}
11431
11432type awsAwsjson11_deserializeOpGetInstance struct {
11433}
11434
11435func (*awsAwsjson11_deserializeOpGetInstance) ID() string {
11436	return "OperationDeserializer"
11437}
11438
11439func (m *awsAwsjson11_deserializeOpGetInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11440	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11441) {
11442	out, metadata, err = next.HandleDeserialize(ctx, in)
11443	if err != nil {
11444		return out, metadata, err
11445	}
11446
11447	response, ok := out.RawResponse.(*smithyhttp.Response)
11448	if !ok {
11449		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11450	}
11451
11452	if response.StatusCode < 200 || response.StatusCode >= 300 {
11453		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstance(response, &metadata)
11454	}
11455	output := &GetInstanceOutput{}
11456	out.Result = output
11457
11458	var buff [1024]byte
11459	ringBuffer := smithyio.NewRingBuffer(buff[:])
11460
11461	body := io.TeeReader(response.Body, ringBuffer)
11462	decoder := json.NewDecoder(body)
11463	decoder.UseNumber()
11464	var shape interface{}
11465	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11466		var snapshot bytes.Buffer
11467		io.Copy(&snapshot, ringBuffer)
11468		err = &smithy.DeserializationError{
11469			Err:      fmt.Errorf("failed to decode response body, %w", err),
11470			Snapshot: snapshot.Bytes(),
11471		}
11472		return out, metadata, err
11473	}
11474
11475	err = awsAwsjson11_deserializeOpDocumentGetInstanceOutput(&output, shape)
11476	if err != nil {
11477		var snapshot bytes.Buffer
11478		io.Copy(&snapshot, ringBuffer)
11479		err = &smithy.DeserializationError{
11480			Err:      fmt.Errorf("failed to decode response body, %w", err),
11481			Snapshot: snapshot.Bytes(),
11482		}
11483		return out, metadata, err
11484	}
11485
11486	return out, metadata, err
11487}
11488
11489func awsAwsjson11_deserializeOpErrorGetInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11490	var errorBuffer bytes.Buffer
11491	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11492		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11493	}
11494	errorBody := bytes.NewReader(errorBuffer.Bytes())
11495
11496	errorCode := "UnknownError"
11497	errorMessage := errorCode
11498
11499	code := response.Header.Get("X-Amzn-ErrorType")
11500	if len(code) != 0 {
11501		errorCode = restjson.SanitizeErrorCode(code)
11502	}
11503
11504	var buff [1024]byte
11505	ringBuffer := smithyio.NewRingBuffer(buff[:])
11506
11507	body := io.TeeReader(errorBody, ringBuffer)
11508	decoder := json.NewDecoder(body)
11509	decoder.UseNumber()
11510	code, message, err := restjson.GetErrorInfo(decoder)
11511	if err != nil {
11512		var snapshot bytes.Buffer
11513		io.Copy(&snapshot, ringBuffer)
11514		err = &smithy.DeserializationError{
11515			Err:      fmt.Errorf("failed to decode response body, %w", err),
11516			Snapshot: snapshot.Bytes(),
11517		}
11518		return err
11519	}
11520
11521	errorBody.Seek(0, io.SeekStart)
11522	if len(code) != 0 {
11523		errorCode = restjson.SanitizeErrorCode(code)
11524	}
11525	if len(message) != 0 {
11526		errorMessage = message
11527	}
11528
11529	switch {
11530	case strings.EqualFold("AccessDeniedException", errorCode):
11531		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11532
11533	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11534		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11535
11536	case strings.EqualFold("InvalidInputException", errorCode):
11537		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11538
11539	case strings.EqualFold("NotFoundException", errorCode):
11540		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11541
11542	case strings.EqualFold("OperationFailureException", errorCode):
11543		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11544
11545	case strings.EqualFold("ServiceException", errorCode):
11546		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11547
11548	case strings.EqualFold("UnauthenticatedException", errorCode):
11549		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11550
11551	default:
11552		genericError := &smithy.GenericAPIError{
11553			Code:    errorCode,
11554			Message: errorMessage,
11555		}
11556		return genericError
11557
11558	}
11559}
11560
11561type awsAwsjson11_deserializeOpGetInstanceAccessDetails struct {
11562}
11563
11564func (*awsAwsjson11_deserializeOpGetInstanceAccessDetails) ID() string {
11565	return "OperationDeserializer"
11566}
11567
11568func (m *awsAwsjson11_deserializeOpGetInstanceAccessDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11569	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11570) {
11571	out, metadata, err = next.HandleDeserialize(ctx, in)
11572	if err != nil {
11573		return out, metadata, err
11574	}
11575
11576	response, ok := out.RawResponse.(*smithyhttp.Response)
11577	if !ok {
11578		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11579	}
11580
11581	if response.StatusCode < 200 || response.StatusCode >= 300 {
11582		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response, &metadata)
11583	}
11584	output := &GetInstanceAccessDetailsOutput{}
11585	out.Result = output
11586
11587	var buff [1024]byte
11588	ringBuffer := smithyio.NewRingBuffer(buff[:])
11589
11590	body := io.TeeReader(response.Body, ringBuffer)
11591	decoder := json.NewDecoder(body)
11592	decoder.UseNumber()
11593	var shape interface{}
11594	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11595		var snapshot bytes.Buffer
11596		io.Copy(&snapshot, ringBuffer)
11597		err = &smithy.DeserializationError{
11598			Err:      fmt.Errorf("failed to decode response body, %w", err),
11599			Snapshot: snapshot.Bytes(),
11600		}
11601		return out, metadata, err
11602	}
11603
11604	err = awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(&output, shape)
11605	if err != nil {
11606		var snapshot bytes.Buffer
11607		io.Copy(&snapshot, ringBuffer)
11608		err = &smithy.DeserializationError{
11609			Err:      fmt.Errorf("failed to decode response body, %w", err),
11610			Snapshot: snapshot.Bytes(),
11611		}
11612		return out, metadata, err
11613	}
11614
11615	return out, metadata, err
11616}
11617
11618func awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11619	var errorBuffer bytes.Buffer
11620	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11621		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11622	}
11623	errorBody := bytes.NewReader(errorBuffer.Bytes())
11624
11625	errorCode := "UnknownError"
11626	errorMessage := errorCode
11627
11628	code := response.Header.Get("X-Amzn-ErrorType")
11629	if len(code) != 0 {
11630		errorCode = restjson.SanitizeErrorCode(code)
11631	}
11632
11633	var buff [1024]byte
11634	ringBuffer := smithyio.NewRingBuffer(buff[:])
11635
11636	body := io.TeeReader(errorBody, ringBuffer)
11637	decoder := json.NewDecoder(body)
11638	decoder.UseNumber()
11639	code, message, err := restjson.GetErrorInfo(decoder)
11640	if err != nil {
11641		var snapshot bytes.Buffer
11642		io.Copy(&snapshot, ringBuffer)
11643		err = &smithy.DeserializationError{
11644			Err:      fmt.Errorf("failed to decode response body, %w", err),
11645			Snapshot: snapshot.Bytes(),
11646		}
11647		return err
11648	}
11649
11650	errorBody.Seek(0, io.SeekStart)
11651	if len(code) != 0 {
11652		errorCode = restjson.SanitizeErrorCode(code)
11653	}
11654	if len(message) != 0 {
11655		errorMessage = message
11656	}
11657
11658	switch {
11659	case strings.EqualFold("AccessDeniedException", errorCode):
11660		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11661
11662	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11663		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11664
11665	case strings.EqualFold("InvalidInputException", errorCode):
11666		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11667
11668	case strings.EqualFold("NotFoundException", errorCode):
11669		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11670
11671	case strings.EqualFold("OperationFailureException", errorCode):
11672		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11673
11674	case strings.EqualFold("ServiceException", errorCode):
11675		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11676
11677	case strings.EqualFold("UnauthenticatedException", errorCode):
11678		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11679
11680	default:
11681		genericError := &smithy.GenericAPIError{
11682			Code:    errorCode,
11683			Message: errorMessage,
11684		}
11685		return genericError
11686
11687	}
11688}
11689
11690type awsAwsjson11_deserializeOpGetInstanceMetricData struct {
11691}
11692
11693func (*awsAwsjson11_deserializeOpGetInstanceMetricData) ID() string {
11694	return "OperationDeserializer"
11695}
11696
11697func (m *awsAwsjson11_deserializeOpGetInstanceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11698	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11699) {
11700	out, metadata, err = next.HandleDeserialize(ctx, in)
11701	if err != nil {
11702		return out, metadata, err
11703	}
11704
11705	response, ok := out.RawResponse.(*smithyhttp.Response)
11706	if !ok {
11707		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11708	}
11709
11710	if response.StatusCode < 200 || response.StatusCode >= 300 {
11711		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response, &metadata)
11712	}
11713	output := &GetInstanceMetricDataOutput{}
11714	out.Result = output
11715
11716	var buff [1024]byte
11717	ringBuffer := smithyio.NewRingBuffer(buff[:])
11718
11719	body := io.TeeReader(response.Body, ringBuffer)
11720	decoder := json.NewDecoder(body)
11721	decoder.UseNumber()
11722	var shape interface{}
11723	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11724		var snapshot bytes.Buffer
11725		io.Copy(&snapshot, ringBuffer)
11726		err = &smithy.DeserializationError{
11727			Err:      fmt.Errorf("failed to decode response body, %w", err),
11728			Snapshot: snapshot.Bytes(),
11729		}
11730		return out, metadata, err
11731	}
11732
11733	err = awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(&output, shape)
11734	if err != nil {
11735		var snapshot bytes.Buffer
11736		io.Copy(&snapshot, ringBuffer)
11737		err = &smithy.DeserializationError{
11738			Err:      fmt.Errorf("failed to decode response body, %w", err),
11739			Snapshot: snapshot.Bytes(),
11740		}
11741		return out, metadata, err
11742	}
11743
11744	return out, metadata, err
11745}
11746
11747func awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11748	var errorBuffer bytes.Buffer
11749	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11750		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11751	}
11752	errorBody := bytes.NewReader(errorBuffer.Bytes())
11753
11754	errorCode := "UnknownError"
11755	errorMessage := errorCode
11756
11757	code := response.Header.Get("X-Amzn-ErrorType")
11758	if len(code) != 0 {
11759		errorCode = restjson.SanitizeErrorCode(code)
11760	}
11761
11762	var buff [1024]byte
11763	ringBuffer := smithyio.NewRingBuffer(buff[:])
11764
11765	body := io.TeeReader(errorBody, ringBuffer)
11766	decoder := json.NewDecoder(body)
11767	decoder.UseNumber()
11768	code, message, err := restjson.GetErrorInfo(decoder)
11769	if err != nil {
11770		var snapshot bytes.Buffer
11771		io.Copy(&snapshot, ringBuffer)
11772		err = &smithy.DeserializationError{
11773			Err:      fmt.Errorf("failed to decode response body, %w", err),
11774			Snapshot: snapshot.Bytes(),
11775		}
11776		return err
11777	}
11778
11779	errorBody.Seek(0, io.SeekStart)
11780	if len(code) != 0 {
11781		errorCode = restjson.SanitizeErrorCode(code)
11782	}
11783	if len(message) != 0 {
11784		errorMessage = message
11785	}
11786
11787	switch {
11788	case strings.EqualFold("AccessDeniedException", errorCode):
11789		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11790
11791	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11792		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11793
11794	case strings.EqualFold("InvalidInputException", errorCode):
11795		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11796
11797	case strings.EqualFold("NotFoundException", errorCode):
11798		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11799
11800	case strings.EqualFold("OperationFailureException", errorCode):
11801		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11802
11803	case strings.EqualFold("ServiceException", errorCode):
11804		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11805
11806	case strings.EqualFold("UnauthenticatedException", errorCode):
11807		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11808
11809	default:
11810		genericError := &smithy.GenericAPIError{
11811			Code:    errorCode,
11812			Message: errorMessage,
11813		}
11814		return genericError
11815
11816	}
11817}
11818
11819type awsAwsjson11_deserializeOpGetInstancePortStates struct {
11820}
11821
11822func (*awsAwsjson11_deserializeOpGetInstancePortStates) ID() string {
11823	return "OperationDeserializer"
11824}
11825
11826func (m *awsAwsjson11_deserializeOpGetInstancePortStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11827	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11828) {
11829	out, metadata, err = next.HandleDeserialize(ctx, in)
11830	if err != nil {
11831		return out, metadata, err
11832	}
11833
11834	response, ok := out.RawResponse.(*smithyhttp.Response)
11835	if !ok {
11836		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11837	}
11838
11839	if response.StatusCode < 200 || response.StatusCode >= 300 {
11840		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstancePortStates(response, &metadata)
11841	}
11842	output := &GetInstancePortStatesOutput{}
11843	out.Result = output
11844
11845	var buff [1024]byte
11846	ringBuffer := smithyio.NewRingBuffer(buff[:])
11847
11848	body := io.TeeReader(response.Body, ringBuffer)
11849	decoder := json.NewDecoder(body)
11850	decoder.UseNumber()
11851	var shape interface{}
11852	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11853		var snapshot bytes.Buffer
11854		io.Copy(&snapshot, ringBuffer)
11855		err = &smithy.DeserializationError{
11856			Err:      fmt.Errorf("failed to decode response body, %w", err),
11857			Snapshot: snapshot.Bytes(),
11858		}
11859		return out, metadata, err
11860	}
11861
11862	err = awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(&output, shape)
11863	if err != nil {
11864		var snapshot bytes.Buffer
11865		io.Copy(&snapshot, ringBuffer)
11866		err = &smithy.DeserializationError{
11867			Err:      fmt.Errorf("failed to decode response body, %w", err),
11868			Snapshot: snapshot.Bytes(),
11869		}
11870		return out, metadata, err
11871	}
11872
11873	return out, metadata, err
11874}
11875
11876func awsAwsjson11_deserializeOpErrorGetInstancePortStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11877	var errorBuffer bytes.Buffer
11878	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11879		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11880	}
11881	errorBody := bytes.NewReader(errorBuffer.Bytes())
11882
11883	errorCode := "UnknownError"
11884	errorMessage := errorCode
11885
11886	code := response.Header.Get("X-Amzn-ErrorType")
11887	if len(code) != 0 {
11888		errorCode = restjson.SanitizeErrorCode(code)
11889	}
11890
11891	var buff [1024]byte
11892	ringBuffer := smithyio.NewRingBuffer(buff[:])
11893
11894	body := io.TeeReader(errorBody, ringBuffer)
11895	decoder := json.NewDecoder(body)
11896	decoder.UseNumber()
11897	code, message, err := restjson.GetErrorInfo(decoder)
11898	if err != nil {
11899		var snapshot bytes.Buffer
11900		io.Copy(&snapshot, ringBuffer)
11901		err = &smithy.DeserializationError{
11902			Err:      fmt.Errorf("failed to decode response body, %w", err),
11903			Snapshot: snapshot.Bytes(),
11904		}
11905		return err
11906	}
11907
11908	errorBody.Seek(0, io.SeekStart)
11909	if len(code) != 0 {
11910		errorCode = restjson.SanitizeErrorCode(code)
11911	}
11912	if len(message) != 0 {
11913		errorMessage = message
11914	}
11915
11916	switch {
11917	case strings.EqualFold("AccessDeniedException", errorCode):
11918		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11919
11920	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11921		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11922
11923	case strings.EqualFold("InvalidInputException", errorCode):
11924		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11925
11926	case strings.EqualFold("NotFoundException", errorCode):
11927		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11928
11929	case strings.EqualFold("OperationFailureException", errorCode):
11930		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11931
11932	case strings.EqualFold("ServiceException", errorCode):
11933		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11934
11935	case strings.EqualFold("UnauthenticatedException", errorCode):
11936		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11937
11938	default:
11939		genericError := &smithy.GenericAPIError{
11940			Code:    errorCode,
11941			Message: errorMessage,
11942		}
11943		return genericError
11944
11945	}
11946}
11947
11948type awsAwsjson11_deserializeOpGetInstances struct {
11949}
11950
11951func (*awsAwsjson11_deserializeOpGetInstances) ID() string {
11952	return "OperationDeserializer"
11953}
11954
11955func (m *awsAwsjson11_deserializeOpGetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11956	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11957) {
11958	out, metadata, err = next.HandleDeserialize(ctx, in)
11959	if err != nil {
11960		return out, metadata, err
11961	}
11962
11963	response, ok := out.RawResponse.(*smithyhttp.Response)
11964	if !ok {
11965		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11966	}
11967
11968	if response.StatusCode < 200 || response.StatusCode >= 300 {
11969		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstances(response, &metadata)
11970	}
11971	output := &GetInstancesOutput{}
11972	out.Result = output
11973
11974	var buff [1024]byte
11975	ringBuffer := smithyio.NewRingBuffer(buff[:])
11976
11977	body := io.TeeReader(response.Body, ringBuffer)
11978	decoder := json.NewDecoder(body)
11979	decoder.UseNumber()
11980	var shape interface{}
11981	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11982		var snapshot bytes.Buffer
11983		io.Copy(&snapshot, ringBuffer)
11984		err = &smithy.DeserializationError{
11985			Err:      fmt.Errorf("failed to decode response body, %w", err),
11986			Snapshot: snapshot.Bytes(),
11987		}
11988		return out, metadata, err
11989	}
11990
11991	err = awsAwsjson11_deserializeOpDocumentGetInstancesOutput(&output, shape)
11992	if err != nil {
11993		var snapshot bytes.Buffer
11994		io.Copy(&snapshot, ringBuffer)
11995		err = &smithy.DeserializationError{
11996			Err:      fmt.Errorf("failed to decode response body, %w", err),
11997			Snapshot: snapshot.Bytes(),
11998		}
11999		return out, metadata, err
12000	}
12001
12002	return out, metadata, err
12003}
12004
12005func awsAwsjson11_deserializeOpErrorGetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12006	var errorBuffer bytes.Buffer
12007	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12008		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12009	}
12010	errorBody := bytes.NewReader(errorBuffer.Bytes())
12011
12012	errorCode := "UnknownError"
12013	errorMessage := errorCode
12014
12015	code := response.Header.Get("X-Amzn-ErrorType")
12016	if len(code) != 0 {
12017		errorCode = restjson.SanitizeErrorCode(code)
12018	}
12019
12020	var buff [1024]byte
12021	ringBuffer := smithyio.NewRingBuffer(buff[:])
12022
12023	body := io.TeeReader(errorBody, ringBuffer)
12024	decoder := json.NewDecoder(body)
12025	decoder.UseNumber()
12026	code, message, err := restjson.GetErrorInfo(decoder)
12027	if err != nil {
12028		var snapshot bytes.Buffer
12029		io.Copy(&snapshot, ringBuffer)
12030		err = &smithy.DeserializationError{
12031			Err:      fmt.Errorf("failed to decode response body, %w", err),
12032			Snapshot: snapshot.Bytes(),
12033		}
12034		return err
12035	}
12036
12037	errorBody.Seek(0, io.SeekStart)
12038	if len(code) != 0 {
12039		errorCode = restjson.SanitizeErrorCode(code)
12040	}
12041	if len(message) != 0 {
12042		errorMessage = message
12043	}
12044
12045	switch {
12046	case strings.EqualFold("AccessDeniedException", errorCode):
12047		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12048
12049	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12050		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12051
12052	case strings.EqualFold("InvalidInputException", errorCode):
12053		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12054
12055	case strings.EqualFold("NotFoundException", errorCode):
12056		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12057
12058	case strings.EqualFold("OperationFailureException", errorCode):
12059		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12060
12061	case strings.EqualFold("ServiceException", errorCode):
12062		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12063
12064	case strings.EqualFold("UnauthenticatedException", errorCode):
12065		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12066
12067	default:
12068		genericError := &smithy.GenericAPIError{
12069			Code:    errorCode,
12070			Message: errorMessage,
12071		}
12072		return genericError
12073
12074	}
12075}
12076
12077type awsAwsjson11_deserializeOpGetInstanceSnapshot struct {
12078}
12079
12080func (*awsAwsjson11_deserializeOpGetInstanceSnapshot) ID() string {
12081	return "OperationDeserializer"
12082}
12083
12084func (m *awsAwsjson11_deserializeOpGetInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12085	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12086) {
12087	out, metadata, err = next.HandleDeserialize(ctx, in)
12088	if err != nil {
12089		return out, metadata, err
12090	}
12091
12092	response, ok := out.RawResponse.(*smithyhttp.Response)
12093	if !ok {
12094		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12095	}
12096
12097	if response.StatusCode < 200 || response.StatusCode >= 300 {
12098		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response, &metadata)
12099	}
12100	output := &GetInstanceSnapshotOutput{}
12101	out.Result = output
12102
12103	var buff [1024]byte
12104	ringBuffer := smithyio.NewRingBuffer(buff[:])
12105
12106	body := io.TeeReader(response.Body, ringBuffer)
12107	decoder := json.NewDecoder(body)
12108	decoder.UseNumber()
12109	var shape interface{}
12110	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12111		var snapshot bytes.Buffer
12112		io.Copy(&snapshot, ringBuffer)
12113		err = &smithy.DeserializationError{
12114			Err:      fmt.Errorf("failed to decode response body, %w", err),
12115			Snapshot: snapshot.Bytes(),
12116		}
12117		return out, metadata, err
12118	}
12119
12120	err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(&output, shape)
12121	if err != nil {
12122		var snapshot bytes.Buffer
12123		io.Copy(&snapshot, ringBuffer)
12124		err = &smithy.DeserializationError{
12125			Err:      fmt.Errorf("failed to decode response body, %w", err),
12126			Snapshot: snapshot.Bytes(),
12127		}
12128		return out, metadata, err
12129	}
12130
12131	return out, metadata, err
12132}
12133
12134func awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12135	var errorBuffer bytes.Buffer
12136	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12137		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12138	}
12139	errorBody := bytes.NewReader(errorBuffer.Bytes())
12140
12141	errorCode := "UnknownError"
12142	errorMessage := errorCode
12143
12144	code := response.Header.Get("X-Amzn-ErrorType")
12145	if len(code) != 0 {
12146		errorCode = restjson.SanitizeErrorCode(code)
12147	}
12148
12149	var buff [1024]byte
12150	ringBuffer := smithyio.NewRingBuffer(buff[:])
12151
12152	body := io.TeeReader(errorBody, ringBuffer)
12153	decoder := json.NewDecoder(body)
12154	decoder.UseNumber()
12155	code, message, err := restjson.GetErrorInfo(decoder)
12156	if err != nil {
12157		var snapshot bytes.Buffer
12158		io.Copy(&snapshot, ringBuffer)
12159		err = &smithy.DeserializationError{
12160			Err:      fmt.Errorf("failed to decode response body, %w", err),
12161			Snapshot: snapshot.Bytes(),
12162		}
12163		return err
12164	}
12165
12166	errorBody.Seek(0, io.SeekStart)
12167	if len(code) != 0 {
12168		errorCode = restjson.SanitizeErrorCode(code)
12169	}
12170	if len(message) != 0 {
12171		errorMessage = message
12172	}
12173
12174	switch {
12175	case strings.EqualFold("AccessDeniedException", errorCode):
12176		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12177
12178	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12179		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12180
12181	case strings.EqualFold("InvalidInputException", errorCode):
12182		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12183
12184	case strings.EqualFold("NotFoundException", errorCode):
12185		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12186
12187	case strings.EqualFold("OperationFailureException", errorCode):
12188		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12189
12190	case strings.EqualFold("ServiceException", errorCode):
12191		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12192
12193	case strings.EqualFold("UnauthenticatedException", errorCode):
12194		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12195
12196	default:
12197		genericError := &smithy.GenericAPIError{
12198			Code:    errorCode,
12199			Message: errorMessage,
12200		}
12201		return genericError
12202
12203	}
12204}
12205
12206type awsAwsjson11_deserializeOpGetInstanceSnapshots struct {
12207}
12208
12209func (*awsAwsjson11_deserializeOpGetInstanceSnapshots) ID() string {
12210	return "OperationDeserializer"
12211}
12212
12213func (m *awsAwsjson11_deserializeOpGetInstanceSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12214	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12215) {
12216	out, metadata, err = next.HandleDeserialize(ctx, in)
12217	if err != nil {
12218		return out, metadata, err
12219	}
12220
12221	response, ok := out.RawResponse.(*smithyhttp.Response)
12222	if !ok {
12223		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12224	}
12225
12226	if response.StatusCode < 200 || response.StatusCode >= 300 {
12227		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response, &metadata)
12228	}
12229	output := &GetInstanceSnapshotsOutput{}
12230	out.Result = output
12231
12232	var buff [1024]byte
12233	ringBuffer := smithyio.NewRingBuffer(buff[:])
12234
12235	body := io.TeeReader(response.Body, ringBuffer)
12236	decoder := json.NewDecoder(body)
12237	decoder.UseNumber()
12238	var shape interface{}
12239	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12240		var snapshot bytes.Buffer
12241		io.Copy(&snapshot, ringBuffer)
12242		err = &smithy.DeserializationError{
12243			Err:      fmt.Errorf("failed to decode response body, %w", err),
12244			Snapshot: snapshot.Bytes(),
12245		}
12246		return out, metadata, err
12247	}
12248
12249	err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(&output, shape)
12250	if err != nil {
12251		var snapshot bytes.Buffer
12252		io.Copy(&snapshot, ringBuffer)
12253		err = &smithy.DeserializationError{
12254			Err:      fmt.Errorf("failed to decode response body, %w", err),
12255			Snapshot: snapshot.Bytes(),
12256		}
12257		return out, metadata, err
12258	}
12259
12260	return out, metadata, err
12261}
12262
12263func awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12264	var errorBuffer bytes.Buffer
12265	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12266		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12267	}
12268	errorBody := bytes.NewReader(errorBuffer.Bytes())
12269
12270	errorCode := "UnknownError"
12271	errorMessage := errorCode
12272
12273	code := response.Header.Get("X-Amzn-ErrorType")
12274	if len(code) != 0 {
12275		errorCode = restjson.SanitizeErrorCode(code)
12276	}
12277
12278	var buff [1024]byte
12279	ringBuffer := smithyio.NewRingBuffer(buff[:])
12280
12281	body := io.TeeReader(errorBody, ringBuffer)
12282	decoder := json.NewDecoder(body)
12283	decoder.UseNumber()
12284	code, message, err := restjson.GetErrorInfo(decoder)
12285	if err != nil {
12286		var snapshot bytes.Buffer
12287		io.Copy(&snapshot, ringBuffer)
12288		err = &smithy.DeserializationError{
12289			Err:      fmt.Errorf("failed to decode response body, %w", err),
12290			Snapshot: snapshot.Bytes(),
12291		}
12292		return err
12293	}
12294
12295	errorBody.Seek(0, io.SeekStart)
12296	if len(code) != 0 {
12297		errorCode = restjson.SanitizeErrorCode(code)
12298	}
12299	if len(message) != 0 {
12300		errorMessage = message
12301	}
12302
12303	switch {
12304	case strings.EqualFold("AccessDeniedException", errorCode):
12305		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12306
12307	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12308		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12309
12310	case strings.EqualFold("InvalidInputException", errorCode):
12311		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12312
12313	case strings.EqualFold("NotFoundException", errorCode):
12314		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12315
12316	case strings.EqualFold("OperationFailureException", errorCode):
12317		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12318
12319	case strings.EqualFold("ServiceException", errorCode):
12320		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12321
12322	case strings.EqualFold("UnauthenticatedException", errorCode):
12323		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12324
12325	default:
12326		genericError := &smithy.GenericAPIError{
12327			Code:    errorCode,
12328			Message: errorMessage,
12329		}
12330		return genericError
12331
12332	}
12333}
12334
12335type awsAwsjson11_deserializeOpGetInstanceState struct {
12336}
12337
12338func (*awsAwsjson11_deserializeOpGetInstanceState) ID() string {
12339	return "OperationDeserializer"
12340}
12341
12342func (m *awsAwsjson11_deserializeOpGetInstanceState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12343	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12344) {
12345	out, metadata, err = next.HandleDeserialize(ctx, in)
12346	if err != nil {
12347		return out, metadata, err
12348	}
12349
12350	response, ok := out.RawResponse.(*smithyhttp.Response)
12351	if !ok {
12352		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12353	}
12354
12355	if response.StatusCode < 200 || response.StatusCode >= 300 {
12356		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceState(response, &metadata)
12357	}
12358	output := &GetInstanceStateOutput{}
12359	out.Result = output
12360
12361	var buff [1024]byte
12362	ringBuffer := smithyio.NewRingBuffer(buff[:])
12363
12364	body := io.TeeReader(response.Body, ringBuffer)
12365	decoder := json.NewDecoder(body)
12366	decoder.UseNumber()
12367	var shape interface{}
12368	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12369		var snapshot bytes.Buffer
12370		io.Copy(&snapshot, ringBuffer)
12371		err = &smithy.DeserializationError{
12372			Err:      fmt.Errorf("failed to decode response body, %w", err),
12373			Snapshot: snapshot.Bytes(),
12374		}
12375		return out, metadata, err
12376	}
12377
12378	err = awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(&output, shape)
12379	if err != nil {
12380		var snapshot bytes.Buffer
12381		io.Copy(&snapshot, ringBuffer)
12382		err = &smithy.DeserializationError{
12383			Err:      fmt.Errorf("failed to decode response body, %w", err),
12384			Snapshot: snapshot.Bytes(),
12385		}
12386		return out, metadata, err
12387	}
12388
12389	return out, metadata, err
12390}
12391
12392func awsAwsjson11_deserializeOpErrorGetInstanceState(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12393	var errorBuffer bytes.Buffer
12394	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12395		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12396	}
12397	errorBody := bytes.NewReader(errorBuffer.Bytes())
12398
12399	errorCode := "UnknownError"
12400	errorMessage := errorCode
12401
12402	code := response.Header.Get("X-Amzn-ErrorType")
12403	if len(code) != 0 {
12404		errorCode = restjson.SanitizeErrorCode(code)
12405	}
12406
12407	var buff [1024]byte
12408	ringBuffer := smithyio.NewRingBuffer(buff[:])
12409
12410	body := io.TeeReader(errorBody, ringBuffer)
12411	decoder := json.NewDecoder(body)
12412	decoder.UseNumber()
12413	code, message, err := restjson.GetErrorInfo(decoder)
12414	if err != nil {
12415		var snapshot bytes.Buffer
12416		io.Copy(&snapshot, ringBuffer)
12417		err = &smithy.DeserializationError{
12418			Err:      fmt.Errorf("failed to decode response body, %w", err),
12419			Snapshot: snapshot.Bytes(),
12420		}
12421		return err
12422	}
12423
12424	errorBody.Seek(0, io.SeekStart)
12425	if len(code) != 0 {
12426		errorCode = restjson.SanitizeErrorCode(code)
12427	}
12428	if len(message) != 0 {
12429		errorMessage = message
12430	}
12431
12432	switch {
12433	case strings.EqualFold("AccessDeniedException", errorCode):
12434		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12435
12436	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12437		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12438
12439	case strings.EqualFold("InvalidInputException", errorCode):
12440		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12441
12442	case strings.EqualFold("NotFoundException", errorCode):
12443		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12444
12445	case strings.EqualFold("OperationFailureException", errorCode):
12446		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12447
12448	case strings.EqualFold("ServiceException", errorCode):
12449		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12450
12451	case strings.EqualFold("UnauthenticatedException", errorCode):
12452		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12453
12454	default:
12455		genericError := &smithy.GenericAPIError{
12456			Code:    errorCode,
12457			Message: errorMessage,
12458		}
12459		return genericError
12460
12461	}
12462}
12463
12464type awsAwsjson11_deserializeOpGetKeyPair struct {
12465}
12466
12467func (*awsAwsjson11_deserializeOpGetKeyPair) ID() string {
12468	return "OperationDeserializer"
12469}
12470
12471func (m *awsAwsjson11_deserializeOpGetKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12472	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12473) {
12474	out, metadata, err = next.HandleDeserialize(ctx, in)
12475	if err != nil {
12476		return out, metadata, err
12477	}
12478
12479	response, ok := out.RawResponse.(*smithyhttp.Response)
12480	if !ok {
12481		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12482	}
12483
12484	if response.StatusCode < 200 || response.StatusCode >= 300 {
12485		return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPair(response, &metadata)
12486	}
12487	output := &GetKeyPairOutput{}
12488	out.Result = output
12489
12490	var buff [1024]byte
12491	ringBuffer := smithyio.NewRingBuffer(buff[:])
12492
12493	body := io.TeeReader(response.Body, ringBuffer)
12494	decoder := json.NewDecoder(body)
12495	decoder.UseNumber()
12496	var shape interface{}
12497	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12498		var snapshot bytes.Buffer
12499		io.Copy(&snapshot, ringBuffer)
12500		err = &smithy.DeserializationError{
12501			Err:      fmt.Errorf("failed to decode response body, %w", err),
12502			Snapshot: snapshot.Bytes(),
12503		}
12504		return out, metadata, err
12505	}
12506
12507	err = awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(&output, shape)
12508	if err != nil {
12509		var snapshot bytes.Buffer
12510		io.Copy(&snapshot, ringBuffer)
12511		err = &smithy.DeserializationError{
12512			Err:      fmt.Errorf("failed to decode response body, %w", err),
12513			Snapshot: snapshot.Bytes(),
12514		}
12515		return out, metadata, err
12516	}
12517
12518	return out, metadata, err
12519}
12520
12521func awsAwsjson11_deserializeOpErrorGetKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12522	var errorBuffer bytes.Buffer
12523	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12524		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12525	}
12526	errorBody := bytes.NewReader(errorBuffer.Bytes())
12527
12528	errorCode := "UnknownError"
12529	errorMessage := errorCode
12530
12531	code := response.Header.Get("X-Amzn-ErrorType")
12532	if len(code) != 0 {
12533		errorCode = restjson.SanitizeErrorCode(code)
12534	}
12535
12536	var buff [1024]byte
12537	ringBuffer := smithyio.NewRingBuffer(buff[:])
12538
12539	body := io.TeeReader(errorBody, ringBuffer)
12540	decoder := json.NewDecoder(body)
12541	decoder.UseNumber()
12542	code, message, err := restjson.GetErrorInfo(decoder)
12543	if err != nil {
12544		var snapshot bytes.Buffer
12545		io.Copy(&snapshot, ringBuffer)
12546		err = &smithy.DeserializationError{
12547			Err:      fmt.Errorf("failed to decode response body, %w", err),
12548			Snapshot: snapshot.Bytes(),
12549		}
12550		return err
12551	}
12552
12553	errorBody.Seek(0, io.SeekStart)
12554	if len(code) != 0 {
12555		errorCode = restjson.SanitizeErrorCode(code)
12556	}
12557	if len(message) != 0 {
12558		errorMessage = message
12559	}
12560
12561	switch {
12562	case strings.EqualFold("AccessDeniedException", errorCode):
12563		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12564
12565	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12566		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12567
12568	case strings.EqualFold("InvalidInputException", errorCode):
12569		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12570
12571	case strings.EqualFold("NotFoundException", errorCode):
12572		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12573
12574	case strings.EqualFold("OperationFailureException", errorCode):
12575		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12576
12577	case strings.EqualFold("ServiceException", errorCode):
12578		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12579
12580	case strings.EqualFold("UnauthenticatedException", errorCode):
12581		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12582
12583	default:
12584		genericError := &smithy.GenericAPIError{
12585			Code:    errorCode,
12586			Message: errorMessage,
12587		}
12588		return genericError
12589
12590	}
12591}
12592
12593type awsAwsjson11_deserializeOpGetKeyPairs struct {
12594}
12595
12596func (*awsAwsjson11_deserializeOpGetKeyPairs) ID() string {
12597	return "OperationDeserializer"
12598}
12599
12600func (m *awsAwsjson11_deserializeOpGetKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12601	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12602) {
12603	out, metadata, err = next.HandleDeserialize(ctx, in)
12604	if err != nil {
12605		return out, metadata, err
12606	}
12607
12608	response, ok := out.RawResponse.(*smithyhttp.Response)
12609	if !ok {
12610		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12611	}
12612
12613	if response.StatusCode < 200 || response.StatusCode >= 300 {
12614		return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPairs(response, &metadata)
12615	}
12616	output := &GetKeyPairsOutput{}
12617	out.Result = output
12618
12619	var buff [1024]byte
12620	ringBuffer := smithyio.NewRingBuffer(buff[:])
12621
12622	body := io.TeeReader(response.Body, ringBuffer)
12623	decoder := json.NewDecoder(body)
12624	decoder.UseNumber()
12625	var shape interface{}
12626	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12627		var snapshot bytes.Buffer
12628		io.Copy(&snapshot, ringBuffer)
12629		err = &smithy.DeserializationError{
12630			Err:      fmt.Errorf("failed to decode response body, %w", err),
12631			Snapshot: snapshot.Bytes(),
12632		}
12633		return out, metadata, err
12634	}
12635
12636	err = awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(&output, shape)
12637	if err != nil {
12638		var snapshot bytes.Buffer
12639		io.Copy(&snapshot, ringBuffer)
12640		err = &smithy.DeserializationError{
12641			Err:      fmt.Errorf("failed to decode response body, %w", err),
12642			Snapshot: snapshot.Bytes(),
12643		}
12644		return out, metadata, err
12645	}
12646
12647	return out, metadata, err
12648}
12649
12650func awsAwsjson11_deserializeOpErrorGetKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12651	var errorBuffer bytes.Buffer
12652	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12653		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12654	}
12655	errorBody := bytes.NewReader(errorBuffer.Bytes())
12656
12657	errorCode := "UnknownError"
12658	errorMessage := errorCode
12659
12660	code := response.Header.Get("X-Amzn-ErrorType")
12661	if len(code) != 0 {
12662		errorCode = restjson.SanitizeErrorCode(code)
12663	}
12664
12665	var buff [1024]byte
12666	ringBuffer := smithyio.NewRingBuffer(buff[:])
12667
12668	body := io.TeeReader(errorBody, ringBuffer)
12669	decoder := json.NewDecoder(body)
12670	decoder.UseNumber()
12671	code, message, err := restjson.GetErrorInfo(decoder)
12672	if err != nil {
12673		var snapshot bytes.Buffer
12674		io.Copy(&snapshot, ringBuffer)
12675		err = &smithy.DeserializationError{
12676			Err:      fmt.Errorf("failed to decode response body, %w", err),
12677			Snapshot: snapshot.Bytes(),
12678		}
12679		return err
12680	}
12681
12682	errorBody.Seek(0, io.SeekStart)
12683	if len(code) != 0 {
12684		errorCode = restjson.SanitizeErrorCode(code)
12685	}
12686	if len(message) != 0 {
12687		errorMessage = message
12688	}
12689
12690	switch {
12691	case strings.EqualFold("AccessDeniedException", errorCode):
12692		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12693
12694	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12695		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12696
12697	case strings.EqualFold("InvalidInputException", errorCode):
12698		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12699
12700	case strings.EqualFold("NotFoundException", errorCode):
12701		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12702
12703	case strings.EqualFold("OperationFailureException", errorCode):
12704		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12705
12706	case strings.EqualFold("ServiceException", errorCode):
12707		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12708
12709	case strings.EqualFold("UnauthenticatedException", errorCode):
12710		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12711
12712	default:
12713		genericError := &smithy.GenericAPIError{
12714			Code:    errorCode,
12715			Message: errorMessage,
12716		}
12717		return genericError
12718
12719	}
12720}
12721
12722type awsAwsjson11_deserializeOpGetLoadBalancer struct {
12723}
12724
12725func (*awsAwsjson11_deserializeOpGetLoadBalancer) ID() string {
12726	return "OperationDeserializer"
12727}
12728
12729func (m *awsAwsjson11_deserializeOpGetLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12730	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12731) {
12732	out, metadata, err = next.HandleDeserialize(ctx, in)
12733	if err != nil {
12734		return out, metadata, err
12735	}
12736
12737	response, ok := out.RawResponse.(*smithyhttp.Response)
12738	if !ok {
12739		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12740	}
12741
12742	if response.StatusCode < 200 || response.StatusCode >= 300 {
12743		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancer(response, &metadata)
12744	}
12745	output := &GetLoadBalancerOutput{}
12746	out.Result = output
12747
12748	var buff [1024]byte
12749	ringBuffer := smithyio.NewRingBuffer(buff[:])
12750
12751	body := io.TeeReader(response.Body, ringBuffer)
12752	decoder := json.NewDecoder(body)
12753	decoder.UseNumber()
12754	var shape interface{}
12755	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12756		var snapshot bytes.Buffer
12757		io.Copy(&snapshot, ringBuffer)
12758		err = &smithy.DeserializationError{
12759			Err:      fmt.Errorf("failed to decode response body, %w", err),
12760			Snapshot: snapshot.Bytes(),
12761		}
12762		return out, metadata, err
12763	}
12764
12765	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(&output, shape)
12766	if err != nil {
12767		var snapshot bytes.Buffer
12768		io.Copy(&snapshot, ringBuffer)
12769		err = &smithy.DeserializationError{
12770			Err:      fmt.Errorf("failed to decode response body, %w", err),
12771			Snapshot: snapshot.Bytes(),
12772		}
12773		return out, metadata, err
12774	}
12775
12776	return out, metadata, err
12777}
12778
12779func awsAwsjson11_deserializeOpErrorGetLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12780	var errorBuffer bytes.Buffer
12781	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12782		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12783	}
12784	errorBody := bytes.NewReader(errorBuffer.Bytes())
12785
12786	errorCode := "UnknownError"
12787	errorMessage := errorCode
12788
12789	code := response.Header.Get("X-Amzn-ErrorType")
12790	if len(code) != 0 {
12791		errorCode = restjson.SanitizeErrorCode(code)
12792	}
12793
12794	var buff [1024]byte
12795	ringBuffer := smithyio.NewRingBuffer(buff[:])
12796
12797	body := io.TeeReader(errorBody, ringBuffer)
12798	decoder := json.NewDecoder(body)
12799	decoder.UseNumber()
12800	code, message, err := restjson.GetErrorInfo(decoder)
12801	if err != nil {
12802		var snapshot bytes.Buffer
12803		io.Copy(&snapshot, ringBuffer)
12804		err = &smithy.DeserializationError{
12805			Err:      fmt.Errorf("failed to decode response body, %w", err),
12806			Snapshot: snapshot.Bytes(),
12807		}
12808		return err
12809	}
12810
12811	errorBody.Seek(0, io.SeekStart)
12812	if len(code) != 0 {
12813		errorCode = restjson.SanitizeErrorCode(code)
12814	}
12815	if len(message) != 0 {
12816		errorMessage = message
12817	}
12818
12819	switch {
12820	case strings.EqualFold("AccessDeniedException", errorCode):
12821		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12822
12823	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12824		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12825
12826	case strings.EqualFold("InvalidInputException", errorCode):
12827		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12828
12829	case strings.EqualFold("NotFoundException", errorCode):
12830		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12831
12832	case strings.EqualFold("OperationFailureException", errorCode):
12833		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12834
12835	case strings.EqualFold("ServiceException", errorCode):
12836		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12837
12838	case strings.EqualFold("UnauthenticatedException", errorCode):
12839		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12840
12841	default:
12842		genericError := &smithy.GenericAPIError{
12843			Code:    errorCode,
12844			Message: errorMessage,
12845		}
12846		return genericError
12847
12848	}
12849}
12850
12851type awsAwsjson11_deserializeOpGetLoadBalancerMetricData struct {
12852}
12853
12854func (*awsAwsjson11_deserializeOpGetLoadBalancerMetricData) ID() string {
12855	return "OperationDeserializer"
12856}
12857
12858func (m *awsAwsjson11_deserializeOpGetLoadBalancerMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12859	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12860) {
12861	out, metadata, err = next.HandleDeserialize(ctx, in)
12862	if err != nil {
12863		return out, metadata, err
12864	}
12865
12866	response, ok := out.RawResponse.(*smithyhttp.Response)
12867	if !ok {
12868		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12869	}
12870
12871	if response.StatusCode < 200 || response.StatusCode >= 300 {
12872		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response, &metadata)
12873	}
12874	output := &GetLoadBalancerMetricDataOutput{}
12875	out.Result = output
12876
12877	var buff [1024]byte
12878	ringBuffer := smithyio.NewRingBuffer(buff[:])
12879
12880	body := io.TeeReader(response.Body, ringBuffer)
12881	decoder := json.NewDecoder(body)
12882	decoder.UseNumber()
12883	var shape interface{}
12884	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12885		var snapshot bytes.Buffer
12886		io.Copy(&snapshot, ringBuffer)
12887		err = &smithy.DeserializationError{
12888			Err:      fmt.Errorf("failed to decode response body, %w", err),
12889			Snapshot: snapshot.Bytes(),
12890		}
12891		return out, metadata, err
12892	}
12893
12894	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(&output, shape)
12895	if err != nil {
12896		var snapshot bytes.Buffer
12897		io.Copy(&snapshot, ringBuffer)
12898		err = &smithy.DeserializationError{
12899			Err:      fmt.Errorf("failed to decode response body, %w", err),
12900			Snapshot: snapshot.Bytes(),
12901		}
12902		return out, metadata, err
12903	}
12904
12905	return out, metadata, err
12906}
12907
12908func awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12909	var errorBuffer bytes.Buffer
12910	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12911		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12912	}
12913	errorBody := bytes.NewReader(errorBuffer.Bytes())
12914
12915	errorCode := "UnknownError"
12916	errorMessage := errorCode
12917
12918	code := response.Header.Get("X-Amzn-ErrorType")
12919	if len(code) != 0 {
12920		errorCode = restjson.SanitizeErrorCode(code)
12921	}
12922
12923	var buff [1024]byte
12924	ringBuffer := smithyio.NewRingBuffer(buff[:])
12925
12926	body := io.TeeReader(errorBody, ringBuffer)
12927	decoder := json.NewDecoder(body)
12928	decoder.UseNumber()
12929	code, message, err := restjson.GetErrorInfo(decoder)
12930	if err != nil {
12931		var snapshot bytes.Buffer
12932		io.Copy(&snapshot, ringBuffer)
12933		err = &smithy.DeserializationError{
12934			Err:      fmt.Errorf("failed to decode response body, %w", err),
12935			Snapshot: snapshot.Bytes(),
12936		}
12937		return err
12938	}
12939
12940	errorBody.Seek(0, io.SeekStart)
12941	if len(code) != 0 {
12942		errorCode = restjson.SanitizeErrorCode(code)
12943	}
12944	if len(message) != 0 {
12945		errorMessage = message
12946	}
12947
12948	switch {
12949	case strings.EqualFold("AccessDeniedException", errorCode):
12950		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12951
12952	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12953		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12954
12955	case strings.EqualFold("InvalidInputException", errorCode):
12956		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12957
12958	case strings.EqualFold("NotFoundException", errorCode):
12959		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12960
12961	case strings.EqualFold("OperationFailureException", errorCode):
12962		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12963
12964	case strings.EqualFold("ServiceException", errorCode):
12965		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12966
12967	case strings.EqualFold("UnauthenticatedException", errorCode):
12968		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12969
12970	default:
12971		genericError := &smithy.GenericAPIError{
12972			Code:    errorCode,
12973			Message: errorMessage,
12974		}
12975		return genericError
12976
12977	}
12978}
12979
12980type awsAwsjson11_deserializeOpGetLoadBalancers struct {
12981}
12982
12983func (*awsAwsjson11_deserializeOpGetLoadBalancers) ID() string {
12984	return "OperationDeserializer"
12985}
12986
12987func (m *awsAwsjson11_deserializeOpGetLoadBalancers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12988	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12989) {
12990	out, metadata, err = next.HandleDeserialize(ctx, in)
12991	if err != nil {
12992		return out, metadata, err
12993	}
12994
12995	response, ok := out.RawResponse.(*smithyhttp.Response)
12996	if !ok {
12997		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12998	}
12999
13000	if response.StatusCode < 200 || response.StatusCode >= 300 {
13001		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancers(response, &metadata)
13002	}
13003	output := &GetLoadBalancersOutput{}
13004	out.Result = output
13005
13006	var buff [1024]byte
13007	ringBuffer := smithyio.NewRingBuffer(buff[:])
13008
13009	body := io.TeeReader(response.Body, ringBuffer)
13010	decoder := json.NewDecoder(body)
13011	decoder.UseNumber()
13012	var shape interface{}
13013	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13014		var snapshot bytes.Buffer
13015		io.Copy(&snapshot, ringBuffer)
13016		err = &smithy.DeserializationError{
13017			Err:      fmt.Errorf("failed to decode response body, %w", err),
13018			Snapshot: snapshot.Bytes(),
13019		}
13020		return out, metadata, err
13021	}
13022
13023	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(&output, shape)
13024	if err != nil {
13025		var snapshot bytes.Buffer
13026		io.Copy(&snapshot, ringBuffer)
13027		err = &smithy.DeserializationError{
13028			Err:      fmt.Errorf("failed to decode response body, %w", err),
13029			Snapshot: snapshot.Bytes(),
13030		}
13031		return out, metadata, err
13032	}
13033
13034	return out, metadata, err
13035}
13036
13037func awsAwsjson11_deserializeOpErrorGetLoadBalancers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13038	var errorBuffer bytes.Buffer
13039	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13040		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13041	}
13042	errorBody := bytes.NewReader(errorBuffer.Bytes())
13043
13044	errorCode := "UnknownError"
13045	errorMessage := errorCode
13046
13047	code := response.Header.Get("X-Amzn-ErrorType")
13048	if len(code) != 0 {
13049		errorCode = restjson.SanitizeErrorCode(code)
13050	}
13051
13052	var buff [1024]byte
13053	ringBuffer := smithyio.NewRingBuffer(buff[:])
13054
13055	body := io.TeeReader(errorBody, ringBuffer)
13056	decoder := json.NewDecoder(body)
13057	decoder.UseNumber()
13058	code, message, err := restjson.GetErrorInfo(decoder)
13059	if err != nil {
13060		var snapshot bytes.Buffer
13061		io.Copy(&snapshot, ringBuffer)
13062		err = &smithy.DeserializationError{
13063			Err:      fmt.Errorf("failed to decode response body, %w", err),
13064			Snapshot: snapshot.Bytes(),
13065		}
13066		return err
13067	}
13068
13069	errorBody.Seek(0, io.SeekStart)
13070	if len(code) != 0 {
13071		errorCode = restjson.SanitizeErrorCode(code)
13072	}
13073	if len(message) != 0 {
13074		errorMessage = message
13075	}
13076
13077	switch {
13078	case strings.EqualFold("AccessDeniedException", errorCode):
13079		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13080
13081	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13082		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13083
13084	case strings.EqualFold("InvalidInputException", errorCode):
13085		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13086
13087	case strings.EqualFold("NotFoundException", errorCode):
13088		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13089
13090	case strings.EqualFold("OperationFailureException", errorCode):
13091		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13092
13093	case strings.EqualFold("ServiceException", errorCode):
13094		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13095
13096	case strings.EqualFold("UnauthenticatedException", errorCode):
13097		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13098
13099	default:
13100		genericError := &smithy.GenericAPIError{
13101			Code:    errorCode,
13102			Message: errorMessage,
13103		}
13104		return genericError
13105
13106	}
13107}
13108
13109type awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates struct {
13110}
13111
13112func (*awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) ID() string {
13113	return "OperationDeserializer"
13114}
13115
13116func (m *awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13117	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13118) {
13119	out, metadata, err = next.HandleDeserialize(ctx, in)
13120	if err != nil {
13121		return out, metadata, err
13122	}
13123
13124	response, ok := out.RawResponse.(*smithyhttp.Response)
13125	if !ok {
13126		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13127	}
13128
13129	if response.StatusCode < 200 || response.StatusCode >= 300 {
13130		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response, &metadata)
13131	}
13132	output := &GetLoadBalancerTlsCertificatesOutput{}
13133	out.Result = output
13134
13135	var buff [1024]byte
13136	ringBuffer := smithyio.NewRingBuffer(buff[:])
13137
13138	body := io.TeeReader(response.Body, ringBuffer)
13139	decoder := json.NewDecoder(body)
13140	decoder.UseNumber()
13141	var shape interface{}
13142	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13143		var snapshot bytes.Buffer
13144		io.Copy(&snapshot, ringBuffer)
13145		err = &smithy.DeserializationError{
13146			Err:      fmt.Errorf("failed to decode response body, %w", err),
13147			Snapshot: snapshot.Bytes(),
13148		}
13149		return out, metadata, err
13150	}
13151
13152	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(&output, shape)
13153	if err != nil {
13154		var snapshot bytes.Buffer
13155		io.Copy(&snapshot, ringBuffer)
13156		err = &smithy.DeserializationError{
13157			Err:      fmt.Errorf("failed to decode response body, %w", err),
13158			Snapshot: snapshot.Bytes(),
13159		}
13160		return out, metadata, err
13161	}
13162
13163	return out, metadata, err
13164}
13165
13166func awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13167	var errorBuffer bytes.Buffer
13168	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13169		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13170	}
13171	errorBody := bytes.NewReader(errorBuffer.Bytes())
13172
13173	errorCode := "UnknownError"
13174	errorMessage := errorCode
13175
13176	code := response.Header.Get("X-Amzn-ErrorType")
13177	if len(code) != 0 {
13178		errorCode = restjson.SanitizeErrorCode(code)
13179	}
13180
13181	var buff [1024]byte
13182	ringBuffer := smithyio.NewRingBuffer(buff[:])
13183
13184	body := io.TeeReader(errorBody, ringBuffer)
13185	decoder := json.NewDecoder(body)
13186	decoder.UseNumber()
13187	code, message, err := restjson.GetErrorInfo(decoder)
13188	if err != nil {
13189		var snapshot bytes.Buffer
13190		io.Copy(&snapshot, ringBuffer)
13191		err = &smithy.DeserializationError{
13192			Err:      fmt.Errorf("failed to decode response body, %w", err),
13193			Snapshot: snapshot.Bytes(),
13194		}
13195		return err
13196	}
13197
13198	errorBody.Seek(0, io.SeekStart)
13199	if len(code) != 0 {
13200		errorCode = restjson.SanitizeErrorCode(code)
13201	}
13202	if len(message) != 0 {
13203		errorMessage = message
13204	}
13205
13206	switch {
13207	case strings.EqualFold("AccessDeniedException", errorCode):
13208		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13209
13210	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13211		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13212
13213	case strings.EqualFold("InvalidInputException", errorCode):
13214		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13215
13216	case strings.EqualFold("NotFoundException", errorCode):
13217		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13218
13219	case strings.EqualFold("OperationFailureException", errorCode):
13220		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13221
13222	case strings.EqualFold("ServiceException", errorCode):
13223		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13224
13225	case strings.EqualFold("UnauthenticatedException", errorCode):
13226		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13227
13228	default:
13229		genericError := &smithy.GenericAPIError{
13230			Code:    errorCode,
13231			Message: errorMessage,
13232		}
13233		return genericError
13234
13235	}
13236}
13237
13238type awsAwsjson11_deserializeOpGetOperation struct {
13239}
13240
13241func (*awsAwsjson11_deserializeOpGetOperation) ID() string {
13242	return "OperationDeserializer"
13243}
13244
13245func (m *awsAwsjson11_deserializeOpGetOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13246	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13247) {
13248	out, metadata, err = next.HandleDeserialize(ctx, in)
13249	if err != nil {
13250		return out, metadata, err
13251	}
13252
13253	response, ok := out.RawResponse.(*smithyhttp.Response)
13254	if !ok {
13255		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13256	}
13257
13258	if response.StatusCode < 200 || response.StatusCode >= 300 {
13259		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperation(response, &metadata)
13260	}
13261	output := &GetOperationOutput{}
13262	out.Result = output
13263
13264	var buff [1024]byte
13265	ringBuffer := smithyio.NewRingBuffer(buff[:])
13266
13267	body := io.TeeReader(response.Body, ringBuffer)
13268	decoder := json.NewDecoder(body)
13269	decoder.UseNumber()
13270	var shape interface{}
13271	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13272		var snapshot bytes.Buffer
13273		io.Copy(&snapshot, ringBuffer)
13274		err = &smithy.DeserializationError{
13275			Err:      fmt.Errorf("failed to decode response body, %w", err),
13276			Snapshot: snapshot.Bytes(),
13277		}
13278		return out, metadata, err
13279	}
13280
13281	err = awsAwsjson11_deserializeOpDocumentGetOperationOutput(&output, shape)
13282	if err != nil {
13283		var snapshot bytes.Buffer
13284		io.Copy(&snapshot, ringBuffer)
13285		err = &smithy.DeserializationError{
13286			Err:      fmt.Errorf("failed to decode response body, %w", err),
13287			Snapshot: snapshot.Bytes(),
13288		}
13289		return out, metadata, err
13290	}
13291
13292	return out, metadata, err
13293}
13294
13295func awsAwsjson11_deserializeOpErrorGetOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13296	var errorBuffer bytes.Buffer
13297	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13298		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13299	}
13300	errorBody := bytes.NewReader(errorBuffer.Bytes())
13301
13302	errorCode := "UnknownError"
13303	errorMessage := errorCode
13304
13305	code := response.Header.Get("X-Amzn-ErrorType")
13306	if len(code) != 0 {
13307		errorCode = restjson.SanitizeErrorCode(code)
13308	}
13309
13310	var buff [1024]byte
13311	ringBuffer := smithyio.NewRingBuffer(buff[:])
13312
13313	body := io.TeeReader(errorBody, ringBuffer)
13314	decoder := json.NewDecoder(body)
13315	decoder.UseNumber()
13316	code, message, err := restjson.GetErrorInfo(decoder)
13317	if err != nil {
13318		var snapshot bytes.Buffer
13319		io.Copy(&snapshot, ringBuffer)
13320		err = &smithy.DeserializationError{
13321			Err:      fmt.Errorf("failed to decode response body, %w", err),
13322			Snapshot: snapshot.Bytes(),
13323		}
13324		return err
13325	}
13326
13327	errorBody.Seek(0, io.SeekStart)
13328	if len(code) != 0 {
13329		errorCode = restjson.SanitizeErrorCode(code)
13330	}
13331	if len(message) != 0 {
13332		errorMessage = message
13333	}
13334
13335	switch {
13336	case strings.EqualFold("AccessDeniedException", errorCode):
13337		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13338
13339	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13340		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13341
13342	case strings.EqualFold("InvalidInputException", errorCode):
13343		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13344
13345	case strings.EqualFold("NotFoundException", errorCode):
13346		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13347
13348	case strings.EqualFold("OperationFailureException", errorCode):
13349		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13350
13351	case strings.EqualFold("ServiceException", errorCode):
13352		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13353
13354	case strings.EqualFold("UnauthenticatedException", errorCode):
13355		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13356
13357	default:
13358		genericError := &smithy.GenericAPIError{
13359			Code:    errorCode,
13360			Message: errorMessage,
13361		}
13362		return genericError
13363
13364	}
13365}
13366
13367type awsAwsjson11_deserializeOpGetOperations struct {
13368}
13369
13370func (*awsAwsjson11_deserializeOpGetOperations) ID() string {
13371	return "OperationDeserializer"
13372}
13373
13374func (m *awsAwsjson11_deserializeOpGetOperations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13375	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13376) {
13377	out, metadata, err = next.HandleDeserialize(ctx, in)
13378	if err != nil {
13379		return out, metadata, err
13380	}
13381
13382	response, ok := out.RawResponse.(*smithyhttp.Response)
13383	if !ok {
13384		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13385	}
13386
13387	if response.StatusCode < 200 || response.StatusCode >= 300 {
13388		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperations(response, &metadata)
13389	}
13390	output := &GetOperationsOutput{}
13391	out.Result = output
13392
13393	var buff [1024]byte
13394	ringBuffer := smithyio.NewRingBuffer(buff[:])
13395
13396	body := io.TeeReader(response.Body, ringBuffer)
13397	decoder := json.NewDecoder(body)
13398	decoder.UseNumber()
13399	var shape interface{}
13400	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13401		var snapshot bytes.Buffer
13402		io.Copy(&snapshot, ringBuffer)
13403		err = &smithy.DeserializationError{
13404			Err:      fmt.Errorf("failed to decode response body, %w", err),
13405			Snapshot: snapshot.Bytes(),
13406		}
13407		return out, metadata, err
13408	}
13409
13410	err = awsAwsjson11_deserializeOpDocumentGetOperationsOutput(&output, shape)
13411	if err != nil {
13412		var snapshot bytes.Buffer
13413		io.Copy(&snapshot, ringBuffer)
13414		err = &smithy.DeserializationError{
13415			Err:      fmt.Errorf("failed to decode response body, %w", err),
13416			Snapshot: snapshot.Bytes(),
13417		}
13418		return out, metadata, err
13419	}
13420
13421	return out, metadata, err
13422}
13423
13424func awsAwsjson11_deserializeOpErrorGetOperations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13425	var errorBuffer bytes.Buffer
13426	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13427		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13428	}
13429	errorBody := bytes.NewReader(errorBuffer.Bytes())
13430
13431	errorCode := "UnknownError"
13432	errorMessage := errorCode
13433
13434	code := response.Header.Get("X-Amzn-ErrorType")
13435	if len(code) != 0 {
13436		errorCode = restjson.SanitizeErrorCode(code)
13437	}
13438
13439	var buff [1024]byte
13440	ringBuffer := smithyio.NewRingBuffer(buff[:])
13441
13442	body := io.TeeReader(errorBody, ringBuffer)
13443	decoder := json.NewDecoder(body)
13444	decoder.UseNumber()
13445	code, message, err := restjson.GetErrorInfo(decoder)
13446	if err != nil {
13447		var snapshot bytes.Buffer
13448		io.Copy(&snapshot, ringBuffer)
13449		err = &smithy.DeserializationError{
13450			Err:      fmt.Errorf("failed to decode response body, %w", err),
13451			Snapshot: snapshot.Bytes(),
13452		}
13453		return err
13454	}
13455
13456	errorBody.Seek(0, io.SeekStart)
13457	if len(code) != 0 {
13458		errorCode = restjson.SanitizeErrorCode(code)
13459	}
13460	if len(message) != 0 {
13461		errorMessage = message
13462	}
13463
13464	switch {
13465	case strings.EqualFold("AccessDeniedException", errorCode):
13466		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13467
13468	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13469		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13470
13471	case strings.EqualFold("InvalidInputException", errorCode):
13472		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13473
13474	case strings.EqualFold("NotFoundException", errorCode):
13475		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13476
13477	case strings.EqualFold("OperationFailureException", errorCode):
13478		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13479
13480	case strings.EqualFold("ServiceException", errorCode):
13481		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13482
13483	case strings.EqualFold("UnauthenticatedException", errorCode):
13484		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13485
13486	default:
13487		genericError := &smithy.GenericAPIError{
13488			Code:    errorCode,
13489			Message: errorMessage,
13490		}
13491		return genericError
13492
13493	}
13494}
13495
13496type awsAwsjson11_deserializeOpGetOperationsForResource struct {
13497}
13498
13499func (*awsAwsjson11_deserializeOpGetOperationsForResource) ID() string {
13500	return "OperationDeserializer"
13501}
13502
13503func (m *awsAwsjson11_deserializeOpGetOperationsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13504	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13505) {
13506	out, metadata, err = next.HandleDeserialize(ctx, in)
13507	if err != nil {
13508		return out, metadata, err
13509	}
13510
13511	response, ok := out.RawResponse.(*smithyhttp.Response)
13512	if !ok {
13513		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13514	}
13515
13516	if response.StatusCode < 200 || response.StatusCode >= 300 {
13517		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperationsForResource(response, &metadata)
13518	}
13519	output := &GetOperationsForResourceOutput{}
13520	out.Result = output
13521
13522	var buff [1024]byte
13523	ringBuffer := smithyio.NewRingBuffer(buff[:])
13524
13525	body := io.TeeReader(response.Body, ringBuffer)
13526	decoder := json.NewDecoder(body)
13527	decoder.UseNumber()
13528	var shape interface{}
13529	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13530		var snapshot bytes.Buffer
13531		io.Copy(&snapshot, ringBuffer)
13532		err = &smithy.DeserializationError{
13533			Err:      fmt.Errorf("failed to decode response body, %w", err),
13534			Snapshot: snapshot.Bytes(),
13535		}
13536		return out, metadata, err
13537	}
13538
13539	err = awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(&output, shape)
13540	if err != nil {
13541		var snapshot bytes.Buffer
13542		io.Copy(&snapshot, ringBuffer)
13543		err = &smithy.DeserializationError{
13544			Err:      fmt.Errorf("failed to decode response body, %w", err),
13545			Snapshot: snapshot.Bytes(),
13546		}
13547		return out, metadata, err
13548	}
13549
13550	return out, metadata, err
13551}
13552
13553func awsAwsjson11_deserializeOpErrorGetOperationsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13554	var errorBuffer bytes.Buffer
13555	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13556		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13557	}
13558	errorBody := bytes.NewReader(errorBuffer.Bytes())
13559
13560	errorCode := "UnknownError"
13561	errorMessage := errorCode
13562
13563	code := response.Header.Get("X-Amzn-ErrorType")
13564	if len(code) != 0 {
13565		errorCode = restjson.SanitizeErrorCode(code)
13566	}
13567
13568	var buff [1024]byte
13569	ringBuffer := smithyio.NewRingBuffer(buff[:])
13570
13571	body := io.TeeReader(errorBody, ringBuffer)
13572	decoder := json.NewDecoder(body)
13573	decoder.UseNumber()
13574	code, message, err := restjson.GetErrorInfo(decoder)
13575	if err != nil {
13576		var snapshot bytes.Buffer
13577		io.Copy(&snapshot, ringBuffer)
13578		err = &smithy.DeserializationError{
13579			Err:      fmt.Errorf("failed to decode response body, %w", err),
13580			Snapshot: snapshot.Bytes(),
13581		}
13582		return err
13583	}
13584
13585	errorBody.Seek(0, io.SeekStart)
13586	if len(code) != 0 {
13587		errorCode = restjson.SanitizeErrorCode(code)
13588	}
13589	if len(message) != 0 {
13590		errorMessage = message
13591	}
13592
13593	switch {
13594	case strings.EqualFold("AccessDeniedException", errorCode):
13595		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13596
13597	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13598		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13599
13600	case strings.EqualFold("InvalidInputException", errorCode):
13601		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13602
13603	case strings.EqualFold("NotFoundException", errorCode):
13604		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13605
13606	case strings.EqualFold("OperationFailureException", errorCode):
13607		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13608
13609	case strings.EqualFold("ServiceException", errorCode):
13610		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13611
13612	case strings.EqualFold("UnauthenticatedException", errorCode):
13613		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13614
13615	default:
13616		genericError := &smithy.GenericAPIError{
13617			Code:    errorCode,
13618			Message: errorMessage,
13619		}
13620		return genericError
13621
13622	}
13623}
13624
13625type awsAwsjson11_deserializeOpGetRegions struct {
13626}
13627
13628func (*awsAwsjson11_deserializeOpGetRegions) ID() string {
13629	return "OperationDeserializer"
13630}
13631
13632func (m *awsAwsjson11_deserializeOpGetRegions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13633	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13634) {
13635	out, metadata, err = next.HandleDeserialize(ctx, in)
13636	if err != nil {
13637		return out, metadata, err
13638	}
13639
13640	response, ok := out.RawResponse.(*smithyhttp.Response)
13641	if !ok {
13642		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13643	}
13644
13645	if response.StatusCode < 200 || response.StatusCode >= 300 {
13646		return out, metadata, awsAwsjson11_deserializeOpErrorGetRegions(response, &metadata)
13647	}
13648	output := &GetRegionsOutput{}
13649	out.Result = output
13650
13651	var buff [1024]byte
13652	ringBuffer := smithyio.NewRingBuffer(buff[:])
13653
13654	body := io.TeeReader(response.Body, ringBuffer)
13655	decoder := json.NewDecoder(body)
13656	decoder.UseNumber()
13657	var shape interface{}
13658	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13659		var snapshot bytes.Buffer
13660		io.Copy(&snapshot, ringBuffer)
13661		err = &smithy.DeserializationError{
13662			Err:      fmt.Errorf("failed to decode response body, %w", err),
13663			Snapshot: snapshot.Bytes(),
13664		}
13665		return out, metadata, err
13666	}
13667
13668	err = awsAwsjson11_deserializeOpDocumentGetRegionsOutput(&output, shape)
13669	if err != nil {
13670		var snapshot bytes.Buffer
13671		io.Copy(&snapshot, ringBuffer)
13672		err = &smithy.DeserializationError{
13673			Err:      fmt.Errorf("failed to decode response body, %w", err),
13674			Snapshot: snapshot.Bytes(),
13675		}
13676		return out, metadata, err
13677	}
13678
13679	return out, metadata, err
13680}
13681
13682func awsAwsjson11_deserializeOpErrorGetRegions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13683	var errorBuffer bytes.Buffer
13684	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13685		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13686	}
13687	errorBody := bytes.NewReader(errorBuffer.Bytes())
13688
13689	errorCode := "UnknownError"
13690	errorMessage := errorCode
13691
13692	code := response.Header.Get("X-Amzn-ErrorType")
13693	if len(code) != 0 {
13694		errorCode = restjson.SanitizeErrorCode(code)
13695	}
13696
13697	var buff [1024]byte
13698	ringBuffer := smithyio.NewRingBuffer(buff[:])
13699
13700	body := io.TeeReader(errorBody, ringBuffer)
13701	decoder := json.NewDecoder(body)
13702	decoder.UseNumber()
13703	code, message, err := restjson.GetErrorInfo(decoder)
13704	if err != nil {
13705		var snapshot bytes.Buffer
13706		io.Copy(&snapshot, ringBuffer)
13707		err = &smithy.DeserializationError{
13708			Err:      fmt.Errorf("failed to decode response body, %w", err),
13709			Snapshot: snapshot.Bytes(),
13710		}
13711		return err
13712	}
13713
13714	errorBody.Seek(0, io.SeekStart)
13715	if len(code) != 0 {
13716		errorCode = restjson.SanitizeErrorCode(code)
13717	}
13718	if len(message) != 0 {
13719		errorMessage = message
13720	}
13721
13722	switch {
13723	case strings.EqualFold("AccessDeniedException", errorCode):
13724		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13725
13726	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13727		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13728
13729	case strings.EqualFold("InvalidInputException", errorCode):
13730		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13731
13732	case strings.EqualFold("NotFoundException", errorCode):
13733		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13734
13735	case strings.EqualFold("OperationFailureException", errorCode):
13736		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13737
13738	case strings.EqualFold("ServiceException", errorCode):
13739		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13740
13741	case strings.EqualFold("UnauthenticatedException", errorCode):
13742		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13743
13744	default:
13745		genericError := &smithy.GenericAPIError{
13746			Code:    errorCode,
13747			Message: errorMessage,
13748		}
13749		return genericError
13750
13751	}
13752}
13753
13754type awsAwsjson11_deserializeOpGetRelationalDatabase struct {
13755}
13756
13757func (*awsAwsjson11_deserializeOpGetRelationalDatabase) ID() string {
13758	return "OperationDeserializer"
13759}
13760
13761func (m *awsAwsjson11_deserializeOpGetRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13762	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13763) {
13764	out, metadata, err = next.HandleDeserialize(ctx, in)
13765	if err != nil {
13766		return out, metadata, err
13767	}
13768
13769	response, ok := out.RawResponse.(*smithyhttp.Response)
13770	if !ok {
13771		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13772	}
13773
13774	if response.StatusCode < 200 || response.StatusCode >= 300 {
13775		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response, &metadata)
13776	}
13777	output := &GetRelationalDatabaseOutput{}
13778	out.Result = output
13779
13780	var buff [1024]byte
13781	ringBuffer := smithyio.NewRingBuffer(buff[:])
13782
13783	body := io.TeeReader(response.Body, ringBuffer)
13784	decoder := json.NewDecoder(body)
13785	decoder.UseNumber()
13786	var shape interface{}
13787	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13788		var snapshot bytes.Buffer
13789		io.Copy(&snapshot, ringBuffer)
13790		err = &smithy.DeserializationError{
13791			Err:      fmt.Errorf("failed to decode response body, %w", err),
13792			Snapshot: snapshot.Bytes(),
13793		}
13794		return out, metadata, err
13795	}
13796
13797	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(&output, shape)
13798	if err != nil {
13799		var snapshot bytes.Buffer
13800		io.Copy(&snapshot, ringBuffer)
13801		err = &smithy.DeserializationError{
13802			Err:      fmt.Errorf("failed to decode response body, %w", err),
13803			Snapshot: snapshot.Bytes(),
13804		}
13805		return out, metadata, err
13806	}
13807
13808	return out, metadata, err
13809}
13810
13811func awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13812	var errorBuffer bytes.Buffer
13813	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13814		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13815	}
13816	errorBody := bytes.NewReader(errorBuffer.Bytes())
13817
13818	errorCode := "UnknownError"
13819	errorMessage := errorCode
13820
13821	code := response.Header.Get("X-Amzn-ErrorType")
13822	if len(code) != 0 {
13823		errorCode = restjson.SanitizeErrorCode(code)
13824	}
13825
13826	var buff [1024]byte
13827	ringBuffer := smithyio.NewRingBuffer(buff[:])
13828
13829	body := io.TeeReader(errorBody, ringBuffer)
13830	decoder := json.NewDecoder(body)
13831	decoder.UseNumber()
13832	code, message, err := restjson.GetErrorInfo(decoder)
13833	if err != nil {
13834		var snapshot bytes.Buffer
13835		io.Copy(&snapshot, ringBuffer)
13836		err = &smithy.DeserializationError{
13837			Err:      fmt.Errorf("failed to decode response body, %w", err),
13838			Snapshot: snapshot.Bytes(),
13839		}
13840		return err
13841	}
13842
13843	errorBody.Seek(0, io.SeekStart)
13844	if len(code) != 0 {
13845		errorCode = restjson.SanitizeErrorCode(code)
13846	}
13847	if len(message) != 0 {
13848		errorMessage = message
13849	}
13850
13851	switch {
13852	case strings.EqualFold("AccessDeniedException", errorCode):
13853		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13854
13855	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13856		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13857
13858	case strings.EqualFold("InvalidInputException", errorCode):
13859		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13860
13861	case strings.EqualFold("NotFoundException", errorCode):
13862		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13863
13864	case strings.EqualFold("OperationFailureException", errorCode):
13865		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13866
13867	case strings.EqualFold("ServiceException", errorCode):
13868		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13869
13870	case strings.EqualFold("UnauthenticatedException", errorCode):
13871		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13872
13873	default:
13874		genericError := &smithy.GenericAPIError{
13875			Code:    errorCode,
13876			Message: errorMessage,
13877		}
13878		return genericError
13879
13880	}
13881}
13882
13883type awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints struct {
13884}
13885
13886func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) ID() string {
13887	return "OperationDeserializer"
13888}
13889
13890func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13891	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13892) {
13893	out, metadata, err = next.HandleDeserialize(ctx, in)
13894	if err != nil {
13895		return out, metadata, err
13896	}
13897
13898	response, ok := out.RawResponse.(*smithyhttp.Response)
13899	if !ok {
13900		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13901	}
13902
13903	if response.StatusCode < 200 || response.StatusCode >= 300 {
13904		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response, &metadata)
13905	}
13906	output := &GetRelationalDatabaseBlueprintsOutput{}
13907	out.Result = output
13908
13909	var buff [1024]byte
13910	ringBuffer := smithyio.NewRingBuffer(buff[:])
13911
13912	body := io.TeeReader(response.Body, ringBuffer)
13913	decoder := json.NewDecoder(body)
13914	decoder.UseNumber()
13915	var shape interface{}
13916	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13917		var snapshot bytes.Buffer
13918		io.Copy(&snapshot, ringBuffer)
13919		err = &smithy.DeserializationError{
13920			Err:      fmt.Errorf("failed to decode response body, %w", err),
13921			Snapshot: snapshot.Bytes(),
13922		}
13923		return out, metadata, err
13924	}
13925
13926	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(&output, shape)
13927	if err != nil {
13928		var snapshot bytes.Buffer
13929		io.Copy(&snapshot, ringBuffer)
13930		err = &smithy.DeserializationError{
13931			Err:      fmt.Errorf("failed to decode response body, %w", err),
13932			Snapshot: snapshot.Bytes(),
13933		}
13934		return out, metadata, err
13935	}
13936
13937	return out, metadata, err
13938}
13939
13940func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13941	var errorBuffer bytes.Buffer
13942	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13943		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13944	}
13945	errorBody := bytes.NewReader(errorBuffer.Bytes())
13946
13947	errorCode := "UnknownError"
13948	errorMessage := errorCode
13949
13950	code := response.Header.Get("X-Amzn-ErrorType")
13951	if len(code) != 0 {
13952		errorCode = restjson.SanitizeErrorCode(code)
13953	}
13954
13955	var buff [1024]byte
13956	ringBuffer := smithyio.NewRingBuffer(buff[:])
13957
13958	body := io.TeeReader(errorBody, ringBuffer)
13959	decoder := json.NewDecoder(body)
13960	decoder.UseNumber()
13961	code, message, err := restjson.GetErrorInfo(decoder)
13962	if err != nil {
13963		var snapshot bytes.Buffer
13964		io.Copy(&snapshot, ringBuffer)
13965		err = &smithy.DeserializationError{
13966			Err:      fmt.Errorf("failed to decode response body, %w", err),
13967			Snapshot: snapshot.Bytes(),
13968		}
13969		return err
13970	}
13971
13972	errorBody.Seek(0, io.SeekStart)
13973	if len(code) != 0 {
13974		errorCode = restjson.SanitizeErrorCode(code)
13975	}
13976	if len(message) != 0 {
13977		errorMessage = message
13978	}
13979
13980	switch {
13981	case strings.EqualFold("AccessDeniedException", errorCode):
13982		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13983
13984	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13985		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13986
13987	case strings.EqualFold("InvalidInputException", errorCode):
13988		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13989
13990	case strings.EqualFold("NotFoundException", errorCode):
13991		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13992
13993	case strings.EqualFold("OperationFailureException", errorCode):
13994		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13995
13996	case strings.EqualFold("ServiceException", errorCode):
13997		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13998
13999	case strings.EqualFold("UnauthenticatedException", errorCode):
14000		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14001
14002	default:
14003		genericError := &smithy.GenericAPIError{
14004			Code:    errorCode,
14005			Message: errorMessage,
14006		}
14007		return genericError
14008
14009	}
14010}
14011
14012type awsAwsjson11_deserializeOpGetRelationalDatabaseBundles struct {
14013}
14014
14015func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) ID() string {
14016	return "OperationDeserializer"
14017}
14018
14019func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14020	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14021) {
14022	out, metadata, err = next.HandleDeserialize(ctx, in)
14023	if err != nil {
14024		return out, metadata, err
14025	}
14026
14027	response, ok := out.RawResponse.(*smithyhttp.Response)
14028	if !ok {
14029		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14030	}
14031
14032	if response.StatusCode < 200 || response.StatusCode >= 300 {
14033		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response, &metadata)
14034	}
14035	output := &GetRelationalDatabaseBundlesOutput{}
14036	out.Result = output
14037
14038	var buff [1024]byte
14039	ringBuffer := smithyio.NewRingBuffer(buff[:])
14040
14041	body := io.TeeReader(response.Body, ringBuffer)
14042	decoder := json.NewDecoder(body)
14043	decoder.UseNumber()
14044	var shape interface{}
14045	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14046		var snapshot bytes.Buffer
14047		io.Copy(&snapshot, ringBuffer)
14048		err = &smithy.DeserializationError{
14049			Err:      fmt.Errorf("failed to decode response body, %w", err),
14050			Snapshot: snapshot.Bytes(),
14051		}
14052		return out, metadata, err
14053	}
14054
14055	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(&output, shape)
14056	if err != nil {
14057		var snapshot bytes.Buffer
14058		io.Copy(&snapshot, ringBuffer)
14059		err = &smithy.DeserializationError{
14060			Err:      fmt.Errorf("failed to decode response body, %w", err),
14061			Snapshot: snapshot.Bytes(),
14062		}
14063		return out, metadata, err
14064	}
14065
14066	return out, metadata, err
14067}
14068
14069func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14070	var errorBuffer bytes.Buffer
14071	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14072		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14073	}
14074	errorBody := bytes.NewReader(errorBuffer.Bytes())
14075
14076	errorCode := "UnknownError"
14077	errorMessage := errorCode
14078
14079	code := response.Header.Get("X-Amzn-ErrorType")
14080	if len(code) != 0 {
14081		errorCode = restjson.SanitizeErrorCode(code)
14082	}
14083
14084	var buff [1024]byte
14085	ringBuffer := smithyio.NewRingBuffer(buff[:])
14086
14087	body := io.TeeReader(errorBody, ringBuffer)
14088	decoder := json.NewDecoder(body)
14089	decoder.UseNumber()
14090	code, message, err := restjson.GetErrorInfo(decoder)
14091	if err != nil {
14092		var snapshot bytes.Buffer
14093		io.Copy(&snapshot, ringBuffer)
14094		err = &smithy.DeserializationError{
14095			Err:      fmt.Errorf("failed to decode response body, %w", err),
14096			Snapshot: snapshot.Bytes(),
14097		}
14098		return err
14099	}
14100
14101	errorBody.Seek(0, io.SeekStart)
14102	if len(code) != 0 {
14103		errorCode = restjson.SanitizeErrorCode(code)
14104	}
14105	if len(message) != 0 {
14106		errorMessage = message
14107	}
14108
14109	switch {
14110	case strings.EqualFold("AccessDeniedException", errorCode):
14111		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14112
14113	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14114		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14115
14116	case strings.EqualFold("InvalidInputException", errorCode):
14117		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14118
14119	case strings.EqualFold("NotFoundException", errorCode):
14120		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14121
14122	case strings.EqualFold("OperationFailureException", errorCode):
14123		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14124
14125	case strings.EqualFold("ServiceException", errorCode):
14126		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14127
14128	case strings.EqualFold("UnauthenticatedException", errorCode):
14129		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14130
14131	default:
14132		genericError := &smithy.GenericAPIError{
14133			Code:    errorCode,
14134			Message: errorMessage,
14135		}
14136		return genericError
14137
14138	}
14139}
14140
14141type awsAwsjson11_deserializeOpGetRelationalDatabaseEvents struct {
14142}
14143
14144func (*awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) ID() string {
14145	return "OperationDeserializer"
14146}
14147
14148func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14149	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14150) {
14151	out, metadata, err = next.HandleDeserialize(ctx, in)
14152	if err != nil {
14153		return out, metadata, err
14154	}
14155
14156	response, ok := out.RawResponse.(*smithyhttp.Response)
14157	if !ok {
14158		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14159	}
14160
14161	if response.StatusCode < 200 || response.StatusCode >= 300 {
14162		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response, &metadata)
14163	}
14164	output := &GetRelationalDatabaseEventsOutput{}
14165	out.Result = output
14166
14167	var buff [1024]byte
14168	ringBuffer := smithyio.NewRingBuffer(buff[:])
14169
14170	body := io.TeeReader(response.Body, ringBuffer)
14171	decoder := json.NewDecoder(body)
14172	decoder.UseNumber()
14173	var shape interface{}
14174	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14175		var snapshot bytes.Buffer
14176		io.Copy(&snapshot, ringBuffer)
14177		err = &smithy.DeserializationError{
14178			Err:      fmt.Errorf("failed to decode response body, %w", err),
14179			Snapshot: snapshot.Bytes(),
14180		}
14181		return out, metadata, err
14182	}
14183
14184	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(&output, shape)
14185	if err != nil {
14186		var snapshot bytes.Buffer
14187		io.Copy(&snapshot, ringBuffer)
14188		err = &smithy.DeserializationError{
14189			Err:      fmt.Errorf("failed to decode response body, %w", err),
14190			Snapshot: snapshot.Bytes(),
14191		}
14192		return out, metadata, err
14193	}
14194
14195	return out, metadata, err
14196}
14197
14198func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14199	var errorBuffer bytes.Buffer
14200	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14201		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14202	}
14203	errorBody := bytes.NewReader(errorBuffer.Bytes())
14204
14205	errorCode := "UnknownError"
14206	errorMessage := errorCode
14207
14208	code := response.Header.Get("X-Amzn-ErrorType")
14209	if len(code) != 0 {
14210		errorCode = restjson.SanitizeErrorCode(code)
14211	}
14212
14213	var buff [1024]byte
14214	ringBuffer := smithyio.NewRingBuffer(buff[:])
14215
14216	body := io.TeeReader(errorBody, ringBuffer)
14217	decoder := json.NewDecoder(body)
14218	decoder.UseNumber()
14219	code, message, err := restjson.GetErrorInfo(decoder)
14220	if err != nil {
14221		var snapshot bytes.Buffer
14222		io.Copy(&snapshot, ringBuffer)
14223		err = &smithy.DeserializationError{
14224			Err:      fmt.Errorf("failed to decode response body, %w", err),
14225			Snapshot: snapshot.Bytes(),
14226		}
14227		return err
14228	}
14229
14230	errorBody.Seek(0, io.SeekStart)
14231	if len(code) != 0 {
14232		errorCode = restjson.SanitizeErrorCode(code)
14233	}
14234	if len(message) != 0 {
14235		errorMessage = message
14236	}
14237
14238	switch {
14239	case strings.EqualFold("AccessDeniedException", errorCode):
14240		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14241
14242	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14243		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14244
14245	case strings.EqualFold("InvalidInputException", errorCode):
14246		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14247
14248	case strings.EqualFold("NotFoundException", errorCode):
14249		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14250
14251	case strings.EqualFold("OperationFailureException", errorCode):
14252		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14253
14254	case strings.EqualFold("ServiceException", errorCode):
14255		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14256
14257	case strings.EqualFold("UnauthenticatedException", errorCode):
14258		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14259
14260	default:
14261		genericError := &smithy.GenericAPIError{
14262			Code:    errorCode,
14263			Message: errorMessage,
14264		}
14265		return genericError
14266
14267	}
14268}
14269
14270type awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents struct {
14271}
14272
14273func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) ID() string {
14274	return "OperationDeserializer"
14275}
14276
14277func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14278	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14279) {
14280	out, metadata, err = next.HandleDeserialize(ctx, in)
14281	if err != nil {
14282		return out, metadata, err
14283	}
14284
14285	response, ok := out.RawResponse.(*smithyhttp.Response)
14286	if !ok {
14287		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14288	}
14289
14290	if response.StatusCode < 200 || response.StatusCode >= 300 {
14291		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response, &metadata)
14292	}
14293	output := &GetRelationalDatabaseLogEventsOutput{}
14294	out.Result = output
14295
14296	var buff [1024]byte
14297	ringBuffer := smithyio.NewRingBuffer(buff[:])
14298
14299	body := io.TeeReader(response.Body, ringBuffer)
14300	decoder := json.NewDecoder(body)
14301	decoder.UseNumber()
14302	var shape interface{}
14303	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14304		var snapshot bytes.Buffer
14305		io.Copy(&snapshot, ringBuffer)
14306		err = &smithy.DeserializationError{
14307			Err:      fmt.Errorf("failed to decode response body, %w", err),
14308			Snapshot: snapshot.Bytes(),
14309		}
14310		return out, metadata, err
14311	}
14312
14313	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(&output, shape)
14314	if err != nil {
14315		var snapshot bytes.Buffer
14316		io.Copy(&snapshot, ringBuffer)
14317		err = &smithy.DeserializationError{
14318			Err:      fmt.Errorf("failed to decode response body, %w", err),
14319			Snapshot: snapshot.Bytes(),
14320		}
14321		return out, metadata, err
14322	}
14323
14324	return out, metadata, err
14325}
14326
14327func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14328	var errorBuffer bytes.Buffer
14329	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14330		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14331	}
14332	errorBody := bytes.NewReader(errorBuffer.Bytes())
14333
14334	errorCode := "UnknownError"
14335	errorMessage := errorCode
14336
14337	code := response.Header.Get("X-Amzn-ErrorType")
14338	if len(code) != 0 {
14339		errorCode = restjson.SanitizeErrorCode(code)
14340	}
14341
14342	var buff [1024]byte
14343	ringBuffer := smithyio.NewRingBuffer(buff[:])
14344
14345	body := io.TeeReader(errorBody, ringBuffer)
14346	decoder := json.NewDecoder(body)
14347	decoder.UseNumber()
14348	code, message, err := restjson.GetErrorInfo(decoder)
14349	if err != nil {
14350		var snapshot bytes.Buffer
14351		io.Copy(&snapshot, ringBuffer)
14352		err = &smithy.DeserializationError{
14353			Err:      fmt.Errorf("failed to decode response body, %w", err),
14354			Snapshot: snapshot.Bytes(),
14355		}
14356		return err
14357	}
14358
14359	errorBody.Seek(0, io.SeekStart)
14360	if len(code) != 0 {
14361		errorCode = restjson.SanitizeErrorCode(code)
14362	}
14363	if len(message) != 0 {
14364		errorMessage = message
14365	}
14366
14367	switch {
14368	case strings.EqualFold("AccessDeniedException", errorCode):
14369		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14370
14371	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14372		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14373
14374	case strings.EqualFold("InvalidInputException", errorCode):
14375		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14376
14377	case strings.EqualFold("NotFoundException", errorCode):
14378		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14379
14380	case strings.EqualFold("OperationFailureException", errorCode):
14381		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14382
14383	case strings.EqualFold("ServiceException", errorCode):
14384		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14385
14386	case strings.EqualFold("UnauthenticatedException", errorCode):
14387		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14388
14389	default:
14390		genericError := &smithy.GenericAPIError{
14391			Code:    errorCode,
14392			Message: errorMessage,
14393		}
14394		return genericError
14395
14396	}
14397}
14398
14399type awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams struct {
14400}
14401
14402func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) ID() string {
14403	return "OperationDeserializer"
14404}
14405
14406func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14407	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14408) {
14409	out, metadata, err = next.HandleDeserialize(ctx, in)
14410	if err != nil {
14411		return out, metadata, err
14412	}
14413
14414	response, ok := out.RawResponse.(*smithyhttp.Response)
14415	if !ok {
14416		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14417	}
14418
14419	if response.StatusCode < 200 || response.StatusCode >= 300 {
14420		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response, &metadata)
14421	}
14422	output := &GetRelationalDatabaseLogStreamsOutput{}
14423	out.Result = output
14424
14425	var buff [1024]byte
14426	ringBuffer := smithyio.NewRingBuffer(buff[:])
14427
14428	body := io.TeeReader(response.Body, ringBuffer)
14429	decoder := json.NewDecoder(body)
14430	decoder.UseNumber()
14431	var shape interface{}
14432	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14433		var snapshot bytes.Buffer
14434		io.Copy(&snapshot, ringBuffer)
14435		err = &smithy.DeserializationError{
14436			Err:      fmt.Errorf("failed to decode response body, %w", err),
14437			Snapshot: snapshot.Bytes(),
14438		}
14439		return out, metadata, err
14440	}
14441
14442	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(&output, shape)
14443	if err != nil {
14444		var snapshot bytes.Buffer
14445		io.Copy(&snapshot, ringBuffer)
14446		err = &smithy.DeserializationError{
14447			Err:      fmt.Errorf("failed to decode response body, %w", err),
14448			Snapshot: snapshot.Bytes(),
14449		}
14450		return out, metadata, err
14451	}
14452
14453	return out, metadata, err
14454}
14455
14456func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14457	var errorBuffer bytes.Buffer
14458	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14459		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14460	}
14461	errorBody := bytes.NewReader(errorBuffer.Bytes())
14462
14463	errorCode := "UnknownError"
14464	errorMessage := errorCode
14465
14466	code := response.Header.Get("X-Amzn-ErrorType")
14467	if len(code) != 0 {
14468		errorCode = restjson.SanitizeErrorCode(code)
14469	}
14470
14471	var buff [1024]byte
14472	ringBuffer := smithyio.NewRingBuffer(buff[:])
14473
14474	body := io.TeeReader(errorBody, ringBuffer)
14475	decoder := json.NewDecoder(body)
14476	decoder.UseNumber()
14477	code, message, err := restjson.GetErrorInfo(decoder)
14478	if err != nil {
14479		var snapshot bytes.Buffer
14480		io.Copy(&snapshot, ringBuffer)
14481		err = &smithy.DeserializationError{
14482			Err:      fmt.Errorf("failed to decode response body, %w", err),
14483			Snapshot: snapshot.Bytes(),
14484		}
14485		return err
14486	}
14487
14488	errorBody.Seek(0, io.SeekStart)
14489	if len(code) != 0 {
14490		errorCode = restjson.SanitizeErrorCode(code)
14491	}
14492	if len(message) != 0 {
14493		errorMessage = message
14494	}
14495
14496	switch {
14497	case strings.EqualFold("AccessDeniedException", errorCode):
14498		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14499
14500	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14501		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14502
14503	case strings.EqualFold("InvalidInputException", errorCode):
14504		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14505
14506	case strings.EqualFold("NotFoundException", errorCode):
14507		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14508
14509	case strings.EqualFold("OperationFailureException", errorCode):
14510		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14511
14512	case strings.EqualFold("ServiceException", errorCode):
14513		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14514
14515	case strings.EqualFold("UnauthenticatedException", errorCode):
14516		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14517
14518	default:
14519		genericError := &smithy.GenericAPIError{
14520			Code:    errorCode,
14521			Message: errorMessage,
14522		}
14523		return genericError
14524
14525	}
14526}
14527
14528type awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword struct {
14529}
14530
14531func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) ID() string {
14532	return "OperationDeserializer"
14533}
14534
14535func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14536	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14537) {
14538	out, metadata, err = next.HandleDeserialize(ctx, in)
14539	if err != nil {
14540		return out, metadata, err
14541	}
14542
14543	response, ok := out.RawResponse.(*smithyhttp.Response)
14544	if !ok {
14545		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14546	}
14547
14548	if response.StatusCode < 200 || response.StatusCode >= 300 {
14549		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response, &metadata)
14550	}
14551	output := &GetRelationalDatabaseMasterUserPasswordOutput{}
14552	out.Result = output
14553
14554	var buff [1024]byte
14555	ringBuffer := smithyio.NewRingBuffer(buff[:])
14556
14557	body := io.TeeReader(response.Body, ringBuffer)
14558	decoder := json.NewDecoder(body)
14559	decoder.UseNumber()
14560	var shape interface{}
14561	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14562		var snapshot bytes.Buffer
14563		io.Copy(&snapshot, ringBuffer)
14564		err = &smithy.DeserializationError{
14565			Err:      fmt.Errorf("failed to decode response body, %w", err),
14566			Snapshot: snapshot.Bytes(),
14567		}
14568		return out, metadata, err
14569	}
14570
14571	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(&output, shape)
14572	if err != nil {
14573		var snapshot bytes.Buffer
14574		io.Copy(&snapshot, ringBuffer)
14575		err = &smithy.DeserializationError{
14576			Err:      fmt.Errorf("failed to decode response body, %w", err),
14577			Snapshot: snapshot.Bytes(),
14578		}
14579		return out, metadata, err
14580	}
14581
14582	return out, metadata, err
14583}
14584
14585func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14586	var errorBuffer bytes.Buffer
14587	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14588		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14589	}
14590	errorBody := bytes.NewReader(errorBuffer.Bytes())
14591
14592	errorCode := "UnknownError"
14593	errorMessage := errorCode
14594
14595	code := response.Header.Get("X-Amzn-ErrorType")
14596	if len(code) != 0 {
14597		errorCode = restjson.SanitizeErrorCode(code)
14598	}
14599
14600	var buff [1024]byte
14601	ringBuffer := smithyio.NewRingBuffer(buff[:])
14602
14603	body := io.TeeReader(errorBody, ringBuffer)
14604	decoder := json.NewDecoder(body)
14605	decoder.UseNumber()
14606	code, message, err := restjson.GetErrorInfo(decoder)
14607	if err != nil {
14608		var snapshot bytes.Buffer
14609		io.Copy(&snapshot, ringBuffer)
14610		err = &smithy.DeserializationError{
14611			Err:      fmt.Errorf("failed to decode response body, %w", err),
14612			Snapshot: snapshot.Bytes(),
14613		}
14614		return err
14615	}
14616
14617	errorBody.Seek(0, io.SeekStart)
14618	if len(code) != 0 {
14619		errorCode = restjson.SanitizeErrorCode(code)
14620	}
14621	if len(message) != 0 {
14622		errorMessage = message
14623	}
14624
14625	switch {
14626	case strings.EqualFold("AccessDeniedException", errorCode):
14627		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14628
14629	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14630		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14631
14632	case strings.EqualFold("InvalidInputException", errorCode):
14633		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14634
14635	case strings.EqualFold("NotFoundException", errorCode):
14636		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14637
14638	case strings.EqualFold("OperationFailureException", errorCode):
14639		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14640
14641	case strings.EqualFold("ServiceException", errorCode):
14642		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14643
14644	case strings.EqualFold("UnauthenticatedException", errorCode):
14645		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14646
14647	default:
14648		genericError := &smithy.GenericAPIError{
14649			Code:    errorCode,
14650			Message: errorMessage,
14651		}
14652		return genericError
14653
14654	}
14655}
14656
14657type awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData struct {
14658}
14659
14660func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) ID() string {
14661	return "OperationDeserializer"
14662}
14663
14664func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14665	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14666) {
14667	out, metadata, err = next.HandleDeserialize(ctx, in)
14668	if err != nil {
14669		return out, metadata, err
14670	}
14671
14672	response, ok := out.RawResponse.(*smithyhttp.Response)
14673	if !ok {
14674		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14675	}
14676
14677	if response.StatusCode < 200 || response.StatusCode >= 300 {
14678		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response, &metadata)
14679	}
14680	output := &GetRelationalDatabaseMetricDataOutput{}
14681	out.Result = output
14682
14683	var buff [1024]byte
14684	ringBuffer := smithyio.NewRingBuffer(buff[:])
14685
14686	body := io.TeeReader(response.Body, ringBuffer)
14687	decoder := json.NewDecoder(body)
14688	decoder.UseNumber()
14689	var shape interface{}
14690	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14691		var snapshot bytes.Buffer
14692		io.Copy(&snapshot, ringBuffer)
14693		err = &smithy.DeserializationError{
14694			Err:      fmt.Errorf("failed to decode response body, %w", err),
14695			Snapshot: snapshot.Bytes(),
14696		}
14697		return out, metadata, err
14698	}
14699
14700	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(&output, shape)
14701	if err != nil {
14702		var snapshot bytes.Buffer
14703		io.Copy(&snapshot, ringBuffer)
14704		err = &smithy.DeserializationError{
14705			Err:      fmt.Errorf("failed to decode response body, %w", err),
14706			Snapshot: snapshot.Bytes(),
14707		}
14708		return out, metadata, err
14709	}
14710
14711	return out, metadata, err
14712}
14713
14714func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14715	var errorBuffer bytes.Buffer
14716	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14717		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14718	}
14719	errorBody := bytes.NewReader(errorBuffer.Bytes())
14720
14721	errorCode := "UnknownError"
14722	errorMessage := errorCode
14723
14724	code := response.Header.Get("X-Amzn-ErrorType")
14725	if len(code) != 0 {
14726		errorCode = restjson.SanitizeErrorCode(code)
14727	}
14728
14729	var buff [1024]byte
14730	ringBuffer := smithyio.NewRingBuffer(buff[:])
14731
14732	body := io.TeeReader(errorBody, ringBuffer)
14733	decoder := json.NewDecoder(body)
14734	decoder.UseNumber()
14735	code, message, err := restjson.GetErrorInfo(decoder)
14736	if err != nil {
14737		var snapshot bytes.Buffer
14738		io.Copy(&snapshot, ringBuffer)
14739		err = &smithy.DeserializationError{
14740			Err:      fmt.Errorf("failed to decode response body, %w", err),
14741			Snapshot: snapshot.Bytes(),
14742		}
14743		return err
14744	}
14745
14746	errorBody.Seek(0, io.SeekStart)
14747	if len(code) != 0 {
14748		errorCode = restjson.SanitizeErrorCode(code)
14749	}
14750	if len(message) != 0 {
14751		errorMessage = message
14752	}
14753
14754	switch {
14755	case strings.EqualFold("AccessDeniedException", errorCode):
14756		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14757
14758	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14759		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14760
14761	case strings.EqualFold("InvalidInputException", errorCode):
14762		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14763
14764	case strings.EqualFold("NotFoundException", errorCode):
14765		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14766
14767	case strings.EqualFold("OperationFailureException", errorCode):
14768		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14769
14770	case strings.EqualFold("ServiceException", errorCode):
14771		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14772
14773	case strings.EqualFold("UnauthenticatedException", errorCode):
14774		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14775
14776	default:
14777		genericError := &smithy.GenericAPIError{
14778			Code:    errorCode,
14779			Message: errorMessage,
14780		}
14781		return genericError
14782
14783	}
14784}
14785
14786type awsAwsjson11_deserializeOpGetRelationalDatabaseParameters struct {
14787}
14788
14789func (*awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) ID() string {
14790	return "OperationDeserializer"
14791}
14792
14793func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14794	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14795) {
14796	out, metadata, err = next.HandleDeserialize(ctx, in)
14797	if err != nil {
14798		return out, metadata, err
14799	}
14800
14801	response, ok := out.RawResponse.(*smithyhttp.Response)
14802	if !ok {
14803		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14804	}
14805
14806	if response.StatusCode < 200 || response.StatusCode >= 300 {
14807		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response, &metadata)
14808	}
14809	output := &GetRelationalDatabaseParametersOutput{}
14810	out.Result = output
14811
14812	var buff [1024]byte
14813	ringBuffer := smithyio.NewRingBuffer(buff[:])
14814
14815	body := io.TeeReader(response.Body, ringBuffer)
14816	decoder := json.NewDecoder(body)
14817	decoder.UseNumber()
14818	var shape interface{}
14819	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14820		var snapshot bytes.Buffer
14821		io.Copy(&snapshot, ringBuffer)
14822		err = &smithy.DeserializationError{
14823			Err:      fmt.Errorf("failed to decode response body, %w", err),
14824			Snapshot: snapshot.Bytes(),
14825		}
14826		return out, metadata, err
14827	}
14828
14829	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(&output, shape)
14830	if err != nil {
14831		var snapshot bytes.Buffer
14832		io.Copy(&snapshot, ringBuffer)
14833		err = &smithy.DeserializationError{
14834			Err:      fmt.Errorf("failed to decode response body, %w", err),
14835			Snapshot: snapshot.Bytes(),
14836		}
14837		return out, metadata, err
14838	}
14839
14840	return out, metadata, err
14841}
14842
14843func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14844	var errorBuffer bytes.Buffer
14845	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14846		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14847	}
14848	errorBody := bytes.NewReader(errorBuffer.Bytes())
14849
14850	errorCode := "UnknownError"
14851	errorMessage := errorCode
14852
14853	code := response.Header.Get("X-Amzn-ErrorType")
14854	if len(code) != 0 {
14855		errorCode = restjson.SanitizeErrorCode(code)
14856	}
14857
14858	var buff [1024]byte
14859	ringBuffer := smithyio.NewRingBuffer(buff[:])
14860
14861	body := io.TeeReader(errorBody, ringBuffer)
14862	decoder := json.NewDecoder(body)
14863	decoder.UseNumber()
14864	code, message, err := restjson.GetErrorInfo(decoder)
14865	if err != nil {
14866		var snapshot bytes.Buffer
14867		io.Copy(&snapshot, ringBuffer)
14868		err = &smithy.DeserializationError{
14869			Err:      fmt.Errorf("failed to decode response body, %w", err),
14870			Snapshot: snapshot.Bytes(),
14871		}
14872		return err
14873	}
14874
14875	errorBody.Seek(0, io.SeekStart)
14876	if len(code) != 0 {
14877		errorCode = restjson.SanitizeErrorCode(code)
14878	}
14879	if len(message) != 0 {
14880		errorMessage = message
14881	}
14882
14883	switch {
14884	case strings.EqualFold("AccessDeniedException", errorCode):
14885		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14886
14887	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14888		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14889
14890	case strings.EqualFold("InvalidInputException", errorCode):
14891		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14892
14893	case strings.EqualFold("NotFoundException", errorCode):
14894		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14895
14896	case strings.EqualFold("OperationFailureException", errorCode):
14897		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14898
14899	case strings.EqualFold("ServiceException", errorCode):
14900		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14901
14902	case strings.EqualFold("UnauthenticatedException", errorCode):
14903		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14904
14905	default:
14906		genericError := &smithy.GenericAPIError{
14907			Code:    errorCode,
14908			Message: errorMessage,
14909		}
14910		return genericError
14911
14912	}
14913}
14914
14915type awsAwsjson11_deserializeOpGetRelationalDatabases struct {
14916}
14917
14918func (*awsAwsjson11_deserializeOpGetRelationalDatabases) ID() string {
14919	return "OperationDeserializer"
14920}
14921
14922func (m *awsAwsjson11_deserializeOpGetRelationalDatabases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14923	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14924) {
14925	out, metadata, err = next.HandleDeserialize(ctx, in)
14926	if err != nil {
14927		return out, metadata, err
14928	}
14929
14930	response, ok := out.RawResponse.(*smithyhttp.Response)
14931	if !ok {
14932		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14933	}
14934
14935	if response.StatusCode < 200 || response.StatusCode >= 300 {
14936		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response, &metadata)
14937	}
14938	output := &GetRelationalDatabasesOutput{}
14939	out.Result = output
14940
14941	var buff [1024]byte
14942	ringBuffer := smithyio.NewRingBuffer(buff[:])
14943
14944	body := io.TeeReader(response.Body, ringBuffer)
14945	decoder := json.NewDecoder(body)
14946	decoder.UseNumber()
14947	var shape interface{}
14948	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14949		var snapshot bytes.Buffer
14950		io.Copy(&snapshot, ringBuffer)
14951		err = &smithy.DeserializationError{
14952			Err:      fmt.Errorf("failed to decode response body, %w", err),
14953			Snapshot: snapshot.Bytes(),
14954		}
14955		return out, metadata, err
14956	}
14957
14958	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(&output, shape)
14959	if err != nil {
14960		var snapshot bytes.Buffer
14961		io.Copy(&snapshot, ringBuffer)
14962		err = &smithy.DeserializationError{
14963			Err:      fmt.Errorf("failed to decode response body, %w", err),
14964			Snapshot: snapshot.Bytes(),
14965		}
14966		return out, metadata, err
14967	}
14968
14969	return out, metadata, err
14970}
14971
14972func awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14973	var errorBuffer bytes.Buffer
14974	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14975		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14976	}
14977	errorBody := bytes.NewReader(errorBuffer.Bytes())
14978
14979	errorCode := "UnknownError"
14980	errorMessage := errorCode
14981
14982	code := response.Header.Get("X-Amzn-ErrorType")
14983	if len(code) != 0 {
14984		errorCode = restjson.SanitizeErrorCode(code)
14985	}
14986
14987	var buff [1024]byte
14988	ringBuffer := smithyio.NewRingBuffer(buff[:])
14989
14990	body := io.TeeReader(errorBody, ringBuffer)
14991	decoder := json.NewDecoder(body)
14992	decoder.UseNumber()
14993	code, message, err := restjson.GetErrorInfo(decoder)
14994	if err != nil {
14995		var snapshot bytes.Buffer
14996		io.Copy(&snapshot, ringBuffer)
14997		err = &smithy.DeserializationError{
14998			Err:      fmt.Errorf("failed to decode response body, %w", err),
14999			Snapshot: snapshot.Bytes(),
15000		}
15001		return err
15002	}
15003
15004	errorBody.Seek(0, io.SeekStart)
15005	if len(code) != 0 {
15006		errorCode = restjson.SanitizeErrorCode(code)
15007	}
15008	if len(message) != 0 {
15009		errorMessage = message
15010	}
15011
15012	switch {
15013	case strings.EqualFold("AccessDeniedException", errorCode):
15014		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15015
15016	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15017		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15018
15019	case strings.EqualFold("InvalidInputException", errorCode):
15020		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15021
15022	case strings.EqualFold("NotFoundException", errorCode):
15023		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15024
15025	case strings.EqualFold("OperationFailureException", errorCode):
15026		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15027
15028	case strings.EqualFold("ServiceException", errorCode):
15029		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15030
15031	case strings.EqualFold("UnauthenticatedException", errorCode):
15032		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15033
15034	default:
15035		genericError := &smithy.GenericAPIError{
15036			Code:    errorCode,
15037			Message: errorMessage,
15038		}
15039		return genericError
15040
15041	}
15042}
15043
15044type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot struct {
15045}
15046
15047func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) ID() string {
15048	return "OperationDeserializer"
15049}
15050
15051func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15052	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15053) {
15054	out, metadata, err = next.HandleDeserialize(ctx, in)
15055	if err != nil {
15056		return out, metadata, err
15057	}
15058
15059	response, ok := out.RawResponse.(*smithyhttp.Response)
15060	if !ok {
15061		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15062	}
15063
15064	if response.StatusCode < 200 || response.StatusCode >= 300 {
15065		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response, &metadata)
15066	}
15067	output := &GetRelationalDatabaseSnapshotOutput{}
15068	out.Result = output
15069
15070	var buff [1024]byte
15071	ringBuffer := smithyio.NewRingBuffer(buff[:])
15072
15073	body := io.TeeReader(response.Body, ringBuffer)
15074	decoder := json.NewDecoder(body)
15075	decoder.UseNumber()
15076	var shape interface{}
15077	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15078		var snapshot bytes.Buffer
15079		io.Copy(&snapshot, ringBuffer)
15080		err = &smithy.DeserializationError{
15081			Err:      fmt.Errorf("failed to decode response body, %w", err),
15082			Snapshot: snapshot.Bytes(),
15083		}
15084		return out, metadata, err
15085	}
15086
15087	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(&output, shape)
15088	if err != nil {
15089		var snapshot bytes.Buffer
15090		io.Copy(&snapshot, ringBuffer)
15091		err = &smithy.DeserializationError{
15092			Err:      fmt.Errorf("failed to decode response body, %w", err),
15093			Snapshot: snapshot.Bytes(),
15094		}
15095		return out, metadata, err
15096	}
15097
15098	return out, metadata, err
15099}
15100
15101func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15102	var errorBuffer bytes.Buffer
15103	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15104		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15105	}
15106	errorBody := bytes.NewReader(errorBuffer.Bytes())
15107
15108	errorCode := "UnknownError"
15109	errorMessage := errorCode
15110
15111	code := response.Header.Get("X-Amzn-ErrorType")
15112	if len(code) != 0 {
15113		errorCode = restjson.SanitizeErrorCode(code)
15114	}
15115
15116	var buff [1024]byte
15117	ringBuffer := smithyio.NewRingBuffer(buff[:])
15118
15119	body := io.TeeReader(errorBody, ringBuffer)
15120	decoder := json.NewDecoder(body)
15121	decoder.UseNumber()
15122	code, message, err := restjson.GetErrorInfo(decoder)
15123	if err != nil {
15124		var snapshot bytes.Buffer
15125		io.Copy(&snapshot, ringBuffer)
15126		err = &smithy.DeserializationError{
15127			Err:      fmt.Errorf("failed to decode response body, %w", err),
15128			Snapshot: snapshot.Bytes(),
15129		}
15130		return err
15131	}
15132
15133	errorBody.Seek(0, io.SeekStart)
15134	if len(code) != 0 {
15135		errorCode = restjson.SanitizeErrorCode(code)
15136	}
15137	if len(message) != 0 {
15138		errorMessage = message
15139	}
15140
15141	switch {
15142	case strings.EqualFold("AccessDeniedException", errorCode):
15143		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15144
15145	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15146		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15147
15148	case strings.EqualFold("InvalidInputException", errorCode):
15149		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15150
15151	case strings.EqualFold("NotFoundException", errorCode):
15152		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15153
15154	case strings.EqualFold("OperationFailureException", errorCode):
15155		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15156
15157	case strings.EqualFold("ServiceException", errorCode):
15158		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15159
15160	case strings.EqualFold("UnauthenticatedException", errorCode):
15161		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15162
15163	default:
15164		genericError := &smithy.GenericAPIError{
15165			Code:    errorCode,
15166			Message: errorMessage,
15167		}
15168		return genericError
15169
15170	}
15171}
15172
15173type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots struct {
15174}
15175
15176func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) ID() string {
15177	return "OperationDeserializer"
15178}
15179
15180func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15181	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15182) {
15183	out, metadata, err = next.HandleDeserialize(ctx, in)
15184	if err != nil {
15185		return out, metadata, err
15186	}
15187
15188	response, ok := out.RawResponse.(*smithyhttp.Response)
15189	if !ok {
15190		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15191	}
15192
15193	if response.StatusCode < 200 || response.StatusCode >= 300 {
15194		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response, &metadata)
15195	}
15196	output := &GetRelationalDatabaseSnapshotsOutput{}
15197	out.Result = output
15198
15199	var buff [1024]byte
15200	ringBuffer := smithyio.NewRingBuffer(buff[:])
15201
15202	body := io.TeeReader(response.Body, ringBuffer)
15203	decoder := json.NewDecoder(body)
15204	decoder.UseNumber()
15205	var shape interface{}
15206	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15207		var snapshot bytes.Buffer
15208		io.Copy(&snapshot, ringBuffer)
15209		err = &smithy.DeserializationError{
15210			Err:      fmt.Errorf("failed to decode response body, %w", err),
15211			Snapshot: snapshot.Bytes(),
15212		}
15213		return out, metadata, err
15214	}
15215
15216	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(&output, shape)
15217	if err != nil {
15218		var snapshot bytes.Buffer
15219		io.Copy(&snapshot, ringBuffer)
15220		err = &smithy.DeserializationError{
15221			Err:      fmt.Errorf("failed to decode response body, %w", err),
15222			Snapshot: snapshot.Bytes(),
15223		}
15224		return out, metadata, err
15225	}
15226
15227	return out, metadata, err
15228}
15229
15230func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15231	var errorBuffer bytes.Buffer
15232	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15233		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15234	}
15235	errorBody := bytes.NewReader(errorBuffer.Bytes())
15236
15237	errorCode := "UnknownError"
15238	errorMessage := errorCode
15239
15240	code := response.Header.Get("X-Amzn-ErrorType")
15241	if len(code) != 0 {
15242		errorCode = restjson.SanitizeErrorCode(code)
15243	}
15244
15245	var buff [1024]byte
15246	ringBuffer := smithyio.NewRingBuffer(buff[:])
15247
15248	body := io.TeeReader(errorBody, ringBuffer)
15249	decoder := json.NewDecoder(body)
15250	decoder.UseNumber()
15251	code, message, err := restjson.GetErrorInfo(decoder)
15252	if err != nil {
15253		var snapshot bytes.Buffer
15254		io.Copy(&snapshot, ringBuffer)
15255		err = &smithy.DeserializationError{
15256			Err:      fmt.Errorf("failed to decode response body, %w", err),
15257			Snapshot: snapshot.Bytes(),
15258		}
15259		return err
15260	}
15261
15262	errorBody.Seek(0, io.SeekStart)
15263	if len(code) != 0 {
15264		errorCode = restjson.SanitizeErrorCode(code)
15265	}
15266	if len(message) != 0 {
15267		errorMessage = message
15268	}
15269
15270	switch {
15271	case strings.EqualFold("AccessDeniedException", errorCode):
15272		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15273
15274	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15275		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15276
15277	case strings.EqualFold("InvalidInputException", errorCode):
15278		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15279
15280	case strings.EqualFold("NotFoundException", errorCode):
15281		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15282
15283	case strings.EqualFold("OperationFailureException", errorCode):
15284		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15285
15286	case strings.EqualFold("ServiceException", errorCode):
15287		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15288
15289	case strings.EqualFold("UnauthenticatedException", errorCode):
15290		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15291
15292	default:
15293		genericError := &smithy.GenericAPIError{
15294			Code:    errorCode,
15295			Message: errorMessage,
15296		}
15297		return genericError
15298
15299	}
15300}
15301
15302type awsAwsjson11_deserializeOpGetStaticIp struct {
15303}
15304
15305func (*awsAwsjson11_deserializeOpGetStaticIp) ID() string {
15306	return "OperationDeserializer"
15307}
15308
15309func (m *awsAwsjson11_deserializeOpGetStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15310	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15311) {
15312	out, metadata, err = next.HandleDeserialize(ctx, in)
15313	if err != nil {
15314		return out, metadata, err
15315	}
15316
15317	response, ok := out.RawResponse.(*smithyhttp.Response)
15318	if !ok {
15319		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15320	}
15321
15322	if response.StatusCode < 200 || response.StatusCode >= 300 {
15323		return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIp(response, &metadata)
15324	}
15325	output := &GetStaticIpOutput{}
15326	out.Result = output
15327
15328	var buff [1024]byte
15329	ringBuffer := smithyio.NewRingBuffer(buff[:])
15330
15331	body := io.TeeReader(response.Body, ringBuffer)
15332	decoder := json.NewDecoder(body)
15333	decoder.UseNumber()
15334	var shape interface{}
15335	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15336		var snapshot bytes.Buffer
15337		io.Copy(&snapshot, ringBuffer)
15338		err = &smithy.DeserializationError{
15339			Err:      fmt.Errorf("failed to decode response body, %w", err),
15340			Snapshot: snapshot.Bytes(),
15341		}
15342		return out, metadata, err
15343	}
15344
15345	err = awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(&output, shape)
15346	if err != nil {
15347		var snapshot bytes.Buffer
15348		io.Copy(&snapshot, ringBuffer)
15349		err = &smithy.DeserializationError{
15350			Err:      fmt.Errorf("failed to decode response body, %w", err),
15351			Snapshot: snapshot.Bytes(),
15352		}
15353		return out, metadata, err
15354	}
15355
15356	return out, metadata, err
15357}
15358
15359func awsAwsjson11_deserializeOpErrorGetStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15360	var errorBuffer bytes.Buffer
15361	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15362		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15363	}
15364	errorBody := bytes.NewReader(errorBuffer.Bytes())
15365
15366	errorCode := "UnknownError"
15367	errorMessage := errorCode
15368
15369	code := response.Header.Get("X-Amzn-ErrorType")
15370	if len(code) != 0 {
15371		errorCode = restjson.SanitizeErrorCode(code)
15372	}
15373
15374	var buff [1024]byte
15375	ringBuffer := smithyio.NewRingBuffer(buff[:])
15376
15377	body := io.TeeReader(errorBody, ringBuffer)
15378	decoder := json.NewDecoder(body)
15379	decoder.UseNumber()
15380	code, message, err := restjson.GetErrorInfo(decoder)
15381	if err != nil {
15382		var snapshot bytes.Buffer
15383		io.Copy(&snapshot, ringBuffer)
15384		err = &smithy.DeserializationError{
15385			Err:      fmt.Errorf("failed to decode response body, %w", err),
15386			Snapshot: snapshot.Bytes(),
15387		}
15388		return err
15389	}
15390
15391	errorBody.Seek(0, io.SeekStart)
15392	if len(code) != 0 {
15393		errorCode = restjson.SanitizeErrorCode(code)
15394	}
15395	if len(message) != 0 {
15396		errorMessage = message
15397	}
15398
15399	switch {
15400	case strings.EqualFold("AccessDeniedException", errorCode):
15401		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15402
15403	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15404		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15405
15406	case strings.EqualFold("InvalidInputException", errorCode):
15407		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15408
15409	case strings.EqualFold("NotFoundException", errorCode):
15410		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15411
15412	case strings.EqualFold("OperationFailureException", errorCode):
15413		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15414
15415	case strings.EqualFold("ServiceException", errorCode):
15416		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15417
15418	case strings.EqualFold("UnauthenticatedException", errorCode):
15419		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15420
15421	default:
15422		genericError := &smithy.GenericAPIError{
15423			Code:    errorCode,
15424			Message: errorMessage,
15425		}
15426		return genericError
15427
15428	}
15429}
15430
15431type awsAwsjson11_deserializeOpGetStaticIps struct {
15432}
15433
15434func (*awsAwsjson11_deserializeOpGetStaticIps) ID() string {
15435	return "OperationDeserializer"
15436}
15437
15438func (m *awsAwsjson11_deserializeOpGetStaticIps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15439	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15440) {
15441	out, metadata, err = next.HandleDeserialize(ctx, in)
15442	if err != nil {
15443		return out, metadata, err
15444	}
15445
15446	response, ok := out.RawResponse.(*smithyhttp.Response)
15447	if !ok {
15448		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15449	}
15450
15451	if response.StatusCode < 200 || response.StatusCode >= 300 {
15452		return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIps(response, &metadata)
15453	}
15454	output := &GetStaticIpsOutput{}
15455	out.Result = output
15456
15457	var buff [1024]byte
15458	ringBuffer := smithyio.NewRingBuffer(buff[:])
15459
15460	body := io.TeeReader(response.Body, ringBuffer)
15461	decoder := json.NewDecoder(body)
15462	decoder.UseNumber()
15463	var shape interface{}
15464	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15465		var snapshot bytes.Buffer
15466		io.Copy(&snapshot, ringBuffer)
15467		err = &smithy.DeserializationError{
15468			Err:      fmt.Errorf("failed to decode response body, %w", err),
15469			Snapshot: snapshot.Bytes(),
15470		}
15471		return out, metadata, err
15472	}
15473
15474	err = awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(&output, shape)
15475	if err != nil {
15476		var snapshot bytes.Buffer
15477		io.Copy(&snapshot, ringBuffer)
15478		err = &smithy.DeserializationError{
15479			Err:      fmt.Errorf("failed to decode response body, %w", err),
15480			Snapshot: snapshot.Bytes(),
15481		}
15482		return out, metadata, err
15483	}
15484
15485	return out, metadata, err
15486}
15487
15488func awsAwsjson11_deserializeOpErrorGetStaticIps(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15489	var errorBuffer bytes.Buffer
15490	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15491		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15492	}
15493	errorBody := bytes.NewReader(errorBuffer.Bytes())
15494
15495	errorCode := "UnknownError"
15496	errorMessage := errorCode
15497
15498	code := response.Header.Get("X-Amzn-ErrorType")
15499	if len(code) != 0 {
15500		errorCode = restjson.SanitizeErrorCode(code)
15501	}
15502
15503	var buff [1024]byte
15504	ringBuffer := smithyio.NewRingBuffer(buff[:])
15505
15506	body := io.TeeReader(errorBody, ringBuffer)
15507	decoder := json.NewDecoder(body)
15508	decoder.UseNumber()
15509	code, message, err := restjson.GetErrorInfo(decoder)
15510	if err != nil {
15511		var snapshot bytes.Buffer
15512		io.Copy(&snapshot, ringBuffer)
15513		err = &smithy.DeserializationError{
15514			Err:      fmt.Errorf("failed to decode response body, %w", err),
15515			Snapshot: snapshot.Bytes(),
15516		}
15517		return err
15518	}
15519
15520	errorBody.Seek(0, io.SeekStart)
15521	if len(code) != 0 {
15522		errorCode = restjson.SanitizeErrorCode(code)
15523	}
15524	if len(message) != 0 {
15525		errorMessage = message
15526	}
15527
15528	switch {
15529	case strings.EqualFold("AccessDeniedException", errorCode):
15530		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15531
15532	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15533		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15534
15535	case strings.EqualFold("InvalidInputException", errorCode):
15536		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15537
15538	case strings.EqualFold("NotFoundException", errorCode):
15539		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15540
15541	case strings.EqualFold("OperationFailureException", errorCode):
15542		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15543
15544	case strings.EqualFold("ServiceException", errorCode):
15545		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15546
15547	case strings.EqualFold("UnauthenticatedException", errorCode):
15548		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15549
15550	default:
15551		genericError := &smithy.GenericAPIError{
15552			Code:    errorCode,
15553			Message: errorMessage,
15554		}
15555		return genericError
15556
15557	}
15558}
15559
15560type awsAwsjson11_deserializeOpImportKeyPair struct {
15561}
15562
15563func (*awsAwsjson11_deserializeOpImportKeyPair) ID() string {
15564	return "OperationDeserializer"
15565}
15566
15567func (m *awsAwsjson11_deserializeOpImportKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15568	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15569) {
15570	out, metadata, err = next.HandleDeserialize(ctx, in)
15571	if err != nil {
15572		return out, metadata, err
15573	}
15574
15575	response, ok := out.RawResponse.(*smithyhttp.Response)
15576	if !ok {
15577		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15578	}
15579
15580	if response.StatusCode < 200 || response.StatusCode >= 300 {
15581		return out, metadata, awsAwsjson11_deserializeOpErrorImportKeyPair(response, &metadata)
15582	}
15583	output := &ImportKeyPairOutput{}
15584	out.Result = output
15585
15586	var buff [1024]byte
15587	ringBuffer := smithyio.NewRingBuffer(buff[:])
15588
15589	body := io.TeeReader(response.Body, ringBuffer)
15590	decoder := json.NewDecoder(body)
15591	decoder.UseNumber()
15592	var shape interface{}
15593	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15594		var snapshot bytes.Buffer
15595		io.Copy(&snapshot, ringBuffer)
15596		err = &smithy.DeserializationError{
15597			Err:      fmt.Errorf("failed to decode response body, %w", err),
15598			Snapshot: snapshot.Bytes(),
15599		}
15600		return out, metadata, err
15601	}
15602
15603	err = awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(&output, shape)
15604	if err != nil {
15605		var snapshot bytes.Buffer
15606		io.Copy(&snapshot, ringBuffer)
15607		err = &smithy.DeserializationError{
15608			Err:      fmt.Errorf("failed to decode response body, %w", err),
15609			Snapshot: snapshot.Bytes(),
15610		}
15611		return out, metadata, err
15612	}
15613
15614	return out, metadata, err
15615}
15616
15617func awsAwsjson11_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15618	var errorBuffer bytes.Buffer
15619	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15620		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15621	}
15622	errorBody := bytes.NewReader(errorBuffer.Bytes())
15623
15624	errorCode := "UnknownError"
15625	errorMessage := errorCode
15626
15627	code := response.Header.Get("X-Amzn-ErrorType")
15628	if len(code) != 0 {
15629		errorCode = restjson.SanitizeErrorCode(code)
15630	}
15631
15632	var buff [1024]byte
15633	ringBuffer := smithyio.NewRingBuffer(buff[:])
15634
15635	body := io.TeeReader(errorBody, ringBuffer)
15636	decoder := json.NewDecoder(body)
15637	decoder.UseNumber()
15638	code, message, err := restjson.GetErrorInfo(decoder)
15639	if err != nil {
15640		var snapshot bytes.Buffer
15641		io.Copy(&snapshot, ringBuffer)
15642		err = &smithy.DeserializationError{
15643			Err:      fmt.Errorf("failed to decode response body, %w", err),
15644			Snapshot: snapshot.Bytes(),
15645		}
15646		return err
15647	}
15648
15649	errorBody.Seek(0, io.SeekStart)
15650	if len(code) != 0 {
15651		errorCode = restjson.SanitizeErrorCode(code)
15652	}
15653	if len(message) != 0 {
15654		errorMessage = message
15655	}
15656
15657	switch {
15658	case strings.EqualFold("AccessDeniedException", errorCode):
15659		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15660
15661	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15662		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15663
15664	case strings.EqualFold("InvalidInputException", errorCode):
15665		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15666
15667	case strings.EqualFold("NotFoundException", errorCode):
15668		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15669
15670	case strings.EqualFold("OperationFailureException", errorCode):
15671		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15672
15673	case strings.EqualFold("ServiceException", errorCode):
15674		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15675
15676	case strings.EqualFold("UnauthenticatedException", errorCode):
15677		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15678
15679	default:
15680		genericError := &smithy.GenericAPIError{
15681			Code:    errorCode,
15682			Message: errorMessage,
15683		}
15684		return genericError
15685
15686	}
15687}
15688
15689type awsAwsjson11_deserializeOpIsVpcPeered struct {
15690}
15691
15692func (*awsAwsjson11_deserializeOpIsVpcPeered) ID() string {
15693	return "OperationDeserializer"
15694}
15695
15696func (m *awsAwsjson11_deserializeOpIsVpcPeered) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15697	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15698) {
15699	out, metadata, err = next.HandleDeserialize(ctx, in)
15700	if err != nil {
15701		return out, metadata, err
15702	}
15703
15704	response, ok := out.RawResponse.(*smithyhttp.Response)
15705	if !ok {
15706		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15707	}
15708
15709	if response.StatusCode < 200 || response.StatusCode >= 300 {
15710		return out, metadata, awsAwsjson11_deserializeOpErrorIsVpcPeered(response, &metadata)
15711	}
15712	output := &IsVpcPeeredOutput{}
15713	out.Result = output
15714
15715	var buff [1024]byte
15716	ringBuffer := smithyio.NewRingBuffer(buff[:])
15717
15718	body := io.TeeReader(response.Body, ringBuffer)
15719	decoder := json.NewDecoder(body)
15720	decoder.UseNumber()
15721	var shape interface{}
15722	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15723		var snapshot bytes.Buffer
15724		io.Copy(&snapshot, ringBuffer)
15725		err = &smithy.DeserializationError{
15726			Err:      fmt.Errorf("failed to decode response body, %w", err),
15727			Snapshot: snapshot.Bytes(),
15728		}
15729		return out, metadata, err
15730	}
15731
15732	err = awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(&output, shape)
15733	if err != nil {
15734		var snapshot bytes.Buffer
15735		io.Copy(&snapshot, ringBuffer)
15736		err = &smithy.DeserializationError{
15737			Err:      fmt.Errorf("failed to decode response body, %w", err),
15738			Snapshot: snapshot.Bytes(),
15739		}
15740		return out, metadata, err
15741	}
15742
15743	return out, metadata, err
15744}
15745
15746func awsAwsjson11_deserializeOpErrorIsVpcPeered(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15747	var errorBuffer bytes.Buffer
15748	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15749		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15750	}
15751	errorBody := bytes.NewReader(errorBuffer.Bytes())
15752
15753	errorCode := "UnknownError"
15754	errorMessage := errorCode
15755
15756	code := response.Header.Get("X-Amzn-ErrorType")
15757	if len(code) != 0 {
15758		errorCode = restjson.SanitizeErrorCode(code)
15759	}
15760
15761	var buff [1024]byte
15762	ringBuffer := smithyio.NewRingBuffer(buff[:])
15763
15764	body := io.TeeReader(errorBody, ringBuffer)
15765	decoder := json.NewDecoder(body)
15766	decoder.UseNumber()
15767	code, message, err := restjson.GetErrorInfo(decoder)
15768	if err != nil {
15769		var snapshot bytes.Buffer
15770		io.Copy(&snapshot, ringBuffer)
15771		err = &smithy.DeserializationError{
15772			Err:      fmt.Errorf("failed to decode response body, %w", err),
15773			Snapshot: snapshot.Bytes(),
15774		}
15775		return err
15776	}
15777
15778	errorBody.Seek(0, io.SeekStart)
15779	if len(code) != 0 {
15780		errorCode = restjson.SanitizeErrorCode(code)
15781	}
15782	if len(message) != 0 {
15783		errorMessage = message
15784	}
15785
15786	switch {
15787	case strings.EqualFold("AccessDeniedException", errorCode):
15788		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15789
15790	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15791		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15792
15793	case strings.EqualFold("InvalidInputException", errorCode):
15794		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15795
15796	case strings.EqualFold("NotFoundException", errorCode):
15797		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15798
15799	case strings.EqualFold("OperationFailureException", errorCode):
15800		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15801
15802	case strings.EqualFold("ServiceException", errorCode):
15803		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15804
15805	case strings.EqualFold("UnauthenticatedException", errorCode):
15806		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15807
15808	default:
15809		genericError := &smithy.GenericAPIError{
15810			Code:    errorCode,
15811			Message: errorMessage,
15812		}
15813		return genericError
15814
15815	}
15816}
15817
15818type awsAwsjson11_deserializeOpOpenInstancePublicPorts struct {
15819}
15820
15821func (*awsAwsjson11_deserializeOpOpenInstancePublicPorts) ID() string {
15822	return "OperationDeserializer"
15823}
15824
15825func (m *awsAwsjson11_deserializeOpOpenInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15826	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15827) {
15828	out, metadata, err = next.HandleDeserialize(ctx, in)
15829	if err != nil {
15830		return out, metadata, err
15831	}
15832
15833	response, ok := out.RawResponse.(*smithyhttp.Response)
15834	if !ok {
15835		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15836	}
15837
15838	if response.StatusCode < 200 || response.StatusCode >= 300 {
15839		return out, metadata, awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response, &metadata)
15840	}
15841	output := &OpenInstancePublicPortsOutput{}
15842	out.Result = output
15843
15844	var buff [1024]byte
15845	ringBuffer := smithyio.NewRingBuffer(buff[:])
15846
15847	body := io.TeeReader(response.Body, ringBuffer)
15848	decoder := json.NewDecoder(body)
15849	decoder.UseNumber()
15850	var shape interface{}
15851	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15852		var snapshot bytes.Buffer
15853		io.Copy(&snapshot, ringBuffer)
15854		err = &smithy.DeserializationError{
15855			Err:      fmt.Errorf("failed to decode response body, %w", err),
15856			Snapshot: snapshot.Bytes(),
15857		}
15858		return out, metadata, err
15859	}
15860
15861	err = awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(&output, shape)
15862	if err != nil {
15863		var snapshot bytes.Buffer
15864		io.Copy(&snapshot, ringBuffer)
15865		err = &smithy.DeserializationError{
15866			Err:      fmt.Errorf("failed to decode response body, %w", err),
15867			Snapshot: snapshot.Bytes(),
15868		}
15869		return out, metadata, err
15870	}
15871
15872	return out, metadata, err
15873}
15874
15875func awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15876	var errorBuffer bytes.Buffer
15877	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15878		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15879	}
15880	errorBody := bytes.NewReader(errorBuffer.Bytes())
15881
15882	errorCode := "UnknownError"
15883	errorMessage := errorCode
15884
15885	code := response.Header.Get("X-Amzn-ErrorType")
15886	if len(code) != 0 {
15887		errorCode = restjson.SanitizeErrorCode(code)
15888	}
15889
15890	var buff [1024]byte
15891	ringBuffer := smithyio.NewRingBuffer(buff[:])
15892
15893	body := io.TeeReader(errorBody, ringBuffer)
15894	decoder := json.NewDecoder(body)
15895	decoder.UseNumber()
15896	code, message, err := restjson.GetErrorInfo(decoder)
15897	if err != nil {
15898		var snapshot bytes.Buffer
15899		io.Copy(&snapshot, ringBuffer)
15900		err = &smithy.DeserializationError{
15901			Err:      fmt.Errorf("failed to decode response body, %w", err),
15902			Snapshot: snapshot.Bytes(),
15903		}
15904		return err
15905	}
15906
15907	errorBody.Seek(0, io.SeekStart)
15908	if len(code) != 0 {
15909		errorCode = restjson.SanitizeErrorCode(code)
15910	}
15911	if len(message) != 0 {
15912		errorMessage = message
15913	}
15914
15915	switch {
15916	case strings.EqualFold("AccessDeniedException", errorCode):
15917		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15918
15919	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15920		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15921
15922	case strings.EqualFold("InvalidInputException", errorCode):
15923		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15924
15925	case strings.EqualFold("NotFoundException", errorCode):
15926		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15927
15928	case strings.EqualFold("OperationFailureException", errorCode):
15929		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15930
15931	case strings.EqualFold("ServiceException", errorCode):
15932		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15933
15934	case strings.EqualFold("UnauthenticatedException", errorCode):
15935		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15936
15937	default:
15938		genericError := &smithy.GenericAPIError{
15939			Code:    errorCode,
15940			Message: errorMessage,
15941		}
15942		return genericError
15943
15944	}
15945}
15946
15947type awsAwsjson11_deserializeOpPeerVpc struct {
15948}
15949
15950func (*awsAwsjson11_deserializeOpPeerVpc) ID() string {
15951	return "OperationDeserializer"
15952}
15953
15954func (m *awsAwsjson11_deserializeOpPeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15955	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15956) {
15957	out, metadata, err = next.HandleDeserialize(ctx, in)
15958	if err != nil {
15959		return out, metadata, err
15960	}
15961
15962	response, ok := out.RawResponse.(*smithyhttp.Response)
15963	if !ok {
15964		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15965	}
15966
15967	if response.StatusCode < 200 || response.StatusCode >= 300 {
15968		return out, metadata, awsAwsjson11_deserializeOpErrorPeerVpc(response, &metadata)
15969	}
15970	output := &PeerVpcOutput{}
15971	out.Result = output
15972
15973	var buff [1024]byte
15974	ringBuffer := smithyio.NewRingBuffer(buff[:])
15975
15976	body := io.TeeReader(response.Body, ringBuffer)
15977	decoder := json.NewDecoder(body)
15978	decoder.UseNumber()
15979	var shape interface{}
15980	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15981		var snapshot bytes.Buffer
15982		io.Copy(&snapshot, ringBuffer)
15983		err = &smithy.DeserializationError{
15984			Err:      fmt.Errorf("failed to decode response body, %w", err),
15985			Snapshot: snapshot.Bytes(),
15986		}
15987		return out, metadata, err
15988	}
15989
15990	err = awsAwsjson11_deserializeOpDocumentPeerVpcOutput(&output, shape)
15991	if err != nil {
15992		var snapshot bytes.Buffer
15993		io.Copy(&snapshot, ringBuffer)
15994		err = &smithy.DeserializationError{
15995			Err:      fmt.Errorf("failed to decode response body, %w", err),
15996			Snapshot: snapshot.Bytes(),
15997		}
15998		return out, metadata, err
15999	}
16000
16001	return out, metadata, err
16002}
16003
16004func awsAwsjson11_deserializeOpErrorPeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16005	var errorBuffer bytes.Buffer
16006	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16007		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16008	}
16009	errorBody := bytes.NewReader(errorBuffer.Bytes())
16010
16011	errorCode := "UnknownError"
16012	errorMessage := errorCode
16013
16014	code := response.Header.Get("X-Amzn-ErrorType")
16015	if len(code) != 0 {
16016		errorCode = restjson.SanitizeErrorCode(code)
16017	}
16018
16019	var buff [1024]byte
16020	ringBuffer := smithyio.NewRingBuffer(buff[:])
16021
16022	body := io.TeeReader(errorBody, ringBuffer)
16023	decoder := json.NewDecoder(body)
16024	decoder.UseNumber()
16025	code, message, err := restjson.GetErrorInfo(decoder)
16026	if err != nil {
16027		var snapshot bytes.Buffer
16028		io.Copy(&snapshot, ringBuffer)
16029		err = &smithy.DeserializationError{
16030			Err:      fmt.Errorf("failed to decode response body, %w", err),
16031			Snapshot: snapshot.Bytes(),
16032		}
16033		return err
16034	}
16035
16036	errorBody.Seek(0, io.SeekStart)
16037	if len(code) != 0 {
16038		errorCode = restjson.SanitizeErrorCode(code)
16039	}
16040	if len(message) != 0 {
16041		errorMessage = message
16042	}
16043
16044	switch {
16045	case strings.EqualFold("AccessDeniedException", errorCode):
16046		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16047
16048	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16049		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16050
16051	case strings.EqualFold("InvalidInputException", errorCode):
16052		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16053
16054	case strings.EqualFold("NotFoundException", errorCode):
16055		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16056
16057	case strings.EqualFold("OperationFailureException", errorCode):
16058		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16059
16060	case strings.EqualFold("ServiceException", errorCode):
16061		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16062
16063	case strings.EqualFold("UnauthenticatedException", errorCode):
16064		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16065
16066	default:
16067		genericError := &smithy.GenericAPIError{
16068			Code:    errorCode,
16069			Message: errorMessage,
16070		}
16071		return genericError
16072
16073	}
16074}
16075
16076type awsAwsjson11_deserializeOpPutAlarm struct {
16077}
16078
16079func (*awsAwsjson11_deserializeOpPutAlarm) ID() string {
16080	return "OperationDeserializer"
16081}
16082
16083func (m *awsAwsjson11_deserializeOpPutAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16084	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16085) {
16086	out, metadata, err = next.HandleDeserialize(ctx, in)
16087	if err != nil {
16088		return out, metadata, err
16089	}
16090
16091	response, ok := out.RawResponse.(*smithyhttp.Response)
16092	if !ok {
16093		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16094	}
16095
16096	if response.StatusCode < 200 || response.StatusCode >= 300 {
16097		return out, metadata, awsAwsjson11_deserializeOpErrorPutAlarm(response, &metadata)
16098	}
16099	output := &PutAlarmOutput{}
16100	out.Result = output
16101
16102	var buff [1024]byte
16103	ringBuffer := smithyio.NewRingBuffer(buff[:])
16104
16105	body := io.TeeReader(response.Body, ringBuffer)
16106	decoder := json.NewDecoder(body)
16107	decoder.UseNumber()
16108	var shape interface{}
16109	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16110		var snapshot bytes.Buffer
16111		io.Copy(&snapshot, ringBuffer)
16112		err = &smithy.DeserializationError{
16113			Err:      fmt.Errorf("failed to decode response body, %w", err),
16114			Snapshot: snapshot.Bytes(),
16115		}
16116		return out, metadata, err
16117	}
16118
16119	err = awsAwsjson11_deserializeOpDocumentPutAlarmOutput(&output, shape)
16120	if err != nil {
16121		var snapshot bytes.Buffer
16122		io.Copy(&snapshot, ringBuffer)
16123		err = &smithy.DeserializationError{
16124			Err:      fmt.Errorf("failed to decode response body, %w", err),
16125			Snapshot: snapshot.Bytes(),
16126		}
16127		return out, metadata, err
16128	}
16129
16130	return out, metadata, err
16131}
16132
16133func awsAwsjson11_deserializeOpErrorPutAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16134	var errorBuffer bytes.Buffer
16135	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16136		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16137	}
16138	errorBody := bytes.NewReader(errorBuffer.Bytes())
16139
16140	errorCode := "UnknownError"
16141	errorMessage := errorCode
16142
16143	code := response.Header.Get("X-Amzn-ErrorType")
16144	if len(code) != 0 {
16145		errorCode = restjson.SanitizeErrorCode(code)
16146	}
16147
16148	var buff [1024]byte
16149	ringBuffer := smithyio.NewRingBuffer(buff[:])
16150
16151	body := io.TeeReader(errorBody, ringBuffer)
16152	decoder := json.NewDecoder(body)
16153	decoder.UseNumber()
16154	code, message, err := restjson.GetErrorInfo(decoder)
16155	if err != nil {
16156		var snapshot bytes.Buffer
16157		io.Copy(&snapshot, ringBuffer)
16158		err = &smithy.DeserializationError{
16159			Err:      fmt.Errorf("failed to decode response body, %w", err),
16160			Snapshot: snapshot.Bytes(),
16161		}
16162		return err
16163	}
16164
16165	errorBody.Seek(0, io.SeekStart)
16166	if len(code) != 0 {
16167		errorCode = restjson.SanitizeErrorCode(code)
16168	}
16169	if len(message) != 0 {
16170		errorMessage = message
16171	}
16172
16173	switch {
16174	case strings.EqualFold("AccessDeniedException", errorCode):
16175		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16176
16177	case strings.EqualFold("InvalidInputException", errorCode):
16178		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16179
16180	case strings.EqualFold("NotFoundException", errorCode):
16181		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16182
16183	case strings.EqualFold("OperationFailureException", errorCode):
16184		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16185
16186	case strings.EqualFold("ServiceException", errorCode):
16187		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16188
16189	case strings.EqualFold("UnauthenticatedException", errorCode):
16190		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16191
16192	default:
16193		genericError := &smithy.GenericAPIError{
16194			Code:    errorCode,
16195			Message: errorMessage,
16196		}
16197		return genericError
16198
16199	}
16200}
16201
16202type awsAwsjson11_deserializeOpPutInstancePublicPorts struct {
16203}
16204
16205func (*awsAwsjson11_deserializeOpPutInstancePublicPorts) ID() string {
16206	return "OperationDeserializer"
16207}
16208
16209func (m *awsAwsjson11_deserializeOpPutInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16210	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16211) {
16212	out, metadata, err = next.HandleDeserialize(ctx, in)
16213	if err != nil {
16214		return out, metadata, err
16215	}
16216
16217	response, ok := out.RawResponse.(*smithyhttp.Response)
16218	if !ok {
16219		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16220	}
16221
16222	if response.StatusCode < 200 || response.StatusCode >= 300 {
16223		return out, metadata, awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response, &metadata)
16224	}
16225	output := &PutInstancePublicPortsOutput{}
16226	out.Result = output
16227
16228	var buff [1024]byte
16229	ringBuffer := smithyio.NewRingBuffer(buff[:])
16230
16231	body := io.TeeReader(response.Body, ringBuffer)
16232	decoder := json.NewDecoder(body)
16233	decoder.UseNumber()
16234	var shape interface{}
16235	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16236		var snapshot bytes.Buffer
16237		io.Copy(&snapshot, ringBuffer)
16238		err = &smithy.DeserializationError{
16239			Err:      fmt.Errorf("failed to decode response body, %w", err),
16240			Snapshot: snapshot.Bytes(),
16241		}
16242		return out, metadata, err
16243	}
16244
16245	err = awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(&output, shape)
16246	if err != nil {
16247		var snapshot bytes.Buffer
16248		io.Copy(&snapshot, ringBuffer)
16249		err = &smithy.DeserializationError{
16250			Err:      fmt.Errorf("failed to decode response body, %w", err),
16251			Snapshot: snapshot.Bytes(),
16252		}
16253		return out, metadata, err
16254	}
16255
16256	return out, metadata, err
16257}
16258
16259func awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16260	var errorBuffer bytes.Buffer
16261	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16262		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16263	}
16264	errorBody := bytes.NewReader(errorBuffer.Bytes())
16265
16266	errorCode := "UnknownError"
16267	errorMessage := errorCode
16268
16269	code := response.Header.Get("X-Amzn-ErrorType")
16270	if len(code) != 0 {
16271		errorCode = restjson.SanitizeErrorCode(code)
16272	}
16273
16274	var buff [1024]byte
16275	ringBuffer := smithyio.NewRingBuffer(buff[:])
16276
16277	body := io.TeeReader(errorBody, ringBuffer)
16278	decoder := json.NewDecoder(body)
16279	decoder.UseNumber()
16280	code, message, err := restjson.GetErrorInfo(decoder)
16281	if err != nil {
16282		var snapshot bytes.Buffer
16283		io.Copy(&snapshot, ringBuffer)
16284		err = &smithy.DeserializationError{
16285			Err:      fmt.Errorf("failed to decode response body, %w", err),
16286			Snapshot: snapshot.Bytes(),
16287		}
16288		return err
16289	}
16290
16291	errorBody.Seek(0, io.SeekStart)
16292	if len(code) != 0 {
16293		errorCode = restjson.SanitizeErrorCode(code)
16294	}
16295	if len(message) != 0 {
16296		errorMessage = message
16297	}
16298
16299	switch {
16300	case strings.EqualFold("AccessDeniedException", errorCode):
16301		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16302
16303	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16304		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16305
16306	case strings.EqualFold("InvalidInputException", errorCode):
16307		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16308
16309	case strings.EqualFold("NotFoundException", errorCode):
16310		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16311
16312	case strings.EqualFold("OperationFailureException", errorCode):
16313		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16314
16315	case strings.EqualFold("ServiceException", errorCode):
16316		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16317
16318	case strings.EqualFold("UnauthenticatedException", errorCode):
16319		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16320
16321	default:
16322		genericError := &smithy.GenericAPIError{
16323			Code:    errorCode,
16324			Message: errorMessage,
16325		}
16326		return genericError
16327
16328	}
16329}
16330
16331type awsAwsjson11_deserializeOpRebootInstance struct {
16332}
16333
16334func (*awsAwsjson11_deserializeOpRebootInstance) ID() string {
16335	return "OperationDeserializer"
16336}
16337
16338func (m *awsAwsjson11_deserializeOpRebootInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16339	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16340) {
16341	out, metadata, err = next.HandleDeserialize(ctx, in)
16342	if err != nil {
16343		return out, metadata, err
16344	}
16345
16346	response, ok := out.RawResponse.(*smithyhttp.Response)
16347	if !ok {
16348		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16349	}
16350
16351	if response.StatusCode < 200 || response.StatusCode >= 300 {
16352		return out, metadata, awsAwsjson11_deserializeOpErrorRebootInstance(response, &metadata)
16353	}
16354	output := &RebootInstanceOutput{}
16355	out.Result = output
16356
16357	var buff [1024]byte
16358	ringBuffer := smithyio.NewRingBuffer(buff[:])
16359
16360	body := io.TeeReader(response.Body, ringBuffer)
16361	decoder := json.NewDecoder(body)
16362	decoder.UseNumber()
16363	var shape interface{}
16364	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16365		var snapshot bytes.Buffer
16366		io.Copy(&snapshot, ringBuffer)
16367		err = &smithy.DeserializationError{
16368			Err:      fmt.Errorf("failed to decode response body, %w", err),
16369			Snapshot: snapshot.Bytes(),
16370		}
16371		return out, metadata, err
16372	}
16373
16374	err = awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(&output, shape)
16375	if err != nil {
16376		var snapshot bytes.Buffer
16377		io.Copy(&snapshot, ringBuffer)
16378		err = &smithy.DeserializationError{
16379			Err:      fmt.Errorf("failed to decode response body, %w", err),
16380			Snapshot: snapshot.Bytes(),
16381		}
16382		return out, metadata, err
16383	}
16384
16385	return out, metadata, err
16386}
16387
16388func awsAwsjson11_deserializeOpErrorRebootInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16389	var errorBuffer bytes.Buffer
16390	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16391		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16392	}
16393	errorBody := bytes.NewReader(errorBuffer.Bytes())
16394
16395	errorCode := "UnknownError"
16396	errorMessage := errorCode
16397
16398	code := response.Header.Get("X-Amzn-ErrorType")
16399	if len(code) != 0 {
16400		errorCode = restjson.SanitizeErrorCode(code)
16401	}
16402
16403	var buff [1024]byte
16404	ringBuffer := smithyio.NewRingBuffer(buff[:])
16405
16406	body := io.TeeReader(errorBody, ringBuffer)
16407	decoder := json.NewDecoder(body)
16408	decoder.UseNumber()
16409	code, message, err := restjson.GetErrorInfo(decoder)
16410	if err != nil {
16411		var snapshot bytes.Buffer
16412		io.Copy(&snapshot, ringBuffer)
16413		err = &smithy.DeserializationError{
16414			Err:      fmt.Errorf("failed to decode response body, %w", err),
16415			Snapshot: snapshot.Bytes(),
16416		}
16417		return err
16418	}
16419
16420	errorBody.Seek(0, io.SeekStart)
16421	if len(code) != 0 {
16422		errorCode = restjson.SanitizeErrorCode(code)
16423	}
16424	if len(message) != 0 {
16425		errorMessage = message
16426	}
16427
16428	switch {
16429	case strings.EqualFold("AccessDeniedException", errorCode):
16430		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16431
16432	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16433		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16434
16435	case strings.EqualFold("InvalidInputException", errorCode):
16436		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16437
16438	case strings.EqualFold("NotFoundException", errorCode):
16439		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16440
16441	case strings.EqualFold("OperationFailureException", errorCode):
16442		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16443
16444	case strings.EqualFold("ServiceException", errorCode):
16445		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16446
16447	case strings.EqualFold("UnauthenticatedException", errorCode):
16448		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16449
16450	default:
16451		genericError := &smithy.GenericAPIError{
16452			Code:    errorCode,
16453			Message: errorMessage,
16454		}
16455		return genericError
16456
16457	}
16458}
16459
16460type awsAwsjson11_deserializeOpRebootRelationalDatabase struct {
16461}
16462
16463func (*awsAwsjson11_deserializeOpRebootRelationalDatabase) ID() string {
16464	return "OperationDeserializer"
16465}
16466
16467func (m *awsAwsjson11_deserializeOpRebootRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16468	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16469) {
16470	out, metadata, err = next.HandleDeserialize(ctx, in)
16471	if err != nil {
16472		return out, metadata, err
16473	}
16474
16475	response, ok := out.RawResponse.(*smithyhttp.Response)
16476	if !ok {
16477		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16478	}
16479
16480	if response.StatusCode < 200 || response.StatusCode >= 300 {
16481		return out, metadata, awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response, &metadata)
16482	}
16483	output := &RebootRelationalDatabaseOutput{}
16484	out.Result = output
16485
16486	var buff [1024]byte
16487	ringBuffer := smithyio.NewRingBuffer(buff[:])
16488
16489	body := io.TeeReader(response.Body, ringBuffer)
16490	decoder := json.NewDecoder(body)
16491	decoder.UseNumber()
16492	var shape interface{}
16493	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16494		var snapshot bytes.Buffer
16495		io.Copy(&snapshot, ringBuffer)
16496		err = &smithy.DeserializationError{
16497			Err:      fmt.Errorf("failed to decode response body, %w", err),
16498			Snapshot: snapshot.Bytes(),
16499		}
16500		return out, metadata, err
16501	}
16502
16503	err = awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(&output, shape)
16504	if err != nil {
16505		var snapshot bytes.Buffer
16506		io.Copy(&snapshot, ringBuffer)
16507		err = &smithy.DeserializationError{
16508			Err:      fmt.Errorf("failed to decode response body, %w", err),
16509			Snapshot: snapshot.Bytes(),
16510		}
16511		return out, metadata, err
16512	}
16513
16514	return out, metadata, err
16515}
16516
16517func awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16518	var errorBuffer bytes.Buffer
16519	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16520		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16521	}
16522	errorBody := bytes.NewReader(errorBuffer.Bytes())
16523
16524	errorCode := "UnknownError"
16525	errorMessage := errorCode
16526
16527	code := response.Header.Get("X-Amzn-ErrorType")
16528	if len(code) != 0 {
16529		errorCode = restjson.SanitizeErrorCode(code)
16530	}
16531
16532	var buff [1024]byte
16533	ringBuffer := smithyio.NewRingBuffer(buff[:])
16534
16535	body := io.TeeReader(errorBody, ringBuffer)
16536	decoder := json.NewDecoder(body)
16537	decoder.UseNumber()
16538	code, message, err := restjson.GetErrorInfo(decoder)
16539	if err != nil {
16540		var snapshot bytes.Buffer
16541		io.Copy(&snapshot, ringBuffer)
16542		err = &smithy.DeserializationError{
16543			Err:      fmt.Errorf("failed to decode response body, %w", err),
16544			Snapshot: snapshot.Bytes(),
16545		}
16546		return err
16547	}
16548
16549	errorBody.Seek(0, io.SeekStart)
16550	if len(code) != 0 {
16551		errorCode = restjson.SanitizeErrorCode(code)
16552	}
16553	if len(message) != 0 {
16554		errorMessage = message
16555	}
16556
16557	switch {
16558	case strings.EqualFold("AccessDeniedException", errorCode):
16559		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16560
16561	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16562		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16563
16564	case strings.EqualFold("InvalidInputException", errorCode):
16565		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16566
16567	case strings.EqualFold("NotFoundException", errorCode):
16568		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16569
16570	case strings.EqualFold("OperationFailureException", errorCode):
16571		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16572
16573	case strings.EqualFold("ServiceException", errorCode):
16574		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16575
16576	case strings.EqualFold("UnauthenticatedException", errorCode):
16577		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16578
16579	default:
16580		genericError := &smithy.GenericAPIError{
16581			Code:    errorCode,
16582			Message: errorMessage,
16583		}
16584		return genericError
16585
16586	}
16587}
16588
16589type awsAwsjson11_deserializeOpRegisterContainerImage struct {
16590}
16591
16592func (*awsAwsjson11_deserializeOpRegisterContainerImage) ID() string {
16593	return "OperationDeserializer"
16594}
16595
16596func (m *awsAwsjson11_deserializeOpRegisterContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16597	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16598) {
16599	out, metadata, err = next.HandleDeserialize(ctx, in)
16600	if err != nil {
16601		return out, metadata, err
16602	}
16603
16604	response, ok := out.RawResponse.(*smithyhttp.Response)
16605	if !ok {
16606		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16607	}
16608
16609	if response.StatusCode < 200 || response.StatusCode >= 300 {
16610		return out, metadata, awsAwsjson11_deserializeOpErrorRegisterContainerImage(response, &metadata)
16611	}
16612	output := &RegisterContainerImageOutput{}
16613	out.Result = output
16614
16615	var buff [1024]byte
16616	ringBuffer := smithyio.NewRingBuffer(buff[:])
16617
16618	body := io.TeeReader(response.Body, ringBuffer)
16619	decoder := json.NewDecoder(body)
16620	decoder.UseNumber()
16621	var shape interface{}
16622	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16623		var snapshot bytes.Buffer
16624		io.Copy(&snapshot, ringBuffer)
16625		err = &smithy.DeserializationError{
16626			Err:      fmt.Errorf("failed to decode response body, %w", err),
16627			Snapshot: snapshot.Bytes(),
16628		}
16629		return out, metadata, err
16630	}
16631
16632	err = awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(&output, shape)
16633	if err != nil {
16634		var snapshot bytes.Buffer
16635		io.Copy(&snapshot, ringBuffer)
16636		err = &smithy.DeserializationError{
16637			Err:      fmt.Errorf("failed to decode response body, %w", err),
16638			Snapshot: snapshot.Bytes(),
16639		}
16640		return out, metadata, err
16641	}
16642
16643	return out, metadata, err
16644}
16645
16646func awsAwsjson11_deserializeOpErrorRegisterContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16647	var errorBuffer bytes.Buffer
16648	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16649		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16650	}
16651	errorBody := bytes.NewReader(errorBuffer.Bytes())
16652
16653	errorCode := "UnknownError"
16654	errorMessage := errorCode
16655
16656	code := response.Header.Get("X-Amzn-ErrorType")
16657	if len(code) != 0 {
16658		errorCode = restjson.SanitizeErrorCode(code)
16659	}
16660
16661	var buff [1024]byte
16662	ringBuffer := smithyio.NewRingBuffer(buff[:])
16663
16664	body := io.TeeReader(errorBody, ringBuffer)
16665	decoder := json.NewDecoder(body)
16666	decoder.UseNumber()
16667	code, message, err := restjson.GetErrorInfo(decoder)
16668	if err != nil {
16669		var snapshot bytes.Buffer
16670		io.Copy(&snapshot, ringBuffer)
16671		err = &smithy.DeserializationError{
16672			Err:      fmt.Errorf("failed to decode response body, %w", err),
16673			Snapshot: snapshot.Bytes(),
16674		}
16675		return err
16676	}
16677
16678	errorBody.Seek(0, io.SeekStart)
16679	if len(code) != 0 {
16680		errorCode = restjson.SanitizeErrorCode(code)
16681	}
16682	if len(message) != 0 {
16683		errorMessage = message
16684	}
16685
16686	switch {
16687	case strings.EqualFold("AccessDeniedException", errorCode):
16688		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16689
16690	case strings.EqualFold("InvalidInputException", errorCode):
16691		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16692
16693	case strings.EqualFold("NotFoundException", errorCode):
16694		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16695
16696	case strings.EqualFold("ServiceException", errorCode):
16697		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16698
16699	case strings.EqualFold("UnauthenticatedException", errorCode):
16700		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16701
16702	default:
16703		genericError := &smithy.GenericAPIError{
16704			Code:    errorCode,
16705			Message: errorMessage,
16706		}
16707		return genericError
16708
16709	}
16710}
16711
16712type awsAwsjson11_deserializeOpReleaseStaticIp struct {
16713}
16714
16715func (*awsAwsjson11_deserializeOpReleaseStaticIp) ID() string {
16716	return "OperationDeserializer"
16717}
16718
16719func (m *awsAwsjson11_deserializeOpReleaseStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16720	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16721) {
16722	out, metadata, err = next.HandleDeserialize(ctx, in)
16723	if err != nil {
16724		return out, metadata, err
16725	}
16726
16727	response, ok := out.RawResponse.(*smithyhttp.Response)
16728	if !ok {
16729		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16730	}
16731
16732	if response.StatusCode < 200 || response.StatusCode >= 300 {
16733		return out, metadata, awsAwsjson11_deserializeOpErrorReleaseStaticIp(response, &metadata)
16734	}
16735	output := &ReleaseStaticIpOutput{}
16736	out.Result = output
16737
16738	var buff [1024]byte
16739	ringBuffer := smithyio.NewRingBuffer(buff[:])
16740
16741	body := io.TeeReader(response.Body, ringBuffer)
16742	decoder := json.NewDecoder(body)
16743	decoder.UseNumber()
16744	var shape interface{}
16745	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16746		var snapshot bytes.Buffer
16747		io.Copy(&snapshot, ringBuffer)
16748		err = &smithy.DeserializationError{
16749			Err:      fmt.Errorf("failed to decode response body, %w", err),
16750			Snapshot: snapshot.Bytes(),
16751		}
16752		return out, metadata, err
16753	}
16754
16755	err = awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(&output, shape)
16756	if err != nil {
16757		var snapshot bytes.Buffer
16758		io.Copy(&snapshot, ringBuffer)
16759		err = &smithy.DeserializationError{
16760			Err:      fmt.Errorf("failed to decode response body, %w", err),
16761			Snapshot: snapshot.Bytes(),
16762		}
16763		return out, metadata, err
16764	}
16765
16766	return out, metadata, err
16767}
16768
16769func awsAwsjson11_deserializeOpErrorReleaseStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16770	var errorBuffer bytes.Buffer
16771	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16772		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16773	}
16774	errorBody := bytes.NewReader(errorBuffer.Bytes())
16775
16776	errorCode := "UnknownError"
16777	errorMessage := errorCode
16778
16779	code := response.Header.Get("X-Amzn-ErrorType")
16780	if len(code) != 0 {
16781		errorCode = restjson.SanitizeErrorCode(code)
16782	}
16783
16784	var buff [1024]byte
16785	ringBuffer := smithyio.NewRingBuffer(buff[:])
16786
16787	body := io.TeeReader(errorBody, ringBuffer)
16788	decoder := json.NewDecoder(body)
16789	decoder.UseNumber()
16790	code, message, err := restjson.GetErrorInfo(decoder)
16791	if err != nil {
16792		var snapshot bytes.Buffer
16793		io.Copy(&snapshot, ringBuffer)
16794		err = &smithy.DeserializationError{
16795			Err:      fmt.Errorf("failed to decode response body, %w", err),
16796			Snapshot: snapshot.Bytes(),
16797		}
16798		return err
16799	}
16800
16801	errorBody.Seek(0, io.SeekStart)
16802	if len(code) != 0 {
16803		errorCode = restjson.SanitizeErrorCode(code)
16804	}
16805	if len(message) != 0 {
16806		errorMessage = message
16807	}
16808
16809	switch {
16810	case strings.EqualFold("AccessDeniedException", errorCode):
16811		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16812
16813	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16814		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16815
16816	case strings.EqualFold("InvalidInputException", errorCode):
16817		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16818
16819	case strings.EqualFold("NotFoundException", errorCode):
16820		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16821
16822	case strings.EqualFold("OperationFailureException", errorCode):
16823		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16824
16825	case strings.EqualFold("ServiceException", errorCode):
16826		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16827
16828	case strings.EqualFold("UnauthenticatedException", errorCode):
16829		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16830
16831	default:
16832		genericError := &smithy.GenericAPIError{
16833			Code:    errorCode,
16834			Message: errorMessage,
16835		}
16836		return genericError
16837
16838	}
16839}
16840
16841type awsAwsjson11_deserializeOpResetDistributionCache struct {
16842}
16843
16844func (*awsAwsjson11_deserializeOpResetDistributionCache) ID() string {
16845	return "OperationDeserializer"
16846}
16847
16848func (m *awsAwsjson11_deserializeOpResetDistributionCache) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16849	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16850) {
16851	out, metadata, err = next.HandleDeserialize(ctx, in)
16852	if err != nil {
16853		return out, metadata, err
16854	}
16855
16856	response, ok := out.RawResponse.(*smithyhttp.Response)
16857	if !ok {
16858		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16859	}
16860
16861	if response.StatusCode < 200 || response.StatusCode >= 300 {
16862		return out, metadata, awsAwsjson11_deserializeOpErrorResetDistributionCache(response, &metadata)
16863	}
16864	output := &ResetDistributionCacheOutput{}
16865	out.Result = output
16866
16867	var buff [1024]byte
16868	ringBuffer := smithyio.NewRingBuffer(buff[:])
16869
16870	body := io.TeeReader(response.Body, ringBuffer)
16871	decoder := json.NewDecoder(body)
16872	decoder.UseNumber()
16873	var shape interface{}
16874	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16875		var snapshot bytes.Buffer
16876		io.Copy(&snapshot, ringBuffer)
16877		err = &smithy.DeserializationError{
16878			Err:      fmt.Errorf("failed to decode response body, %w", err),
16879			Snapshot: snapshot.Bytes(),
16880		}
16881		return out, metadata, err
16882	}
16883
16884	err = awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(&output, shape)
16885	if err != nil {
16886		var snapshot bytes.Buffer
16887		io.Copy(&snapshot, ringBuffer)
16888		err = &smithy.DeserializationError{
16889			Err:      fmt.Errorf("failed to decode response body, %w", err),
16890			Snapshot: snapshot.Bytes(),
16891		}
16892		return out, metadata, err
16893	}
16894
16895	return out, metadata, err
16896}
16897
16898func awsAwsjson11_deserializeOpErrorResetDistributionCache(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16899	var errorBuffer bytes.Buffer
16900	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16901		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16902	}
16903	errorBody := bytes.NewReader(errorBuffer.Bytes())
16904
16905	errorCode := "UnknownError"
16906	errorMessage := errorCode
16907
16908	code := response.Header.Get("X-Amzn-ErrorType")
16909	if len(code) != 0 {
16910		errorCode = restjson.SanitizeErrorCode(code)
16911	}
16912
16913	var buff [1024]byte
16914	ringBuffer := smithyio.NewRingBuffer(buff[:])
16915
16916	body := io.TeeReader(errorBody, ringBuffer)
16917	decoder := json.NewDecoder(body)
16918	decoder.UseNumber()
16919	code, message, err := restjson.GetErrorInfo(decoder)
16920	if err != nil {
16921		var snapshot bytes.Buffer
16922		io.Copy(&snapshot, ringBuffer)
16923		err = &smithy.DeserializationError{
16924			Err:      fmt.Errorf("failed to decode response body, %w", err),
16925			Snapshot: snapshot.Bytes(),
16926		}
16927		return err
16928	}
16929
16930	errorBody.Seek(0, io.SeekStart)
16931	if len(code) != 0 {
16932		errorCode = restjson.SanitizeErrorCode(code)
16933	}
16934	if len(message) != 0 {
16935		errorMessage = message
16936	}
16937
16938	switch {
16939	case strings.EqualFold("AccessDeniedException", errorCode):
16940		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16941
16942	case strings.EqualFold("InvalidInputException", errorCode):
16943		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16944
16945	case strings.EqualFold("NotFoundException", errorCode):
16946		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16947
16948	case strings.EqualFold("OperationFailureException", errorCode):
16949		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16950
16951	case strings.EqualFold("ServiceException", errorCode):
16952		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16953
16954	case strings.EqualFold("UnauthenticatedException", errorCode):
16955		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16956
16957	default:
16958		genericError := &smithy.GenericAPIError{
16959			Code:    errorCode,
16960			Message: errorMessage,
16961		}
16962		return genericError
16963
16964	}
16965}
16966
16967type awsAwsjson11_deserializeOpSendContactMethodVerification struct {
16968}
16969
16970func (*awsAwsjson11_deserializeOpSendContactMethodVerification) ID() string {
16971	return "OperationDeserializer"
16972}
16973
16974func (m *awsAwsjson11_deserializeOpSendContactMethodVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16975	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16976) {
16977	out, metadata, err = next.HandleDeserialize(ctx, in)
16978	if err != nil {
16979		return out, metadata, err
16980	}
16981
16982	response, ok := out.RawResponse.(*smithyhttp.Response)
16983	if !ok {
16984		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16985	}
16986
16987	if response.StatusCode < 200 || response.StatusCode >= 300 {
16988		return out, metadata, awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response, &metadata)
16989	}
16990	output := &SendContactMethodVerificationOutput{}
16991	out.Result = output
16992
16993	var buff [1024]byte
16994	ringBuffer := smithyio.NewRingBuffer(buff[:])
16995
16996	body := io.TeeReader(response.Body, ringBuffer)
16997	decoder := json.NewDecoder(body)
16998	decoder.UseNumber()
16999	var shape interface{}
17000	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17001		var snapshot bytes.Buffer
17002		io.Copy(&snapshot, ringBuffer)
17003		err = &smithy.DeserializationError{
17004			Err:      fmt.Errorf("failed to decode response body, %w", err),
17005			Snapshot: snapshot.Bytes(),
17006		}
17007		return out, metadata, err
17008	}
17009
17010	err = awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(&output, shape)
17011	if err != nil {
17012		var snapshot bytes.Buffer
17013		io.Copy(&snapshot, ringBuffer)
17014		err = &smithy.DeserializationError{
17015			Err:      fmt.Errorf("failed to decode response body, %w", err),
17016			Snapshot: snapshot.Bytes(),
17017		}
17018		return out, metadata, err
17019	}
17020
17021	return out, metadata, err
17022}
17023
17024func awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17025	var errorBuffer bytes.Buffer
17026	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17027		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17028	}
17029	errorBody := bytes.NewReader(errorBuffer.Bytes())
17030
17031	errorCode := "UnknownError"
17032	errorMessage := errorCode
17033
17034	code := response.Header.Get("X-Amzn-ErrorType")
17035	if len(code) != 0 {
17036		errorCode = restjson.SanitizeErrorCode(code)
17037	}
17038
17039	var buff [1024]byte
17040	ringBuffer := smithyio.NewRingBuffer(buff[:])
17041
17042	body := io.TeeReader(errorBody, ringBuffer)
17043	decoder := json.NewDecoder(body)
17044	decoder.UseNumber()
17045	code, message, err := restjson.GetErrorInfo(decoder)
17046	if err != nil {
17047		var snapshot bytes.Buffer
17048		io.Copy(&snapshot, ringBuffer)
17049		err = &smithy.DeserializationError{
17050			Err:      fmt.Errorf("failed to decode response body, %w", err),
17051			Snapshot: snapshot.Bytes(),
17052		}
17053		return err
17054	}
17055
17056	errorBody.Seek(0, io.SeekStart)
17057	if len(code) != 0 {
17058		errorCode = restjson.SanitizeErrorCode(code)
17059	}
17060	if len(message) != 0 {
17061		errorMessage = message
17062	}
17063
17064	switch {
17065	case strings.EqualFold("AccessDeniedException", errorCode):
17066		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17067
17068	case strings.EqualFold("InvalidInputException", errorCode):
17069		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17070
17071	case strings.EqualFold("NotFoundException", errorCode):
17072		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17073
17074	case strings.EqualFold("OperationFailureException", errorCode):
17075		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17076
17077	case strings.EqualFold("ServiceException", errorCode):
17078		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17079
17080	case strings.EqualFold("UnauthenticatedException", errorCode):
17081		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17082
17083	default:
17084		genericError := &smithy.GenericAPIError{
17085			Code:    errorCode,
17086			Message: errorMessage,
17087		}
17088		return genericError
17089
17090	}
17091}
17092
17093type awsAwsjson11_deserializeOpSetIpAddressType struct {
17094}
17095
17096func (*awsAwsjson11_deserializeOpSetIpAddressType) ID() string {
17097	return "OperationDeserializer"
17098}
17099
17100func (m *awsAwsjson11_deserializeOpSetIpAddressType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17101	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17102) {
17103	out, metadata, err = next.HandleDeserialize(ctx, in)
17104	if err != nil {
17105		return out, metadata, err
17106	}
17107
17108	response, ok := out.RawResponse.(*smithyhttp.Response)
17109	if !ok {
17110		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17111	}
17112
17113	if response.StatusCode < 200 || response.StatusCode >= 300 {
17114		return out, metadata, awsAwsjson11_deserializeOpErrorSetIpAddressType(response, &metadata)
17115	}
17116	output := &SetIpAddressTypeOutput{}
17117	out.Result = output
17118
17119	var buff [1024]byte
17120	ringBuffer := smithyio.NewRingBuffer(buff[:])
17121
17122	body := io.TeeReader(response.Body, ringBuffer)
17123	decoder := json.NewDecoder(body)
17124	decoder.UseNumber()
17125	var shape interface{}
17126	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17127		var snapshot bytes.Buffer
17128		io.Copy(&snapshot, ringBuffer)
17129		err = &smithy.DeserializationError{
17130			Err:      fmt.Errorf("failed to decode response body, %w", err),
17131			Snapshot: snapshot.Bytes(),
17132		}
17133		return out, metadata, err
17134	}
17135
17136	err = awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(&output, shape)
17137	if err != nil {
17138		var snapshot bytes.Buffer
17139		io.Copy(&snapshot, ringBuffer)
17140		err = &smithy.DeserializationError{
17141			Err:      fmt.Errorf("failed to decode response body, %w", err),
17142			Snapshot: snapshot.Bytes(),
17143		}
17144		return out, metadata, err
17145	}
17146
17147	return out, metadata, err
17148}
17149
17150func awsAwsjson11_deserializeOpErrorSetIpAddressType(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17151	var errorBuffer bytes.Buffer
17152	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17153		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17154	}
17155	errorBody := bytes.NewReader(errorBuffer.Bytes())
17156
17157	errorCode := "UnknownError"
17158	errorMessage := errorCode
17159
17160	code := response.Header.Get("X-Amzn-ErrorType")
17161	if len(code) != 0 {
17162		errorCode = restjson.SanitizeErrorCode(code)
17163	}
17164
17165	var buff [1024]byte
17166	ringBuffer := smithyio.NewRingBuffer(buff[:])
17167
17168	body := io.TeeReader(errorBody, ringBuffer)
17169	decoder := json.NewDecoder(body)
17170	decoder.UseNumber()
17171	code, message, err := restjson.GetErrorInfo(decoder)
17172	if err != nil {
17173		var snapshot bytes.Buffer
17174		io.Copy(&snapshot, ringBuffer)
17175		err = &smithy.DeserializationError{
17176			Err:      fmt.Errorf("failed to decode response body, %w", err),
17177			Snapshot: snapshot.Bytes(),
17178		}
17179		return err
17180	}
17181
17182	errorBody.Seek(0, io.SeekStart)
17183	if len(code) != 0 {
17184		errorCode = restjson.SanitizeErrorCode(code)
17185	}
17186	if len(message) != 0 {
17187		errorMessage = message
17188	}
17189
17190	switch {
17191	case strings.EqualFold("AccessDeniedException", errorCode):
17192		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17193
17194	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17195		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17196
17197	case strings.EqualFold("InvalidInputException", errorCode):
17198		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17199
17200	case strings.EqualFold("NotFoundException", errorCode):
17201		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17202
17203	case strings.EqualFold("OperationFailureException", errorCode):
17204		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17205
17206	case strings.EqualFold("ServiceException", errorCode):
17207		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17208
17209	case strings.EqualFold("UnauthenticatedException", errorCode):
17210		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17211
17212	default:
17213		genericError := &smithy.GenericAPIError{
17214			Code:    errorCode,
17215			Message: errorMessage,
17216		}
17217		return genericError
17218
17219	}
17220}
17221
17222type awsAwsjson11_deserializeOpSetResourceAccessForBucket struct {
17223}
17224
17225func (*awsAwsjson11_deserializeOpSetResourceAccessForBucket) ID() string {
17226	return "OperationDeserializer"
17227}
17228
17229func (m *awsAwsjson11_deserializeOpSetResourceAccessForBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17230	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17231) {
17232	out, metadata, err = next.HandleDeserialize(ctx, in)
17233	if err != nil {
17234		return out, metadata, err
17235	}
17236
17237	response, ok := out.RawResponse.(*smithyhttp.Response)
17238	if !ok {
17239		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17240	}
17241
17242	if response.StatusCode < 200 || response.StatusCode >= 300 {
17243		return out, metadata, awsAwsjson11_deserializeOpErrorSetResourceAccessForBucket(response, &metadata)
17244	}
17245	output := &SetResourceAccessForBucketOutput{}
17246	out.Result = output
17247
17248	var buff [1024]byte
17249	ringBuffer := smithyio.NewRingBuffer(buff[:])
17250
17251	body := io.TeeReader(response.Body, ringBuffer)
17252	decoder := json.NewDecoder(body)
17253	decoder.UseNumber()
17254	var shape interface{}
17255	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17256		var snapshot bytes.Buffer
17257		io.Copy(&snapshot, ringBuffer)
17258		err = &smithy.DeserializationError{
17259			Err:      fmt.Errorf("failed to decode response body, %w", err),
17260			Snapshot: snapshot.Bytes(),
17261		}
17262		return out, metadata, err
17263	}
17264
17265	err = awsAwsjson11_deserializeOpDocumentSetResourceAccessForBucketOutput(&output, shape)
17266	if err != nil {
17267		var snapshot bytes.Buffer
17268		io.Copy(&snapshot, ringBuffer)
17269		err = &smithy.DeserializationError{
17270			Err:      fmt.Errorf("failed to decode response body, %w", err),
17271			Snapshot: snapshot.Bytes(),
17272		}
17273		return out, metadata, err
17274	}
17275
17276	return out, metadata, err
17277}
17278
17279func awsAwsjson11_deserializeOpErrorSetResourceAccessForBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17280	var errorBuffer bytes.Buffer
17281	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17282		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17283	}
17284	errorBody := bytes.NewReader(errorBuffer.Bytes())
17285
17286	errorCode := "UnknownError"
17287	errorMessage := errorCode
17288
17289	code := response.Header.Get("X-Amzn-ErrorType")
17290	if len(code) != 0 {
17291		errorCode = restjson.SanitizeErrorCode(code)
17292	}
17293
17294	var buff [1024]byte
17295	ringBuffer := smithyio.NewRingBuffer(buff[:])
17296
17297	body := io.TeeReader(errorBody, ringBuffer)
17298	decoder := json.NewDecoder(body)
17299	decoder.UseNumber()
17300	code, message, err := restjson.GetErrorInfo(decoder)
17301	if err != nil {
17302		var snapshot bytes.Buffer
17303		io.Copy(&snapshot, ringBuffer)
17304		err = &smithy.DeserializationError{
17305			Err:      fmt.Errorf("failed to decode response body, %w", err),
17306			Snapshot: snapshot.Bytes(),
17307		}
17308		return err
17309	}
17310
17311	errorBody.Seek(0, io.SeekStart)
17312	if len(code) != 0 {
17313		errorCode = restjson.SanitizeErrorCode(code)
17314	}
17315	if len(message) != 0 {
17316		errorMessage = message
17317	}
17318
17319	switch {
17320	case strings.EqualFold("AccessDeniedException", errorCode):
17321		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17322
17323	case strings.EqualFold("InvalidInputException", errorCode):
17324		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17325
17326	case strings.EqualFold("NotFoundException", errorCode):
17327		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17328
17329	case strings.EqualFold("ServiceException", errorCode):
17330		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17331
17332	case strings.EqualFold("UnauthenticatedException", errorCode):
17333		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17334
17335	default:
17336		genericError := &smithy.GenericAPIError{
17337			Code:    errorCode,
17338			Message: errorMessage,
17339		}
17340		return genericError
17341
17342	}
17343}
17344
17345type awsAwsjson11_deserializeOpStartInstance struct {
17346}
17347
17348func (*awsAwsjson11_deserializeOpStartInstance) ID() string {
17349	return "OperationDeserializer"
17350}
17351
17352func (m *awsAwsjson11_deserializeOpStartInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17353	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17354) {
17355	out, metadata, err = next.HandleDeserialize(ctx, in)
17356	if err != nil {
17357		return out, metadata, err
17358	}
17359
17360	response, ok := out.RawResponse.(*smithyhttp.Response)
17361	if !ok {
17362		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17363	}
17364
17365	if response.StatusCode < 200 || response.StatusCode >= 300 {
17366		return out, metadata, awsAwsjson11_deserializeOpErrorStartInstance(response, &metadata)
17367	}
17368	output := &StartInstanceOutput{}
17369	out.Result = output
17370
17371	var buff [1024]byte
17372	ringBuffer := smithyio.NewRingBuffer(buff[:])
17373
17374	body := io.TeeReader(response.Body, ringBuffer)
17375	decoder := json.NewDecoder(body)
17376	decoder.UseNumber()
17377	var shape interface{}
17378	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17379		var snapshot bytes.Buffer
17380		io.Copy(&snapshot, ringBuffer)
17381		err = &smithy.DeserializationError{
17382			Err:      fmt.Errorf("failed to decode response body, %w", err),
17383			Snapshot: snapshot.Bytes(),
17384		}
17385		return out, metadata, err
17386	}
17387
17388	err = awsAwsjson11_deserializeOpDocumentStartInstanceOutput(&output, shape)
17389	if err != nil {
17390		var snapshot bytes.Buffer
17391		io.Copy(&snapshot, ringBuffer)
17392		err = &smithy.DeserializationError{
17393			Err:      fmt.Errorf("failed to decode response body, %w", err),
17394			Snapshot: snapshot.Bytes(),
17395		}
17396		return out, metadata, err
17397	}
17398
17399	return out, metadata, err
17400}
17401
17402func awsAwsjson11_deserializeOpErrorStartInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17403	var errorBuffer bytes.Buffer
17404	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17405		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17406	}
17407	errorBody := bytes.NewReader(errorBuffer.Bytes())
17408
17409	errorCode := "UnknownError"
17410	errorMessage := errorCode
17411
17412	code := response.Header.Get("X-Amzn-ErrorType")
17413	if len(code) != 0 {
17414		errorCode = restjson.SanitizeErrorCode(code)
17415	}
17416
17417	var buff [1024]byte
17418	ringBuffer := smithyio.NewRingBuffer(buff[:])
17419
17420	body := io.TeeReader(errorBody, ringBuffer)
17421	decoder := json.NewDecoder(body)
17422	decoder.UseNumber()
17423	code, message, err := restjson.GetErrorInfo(decoder)
17424	if err != nil {
17425		var snapshot bytes.Buffer
17426		io.Copy(&snapshot, ringBuffer)
17427		err = &smithy.DeserializationError{
17428			Err:      fmt.Errorf("failed to decode response body, %w", err),
17429			Snapshot: snapshot.Bytes(),
17430		}
17431		return err
17432	}
17433
17434	errorBody.Seek(0, io.SeekStart)
17435	if len(code) != 0 {
17436		errorCode = restjson.SanitizeErrorCode(code)
17437	}
17438	if len(message) != 0 {
17439		errorMessage = message
17440	}
17441
17442	switch {
17443	case strings.EqualFold("AccessDeniedException", errorCode):
17444		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17445
17446	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17447		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17448
17449	case strings.EqualFold("InvalidInputException", errorCode):
17450		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17451
17452	case strings.EqualFold("NotFoundException", errorCode):
17453		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17454
17455	case strings.EqualFold("OperationFailureException", errorCode):
17456		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17457
17458	case strings.EqualFold("ServiceException", errorCode):
17459		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17460
17461	case strings.EqualFold("UnauthenticatedException", errorCode):
17462		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17463
17464	default:
17465		genericError := &smithy.GenericAPIError{
17466			Code:    errorCode,
17467			Message: errorMessage,
17468		}
17469		return genericError
17470
17471	}
17472}
17473
17474type awsAwsjson11_deserializeOpStartRelationalDatabase struct {
17475}
17476
17477func (*awsAwsjson11_deserializeOpStartRelationalDatabase) ID() string {
17478	return "OperationDeserializer"
17479}
17480
17481func (m *awsAwsjson11_deserializeOpStartRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17482	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17483) {
17484	out, metadata, err = next.HandleDeserialize(ctx, in)
17485	if err != nil {
17486		return out, metadata, err
17487	}
17488
17489	response, ok := out.RawResponse.(*smithyhttp.Response)
17490	if !ok {
17491		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17492	}
17493
17494	if response.StatusCode < 200 || response.StatusCode >= 300 {
17495		return out, metadata, awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response, &metadata)
17496	}
17497	output := &StartRelationalDatabaseOutput{}
17498	out.Result = output
17499
17500	var buff [1024]byte
17501	ringBuffer := smithyio.NewRingBuffer(buff[:])
17502
17503	body := io.TeeReader(response.Body, ringBuffer)
17504	decoder := json.NewDecoder(body)
17505	decoder.UseNumber()
17506	var shape interface{}
17507	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17508		var snapshot bytes.Buffer
17509		io.Copy(&snapshot, ringBuffer)
17510		err = &smithy.DeserializationError{
17511			Err:      fmt.Errorf("failed to decode response body, %w", err),
17512			Snapshot: snapshot.Bytes(),
17513		}
17514		return out, metadata, err
17515	}
17516
17517	err = awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(&output, shape)
17518	if err != nil {
17519		var snapshot bytes.Buffer
17520		io.Copy(&snapshot, ringBuffer)
17521		err = &smithy.DeserializationError{
17522			Err:      fmt.Errorf("failed to decode response body, %w", err),
17523			Snapshot: snapshot.Bytes(),
17524		}
17525		return out, metadata, err
17526	}
17527
17528	return out, metadata, err
17529}
17530
17531func awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17532	var errorBuffer bytes.Buffer
17533	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17534		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17535	}
17536	errorBody := bytes.NewReader(errorBuffer.Bytes())
17537
17538	errorCode := "UnknownError"
17539	errorMessage := errorCode
17540
17541	code := response.Header.Get("X-Amzn-ErrorType")
17542	if len(code) != 0 {
17543		errorCode = restjson.SanitizeErrorCode(code)
17544	}
17545
17546	var buff [1024]byte
17547	ringBuffer := smithyio.NewRingBuffer(buff[:])
17548
17549	body := io.TeeReader(errorBody, ringBuffer)
17550	decoder := json.NewDecoder(body)
17551	decoder.UseNumber()
17552	code, message, err := restjson.GetErrorInfo(decoder)
17553	if err != nil {
17554		var snapshot bytes.Buffer
17555		io.Copy(&snapshot, ringBuffer)
17556		err = &smithy.DeserializationError{
17557			Err:      fmt.Errorf("failed to decode response body, %w", err),
17558			Snapshot: snapshot.Bytes(),
17559		}
17560		return err
17561	}
17562
17563	errorBody.Seek(0, io.SeekStart)
17564	if len(code) != 0 {
17565		errorCode = restjson.SanitizeErrorCode(code)
17566	}
17567	if len(message) != 0 {
17568		errorMessage = message
17569	}
17570
17571	switch {
17572	case strings.EqualFold("AccessDeniedException", errorCode):
17573		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17574
17575	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17576		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17577
17578	case strings.EqualFold("InvalidInputException", errorCode):
17579		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17580
17581	case strings.EqualFold("NotFoundException", errorCode):
17582		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17583
17584	case strings.EqualFold("OperationFailureException", errorCode):
17585		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17586
17587	case strings.EqualFold("ServiceException", errorCode):
17588		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17589
17590	case strings.EqualFold("UnauthenticatedException", errorCode):
17591		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17592
17593	default:
17594		genericError := &smithy.GenericAPIError{
17595			Code:    errorCode,
17596			Message: errorMessage,
17597		}
17598		return genericError
17599
17600	}
17601}
17602
17603type awsAwsjson11_deserializeOpStopInstance struct {
17604}
17605
17606func (*awsAwsjson11_deserializeOpStopInstance) ID() string {
17607	return "OperationDeserializer"
17608}
17609
17610func (m *awsAwsjson11_deserializeOpStopInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17611	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17612) {
17613	out, metadata, err = next.HandleDeserialize(ctx, in)
17614	if err != nil {
17615		return out, metadata, err
17616	}
17617
17618	response, ok := out.RawResponse.(*smithyhttp.Response)
17619	if !ok {
17620		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17621	}
17622
17623	if response.StatusCode < 200 || response.StatusCode >= 300 {
17624		return out, metadata, awsAwsjson11_deserializeOpErrorStopInstance(response, &metadata)
17625	}
17626	output := &StopInstanceOutput{}
17627	out.Result = output
17628
17629	var buff [1024]byte
17630	ringBuffer := smithyio.NewRingBuffer(buff[:])
17631
17632	body := io.TeeReader(response.Body, ringBuffer)
17633	decoder := json.NewDecoder(body)
17634	decoder.UseNumber()
17635	var shape interface{}
17636	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17637		var snapshot bytes.Buffer
17638		io.Copy(&snapshot, ringBuffer)
17639		err = &smithy.DeserializationError{
17640			Err:      fmt.Errorf("failed to decode response body, %w", err),
17641			Snapshot: snapshot.Bytes(),
17642		}
17643		return out, metadata, err
17644	}
17645
17646	err = awsAwsjson11_deserializeOpDocumentStopInstanceOutput(&output, shape)
17647	if err != nil {
17648		var snapshot bytes.Buffer
17649		io.Copy(&snapshot, ringBuffer)
17650		err = &smithy.DeserializationError{
17651			Err:      fmt.Errorf("failed to decode response body, %w", err),
17652			Snapshot: snapshot.Bytes(),
17653		}
17654		return out, metadata, err
17655	}
17656
17657	return out, metadata, err
17658}
17659
17660func awsAwsjson11_deserializeOpErrorStopInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17661	var errorBuffer bytes.Buffer
17662	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17663		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17664	}
17665	errorBody := bytes.NewReader(errorBuffer.Bytes())
17666
17667	errorCode := "UnknownError"
17668	errorMessage := errorCode
17669
17670	code := response.Header.Get("X-Amzn-ErrorType")
17671	if len(code) != 0 {
17672		errorCode = restjson.SanitizeErrorCode(code)
17673	}
17674
17675	var buff [1024]byte
17676	ringBuffer := smithyio.NewRingBuffer(buff[:])
17677
17678	body := io.TeeReader(errorBody, ringBuffer)
17679	decoder := json.NewDecoder(body)
17680	decoder.UseNumber()
17681	code, message, err := restjson.GetErrorInfo(decoder)
17682	if err != nil {
17683		var snapshot bytes.Buffer
17684		io.Copy(&snapshot, ringBuffer)
17685		err = &smithy.DeserializationError{
17686			Err:      fmt.Errorf("failed to decode response body, %w", err),
17687			Snapshot: snapshot.Bytes(),
17688		}
17689		return err
17690	}
17691
17692	errorBody.Seek(0, io.SeekStart)
17693	if len(code) != 0 {
17694		errorCode = restjson.SanitizeErrorCode(code)
17695	}
17696	if len(message) != 0 {
17697		errorMessage = message
17698	}
17699
17700	switch {
17701	case strings.EqualFold("AccessDeniedException", errorCode):
17702		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17703
17704	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17705		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17706
17707	case strings.EqualFold("InvalidInputException", errorCode):
17708		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17709
17710	case strings.EqualFold("NotFoundException", errorCode):
17711		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17712
17713	case strings.EqualFold("OperationFailureException", errorCode):
17714		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17715
17716	case strings.EqualFold("ServiceException", errorCode):
17717		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17718
17719	case strings.EqualFold("UnauthenticatedException", errorCode):
17720		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17721
17722	default:
17723		genericError := &smithy.GenericAPIError{
17724			Code:    errorCode,
17725			Message: errorMessage,
17726		}
17727		return genericError
17728
17729	}
17730}
17731
17732type awsAwsjson11_deserializeOpStopRelationalDatabase struct {
17733}
17734
17735func (*awsAwsjson11_deserializeOpStopRelationalDatabase) ID() string {
17736	return "OperationDeserializer"
17737}
17738
17739func (m *awsAwsjson11_deserializeOpStopRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17740	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17741) {
17742	out, metadata, err = next.HandleDeserialize(ctx, in)
17743	if err != nil {
17744		return out, metadata, err
17745	}
17746
17747	response, ok := out.RawResponse.(*smithyhttp.Response)
17748	if !ok {
17749		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17750	}
17751
17752	if response.StatusCode < 200 || response.StatusCode >= 300 {
17753		return out, metadata, awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response, &metadata)
17754	}
17755	output := &StopRelationalDatabaseOutput{}
17756	out.Result = output
17757
17758	var buff [1024]byte
17759	ringBuffer := smithyio.NewRingBuffer(buff[:])
17760
17761	body := io.TeeReader(response.Body, ringBuffer)
17762	decoder := json.NewDecoder(body)
17763	decoder.UseNumber()
17764	var shape interface{}
17765	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17766		var snapshot bytes.Buffer
17767		io.Copy(&snapshot, ringBuffer)
17768		err = &smithy.DeserializationError{
17769			Err:      fmt.Errorf("failed to decode response body, %w", err),
17770			Snapshot: snapshot.Bytes(),
17771		}
17772		return out, metadata, err
17773	}
17774
17775	err = awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(&output, shape)
17776	if err != nil {
17777		var snapshot bytes.Buffer
17778		io.Copy(&snapshot, ringBuffer)
17779		err = &smithy.DeserializationError{
17780			Err:      fmt.Errorf("failed to decode response body, %w", err),
17781			Snapshot: snapshot.Bytes(),
17782		}
17783		return out, metadata, err
17784	}
17785
17786	return out, metadata, err
17787}
17788
17789func awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17790	var errorBuffer bytes.Buffer
17791	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17792		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17793	}
17794	errorBody := bytes.NewReader(errorBuffer.Bytes())
17795
17796	errorCode := "UnknownError"
17797	errorMessage := errorCode
17798
17799	code := response.Header.Get("X-Amzn-ErrorType")
17800	if len(code) != 0 {
17801		errorCode = restjson.SanitizeErrorCode(code)
17802	}
17803
17804	var buff [1024]byte
17805	ringBuffer := smithyio.NewRingBuffer(buff[:])
17806
17807	body := io.TeeReader(errorBody, ringBuffer)
17808	decoder := json.NewDecoder(body)
17809	decoder.UseNumber()
17810	code, message, err := restjson.GetErrorInfo(decoder)
17811	if err != nil {
17812		var snapshot bytes.Buffer
17813		io.Copy(&snapshot, ringBuffer)
17814		err = &smithy.DeserializationError{
17815			Err:      fmt.Errorf("failed to decode response body, %w", err),
17816			Snapshot: snapshot.Bytes(),
17817		}
17818		return err
17819	}
17820
17821	errorBody.Seek(0, io.SeekStart)
17822	if len(code) != 0 {
17823		errorCode = restjson.SanitizeErrorCode(code)
17824	}
17825	if len(message) != 0 {
17826		errorMessage = message
17827	}
17828
17829	switch {
17830	case strings.EqualFold("AccessDeniedException", errorCode):
17831		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17832
17833	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17834		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17835
17836	case strings.EqualFold("InvalidInputException", errorCode):
17837		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17838
17839	case strings.EqualFold("NotFoundException", errorCode):
17840		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17841
17842	case strings.EqualFold("OperationFailureException", errorCode):
17843		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17844
17845	case strings.EqualFold("ServiceException", errorCode):
17846		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17847
17848	case strings.EqualFold("UnauthenticatedException", errorCode):
17849		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17850
17851	default:
17852		genericError := &smithy.GenericAPIError{
17853			Code:    errorCode,
17854			Message: errorMessage,
17855		}
17856		return genericError
17857
17858	}
17859}
17860
17861type awsAwsjson11_deserializeOpTagResource struct {
17862}
17863
17864func (*awsAwsjson11_deserializeOpTagResource) ID() string {
17865	return "OperationDeserializer"
17866}
17867
17868func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17869	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17870) {
17871	out, metadata, err = next.HandleDeserialize(ctx, in)
17872	if err != nil {
17873		return out, metadata, err
17874	}
17875
17876	response, ok := out.RawResponse.(*smithyhttp.Response)
17877	if !ok {
17878		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17879	}
17880
17881	if response.StatusCode < 200 || response.StatusCode >= 300 {
17882		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
17883	}
17884	output := &TagResourceOutput{}
17885	out.Result = output
17886
17887	var buff [1024]byte
17888	ringBuffer := smithyio.NewRingBuffer(buff[:])
17889
17890	body := io.TeeReader(response.Body, ringBuffer)
17891	decoder := json.NewDecoder(body)
17892	decoder.UseNumber()
17893	var shape interface{}
17894	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17895		var snapshot bytes.Buffer
17896		io.Copy(&snapshot, ringBuffer)
17897		err = &smithy.DeserializationError{
17898			Err:      fmt.Errorf("failed to decode response body, %w", err),
17899			Snapshot: snapshot.Bytes(),
17900		}
17901		return out, metadata, err
17902	}
17903
17904	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
17905	if err != nil {
17906		var snapshot bytes.Buffer
17907		io.Copy(&snapshot, ringBuffer)
17908		err = &smithy.DeserializationError{
17909			Err:      fmt.Errorf("failed to decode response body, %w", err),
17910			Snapshot: snapshot.Bytes(),
17911		}
17912		return out, metadata, err
17913	}
17914
17915	return out, metadata, err
17916}
17917
17918func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17919	var errorBuffer bytes.Buffer
17920	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17921		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17922	}
17923	errorBody := bytes.NewReader(errorBuffer.Bytes())
17924
17925	errorCode := "UnknownError"
17926	errorMessage := errorCode
17927
17928	code := response.Header.Get("X-Amzn-ErrorType")
17929	if len(code) != 0 {
17930		errorCode = restjson.SanitizeErrorCode(code)
17931	}
17932
17933	var buff [1024]byte
17934	ringBuffer := smithyio.NewRingBuffer(buff[:])
17935
17936	body := io.TeeReader(errorBody, ringBuffer)
17937	decoder := json.NewDecoder(body)
17938	decoder.UseNumber()
17939	code, message, err := restjson.GetErrorInfo(decoder)
17940	if err != nil {
17941		var snapshot bytes.Buffer
17942		io.Copy(&snapshot, ringBuffer)
17943		err = &smithy.DeserializationError{
17944			Err:      fmt.Errorf("failed to decode response body, %w", err),
17945			Snapshot: snapshot.Bytes(),
17946		}
17947		return err
17948	}
17949
17950	errorBody.Seek(0, io.SeekStart)
17951	if len(code) != 0 {
17952		errorCode = restjson.SanitizeErrorCode(code)
17953	}
17954	if len(message) != 0 {
17955		errorMessage = message
17956	}
17957
17958	switch {
17959	case strings.EqualFold("AccessDeniedException", errorCode):
17960		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17961
17962	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17963		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17964
17965	case strings.EqualFold("InvalidInputException", errorCode):
17966		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17967
17968	case strings.EqualFold("NotFoundException", errorCode):
17969		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17970
17971	case strings.EqualFold("OperationFailureException", errorCode):
17972		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17973
17974	case strings.EqualFold("ServiceException", errorCode):
17975		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17976
17977	case strings.EqualFold("UnauthenticatedException", errorCode):
17978		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17979
17980	default:
17981		genericError := &smithy.GenericAPIError{
17982			Code:    errorCode,
17983			Message: errorMessage,
17984		}
17985		return genericError
17986
17987	}
17988}
17989
17990type awsAwsjson11_deserializeOpTestAlarm struct {
17991}
17992
17993func (*awsAwsjson11_deserializeOpTestAlarm) ID() string {
17994	return "OperationDeserializer"
17995}
17996
17997func (m *awsAwsjson11_deserializeOpTestAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17998	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17999) {
18000	out, metadata, err = next.HandleDeserialize(ctx, in)
18001	if err != nil {
18002		return out, metadata, err
18003	}
18004
18005	response, ok := out.RawResponse.(*smithyhttp.Response)
18006	if !ok {
18007		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18008	}
18009
18010	if response.StatusCode < 200 || response.StatusCode >= 300 {
18011		return out, metadata, awsAwsjson11_deserializeOpErrorTestAlarm(response, &metadata)
18012	}
18013	output := &TestAlarmOutput{}
18014	out.Result = output
18015
18016	var buff [1024]byte
18017	ringBuffer := smithyio.NewRingBuffer(buff[:])
18018
18019	body := io.TeeReader(response.Body, ringBuffer)
18020	decoder := json.NewDecoder(body)
18021	decoder.UseNumber()
18022	var shape interface{}
18023	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18024		var snapshot bytes.Buffer
18025		io.Copy(&snapshot, ringBuffer)
18026		err = &smithy.DeserializationError{
18027			Err:      fmt.Errorf("failed to decode response body, %w", err),
18028			Snapshot: snapshot.Bytes(),
18029		}
18030		return out, metadata, err
18031	}
18032
18033	err = awsAwsjson11_deserializeOpDocumentTestAlarmOutput(&output, shape)
18034	if err != nil {
18035		var snapshot bytes.Buffer
18036		io.Copy(&snapshot, ringBuffer)
18037		err = &smithy.DeserializationError{
18038			Err:      fmt.Errorf("failed to decode response body, %w", err),
18039			Snapshot: snapshot.Bytes(),
18040		}
18041		return out, metadata, err
18042	}
18043
18044	return out, metadata, err
18045}
18046
18047func awsAwsjson11_deserializeOpErrorTestAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18048	var errorBuffer bytes.Buffer
18049	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18050		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18051	}
18052	errorBody := bytes.NewReader(errorBuffer.Bytes())
18053
18054	errorCode := "UnknownError"
18055	errorMessage := errorCode
18056
18057	code := response.Header.Get("X-Amzn-ErrorType")
18058	if len(code) != 0 {
18059		errorCode = restjson.SanitizeErrorCode(code)
18060	}
18061
18062	var buff [1024]byte
18063	ringBuffer := smithyio.NewRingBuffer(buff[:])
18064
18065	body := io.TeeReader(errorBody, ringBuffer)
18066	decoder := json.NewDecoder(body)
18067	decoder.UseNumber()
18068	code, message, err := restjson.GetErrorInfo(decoder)
18069	if err != nil {
18070		var snapshot bytes.Buffer
18071		io.Copy(&snapshot, ringBuffer)
18072		err = &smithy.DeserializationError{
18073			Err:      fmt.Errorf("failed to decode response body, %w", err),
18074			Snapshot: snapshot.Bytes(),
18075		}
18076		return err
18077	}
18078
18079	errorBody.Seek(0, io.SeekStart)
18080	if len(code) != 0 {
18081		errorCode = restjson.SanitizeErrorCode(code)
18082	}
18083	if len(message) != 0 {
18084		errorMessage = message
18085	}
18086
18087	switch {
18088	case strings.EqualFold("AccessDeniedException", errorCode):
18089		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18090
18091	case strings.EqualFold("InvalidInputException", errorCode):
18092		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18093
18094	case strings.EqualFold("NotFoundException", errorCode):
18095		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18096
18097	case strings.EqualFold("OperationFailureException", errorCode):
18098		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18099
18100	case strings.EqualFold("ServiceException", errorCode):
18101		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18102
18103	case strings.EqualFold("UnauthenticatedException", errorCode):
18104		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18105
18106	default:
18107		genericError := &smithy.GenericAPIError{
18108			Code:    errorCode,
18109			Message: errorMessage,
18110		}
18111		return genericError
18112
18113	}
18114}
18115
18116type awsAwsjson11_deserializeOpUnpeerVpc struct {
18117}
18118
18119func (*awsAwsjson11_deserializeOpUnpeerVpc) ID() string {
18120	return "OperationDeserializer"
18121}
18122
18123func (m *awsAwsjson11_deserializeOpUnpeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18124	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18125) {
18126	out, metadata, err = next.HandleDeserialize(ctx, in)
18127	if err != nil {
18128		return out, metadata, err
18129	}
18130
18131	response, ok := out.RawResponse.(*smithyhttp.Response)
18132	if !ok {
18133		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18134	}
18135
18136	if response.StatusCode < 200 || response.StatusCode >= 300 {
18137		return out, metadata, awsAwsjson11_deserializeOpErrorUnpeerVpc(response, &metadata)
18138	}
18139	output := &UnpeerVpcOutput{}
18140	out.Result = output
18141
18142	var buff [1024]byte
18143	ringBuffer := smithyio.NewRingBuffer(buff[:])
18144
18145	body := io.TeeReader(response.Body, ringBuffer)
18146	decoder := json.NewDecoder(body)
18147	decoder.UseNumber()
18148	var shape interface{}
18149	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18150		var snapshot bytes.Buffer
18151		io.Copy(&snapshot, ringBuffer)
18152		err = &smithy.DeserializationError{
18153			Err:      fmt.Errorf("failed to decode response body, %w", err),
18154			Snapshot: snapshot.Bytes(),
18155		}
18156		return out, metadata, err
18157	}
18158
18159	err = awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(&output, shape)
18160	if err != nil {
18161		var snapshot bytes.Buffer
18162		io.Copy(&snapshot, ringBuffer)
18163		err = &smithy.DeserializationError{
18164			Err:      fmt.Errorf("failed to decode response body, %w", err),
18165			Snapshot: snapshot.Bytes(),
18166		}
18167		return out, metadata, err
18168	}
18169
18170	return out, metadata, err
18171}
18172
18173func awsAwsjson11_deserializeOpErrorUnpeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18174	var errorBuffer bytes.Buffer
18175	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18176		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18177	}
18178	errorBody := bytes.NewReader(errorBuffer.Bytes())
18179
18180	errorCode := "UnknownError"
18181	errorMessage := errorCode
18182
18183	code := response.Header.Get("X-Amzn-ErrorType")
18184	if len(code) != 0 {
18185		errorCode = restjson.SanitizeErrorCode(code)
18186	}
18187
18188	var buff [1024]byte
18189	ringBuffer := smithyio.NewRingBuffer(buff[:])
18190
18191	body := io.TeeReader(errorBody, ringBuffer)
18192	decoder := json.NewDecoder(body)
18193	decoder.UseNumber()
18194	code, message, err := restjson.GetErrorInfo(decoder)
18195	if err != nil {
18196		var snapshot bytes.Buffer
18197		io.Copy(&snapshot, ringBuffer)
18198		err = &smithy.DeserializationError{
18199			Err:      fmt.Errorf("failed to decode response body, %w", err),
18200			Snapshot: snapshot.Bytes(),
18201		}
18202		return err
18203	}
18204
18205	errorBody.Seek(0, io.SeekStart)
18206	if len(code) != 0 {
18207		errorCode = restjson.SanitizeErrorCode(code)
18208	}
18209	if len(message) != 0 {
18210		errorMessage = message
18211	}
18212
18213	switch {
18214	case strings.EqualFold("AccessDeniedException", errorCode):
18215		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18216
18217	case strings.EqualFold("AccountSetupInProgressException", errorCode):
18218		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18219
18220	case strings.EqualFold("InvalidInputException", errorCode):
18221		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18222
18223	case strings.EqualFold("NotFoundException", errorCode):
18224		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18225
18226	case strings.EqualFold("OperationFailureException", errorCode):
18227		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18228
18229	case strings.EqualFold("ServiceException", errorCode):
18230		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18231
18232	case strings.EqualFold("UnauthenticatedException", errorCode):
18233		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18234
18235	default:
18236		genericError := &smithy.GenericAPIError{
18237			Code:    errorCode,
18238			Message: errorMessage,
18239		}
18240		return genericError
18241
18242	}
18243}
18244
18245type awsAwsjson11_deserializeOpUntagResource struct {
18246}
18247
18248func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
18249	return "OperationDeserializer"
18250}
18251
18252func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18253	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18254) {
18255	out, metadata, err = next.HandleDeserialize(ctx, in)
18256	if err != nil {
18257		return out, metadata, err
18258	}
18259
18260	response, ok := out.RawResponse.(*smithyhttp.Response)
18261	if !ok {
18262		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18263	}
18264
18265	if response.StatusCode < 200 || response.StatusCode >= 300 {
18266		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
18267	}
18268	output := &UntagResourceOutput{}
18269	out.Result = output
18270
18271	var buff [1024]byte
18272	ringBuffer := smithyio.NewRingBuffer(buff[:])
18273
18274	body := io.TeeReader(response.Body, ringBuffer)
18275	decoder := json.NewDecoder(body)
18276	decoder.UseNumber()
18277	var shape interface{}
18278	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18279		var snapshot bytes.Buffer
18280		io.Copy(&snapshot, ringBuffer)
18281		err = &smithy.DeserializationError{
18282			Err:      fmt.Errorf("failed to decode response body, %w", err),
18283			Snapshot: snapshot.Bytes(),
18284		}
18285		return out, metadata, err
18286	}
18287
18288	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
18289	if err != nil {
18290		var snapshot bytes.Buffer
18291		io.Copy(&snapshot, ringBuffer)
18292		err = &smithy.DeserializationError{
18293			Err:      fmt.Errorf("failed to decode response body, %w", err),
18294			Snapshot: snapshot.Bytes(),
18295		}
18296		return out, metadata, err
18297	}
18298
18299	return out, metadata, err
18300}
18301
18302func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18303	var errorBuffer bytes.Buffer
18304	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18305		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18306	}
18307	errorBody := bytes.NewReader(errorBuffer.Bytes())
18308
18309	errorCode := "UnknownError"
18310	errorMessage := errorCode
18311
18312	code := response.Header.Get("X-Amzn-ErrorType")
18313	if len(code) != 0 {
18314		errorCode = restjson.SanitizeErrorCode(code)
18315	}
18316
18317	var buff [1024]byte
18318	ringBuffer := smithyio.NewRingBuffer(buff[:])
18319
18320	body := io.TeeReader(errorBody, ringBuffer)
18321	decoder := json.NewDecoder(body)
18322	decoder.UseNumber()
18323	code, message, err := restjson.GetErrorInfo(decoder)
18324	if err != nil {
18325		var snapshot bytes.Buffer
18326		io.Copy(&snapshot, ringBuffer)
18327		err = &smithy.DeserializationError{
18328			Err:      fmt.Errorf("failed to decode response body, %w", err),
18329			Snapshot: snapshot.Bytes(),
18330		}
18331		return err
18332	}
18333
18334	errorBody.Seek(0, io.SeekStart)
18335	if len(code) != 0 {
18336		errorCode = restjson.SanitizeErrorCode(code)
18337	}
18338	if len(message) != 0 {
18339		errorMessage = message
18340	}
18341
18342	switch {
18343	case strings.EqualFold("AccessDeniedException", errorCode):
18344		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18345
18346	case strings.EqualFold("AccountSetupInProgressException", errorCode):
18347		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18348
18349	case strings.EqualFold("InvalidInputException", errorCode):
18350		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18351
18352	case strings.EqualFold("NotFoundException", errorCode):
18353		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18354
18355	case strings.EqualFold("OperationFailureException", errorCode):
18356		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18357
18358	case strings.EqualFold("ServiceException", errorCode):
18359		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18360
18361	case strings.EqualFold("UnauthenticatedException", errorCode):
18362		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18363
18364	default:
18365		genericError := &smithy.GenericAPIError{
18366			Code:    errorCode,
18367			Message: errorMessage,
18368		}
18369		return genericError
18370
18371	}
18372}
18373
18374type awsAwsjson11_deserializeOpUpdateBucket struct {
18375}
18376
18377func (*awsAwsjson11_deserializeOpUpdateBucket) ID() string {
18378	return "OperationDeserializer"
18379}
18380
18381func (m *awsAwsjson11_deserializeOpUpdateBucket) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18382	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18383) {
18384	out, metadata, err = next.HandleDeserialize(ctx, in)
18385	if err != nil {
18386		return out, metadata, err
18387	}
18388
18389	response, ok := out.RawResponse.(*smithyhttp.Response)
18390	if !ok {
18391		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18392	}
18393
18394	if response.StatusCode < 200 || response.StatusCode >= 300 {
18395		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateBucket(response, &metadata)
18396	}
18397	output := &UpdateBucketOutput{}
18398	out.Result = output
18399
18400	var buff [1024]byte
18401	ringBuffer := smithyio.NewRingBuffer(buff[:])
18402
18403	body := io.TeeReader(response.Body, ringBuffer)
18404	decoder := json.NewDecoder(body)
18405	decoder.UseNumber()
18406	var shape interface{}
18407	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18408		var snapshot bytes.Buffer
18409		io.Copy(&snapshot, ringBuffer)
18410		err = &smithy.DeserializationError{
18411			Err:      fmt.Errorf("failed to decode response body, %w", err),
18412			Snapshot: snapshot.Bytes(),
18413		}
18414		return out, metadata, err
18415	}
18416
18417	err = awsAwsjson11_deserializeOpDocumentUpdateBucketOutput(&output, shape)
18418	if err != nil {
18419		var snapshot bytes.Buffer
18420		io.Copy(&snapshot, ringBuffer)
18421		err = &smithy.DeserializationError{
18422			Err:      fmt.Errorf("failed to decode response body, %w", err),
18423			Snapshot: snapshot.Bytes(),
18424		}
18425		return out, metadata, err
18426	}
18427
18428	return out, metadata, err
18429}
18430
18431func awsAwsjson11_deserializeOpErrorUpdateBucket(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18432	var errorBuffer bytes.Buffer
18433	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18434		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18435	}
18436	errorBody := bytes.NewReader(errorBuffer.Bytes())
18437
18438	errorCode := "UnknownError"
18439	errorMessage := errorCode
18440
18441	code := response.Header.Get("X-Amzn-ErrorType")
18442	if len(code) != 0 {
18443		errorCode = restjson.SanitizeErrorCode(code)
18444	}
18445
18446	var buff [1024]byte
18447	ringBuffer := smithyio.NewRingBuffer(buff[:])
18448
18449	body := io.TeeReader(errorBody, ringBuffer)
18450	decoder := json.NewDecoder(body)
18451	decoder.UseNumber()
18452	code, message, err := restjson.GetErrorInfo(decoder)
18453	if err != nil {
18454		var snapshot bytes.Buffer
18455		io.Copy(&snapshot, ringBuffer)
18456		err = &smithy.DeserializationError{
18457			Err:      fmt.Errorf("failed to decode response body, %w", err),
18458			Snapshot: snapshot.Bytes(),
18459		}
18460		return err
18461	}
18462
18463	errorBody.Seek(0, io.SeekStart)
18464	if len(code) != 0 {
18465		errorCode = restjson.SanitizeErrorCode(code)
18466	}
18467	if len(message) != 0 {
18468		errorMessage = message
18469	}
18470
18471	switch {
18472	case strings.EqualFold("AccessDeniedException", errorCode):
18473		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18474
18475	case strings.EqualFold("InvalidInputException", errorCode):
18476		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18477
18478	case strings.EqualFold("NotFoundException", errorCode):
18479		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18480
18481	case strings.EqualFold("ServiceException", errorCode):
18482		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18483
18484	case strings.EqualFold("UnauthenticatedException", errorCode):
18485		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18486
18487	default:
18488		genericError := &smithy.GenericAPIError{
18489			Code:    errorCode,
18490			Message: errorMessage,
18491		}
18492		return genericError
18493
18494	}
18495}
18496
18497type awsAwsjson11_deserializeOpUpdateBucketBundle struct {
18498}
18499
18500func (*awsAwsjson11_deserializeOpUpdateBucketBundle) ID() string {
18501	return "OperationDeserializer"
18502}
18503
18504func (m *awsAwsjson11_deserializeOpUpdateBucketBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18505	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18506) {
18507	out, metadata, err = next.HandleDeserialize(ctx, in)
18508	if err != nil {
18509		return out, metadata, err
18510	}
18511
18512	response, ok := out.RawResponse.(*smithyhttp.Response)
18513	if !ok {
18514		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18515	}
18516
18517	if response.StatusCode < 200 || response.StatusCode >= 300 {
18518		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateBucketBundle(response, &metadata)
18519	}
18520	output := &UpdateBucketBundleOutput{}
18521	out.Result = output
18522
18523	var buff [1024]byte
18524	ringBuffer := smithyio.NewRingBuffer(buff[:])
18525
18526	body := io.TeeReader(response.Body, ringBuffer)
18527	decoder := json.NewDecoder(body)
18528	decoder.UseNumber()
18529	var shape interface{}
18530	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18531		var snapshot bytes.Buffer
18532		io.Copy(&snapshot, ringBuffer)
18533		err = &smithy.DeserializationError{
18534			Err:      fmt.Errorf("failed to decode response body, %w", err),
18535			Snapshot: snapshot.Bytes(),
18536		}
18537		return out, metadata, err
18538	}
18539
18540	err = awsAwsjson11_deserializeOpDocumentUpdateBucketBundleOutput(&output, shape)
18541	if err != nil {
18542		var snapshot bytes.Buffer
18543		io.Copy(&snapshot, ringBuffer)
18544		err = &smithy.DeserializationError{
18545			Err:      fmt.Errorf("failed to decode response body, %w", err),
18546			Snapshot: snapshot.Bytes(),
18547		}
18548		return out, metadata, err
18549	}
18550
18551	return out, metadata, err
18552}
18553
18554func awsAwsjson11_deserializeOpErrorUpdateBucketBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18555	var errorBuffer bytes.Buffer
18556	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18557		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18558	}
18559	errorBody := bytes.NewReader(errorBuffer.Bytes())
18560
18561	errorCode := "UnknownError"
18562	errorMessage := errorCode
18563
18564	code := response.Header.Get("X-Amzn-ErrorType")
18565	if len(code) != 0 {
18566		errorCode = restjson.SanitizeErrorCode(code)
18567	}
18568
18569	var buff [1024]byte
18570	ringBuffer := smithyio.NewRingBuffer(buff[:])
18571
18572	body := io.TeeReader(errorBody, ringBuffer)
18573	decoder := json.NewDecoder(body)
18574	decoder.UseNumber()
18575	code, message, err := restjson.GetErrorInfo(decoder)
18576	if err != nil {
18577		var snapshot bytes.Buffer
18578		io.Copy(&snapshot, ringBuffer)
18579		err = &smithy.DeserializationError{
18580			Err:      fmt.Errorf("failed to decode response body, %w", err),
18581			Snapshot: snapshot.Bytes(),
18582		}
18583		return err
18584	}
18585
18586	errorBody.Seek(0, io.SeekStart)
18587	if len(code) != 0 {
18588		errorCode = restjson.SanitizeErrorCode(code)
18589	}
18590	if len(message) != 0 {
18591		errorMessage = message
18592	}
18593
18594	switch {
18595	case strings.EqualFold("AccessDeniedException", errorCode):
18596		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18597
18598	case strings.EqualFold("InvalidInputException", errorCode):
18599		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18600
18601	case strings.EqualFold("NotFoundException", errorCode):
18602		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18603
18604	case strings.EqualFold("ServiceException", errorCode):
18605		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18606
18607	case strings.EqualFold("UnauthenticatedException", errorCode):
18608		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18609
18610	default:
18611		genericError := &smithy.GenericAPIError{
18612			Code:    errorCode,
18613			Message: errorMessage,
18614		}
18615		return genericError
18616
18617	}
18618}
18619
18620type awsAwsjson11_deserializeOpUpdateContainerService struct {
18621}
18622
18623func (*awsAwsjson11_deserializeOpUpdateContainerService) ID() string {
18624	return "OperationDeserializer"
18625}
18626
18627func (m *awsAwsjson11_deserializeOpUpdateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18628	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18629) {
18630	out, metadata, err = next.HandleDeserialize(ctx, in)
18631	if err != nil {
18632		return out, metadata, err
18633	}
18634
18635	response, ok := out.RawResponse.(*smithyhttp.Response)
18636	if !ok {
18637		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18638	}
18639
18640	if response.StatusCode < 200 || response.StatusCode >= 300 {
18641		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerService(response, &metadata)
18642	}
18643	output := &UpdateContainerServiceOutput{}
18644	out.Result = output
18645
18646	var buff [1024]byte
18647	ringBuffer := smithyio.NewRingBuffer(buff[:])
18648
18649	body := io.TeeReader(response.Body, ringBuffer)
18650	decoder := json.NewDecoder(body)
18651	decoder.UseNumber()
18652	var shape interface{}
18653	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18654		var snapshot bytes.Buffer
18655		io.Copy(&snapshot, ringBuffer)
18656		err = &smithy.DeserializationError{
18657			Err:      fmt.Errorf("failed to decode response body, %w", err),
18658			Snapshot: snapshot.Bytes(),
18659		}
18660		return out, metadata, err
18661	}
18662
18663	err = awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(&output, shape)
18664	if err != nil {
18665		var snapshot bytes.Buffer
18666		io.Copy(&snapshot, ringBuffer)
18667		err = &smithy.DeserializationError{
18668			Err:      fmt.Errorf("failed to decode response body, %w", err),
18669			Snapshot: snapshot.Bytes(),
18670		}
18671		return out, metadata, err
18672	}
18673
18674	return out, metadata, err
18675}
18676
18677func awsAwsjson11_deserializeOpErrorUpdateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18678	var errorBuffer bytes.Buffer
18679	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18680		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18681	}
18682	errorBody := bytes.NewReader(errorBuffer.Bytes())
18683
18684	errorCode := "UnknownError"
18685	errorMessage := errorCode
18686
18687	code := response.Header.Get("X-Amzn-ErrorType")
18688	if len(code) != 0 {
18689		errorCode = restjson.SanitizeErrorCode(code)
18690	}
18691
18692	var buff [1024]byte
18693	ringBuffer := smithyio.NewRingBuffer(buff[:])
18694
18695	body := io.TeeReader(errorBody, ringBuffer)
18696	decoder := json.NewDecoder(body)
18697	decoder.UseNumber()
18698	code, message, err := restjson.GetErrorInfo(decoder)
18699	if err != nil {
18700		var snapshot bytes.Buffer
18701		io.Copy(&snapshot, ringBuffer)
18702		err = &smithy.DeserializationError{
18703			Err:      fmt.Errorf("failed to decode response body, %w", err),
18704			Snapshot: snapshot.Bytes(),
18705		}
18706		return err
18707	}
18708
18709	errorBody.Seek(0, io.SeekStart)
18710	if len(code) != 0 {
18711		errorCode = restjson.SanitizeErrorCode(code)
18712	}
18713	if len(message) != 0 {
18714		errorMessage = message
18715	}
18716
18717	switch {
18718	case strings.EqualFold("AccessDeniedException", errorCode):
18719		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18720
18721	case strings.EqualFold("InvalidInputException", errorCode):
18722		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18723
18724	case strings.EqualFold("NotFoundException", errorCode):
18725		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18726
18727	case strings.EqualFold("ServiceException", errorCode):
18728		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18729
18730	case strings.EqualFold("UnauthenticatedException", errorCode):
18731		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18732
18733	default:
18734		genericError := &smithy.GenericAPIError{
18735			Code:    errorCode,
18736			Message: errorMessage,
18737		}
18738		return genericError
18739
18740	}
18741}
18742
18743type awsAwsjson11_deserializeOpUpdateDistribution struct {
18744}
18745
18746func (*awsAwsjson11_deserializeOpUpdateDistribution) ID() string {
18747	return "OperationDeserializer"
18748}
18749
18750func (m *awsAwsjson11_deserializeOpUpdateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18751	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18752) {
18753	out, metadata, err = next.HandleDeserialize(ctx, in)
18754	if err != nil {
18755		return out, metadata, err
18756	}
18757
18758	response, ok := out.RawResponse.(*smithyhttp.Response)
18759	if !ok {
18760		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18761	}
18762
18763	if response.StatusCode < 200 || response.StatusCode >= 300 {
18764		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistribution(response, &metadata)
18765	}
18766	output := &UpdateDistributionOutput{}
18767	out.Result = output
18768
18769	var buff [1024]byte
18770	ringBuffer := smithyio.NewRingBuffer(buff[:])
18771
18772	body := io.TeeReader(response.Body, ringBuffer)
18773	decoder := json.NewDecoder(body)
18774	decoder.UseNumber()
18775	var shape interface{}
18776	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18777		var snapshot bytes.Buffer
18778		io.Copy(&snapshot, ringBuffer)
18779		err = &smithy.DeserializationError{
18780			Err:      fmt.Errorf("failed to decode response body, %w", err),
18781			Snapshot: snapshot.Bytes(),
18782		}
18783		return out, metadata, err
18784	}
18785
18786	err = awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(&output, shape)
18787	if err != nil {
18788		var snapshot bytes.Buffer
18789		io.Copy(&snapshot, ringBuffer)
18790		err = &smithy.DeserializationError{
18791			Err:      fmt.Errorf("failed to decode response body, %w", err),
18792			Snapshot: snapshot.Bytes(),
18793		}
18794		return out, metadata, err
18795	}
18796
18797	return out, metadata, err
18798}
18799
18800func awsAwsjson11_deserializeOpErrorUpdateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18801	var errorBuffer bytes.Buffer
18802	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18803		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18804	}
18805	errorBody := bytes.NewReader(errorBuffer.Bytes())
18806
18807	errorCode := "UnknownError"
18808	errorMessage := errorCode
18809
18810	code := response.Header.Get("X-Amzn-ErrorType")
18811	if len(code) != 0 {
18812		errorCode = restjson.SanitizeErrorCode(code)
18813	}
18814
18815	var buff [1024]byte
18816	ringBuffer := smithyio.NewRingBuffer(buff[:])
18817
18818	body := io.TeeReader(errorBody, ringBuffer)
18819	decoder := json.NewDecoder(body)
18820	decoder.UseNumber()
18821	code, message, err := restjson.GetErrorInfo(decoder)
18822	if err != nil {
18823		var snapshot bytes.Buffer
18824		io.Copy(&snapshot, ringBuffer)
18825		err = &smithy.DeserializationError{
18826			Err:      fmt.Errorf("failed to decode response body, %w", err),
18827			Snapshot: snapshot.Bytes(),
18828		}
18829		return err
18830	}
18831
18832	errorBody.Seek(0, io.SeekStart)
18833	if len(code) != 0 {
18834		errorCode = restjson.SanitizeErrorCode(code)
18835	}
18836	if len(message) != 0 {
18837		errorMessage = message
18838	}
18839
18840	switch {
18841	case strings.EqualFold("AccessDeniedException", errorCode):
18842		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18843
18844	case strings.EqualFold("InvalidInputException", errorCode):
18845		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18846
18847	case strings.EqualFold("NotFoundException", errorCode):
18848		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18849
18850	case strings.EqualFold("OperationFailureException", errorCode):
18851		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18852
18853	case strings.EqualFold("ServiceException", errorCode):
18854		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18855
18856	case strings.EqualFold("UnauthenticatedException", errorCode):
18857		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18858
18859	default:
18860		genericError := &smithy.GenericAPIError{
18861			Code:    errorCode,
18862			Message: errorMessage,
18863		}
18864		return genericError
18865
18866	}
18867}
18868
18869type awsAwsjson11_deserializeOpUpdateDistributionBundle struct {
18870}
18871
18872func (*awsAwsjson11_deserializeOpUpdateDistributionBundle) ID() string {
18873	return "OperationDeserializer"
18874}
18875
18876func (m *awsAwsjson11_deserializeOpUpdateDistributionBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18877	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18878) {
18879	out, metadata, err = next.HandleDeserialize(ctx, in)
18880	if err != nil {
18881		return out, metadata, err
18882	}
18883
18884	response, ok := out.RawResponse.(*smithyhttp.Response)
18885	if !ok {
18886		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18887	}
18888
18889	if response.StatusCode < 200 || response.StatusCode >= 300 {
18890		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response, &metadata)
18891	}
18892	output := &UpdateDistributionBundleOutput{}
18893	out.Result = output
18894
18895	var buff [1024]byte
18896	ringBuffer := smithyio.NewRingBuffer(buff[:])
18897
18898	body := io.TeeReader(response.Body, ringBuffer)
18899	decoder := json.NewDecoder(body)
18900	decoder.UseNumber()
18901	var shape interface{}
18902	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18903		var snapshot bytes.Buffer
18904		io.Copy(&snapshot, ringBuffer)
18905		err = &smithy.DeserializationError{
18906			Err:      fmt.Errorf("failed to decode response body, %w", err),
18907			Snapshot: snapshot.Bytes(),
18908		}
18909		return out, metadata, err
18910	}
18911
18912	err = awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(&output, shape)
18913	if err != nil {
18914		var snapshot bytes.Buffer
18915		io.Copy(&snapshot, ringBuffer)
18916		err = &smithy.DeserializationError{
18917			Err:      fmt.Errorf("failed to decode response body, %w", err),
18918			Snapshot: snapshot.Bytes(),
18919		}
18920		return out, metadata, err
18921	}
18922
18923	return out, metadata, err
18924}
18925
18926func awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18927	var errorBuffer bytes.Buffer
18928	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18929		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18930	}
18931	errorBody := bytes.NewReader(errorBuffer.Bytes())
18932
18933	errorCode := "UnknownError"
18934	errorMessage := errorCode
18935
18936	code := response.Header.Get("X-Amzn-ErrorType")
18937	if len(code) != 0 {
18938		errorCode = restjson.SanitizeErrorCode(code)
18939	}
18940
18941	var buff [1024]byte
18942	ringBuffer := smithyio.NewRingBuffer(buff[:])
18943
18944	body := io.TeeReader(errorBody, ringBuffer)
18945	decoder := json.NewDecoder(body)
18946	decoder.UseNumber()
18947	code, message, err := restjson.GetErrorInfo(decoder)
18948	if err != nil {
18949		var snapshot bytes.Buffer
18950		io.Copy(&snapshot, ringBuffer)
18951		err = &smithy.DeserializationError{
18952			Err:      fmt.Errorf("failed to decode response body, %w", err),
18953			Snapshot: snapshot.Bytes(),
18954		}
18955		return err
18956	}
18957
18958	errorBody.Seek(0, io.SeekStart)
18959	if len(code) != 0 {
18960		errorCode = restjson.SanitizeErrorCode(code)
18961	}
18962	if len(message) != 0 {
18963		errorMessage = message
18964	}
18965
18966	switch {
18967	case strings.EqualFold("AccessDeniedException", errorCode):
18968		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18969
18970	case strings.EqualFold("InvalidInputException", errorCode):
18971		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18972
18973	case strings.EqualFold("NotFoundException", errorCode):
18974		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18975
18976	case strings.EqualFold("OperationFailureException", errorCode):
18977		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18978
18979	case strings.EqualFold("ServiceException", errorCode):
18980		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18981
18982	case strings.EqualFold("UnauthenticatedException", errorCode):
18983		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18984
18985	default:
18986		genericError := &smithy.GenericAPIError{
18987			Code:    errorCode,
18988			Message: errorMessage,
18989		}
18990		return genericError
18991
18992	}
18993}
18994
18995type awsAwsjson11_deserializeOpUpdateDomainEntry struct {
18996}
18997
18998func (*awsAwsjson11_deserializeOpUpdateDomainEntry) ID() string {
18999	return "OperationDeserializer"
19000}
19001
19002func (m *awsAwsjson11_deserializeOpUpdateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19003	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19004) {
19005	out, metadata, err = next.HandleDeserialize(ctx, in)
19006	if err != nil {
19007		return out, metadata, err
19008	}
19009
19010	response, ok := out.RawResponse.(*smithyhttp.Response)
19011	if !ok {
19012		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19013	}
19014
19015	if response.StatusCode < 200 || response.StatusCode >= 300 {
19016		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response, &metadata)
19017	}
19018	output := &UpdateDomainEntryOutput{}
19019	out.Result = output
19020
19021	var buff [1024]byte
19022	ringBuffer := smithyio.NewRingBuffer(buff[:])
19023
19024	body := io.TeeReader(response.Body, ringBuffer)
19025	decoder := json.NewDecoder(body)
19026	decoder.UseNumber()
19027	var shape interface{}
19028	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19029		var snapshot bytes.Buffer
19030		io.Copy(&snapshot, ringBuffer)
19031		err = &smithy.DeserializationError{
19032			Err:      fmt.Errorf("failed to decode response body, %w", err),
19033			Snapshot: snapshot.Bytes(),
19034		}
19035		return out, metadata, err
19036	}
19037
19038	err = awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(&output, shape)
19039	if err != nil {
19040		var snapshot bytes.Buffer
19041		io.Copy(&snapshot, ringBuffer)
19042		err = &smithy.DeserializationError{
19043			Err:      fmt.Errorf("failed to decode response body, %w", err),
19044			Snapshot: snapshot.Bytes(),
19045		}
19046		return out, metadata, err
19047	}
19048
19049	return out, metadata, err
19050}
19051
19052func awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19053	var errorBuffer bytes.Buffer
19054	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19055		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19056	}
19057	errorBody := bytes.NewReader(errorBuffer.Bytes())
19058
19059	errorCode := "UnknownError"
19060	errorMessage := errorCode
19061
19062	code := response.Header.Get("X-Amzn-ErrorType")
19063	if len(code) != 0 {
19064		errorCode = restjson.SanitizeErrorCode(code)
19065	}
19066
19067	var buff [1024]byte
19068	ringBuffer := smithyio.NewRingBuffer(buff[:])
19069
19070	body := io.TeeReader(errorBody, ringBuffer)
19071	decoder := json.NewDecoder(body)
19072	decoder.UseNumber()
19073	code, message, err := restjson.GetErrorInfo(decoder)
19074	if err != nil {
19075		var snapshot bytes.Buffer
19076		io.Copy(&snapshot, ringBuffer)
19077		err = &smithy.DeserializationError{
19078			Err:      fmt.Errorf("failed to decode response body, %w", err),
19079			Snapshot: snapshot.Bytes(),
19080		}
19081		return err
19082	}
19083
19084	errorBody.Seek(0, io.SeekStart)
19085	if len(code) != 0 {
19086		errorCode = restjson.SanitizeErrorCode(code)
19087	}
19088	if len(message) != 0 {
19089		errorMessage = message
19090	}
19091
19092	switch {
19093	case strings.EqualFold("AccessDeniedException", errorCode):
19094		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19095
19096	case strings.EqualFold("AccountSetupInProgressException", errorCode):
19097		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19098
19099	case strings.EqualFold("InvalidInputException", errorCode):
19100		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19101
19102	case strings.EqualFold("NotFoundException", errorCode):
19103		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19104
19105	case strings.EqualFold("OperationFailureException", errorCode):
19106		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19107
19108	case strings.EqualFold("ServiceException", errorCode):
19109		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19110
19111	case strings.EqualFold("UnauthenticatedException", errorCode):
19112		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19113
19114	default:
19115		genericError := &smithy.GenericAPIError{
19116			Code:    errorCode,
19117			Message: errorMessage,
19118		}
19119		return genericError
19120
19121	}
19122}
19123
19124type awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute struct {
19125}
19126
19127func (*awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) ID() string {
19128	return "OperationDeserializer"
19129}
19130
19131func (m *awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19132	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19133) {
19134	out, metadata, err = next.HandleDeserialize(ctx, in)
19135	if err != nil {
19136		return out, metadata, err
19137	}
19138
19139	response, ok := out.RawResponse.(*smithyhttp.Response)
19140	if !ok {
19141		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19142	}
19143
19144	if response.StatusCode < 200 || response.StatusCode >= 300 {
19145		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response, &metadata)
19146	}
19147	output := &UpdateLoadBalancerAttributeOutput{}
19148	out.Result = output
19149
19150	var buff [1024]byte
19151	ringBuffer := smithyio.NewRingBuffer(buff[:])
19152
19153	body := io.TeeReader(response.Body, ringBuffer)
19154	decoder := json.NewDecoder(body)
19155	decoder.UseNumber()
19156	var shape interface{}
19157	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19158		var snapshot bytes.Buffer
19159		io.Copy(&snapshot, ringBuffer)
19160		err = &smithy.DeserializationError{
19161			Err:      fmt.Errorf("failed to decode response body, %w", err),
19162			Snapshot: snapshot.Bytes(),
19163		}
19164		return out, metadata, err
19165	}
19166
19167	err = awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(&output, shape)
19168	if err != nil {
19169		var snapshot bytes.Buffer
19170		io.Copy(&snapshot, ringBuffer)
19171		err = &smithy.DeserializationError{
19172			Err:      fmt.Errorf("failed to decode response body, %w", err),
19173			Snapshot: snapshot.Bytes(),
19174		}
19175		return out, metadata, err
19176	}
19177
19178	return out, metadata, err
19179}
19180
19181func awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19182	var errorBuffer bytes.Buffer
19183	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19184		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19185	}
19186	errorBody := bytes.NewReader(errorBuffer.Bytes())
19187
19188	errorCode := "UnknownError"
19189	errorMessage := errorCode
19190
19191	code := response.Header.Get("X-Amzn-ErrorType")
19192	if len(code) != 0 {
19193		errorCode = restjson.SanitizeErrorCode(code)
19194	}
19195
19196	var buff [1024]byte
19197	ringBuffer := smithyio.NewRingBuffer(buff[:])
19198
19199	body := io.TeeReader(errorBody, ringBuffer)
19200	decoder := json.NewDecoder(body)
19201	decoder.UseNumber()
19202	code, message, err := restjson.GetErrorInfo(decoder)
19203	if err != nil {
19204		var snapshot bytes.Buffer
19205		io.Copy(&snapshot, ringBuffer)
19206		err = &smithy.DeserializationError{
19207			Err:      fmt.Errorf("failed to decode response body, %w", err),
19208			Snapshot: snapshot.Bytes(),
19209		}
19210		return err
19211	}
19212
19213	errorBody.Seek(0, io.SeekStart)
19214	if len(code) != 0 {
19215		errorCode = restjson.SanitizeErrorCode(code)
19216	}
19217	if len(message) != 0 {
19218		errorMessage = message
19219	}
19220
19221	switch {
19222	case strings.EqualFold("AccessDeniedException", errorCode):
19223		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19224
19225	case strings.EqualFold("AccountSetupInProgressException", errorCode):
19226		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19227
19228	case strings.EqualFold("InvalidInputException", errorCode):
19229		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19230
19231	case strings.EqualFold("NotFoundException", errorCode):
19232		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19233
19234	case strings.EqualFold("OperationFailureException", errorCode):
19235		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19236
19237	case strings.EqualFold("ServiceException", errorCode):
19238		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19239
19240	case strings.EqualFold("UnauthenticatedException", errorCode):
19241		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19242
19243	default:
19244		genericError := &smithy.GenericAPIError{
19245			Code:    errorCode,
19246			Message: errorMessage,
19247		}
19248		return genericError
19249
19250	}
19251}
19252
19253type awsAwsjson11_deserializeOpUpdateRelationalDatabase struct {
19254}
19255
19256func (*awsAwsjson11_deserializeOpUpdateRelationalDatabase) ID() string {
19257	return "OperationDeserializer"
19258}
19259
19260func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19261	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19262) {
19263	out, metadata, err = next.HandleDeserialize(ctx, in)
19264	if err != nil {
19265		return out, metadata, err
19266	}
19267
19268	response, ok := out.RawResponse.(*smithyhttp.Response)
19269	if !ok {
19270		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19271	}
19272
19273	if response.StatusCode < 200 || response.StatusCode >= 300 {
19274		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response, &metadata)
19275	}
19276	output := &UpdateRelationalDatabaseOutput{}
19277	out.Result = output
19278
19279	var buff [1024]byte
19280	ringBuffer := smithyio.NewRingBuffer(buff[:])
19281
19282	body := io.TeeReader(response.Body, ringBuffer)
19283	decoder := json.NewDecoder(body)
19284	decoder.UseNumber()
19285	var shape interface{}
19286	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19287		var snapshot bytes.Buffer
19288		io.Copy(&snapshot, ringBuffer)
19289		err = &smithy.DeserializationError{
19290			Err:      fmt.Errorf("failed to decode response body, %w", err),
19291			Snapshot: snapshot.Bytes(),
19292		}
19293		return out, metadata, err
19294	}
19295
19296	err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(&output, shape)
19297	if err != nil {
19298		var snapshot bytes.Buffer
19299		io.Copy(&snapshot, ringBuffer)
19300		err = &smithy.DeserializationError{
19301			Err:      fmt.Errorf("failed to decode response body, %w", err),
19302			Snapshot: snapshot.Bytes(),
19303		}
19304		return out, metadata, err
19305	}
19306
19307	return out, metadata, err
19308}
19309
19310func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19311	var errorBuffer bytes.Buffer
19312	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19313		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19314	}
19315	errorBody := bytes.NewReader(errorBuffer.Bytes())
19316
19317	errorCode := "UnknownError"
19318	errorMessage := errorCode
19319
19320	code := response.Header.Get("X-Amzn-ErrorType")
19321	if len(code) != 0 {
19322		errorCode = restjson.SanitizeErrorCode(code)
19323	}
19324
19325	var buff [1024]byte
19326	ringBuffer := smithyio.NewRingBuffer(buff[:])
19327
19328	body := io.TeeReader(errorBody, ringBuffer)
19329	decoder := json.NewDecoder(body)
19330	decoder.UseNumber()
19331	code, message, err := restjson.GetErrorInfo(decoder)
19332	if err != nil {
19333		var snapshot bytes.Buffer
19334		io.Copy(&snapshot, ringBuffer)
19335		err = &smithy.DeserializationError{
19336			Err:      fmt.Errorf("failed to decode response body, %w", err),
19337			Snapshot: snapshot.Bytes(),
19338		}
19339		return err
19340	}
19341
19342	errorBody.Seek(0, io.SeekStart)
19343	if len(code) != 0 {
19344		errorCode = restjson.SanitizeErrorCode(code)
19345	}
19346	if len(message) != 0 {
19347		errorMessage = message
19348	}
19349
19350	switch {
19351	case strings.EqualFold("AccessDeniedException", errorCode):
19352		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19353
19354	case strings.EqualFold("AccountSetupInProgressException", errorCode):
19355		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19356
19357	case strings.EqualFold("InvalidInputException", errorCode):
19358		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19359
19360	case strings.EqualFold("NotFoundException", errorCode):
19361		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19362
19363	case strings.EqualFold("OperationFailureException", errorCode):
19364		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19365
19366	case strings.EqualFold("ServiceException", errorCode):
19367		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19368
19369	case strings.EqualFold("UnauthenticatedException", errorCode):
19370		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19371
19372	default:
19373		genericError := &smithy.GenericAPIError{
19374			Code:    errorCode,
19375			Message: errorMessage,
19376		}
19377		return genericError
19378
19379	}
19380}
19381
19382type awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters struct {
19383}
19384
19385func (*awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) ID() string {
19386	return "OperationDeserializer"
19387}
19388
19389func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
19390	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
19391) {
19392	out, metadata, err = next.HandleDeserialize(ctx, in)
19393	if err != nil {
19394		return out, metadata, err
19395	}
19396
19397	response, ok := out.RawResponse.(*smithyhttp.Response)
19398	if !ok {
19399		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
19400	}
19401
19402	if response.StatusCode < 200 || response.StatusCode >= 300 {
19403		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response, &metadata)
19404	}
19405	output := &UpdateRelationalDatabaseParametersOutput{}
19406	out.Result = output
19407
19408	var buff [1024]byte
19409	ringBuffer := smithyio.NewRingBuffer(buff[:])
19410
19411	body := io.TeeReader(response.Body, ringBuffer)
19412	decoder := json.NewDecoder(body)
19413	decoder.UseNumber()
19414	var shape interface{}
19415	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19416		var snapshot bytes.Buffer
19417		io.Copy(&snapshot, ringBuffer)
19418		err = &smithy.DeserializationError{
19419			Err:      fmt.Errorf("failed to decode response body, %w", err),
19420			Snapshot: snapshot.Bytes(),
19421		}
19422		return out, metadata, err
19423	}
19424
19425	err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(&output, shape)
19426	if err != nil {
19427		var snapshot bytes.Buffer
19428		io.Copy(&snapshot, ringBuffer)
19429		err = &smithy.DeserializationError{
19430			Err:      fmt.Errorf("failed to decode response body, %w", err),
19431			Snapshot: snapshot.Bytes(),
19432		}
19433		return out, metadata, err
19434	}
19435
19436	return out, metadata, err
19437}
19438
19439func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
19440	var errorBuffer bytes.Buffer
19441	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
19442		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
19443	}
19444	errorBody := bytes.NewReader(errorBuffer.Bytes())
19445
19446	errorCode := "UnknownError"
19447	errorMessage := errorCode
19448
19449	code := response.Header.Get("X-Amzn-ErrorType")
19450	if len(code) != 0 {
19451		errorCode = restjson.SanitizeErrorCode(code)
19452	}
19453
19454	var buff [1024]byte
19455	ringBuffer := smithyio.NewRingBuffer(buff[:])
19456
19457	body := io.TeeReader(errorBody, ringBuffer)
19458	decoder := json.NewDecoder(body)
19459	decoder.UseNumber()
19460	code, message, err := restjson.GetErrorInfo(decoder)
19461	if err != nil {
19462		var snapshot bytes.Buffer
19463		io.Copy(&snapshot, ringBuffer)
19464		err = &smithy.DeserializationError{
19465			Err:      fmt.Errorf("failed to decode response body, %w", err),
19466			Snapshot: snapshot.Bytes(),
19467		}
19468		return err
19469	}
19470
19471	errorBody.Seek(0, io.SeekStart)
19472	if len(code) != 0 {
19473		errorCode = restjson.SanitizeErrorCode(code)
19474	}
19475	if len(message) != 0 {
19476		errorMessage = message
19477	}
19478
19479	switch {
19480	case strings.EqualFold("AccessDeniedException", errorCode):
19481		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
19482
19483	case strings.EqualFold("AccountSetupInProgressException", errorCode):
19484		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
19485
19486	case strings.EqualFold("InvalidInputException", errorCode):
19487		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
19488
19489	case strings.EqualFold("NotFoundException", errorCode):
19490		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
19491
19492	case strings.EqualFold("OperationFailureException", errorCode):
19493		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
19494
19495	case strings.EqualFold("ServiceException", errorCode):
19496		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
19497
19498	case strings.EqualFold("UnauthenticatedException", errorCode):
19499		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
19500
19501	default:
19502		genericError := &smithy.GenericAPIError{
19503			Code:    errorCode,
19504			Message: errorMessage,
19505		}
19506		return genericError
19507
19508	}
19509}
19510
19511func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19512	var buff [1024]byte
19513	ringBuffer := smithyio.NewRingBuffer(buff[:])
19514
19515	body := io.TeeReader(errorBody, ringBuffer)
19516	decoder := json.NewDecoder(body)
19517	decoder.UseNumber()
19518	var shape interface{}
19519	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19520		var snapshot bytes.Buffer
19521		io.Copy(&snapshot, ringBuffer)
19522		err = &smithy.DeserializationError{
19523			Err:      fmt.Errorf("failed to decode response body, %w", err),
19524			Snapshot: snapshot.Bytes(),
19525		}
19526		return err
19527	}
19528
19529	output := &types.AccessDeniedException{}
19530	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
19531
19532	if err != nil {
19533		var snapshot bytes.Buffer
19534		io.Copy(&snapshot, ringBuffer)
19535		err = &smithy.DeserializationError{
19536			Err:      fmt.Errorf("failed to decode response body, %w", err),
19537			Snapshot: snapshot.Bytes(),
19538		}
19539		return err
19540	}
19541
19542	errorBody.Seek(0, io.SeekStart)
19543	return output
19544}
19545
19546func awsAwsjson11_deserializeErrorAccountSetupInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19547	var buff [1024]byte
19548	ringBuffer := smithyio.NewRingBuffer(buff[:])
19549
19550	body := io.TeeReader(errorBody, ringBuffer)
19551	decoder := json.NewDecoder(body)
19552	decoder.UseNumber()
19553	var shape interface{}
19554	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19555		var snapshot bytes.Buffer
19556		io.Copy(&snapshot, ringBuffer)
19557		err = &smithy.DeserializationError{
19558			Err:      fmt.Errorf("failed to decode response body, %w", err),
19559			Snapshot: snapshot.Bytes(),
19560		}
19561		return err
19562	}
19563
19564	output := &types.AccountSetupInProgressException{}
19565	err := awsAwsjson11_deserializeDocumentAccountSetupInProgressException(&output, shape)
19566
19567	if err != nil {
19568		var snapshot bytes.Buffer
19569		io.Copy(&snapshot, ringBuffer)
19570		err = &smithy.DeserializationError{
19571			Err:      fmt.Errorf("failed to decode response body, %w", err),
19572			Snapshot: snapshot.Bytes(),
19573		}
19574		return err
19575	}
19576
19577	errorBody.Seek(0, io.SeekStart)
19578	return output
19579}
19580
19581func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19582	var buff [1024]byte
19583	ringBuffer := smithyio.NewRingBuffer(buff[:])
19584
19585	body := io.TeeReader(errorBody, ringBuffer)
19586	decoder := json.NewDecoder(body)
19587	decoder.UseNumber()
19588	var shape interface{}
19589	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19590		var snapshot bytes.Buffer
19591		io.Copy(&snapshot, ringBuffer)
19592		err = &smithy.DeserializationError{
19593			Err:      fmt.Errorf("failed to decode response body, %w", err),
19594			Snapshot: snapshot.Bytes(),
19595		}
19596		return err
19597	}
19598
19599	output := &types.InvalidInputException{}
19600	err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape)
19601
19602	if err != nil {
19603		var snapshot bytes.Buffer
19604		io.Copy(&snapshot, ringBuffer)
19605		err = &smithy.DeserializationError{
19606			Err:      fmt.Errorf("failed to decode response body, %w", err),
19607			Snapshot: snapshot.Bytes(),
19608		}
19609		return err
19610	}
19611
19612	errorBody.Seek(0, io.SeekStart)
19613	return output
19614}
19615
19616func awsAwsjson11_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19617	var buff [1024]byte
19618	ringBuffer := smithyio.NewRingBuffer(buff[:])
19619
19620	body := io.TeeReader(errorBody, ringBuffer)
19621	decoder := json.NewDecoder(body)
19622	decoder.UseNumber()
19623	var shape interface{}
19624	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19625		var snapshot bytes.Buffer
19626		io.Copy(&snapshot, ringBuffer)
19627		err = &smithy.DeserializationError{
19628			Err:      fmt.Errorf("failed to decode response body, %w", err),
19629			Snapshot: snapshot.Bytes(),
19630		}
19631		return err
19632	}
19633
19634	output := &types.NotFoundException{}
19635	err := awsAwsjson11_deserializeDocumentNotFoundException(&output, shape)
19636
19637	if err != nil {
19638		var snapshot bytes.Buffer
19639		io.Copy(&snapshot, ringBuffer)
19640		err = &smithy.DeserializationError{
19641			Err:      fmt.Errorf("failed to decode response body, %w", err),
19642			Snapshot: snapshot.Bytes(),
19643		}
19644		return err
19645	}
19646
19647	errorBody.Seek(0, io.SeekStart)
19648	return output
19649}
19650
19651func awsAwsjson11_deserializeErrorOperationFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19652	var buff [1024]byte
19653	ringBuffer := smithyio.NewRingBuffer(buff[:])
19654
19655	body := io.TeeReader(errorBody, ringBuffer)
19656	decoder := json.NewDecoder(body)
19657	decoder.UseNumber()
19658	var shape interface{}
19659	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19660		var snapshot bytes.Buffer
19661		io.Copy(&snapshot, ringBuffer)
19662		err = &smithy.DeserializationError{
19663			Err:      fmt.Errorf("failed to decode response body, %w", err),
19664			Snapshot: snapshot.Bytes(),
19665		}
19666		return err
19667	}
19668
19669	output := &types.OperationFailureException{}
19670	err := awsAwsjson11_deserializeDocumentOperationFailureException(&output, shape)
19671
19672	if err != nil {
19673		var snapshot bytes.Buffer
19674		io.Copy(&snapshot, ringBuffer)
19675		err = &smithy.DeserializationError{
19676			Err:      fmt.Errorf("failed to decode response body, %w", err),
19677			Snapshot: snapshot.Bytes(),
19678		}
19679		return err
19680	}
19681
19682	errorBody.Seek(0, io.SeekStart)
19683	return output
19684}
19685
19686func awsAwsjson11_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19687	var buff [1024]byte
19688	ringBuffer := smithyio.NewRingBuffer(buff[:])
19689
19690	body := io.TeeReader(errorBody, ringBuffer)
19691	decoder := json.NewDecoder(body)
19692	decoder.UseNumber()
19693	var shape interface{}
19694	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19695		var snapshot bytes.Buffer
19696		io.Copy(&snapshot, ringBuffer)
19697		err = &smithy.DeserializationError{
19698			Err:      fmt.Errorf("failed to decode response body, %w", err),
19699			Snapshot: snapshot.Bytes(),
19700		}
19701		return err
19702	}
19703
19704	output := &types.ServiceException{}
19705	err := awsAwsjson11_deserializeDocumentServiceException(&output, shape)
19706
19707	if err != nil {
19708		var snapshot bytes.Buffer
19709		io.Copy(&snapshot, ringBuffer)
19710		err = &smithy.DeserializationError{
19711			Err:      fmt.Errorf("failed to decode response body, %w", err),
19712			Snapshot: snapshot.Bytes(),
19713		}
19714		return err
19715	}
19716
19717	errorBody.Seek(0, io.SeekStart)
19718	return output
19719}
19720
19721func awsAwsjson11_deserializeErrorUnauthenticatedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
19722	var buff [1024]byte
19723	ringBuffer := smithyio.NewRingBuffer(buff[:])
19724
19725	body := io.TeeReader(errorBody, ringBuffer)
19726	decoder := json.NewDecoder(body)
19727	decoder.UseNumber()
19728	var shape interface{}
19729	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
19730		var snapshot bytes.Buffer
19731		io.Copy(&snapshot, ringBuffer)
19732		err = &smithy.DeserializationError{
19733			Err:      fmt.Errorf("failed to decode response body, %w", err),
19734			Snapshot: snapshot.Bytes(),
19735		}
19736		return err
19737	}
19738
19739	output := &types.UnauthenticatedException{}
19740	err := awsAwsjson11_deserializeDocumentUnauthenticatedException(&output, shape)
19741
19742	if err != nil {
19743		var snapshot bytes.Buffer
19744		io.Copy(&snapshot, ringBuffer)
19745		err = &smithy.DeserializationError{
19746			Err:      fmt.Errorf("failed to decode response body, %w", err),
19747			Snapshot: snapshot.Bytes(),
19748		}
19749		return err
19750	}
19751
19752	errorBody.Seek(0, io.SeekStart)
19753	return output
19754}
19755
19756func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
19757	if v == nil {
19758		return fmt.Errorf("unexpected nil of type %T", v)
19759	}
19760	if value == nil {
19761		return nil
19762	}
19763
19764	shape, ok := value.(map[string]interface{})
19765	if !ok {
19766		return fmt.Errorf("unexpected JSON type %v", value)
19767	}
19768
19769	var sv *types.AccessDeniedException
19770	if *v == nil {
19771		sv = &types.AccessDeniedException{}
19772	} else {
19773		sv = *v
19774	}
19775
19776	for key, value := range shape {
19777		switch key {
19778		case "code":
19779			if value != nil {
19780				jtv, ok := value.(string)
19781				if !ok {
19782					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19783				}
19784				sv.Code = ptr.String(jtv)
19785			}
19786
19787		case "docs":
19788			if value != nil {
19789				jtv, ok := value.(string)
19790				if !ok {
19791					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19792				}
19793				sv.Docs = ptr.String(jtv)
19794			}
19795
19796		case "message":
19797			if value != nil {
19798				jtv, ok := value.(string)
19799				if !ok {
19800					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19801				}
19802				sv.Message = ptr.String(jtv)
19803			}
19804
19805		case "tip":
19806			if value != nil {
19807				jtv, ok := value.(string)
19808				if !ok {
19809					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19810				}
19811				sv.Tip = ptr.String(jtv)
19812			}
19813
19814		default:
19815			_, _ = key, value
19816
19817		}
19818	}
19819	*v = sv
19820	return nil
19821}
19822
19823func awsAwsjson11_deserializeDocumentAccessKey(v **types.AccessKey, value interface{}) error {
19824	if v == nil {
19825		return fmt.Errorf("unexpected nil of type %T", v)
19826	}
19827	if value == nil {
19828		return nil
19829	}
19830
19831	shape, ok := value.(map[string]interface{})
19832	if !ok {
19833		return fmt.Errorf("unexpected JSON type %v", value)
19834	}
19835
19836	var sv *types.AccessKey
19837	if *v == nil {
19838		sv = &types.AccessKey{}
19839	} else {
19840		sv = *v
19841	}
19842
19843	for key, value := range shape {
19844		switch key {
19845		case "accessKeyId":
19846			if value != nil {
19847				jtv, ok := value.(string)
19848				if !ok {
19849					return fmt.Errorf("expected IAMAccessKeyId to be of type string, got %T instead", value)
19850				}
19851				sv.AccessKeyId = ptr.String(jtv)
19852			}
19853
19854		case "createdAt":
19855			if value != nil {
19856				switch jtv := value.(type) {
19857				case json.Number:
19858					f64, err := jtv.Float64()
19859					if err != nil {
19860						return err
19861					}
19862					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
19863
19864				default:
19865					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
19866
19867				}
19868			}
19869
19870		case "lastUsed":
19871			if err := awsAwsjson11_deserializeDocumentAccessKeyLastUsed(&sv.LastUsed, value); err != nil {
19872				return err
19873			}
19874
19875		case "secretAccessKey":
19876			if value != nil {
19877				jtv, ok := value.(string)
19878				if !ok {
19879					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19880				}
19881				sv.SecretAccessKey = ptr.String(jtv)
19882			}
19883
19884		case "status":
19885			if value != nil {
19886				jtv, ok := value.(string)
19887				if !ok {
19888					return fmt.Errorf("expected StatusType to be of type string, got %T instead", value)
19889				}
19890				sv.Status = types.StatusType(jtv)
19891			}
19892
19893		default:
19894			_, _ = key, value
19895
19896		}
19897	}
19898	*v = sv
19899	return nil
19900}
19901
19902func awsAwsjson11_deserializeDocumentAccessKeyLastUsed(v **types.AccessKeyLastUsed, value interface{}) error {
19903	if v == nil {
19904		return fmt.Errorf("unexpected nil of type %T", v)
19905	}
19906	if value == nil {
19907		return nil
19908	}
19909
19910	shape, ok := value.(map[string]interface{})
19911	if !ok {
19912		return fmt.Errorf("unexpected JSON type %v", value)
19913	}
19914
19915	var sv *types.AccessKeyLastUsed
19916	if *v == nil {
19917		sv = &types.AccessKeyLastUsed{}
19918	} else {
19919		sv = *v
19920	}
19921
19922	for key, value := range shape {
19923		switch key {
19924		case "lastUsedDate":
19925			if value != nil {
19926				switch jtv := value.(type) {
19927				case json.Number:
19928					f64, err := jtv.Float64()
19929					if err != nil {
19930						return err
19931					}
19932					sv.LastUsedDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
19933
19934				default:
19935					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
19936
19937				}
19938			}
19939
19940		case "region":
19941			if value != nil {
19942				jtv, ok := value.(string)
19943				if !ok {
19944					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19945				}
19946				sv.Region = ptr.String(jtv)
19947			}
19948
19949		case "serviceName":
19950			if value != nil {
19951				jtv, ok := value.(string)
19952				if !ok {
19953					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19954				}
19955				sv.ServiceName = ptr.String(jtv)
19956			}
19957
19958		default:
19959			_, _ = key, value
19960
19961		}
19962	}
19963	*v = sv
19964	return nil
19965}
19966
19967func awsAwsjson11_deserializeDocumentAccessKeyList(v *[]types.AccessKey, value interface{}) error {
19968	if v == nil {
19969		return fmt.Errorf("unexpected nil of type %T", v)
19970	}
19971	if value == nil {
19972		return nil
19973	}
19974
19975	shape, ok := value.([]interface{})
19976	if !ok {
19977		return fmt.Errorf("unexpected JSON type %v", value)
19978	}
19979
19980	var cv []types.AccessKey
19981	if *v == nil {
19982		cv = []types.AccessKey{}
19983	} else {
19984		cv = *v
19985	}
19986
19987	for _, value := range shape {
19988		var col types.AccessKey
19989		destAddr := &col
19990		if err := awsAwsjson11_deserializeDocumentAccessKey(&destAddr, value); err != nil {
19991			return err
19992		}
19993		col = *destAddr
19994		cv = append(cv, col)
19995
19996	}
19997	*v = cv
19998	return nil
19999}
20000
20001func awsAwsjson11_deserializeDocumentAccessReceiverList(v *[]types.ResourceReceivingAccess, value interface{}) error {
20002	if v == nil {
20003		return fmt.Errorf("unexpected nil of type %T", v)
20004	}
20005	if value == nil {
20006		return nil
20007	}
20008
20009	shape, ok := value.([]interface{})
20010	if !ok {
20011		return fmt.Errorf("unexpected JSON type %v", value)
20012	}
20013
20014	var cv []types.ResourceReceivingAccess
20015	if *v == nil {
20016		cv = []types.ResourceReceivingAccess{}
20017	} else {
20018		cv = *v
20019	}
20020
20021	for _, value := range shape {
20022		var col types.ResourceReceivingAccess
20023		destAddr := &col
20024		if err := awsAwsjson11_deserializeDocumentResourceReceivingAccess(&destAddr, value); err != nil {
20025			return err
20026		}
20027		col = *destAddr
20028		cv = append(cv, col)
20029
20030	}
20031	*v = cv
20032	return nil
20033}
20034
20035func awsAwsjson11_deserializeDocumentAccessRules(v **types.AccessRules, value interface{}) error {
20036	if v == nil {
20037		return fmt.Errorf("unexpected nil of type %T", v)
20038	}
20039	if value == nil {
20040		return nil
20041	}
20042
20043	shape, ok := value.(map[string]interface{})
20044	if !ok {
20045		return fmt.Errorf("unexpected JSON type %v", value)
20046	}
20047
20048	var sv *types.AccessRules
20049	if *v == nil {
20050		sv = &types.AccessRules{}
20051	} else {
20052		sv = *v
20053	}
20054
20055	for key, value := range shape {
20056		switch key {
20057		case "allowPublicOverrides":
20058			if value != nil {
20059				jtv, ok := value.(bool)
20060				if !ok {
20061					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
20062				}
20063				sv.AllowPublicOverrides = ptr.Bool(jtv)
20064			}
20065
20066		case "getObject":
20067			if value != nil {
20068				jtv, ok := value.(string)
20069				if !ok {
20070					return fmt.Errorf("expected AccessType to be of type string, got %T instead", value)
20071				}
20072				sv.GetObject = types.AccessType(jtv)
20073			}
20074
20075		default:
20076			_, _ = key, value
20077
20078		}
20079	}
20080	*v = sv
20081	return nil
20082}
20083
20084func awsAwsjson11_deserializeDocumentAccountSetupInProgressException(v **types.AccountSetupInProgressException, value interface{}) error {
20085	if v == nil {
20086		return fmt.Errorf("unexpected nil of type %T", v)
20087	}
20088	if value == nil {
20089		return nil
20090	}
20091
20092	shape, ok := value.(map[string]interface{})
20093	if !ok {
20094		return fmt.Errorf("unexpected JSON type %v", value)
20095	}
20096
20097	var sv *types.AccountSetupInProgressException
20098	if *v == nil {
20099		sv = &types.AccountSetupInProgressException{}
20100	} else {
20101		sv = *v
20102	}
20103
20104	for key, value := range shape {
20105		switch key {
20106		case "code":
20107			if value != nil {
20108				jtv, ok := value.(string)
20109				if !ok {
20110					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20111				}
20112				sv.Code = ptr.String(jtv)
20113			}
20114
20115		case "docs":
20116			if value != nil {
20117				jtv, ok := value.(string)
20118				if !ok {
20119					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20120				}
20121				sv.Docs = ptr.String(jtv)
20122			}
20123
20124		case "message":
20125			if value != nil {
20126				jtv, ok := value.(string)
20127				if !ok {
20128					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20129				}
20130				sv.Message = ptr.String(jtv)
20131			}
20132
20133		case "tip":
20134			if value != nil {
20135				jtv, ok := value.(string)
20136				if !ok {
20137					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20138				}
20139				sv.Tip = ptr.String(jtv)
20140			}
20141
20142		default:
20143			_, _ = key, value
20144
20145		}
20146	}
20147	*v = sv
20148	return nil
20149}
20150
20151func awsAwsjson11_deserializeDocumentAddOn(v **types.AddOn, value interface{}) error {
20152	if v == nil {
20153		return fmt.Errorf("unexpected nil of type %T", v)
20154	}
20155	if value == nil {
20156		return nil
20157	}
20158
20159	shape, ok := value.(map[string]interface{})
20160	if !ok {
20161		return fmt.Errorf("unexpected JSON type %v", value)
20162	}
20163
20164	var sv *types.AddOn
20165	if *v == nil {
20166		sv = &types.AddOn{}
20167	} else {
20168		sv = *v
20169	}
20170
20171	for key, value := range shape {
20172		switch key {
20173		case "name":
20174			if value != nil {
20175				jtv, ok := value.(string)
20176				if !ok {
20177					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20178				}
20179				sv.Name = ptr.String(jtv)
20180			}
20181
20182		case "nextSnapshotTimeOfDay":
20183			if value != nil {
20184				jtv, ok := value.(string)
20185				if !ok {
20186					return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
20187				}
20188				sv.NextSnapshotTimeOfDay = ptr.String(jtv)
20189			}
20190
20191		case "snapshotTimeOfDay":
20192			if value != nil {
20193				jtv, ok := value.(string)
20194				if !ok {
20195					return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
20196				}
20197				sv.SnapshotTimeOfDay = ptr.String(jtv)
20198			}
20199
20200		case "status":
20201			if value != nil {
20202				jtv, ok := value.(string)
20203				if !ok {
20204					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20205				}
20206				sv.Status = ptr.String(jtv)
20207			}
20208
20209		default:
20210			_, _ = key, value
20211
20212		}
20213	}
20214	*v = sv
20215	return nil
20216}
20217
20218func awsAwsjson11_deserializeDocumentAddOnList(v *[]types.AddOn, value interface{}) error {
20219	if v == nil {
20220		return fmt.Errorf("unexpected nil of type %T", v)
20221	}
20222	if value == nil {
20223		return nil
20224	}
20225
20226	shape, ok := value.([]interface{})
20227	if !ok {
20228		return fmt.Errorf("unexpected JSON type %v", value)
20229	}
20230
20231	var cv []types.AddOn
20232	if *v == nil {
20233		cv = []types.AddOn{}
20234	} else {
20235		cv = *v
20236	}
20237
20238	for _, value := range shape {
20239		var col types.AddOn
20240		destAddr := &col
20241		if err := awsAwsjson11_deserializeDocumentAddOn(&destAddr, value); err != nil {
20242			return err
20243		}
20244		col = *destAddr
20245		cv = append(cv, col)
20246
20247	}
20248	*v = cv
20249	return nil
20250}
20251
20252func awsAwsjson11_deserializeDocumentAlarm(v **types.Alarm, value interface{}) error {
20253	if v == nil {
20254		return fmt.Errorf("unexpected nil of type %T", v)
20255	}
20256	if value == nil {
20257		return nil
20258	}
20259
20260	shape, ok := value.(map[string]interface{})
20261	if !ok {
20262		return fmt.Errorf("unexpected JSON type %v", value)
20263	}
20264
20265	var sv *types.Alarm
20266	if *v == nil {
20267		sv = &types.Alarm{}
20268	} else {
20269		sv = *v
20270	}
20271
20272	for key, value := range shape {
20273		switch key {
20274		case "arn":
20275			if value != nil {
20276				jtv, ok := value.(string)
20277				if !ok {
20278					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20279				}
20280				sv.Arn = ptr.String(jtv)
20281			}
20282
20283		case "comparisonOperator":
20284			if value != nil {
20285				jtv, ok := value.(string)
20286				if !ok {
20287					return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
20288				}
20289				sv.ComparisonOperator = types.ComparisonOperator(jtv)
20290			}
20291
20292		case "contactProtocols":
20293			if err := awsAwsjson11_deserializeDocumentContactProtocolsList(&sv.ContactProtocols, value); err != nil {
20294				return err
20295			}
20296
20297		case "createdAt":
20298			if value != nil {
20299				switch jtv := value.(type) {
20300				case json.Number:
20301					f64, err := jtv.Float64()
20302					if err != nil {
20303						return err
20304					}
20305					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20306
20307				default:
20308					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
20309
20310				}
20311			}
20312
20313		case "datapointsToAlarm":
20314			if value != nil {
20315				jtv, ok := value.(json.Number)
20316				if !ok {
20317					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20318				}
20319				i64, err := jtv.Int64()
20320				if err != nil {
20321					return err
20322				}
20323				sv.DatapointsToAlarm = ptr.Int32(int32(i64))
20324			}
20325
20326		case "evaluationPeriods":
20327			if value != nil {
20328				jtv, ok := value.(json.Number)
20329				if !ok {
20330					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20331				}
20332				i64, err := jtv.Int64()
20333				if err != nil {
20334					return err
20335				}
20336				sv.EvaluationPeriods = ptr.Int32(int32(i64))
20337			}
20338
20339		case "location":
20340			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
20341				return err
20342			}
20343
20344		case "metricName":
20345			if value != nil {
20346				jtv, ok := value.(string)
20347				if !ok {
20348					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
20349				}
20350				sv.MetricName = types.MetricName(jtv)
20351			}
20352
20353		case "monitoredResourceInfo":
20354			if err := awsAwsjson11_deserializeDocumentMonitoredResourceInfo(&sv.MonitoredResourceInfo, value); err != nil {
20355				return err
20356			}
20357
20358		case "name":
20359			if value != nil {
20360				jtv, ok := value.(string)
20361				if !ok {
20362					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
20363				}
20364				sv.Name = ptr.String(jtv)
20365			}
20366
20367		case "notificationEnabled":
20368			if value != nil {
20369				jtv, ok := value.(bool)
20370				if !ok {
20371					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
20372				}
20373				sv.NotificationEnabled = ptr.Bool(jtv)
20374			}
20375
20376		case "notificationTriggers":
20377			if err := awsAwsjson11_deserializeDocumentNotificationTriggerList(&sv.NotificationTriggers, value); err != nil {
20378				return err
20379			}
20380
20381		case "period":
20382			if value != nil {
20383				jtv, ok := value.(json.Number)
20384				if !ok {
20385					return fmt.Errorf("expected MetricPeriod to be json.Number, got %T instead", value)
20386				}
20387				i64, err := jtv.Int64()
20388				if err != nil {
20389					return err
20390				}
20391				sv.Period = int32(i64)
20392			}
20393
20394		case "resourceType":
20395			if value != nil {
20396				jtv, ok := value.(string)
20397				if !ok {
20398					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
20399				}
20400				sv.ResourceType = types.ResourceType(jtv)
20401			}
20402
20403		case "state":
20404			if value != nil {
20405				jtv, ok := value.(string)
20406				if !ok {
20407					return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
20408				}
20409				sv.State = types.AlarmState(jtv)
20410			}
20411
20412		case "statistic":
20413			if value != nil {
20414				jtv, ok := value.(string)
20415				if !ok {
20416					return fmt.Errorf("expected MetricStatistic to be of type string, got %T instead", value)
20417				}
20418				sv.Statistic = types.MetricStatistic(jtv)
20419			}
20420
20421		case "supportCode":
20422			if value != nil {
20423				jtv, ok := value.(string)
20424				if !ok {
20425					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20426				}
20427				sv.SupportCode = ptr.String(jtv)
20428			}
20429
20430		case "threshold":
20431			if value != nil {
20432				switch jtv := value.(type) {
20433				case json.Number:
20434					f64, err := jtv.Float64()
20435					if err != nil {
20436						return err
20437					}
20438					sv.Threshold = ptr.Float64(f64)
20439
20440				case string:
20441					var f64 float64
20442					switch {
20443					case strings.EqualFold(jtv, "NaN"):
20444						f64 = math.NaN()
20445
20446					case strings.EqualFold(jtv, "Infinity"):
20447						f64 = math.Inf(1)
20448
20449					case strings.EqualFold(jtv, "-Infinity"):
20450						f64 = math.Inf(-1)
20451
20452					default:
20453						return fmt.Errorf("unknown JSON number value: %s", jtv)
20454
20455					}
20456					sv.Threshold = ptr.Float64(f64)
20457
20458				default:
20459					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
20460
20461				}
20462			}
20463
20464		case "treatMissingData":
20465			if value != nil {
20466				jtv, ok := value.(string)
20467				if !ok {
20468					return fmt.Errorf("expected TreatMissingData to be of type string, got %T instead", value)
20469				}
20470				sv.TreatMissingData = types.TreatMissingData(jtv)
20471			}
20472
20473		case "unit":
20474			if value != nil {
20475				jtv, ok := value.(string)
20476				if !ok {
20477					return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
20478				}
20479				sv.Unit = types.MetricUnit(jtv)
20480			}
20481
20482		default:
20483			_, _ = key, value
20484
20485		}
20486	}
20487	*v = sv
20488	return nil
20489}
20490
20491func awsAwsjson11_deserializeDocumentAlarmsList(v *[]types.Alarm, value interface{}) error {
20492	if v == nil {
20493		return fmt.Errorf("unexpected nil of type %T", v)
20494	}
20495	if value == nil {
20496		return nil
20497	}
20498
20499	shape, ok := value.([]interface{})
20500	if !ok {
20501		return fmt.Errorf("unexpected JSON type %v", value)
20502	}
20503
20504	var cv []types.Alarm
20505	if *v == nil {
20506		cv = []types.Alarm{}
20507	} else {
20508		cv = *v
20509	}
20510
20511	for _, value := range shape {
20512		var col types.Alarm
20513		destAddr := &col
20514		if err := awsAwsjson11_deserializeDocumentAlarm(&destAddr, value); err != nil {
20515			return err
20516		}
20517		col = *destAddr
20518		cv = append(cv, col)
20519
20520	}
20521	*v = cv
20522	return nil
20523}
20524
20525func awsAwsjson11_deserializeDocumentAttachedDisk(v **types.AttachedDisk, value interface{}) error {
20526	if v == nil {
20527		return fmt.Errorf("unexpected nil of type %T", v)
20528	}
20529	if value == nil {
20530		return nil
20531	}
20532
20533	shape, ok := value.(map[string]interface{})
20534	if !ok {
20535		return fmt.Errorf("unexpected JSON type %v", value)
20536	}
20537
20538	var sv *types.AttachedDisk
20539	if *v == nil {
20540		sv = &types.AttachedDisk{}
20541	} else {
20542		sv = *v
20543	}
20544
20545	for key, value := range shape {
20546		switch key {
20547		case "path":
20548			if value != nil {
20549				jtv, ok := value.(string)
20550				if !ok {
20551					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20552				}
20553				sv.Path = ptr.String(jtv)
20554			}
20555
20556		case "sizeInGb":
20557			if value != nil {
20558				jtv, ok := value.(json.Number)
20559				if !ok {
20560					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20561				}
20562				i64, err := jtv.Int64()
20563				if err != nil {
20564					return err
20565				}
20566				sv.SizeInGb = ptr.Int32(int32(i64))
20567			}
20568
20569		default:
20570			_, _ = key, value
20571
20572		}
20573	}
20574	*v = sv
20575	return nil
20576}
20577
20578func awsAwsjson11_deserializeDocumentAttachedDiskList(v *[]types.AttachedDisk, value interface{}) error {
20579	if v == nil {
20580		return fmt.Errorf("unexpected nil of type %T", v)
20581	}
20582	if value == nil {
20583		return nil
20584	}
20585
20586	shape, ok := value.([]interface{})
20587	if !ok {
20588		return fmt.Errorf("unexpected JSON type %v", value)
20589	}
20590
20591	var cv []types.AttachedDisk
20592	if *v == nil {
20593		cv = []types.AttachedDisk{}
20594	} else {
20595		cv = *v
20596	}
20597
20598	for _, value := range shape {
20599		var col types.AttachedDisk
20600		destAddr := &col
20601		if err := awsAwsjson11_deserializeDocumentAttachedDisk(&destAddr, value); err != nil {
20602			return err
20603		}
20604		col = *destAddr
20605		cv = append(cv, col)
20606
20607	}
20608	*v = cv
20609	return nil
20610}
20611
20612func awsAwsjson11_deserializeDocumentAutoSnapshotDetails(v **types.AutoSnapshotDetails, value interface{}) error {
20613	if v == nil {
20614		return fmt.Errorf("unexpected nil of type %T", v)
20615	}
20616	if value == nil {
20617		return nil
20618	}
20619
20620	shape, ok := value.(map[string]interface{})
20621	if !ok {
20622		return fmt.Errorf("unexpected JSON type %v", value)
20623	}
20624
20625	var sv *types.AutoSnapshotDetails
20626	if *v == nil {
20627		sv = &types.AutoSnapshotDetails{}
20628	} else {
20629		sv = *v
20630	}
20631
20632	for key, value := range shape {
20633		switch key {
20634		case "createdAt":
20635			if value != nil {
20636				switch jtv := value.(type) {
20637				case json.Number:
20638					f64, err := jtv.Float64()
20639					if err != nil {
20640						return err
20641					}
20642					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20643
20644				default:
20645					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
20646
20647				}
20648			}
20649
20650		case "date":
20651			if value != nil {
20652				jtv, ok := value.(string)
20653				if !ok {
20654					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20655				}
20656				sv.Date = ptr.String(jtv)
20657			}
20658
20659		case "fromAttachedDisks":
20660			if err := awsAwsjson11_deserializeDocumentAttachedDiskList(&sv.FromAttachedDisks, value); err != nil {
20661				return err
20662			}
20663
20664		case "status":
20665			if value != nil {
20666				jtv, ok := value.(string)
20667				if !ok {
20668					return fmt.Errorf("expected AutoSnapshotStatus to be of type string, got %T instead", value)
20669				}
20670				sv.Status = types.AutoSnapshotStatus(jtv)
20671			}
20672
20673		default:
20674			_, _ = key, value
20675
20676		}
20677	}
20678	*v = sv
20679	return nil
20680}
20681
20682func awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(v *[]types.AutoSnapshotDetails, value interface{}) error {
20683	if v == nil {
20684		return fmt.Errorf("unexpected nil of type %T", v)
20685	}
20686	if value == nil {
20687		return nil
20688	}
20689
20690	shape, ok := value.([]interface{})
20691	if !ok {
20692		return fmt.Errorf("unexpected JSON type %v", value)
20693	}
20694
20695	var cv []types.AutoSnapshotDetails
20696	if *v == nil {
20697		cv = []types.AutoSnapshotDetails{}
20698	} else {
20699		cv = *v
20700	}
20701
20702	for _, value := range shape {
20703		var col types.AutoSnapshotDetails
20704		destAddr := &col
20705		if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetails(&destAddr, value); err != nil {
20706			return err
20707		}
20708		col = *destAddr
20709		cv = append(cv, col)
20710
20711	}
20712	*v = cv
20713	return nil
20714}
20715
20716func awsAwsjson11_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, value interface{}) error {
20717	if v == nil {
20718		return fmt.Errorf("unexpected nil of type %T", v)
20719	}
20720	if value == nil {
20721		return nil
20722	}
20723
20724	shape, ok := value.(map[string]interface{})
20725	if !ok {
20726		return fmt.Errorf("unexpected JSON type %v", value)
20727	}
20728
20729	var sv *types.AvailabilityZone
20730	if *v == nil {
20731		sv = &types.AvailabilityZone{}
20732	} else {
20733		sv = *v
20734	}
20735
20736	for key, value := range shape {
20737		switch key {
20738		case "state":
20739			if value != nil {
20740				jtv, ok := value.(string)
20741				if !ok {
20742					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20743				}
20744				sv.State = ptr.String(jtv)
20745			}
20746
20747		case "zoneName":
20748			if value != nil {
20749				jtv, ok := value.(string)
20750				if !ok {
20751					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20752				}
20753				sv.ZoneName = ptr.String(jtv)
20754			}
20755
20756		default:
20757			_, _ = key, value
20758
20759		}
20760	}
20761	*v = sv
20762	return nil
20763}
20764
20765func awsAwsjson11_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, value interface{}) error {
20766	if v == nil {
20767		return fmt.Errorf("unexpected nil of type %T", v)
20768	}
20769	if value == nil {
20770		return nil
20771	}
20772
20773	shape, ok := value.([]interface{})
20774	if !ok {
20775		return fmt.Errorf("unexpected JSON type %v", value)
20776	}
20777
20778	var cv []types.AvailabilityZone
20779	if *v == nil {
20780		cv = []types.AvailabilityZone{}
20781	} else {
20782		cv = *v
20783	}
20784
20785	for _, value := range shape {
20786		var col types.AvailabilityZone
20787		destAddr := &col
20788		if err := awsAwsjson11_deserializeDocumentAvailabilityZone(&destAddr, value); err != nil {
20789			return err
20790		}
20791		col = *destAddr
20792		cv = append(cv, col)
20793
20794	}
20795	*v = cv
20796	return nil
20797}
20798
20799func awsAwsjson11_deserializeDocumentBlueprint(v **types.Blueprint, value interface{}) error {
20800	if v == nil {
20801		return fmt.Errorf("unexpected nil of type %T", v)
20802	}
20803	if value == nil {
20804		return nil
20805	}
20806
20807	shape, ok := value.(map[string]interface{})
20808	if !ok {
20809		return fmt.Errorf("unexpected JSON type %v", value)
20810	}
20811
20812	var sv *types.Blueprint
20813	if *v == nil {
20814		sv = &types.Blueprint{}
20815	} else {
20816		sv = *v
20817	}
20818
20819	for key, value := range shape {
20820		switch key {
20821		case "blueprintId":
20822			if value != nil {
20823				jtv, ok := value.(string)
20824				if !ok {
20825					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20826				}
20827				sv.BlueprintId = ptr.String(jtv)
20828			}
20829
20830		case "description":
20831			if value != nil {
20832				jtv, ok := value.(string)
20833				if !ok {
20834					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20835				}
20836				sv.Description = ptr.String(jtv)
20837			}
20838
20839		case "group":
20840			if value != nil {
20841				jtv, ok := value.(string)
20842				if !ok {
20843					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20844				}
20845				sv.Group = ptr.String(jtv)
20846			}
20847
20848		case "isActive":
20849			if value != nil {
20850				jtv, ok := value.(bool)
20851				if !ok {
20852					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
20853				}
20854				sv.IsActive = ptr.Bool(jtv)
20855			}
20856
20857		case "licenseUrl":
20858			if value != nil {
20859				jtv, ok := value.(string)
20860				if !ok {
20861					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20862				}
20863				sv.LicenseUrl = ptr.String(jtv)
20864			}
20865
20866		case "minPower":
20867			if value != nil {
20868				jtv, ok := value.(json.Number)
20869				if !ok {
20870					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20871				}
20872				i64, err := jtv.Int64()
20873				if err != nil {
20874					return err
20875				}
20876				sv.MinPower = ptr.Int32(int32(i64))
20877			}
20878
20879		case "name":
20880			if value != nil {
20881				jtv, ok := value.(string)
20882				if !ok {
20883					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
20884				}
20885				sv.Name = ptr.String(jtv)
20886			}
20887
20888		case "platform":
20889			if value != nil {
20890				jtv, ok := value.(string)
20891				if !ok {
20892					return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
20893				}
20894				sv.Platform = types.InstancePlatform(jtv)
20895			}
20896
20897		case "productUrl":
20898			if value != nil {
20899				jtv, ok := value.(string)
20900				if !ok {
20901					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20902				}
20903				sv.ProductUrl = ptr.String(jtv)
20904			}
20905
20906		case "type":
20907			if value != nil {
20908				jtv, ok := value.(string)
20909				if !ok {
20910					return fmt.Errorf("expected BlueprintType to be of type string, got %T instead", value)
20911				}
20912				sv.Type = types.BlueprintType(jtv)
20913			}
20914
20915		case "version":
20916			if value != nil {
20917				jtv, ok := value.(string)
20918				if !ok {
20919					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20920				}
20921				sv.Version = ptr.String(jtv)
20922			}
20923
20924		case "versionCode":
20925			if value != nil {
20926				jtv, ok := value.(string)
20927				if !ok {
20928					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20929				}
20930				sv.VersionCode = ptr.String(jtv)
20931			}
20932
20933		default:
20934			_, _ = key, value
20935
20936		}
20937	}
20938	*v = sv
20939	return nil
20940}
20941
20942func awsAwsjson11_deserializeDocumentBlueprintList(v *[]types.Blueprint, value interface{}) error {
20943	if v == nil {
20944		return fmt.Errorf("unexpected nil of type %T", v)
20945	}
20946	if value == nil {
20947		return nil
20948	}
20949
20950	shape, ok := value.([]interface{})
20951	if !ok {
20952		return fmt.Errorf("unexpected JSON type %v", value)
20953	}
20954
20955	var cv []types.Blueprint
20956	if *v == nil {
20957		cv = []types.Blueprint{}
20958	} else {
20959		cv = *v
20960	}
20961
20962	for _, value := range shape {
20963		var col types.Blueprint
20964		destAddr := &col
20965		if err := awsAwsjson11_deserializeDocumentBlueprint(&destAddr, value); err != nil {
20966			return err
20967		}
20968		col = *destAddr
20969		cv = append(cv, col)
20970
20971	}
20972	*v = cv
20973	return nil
20974}
20975
20976func awsAwsjson11_deserializeDocumentBucket(v **types.Bucket, value interface{}) error {
20977	if v == nil {
20978		return fmt.Errorf("unexpected nil of type %T", v)
20979	}
20980	if value == nil {
20981		return nil
20982	}
20983
20984	shape, ok := value.(map[string]interface{})
20985	if !ok {
20986		return fmt.Errorf("unexpected JSON type %v", value)
20987	}
20988
20989	var sv *types.Bucket
20990	if *v == nil {
20991		sv = &types.Bucket{}
20992	} else {
20993		sv = *v
20994	}
20995
20996	for key, value := range shape {
20997		switch key {
20998		case "ableToUpdateBundle":
20999			if value != nil {
21000				jtv, ok := value.(bool)
21001				if !ok {
21002					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21003				}
21004				sv.AbleToUpdateBundle = ptr.Bool(jtv)
21005			}
21006
21007		case "accessRules":
21008			if err := awsAwsjson11_deserializeDocumentAccessRules(&sv.AccessRules, value); err != nil {
21009				return err
21010			}
21011
21012		case "arn":
21013			if value != nil {
21014				jtv, ok := value.(string)
21015				if !ok {
21016					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21017				}
21018				sv.Arn = ptr.String(jtv)
21019			}
21020
21021		case "bundleId":
21022			if value != nil {
21023				jtv, ok := value.(string)
21024				if !ok {
21025					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21026				}
21027				sv.BundleId = ptr.String(jtv)
21028			}
21029
21030		case "createdAt":
21031			if value != nil {
21032				switch jtv := value.(type) {
21033				case json.Number:
21034					f64, err := jtv.Float64()
21035					if err != nil {
21036						return err
21037					}
21038					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21039
21040				default:
21041					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21042
21043				}
21044			}
21045
21046		case "location":
21047			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
21048				return err
21049			}
21050
21051		case "name":
21052			if value != nil {
21053				jtv, ok := value.(string)
21054				if !ok {
21055					return fmt.Errorf("expected BucketName to be of type string, got %T instead", value)
21056				}
21057				sv.Name = ptr.String(jtv)
21058			}
21059
21060		case "objectVersioning":
21061			if value != nil {
21062				jtv, ok := value.(string)
21063				if !ok {
21064					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21065				}
21066				sv.ObjectVersioning = ptr.String(jtv)
21067			}
21068
21069		case "readonlyAccessAccounts":
21070			if err := awsAwsjson11_deserializeDocumentPartnerIdList(&sv.ReadonlyAccessAccounts, value); err != nil {
21071				return err
21072			}
21073
21074		case "resourcesReceivingAccess":
21075			if err := awsAwsjson11_deserializeDocumentAccessReceiverList(&sv.ResourcesReceivingAccess, value); err != nil {
21076				return err
21077			}
21078
21079		case "resourceType":
21080			if value != nil {
21081				jtv, ok := value.(string)
21082				if !ok {
21083					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21084				}
21085				sv.ResourceType = ptr.String(jtv)
21086			}
21087
21088		case "state":
21089			if err := awsAwsjson11_deserializeDocumentBucketState(&sv.State, value); err != nil {
21090				return err
21091			}
21092
21093		case "supportCode":
21094			if value != nil {
21095				jtv, ok := value.(string)
21096				if !ok {
21097					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21098				}
21099				sv.SupportCode = ptr.String(jtv)
21100			}
21101
21102		case "tags":
21103			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
21104				return err
21105			}
21106
21107		case "url":
21108			if value != nil {
21109				jtv, ok := value.(string)
21110				if !ok {
21111					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21112				}
21113				sv.Url = ptr.String(jtv)
21114			}
21115
21116		default:
21117			_, _ = key, value
21118
21119		}
21120	}
21121	*v = sv
21122	return nil
21123}
21124
21125func awsAwsjson11_deserializeDocumentBucketBundle(v **types.BucketBundle, value interface{}) error {
21126	if v == nil {
21127		return fmt.Errorf("unexpected nil of type %T", v)
21128	}
21129	if value == nil {
21130		return nil
21131	}
21132
21133	shape, ok := value.(map[string]interface{})
21134	if !ok {
21135		return fmt.Errorf("unexpected JSON type %v", value)
21136	}
21137
21138	var sv *types.BucketBundle
21139	if *v == nil {
21140		sv = &types.BucketBundle{}
21141	} else {
21142		sv = *v
21143	}
21144
21145	for key, value := range shape {
21146		switch key {
21147		case "bundleId":
21148			if value != nil {
21149				jtv, ok := value.(string)
21150				if !ok {
21151					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21152				}
21153				sv.BundleId = ptr.String(jtv)
21154			}
21155
21156		case "isActive":
21157			if value != nil {
21158				jtv, ok := value.(bool)
21159				if !ok {
21160					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21161				}
21162				sv.IsActive = ptr.Bool(jtv)
21163			}
21164
21165		case "name":
21166			if value != nil {
21167				jtv, ok := value.(string)
21168				if !ok {
21169					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21170				}
21171				sv.Name = ptr.String(jtv)
21172			}
21173
21174		case "price":
21175			if value != nil {
21176				switch jtv := value.(type) {
21177				case json.Number:
21178					f64, err := jtv.Float64()
21179					if err != nil {
21180						return err
21181					}
21182					sv.Price = ptr.Float32(float32(f64))
21183
21184				case string:
21185					var f64 float64
21186					switch {
21187					case strings.EqualFold(jtv, "NaN"):
21188						f64 = math.NaN()
21189
21190					case strings.EqualFold(jtv, "Infinity"):
21191						f64 = math.Inf(1)
21192
21193					case strings.EqualFold(jtv, "-Infinity"):
21194						f64 = math.Inf(-1)
21195
21196					default:
21197						return fmt.Errorf("unknown JSON number value: %s", jtv)
21198
21199					}
21200					sv.Price = ptr.Float32(float32(f64))
21201
21202				default:
21203					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
21204
21205				}
21206			}
21207
21208		case "storagePerMonthInGb":
21209			if value != nil {
21210				jtv, ok := value.(json.Number)
21211				if !ok {
21212					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21213				}
21214				i64, err := jtv.Int64()
21215				if err != nil {
21216					return err
21217				}
21218				sv.StoragePerMonthInGb = ptr.Int32(int32(i64))
21219			}
21220
21221		case "transferPerMonthInGb":
21222			if value != nil {
21223				jtv, ok := value.(json.Number)
21224				if !ok {
21225					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21226				}
21227				i64, err := jtv.Int64()
21228				if err != nil {
21229					return err
21230				}
21231				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
21232			}
21233
21234		default:
21235			_, _ = key, value
21236
21237		}
21238	}
21239	*v = sv
21240	return nil
21241}
21242
21243func awsAwsjson11_deserializeDocumentBucketBundleList(v *[]types.BucketBundle, value interface{}) error {
21244	if v == nil {
21245		return fmt.Errorf("unexpected nil of type %T", v)
21246	}
21247	if value == nil {
21248		return nil
21249	}
21250
21251	shape, ok := value.([]interface{})
21252	if !ok {
21253		return fmt.Errorf("unexpected JSON type %v", value)
21254	}
21255
21256	var cv []types.BucketBundle
21257	if *v == nil {
21258		cv = []types.BucketBundle{}
21259	} else {
21260		cv = *v
21261	}
21262
21263	for _, value := range shape {
21264		var col types.BucketBundle
21265		destAddr := &col
21266		if err := awsAwsjson11_deserializeDocumentBucketBundle(&destAddr, value); err != nil {
21267			return err
21268		}
21269		col = *destAddr
21270		cv = append(cv, col)
21271
21272	}
21273	*v = cv
21274	return nil
21275}
21276
21277func awsAwsjson11_deserializeDocumentBucketList(v *[]types.Bucket, value interface{}) error {
21278	if v == nil {
21279		return fmt.Errorf("unexpected nil of type %T", v)
21280	}
21281	if value == nil {
21282		return nil
21283	}
21284
21285	shape, ok := value.([]interface{})
21286	if !ok {
21287		return fmt.Errorf("unexpected JSON type %v", value)
21288	}
21289
21290	var cv []types.Bucket
21291	if *v == nil {
21292		cv = []types.Bucket{}
21293	} else {
21294		cv = *v
21295	}
21296
21297	for _, value := range shape {
21298		var col types.Bucket
21299		destAddr := &col
21300		if err := awsAwsjson11_deserializeDocumentBucket(&destAddr, value); err != nil {
21301			return err
21302		}
21303		col = *destAddr
21304		cv = append(cv, col)
21305
21306	}
21307	*v = cv
21308	return nil
21309}
21310
21311func awsAwsjson11_deserializeDocumentBucketState(v **types.BucketState, value interface{}) error {
21312	if v == nil {
21313		return fmt.Errorf("unexpected nil of type %T", v)
21314	}
21315	if value == nil {
21316		return nil
21317	}
21318
21319	shape, ok := value.(map[string]interface{})
21320	if !ok {
21321		return fmt.Errorf("unexpected JSON type %v", value)
21322	}
21323
21324	var sv *types.BucketState
21325	if *v == nil {
21326		sv = &types.BucketState{}
21327	} else {
21328		sv = *v
21329	}
21330
21331	for key, value := range shape {
21332		switch key {
21333		case "code":
21334			if value != nil {
21335				jtv, ok := value.(string)
21336				if !ok {
21337					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21338				}
21339				sv.Code = ptr.String(jtv)
21340			}
21341
21342		case "message":
21343			if value != nil {
21344				jtv, ok := value.(string)
21345				if !ok {
21346					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21347				}
21348				sv.Message = ptr.String(jtv)
21349			}
21350
21351		default:
21352			_, _ = key, value
21353
21354		}
21355	}
21356	*v = sv
21357	return nil
21358}
21359
21360func awsAwsjson11_deserializeDocumentBundle(v **types.Bundle, value interface{}) error {
21361	if v == nil {
21362		return fmt.Errorf("unexpected nil of type %T", v)
21363	}
21364	if value == nil {
21365		return nil
21366	}
21367
21368	shape, ok := value.(map[string]interface{})
21369	if !ok {
21370		return fmt.Errorf("unexpected JSON type %v", value)
21371	}
21372
21373	var sv *types.Bundle
21374	if *v == nil {
21375		sv = &types.Bundle{}
21376	} else {
21377		sv = *v
21378	}
21379
21380	for key, value := range shape {
21381		switch key {
21382		case "bundleId":
21383			if value != nil {
21384				jtv, ok := value.(string)
21385				if !ok {
21386					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21387				}
21388				sv.BundleId = ptr.String(jtv)
21389			}
21390
21391		case "cpuCount":
21392			if value != nil {
21393				jtv, ok := value.(json.Number)
21394				if !ok {
21395					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21396				}
21397				i64, err := jtv.Int64()
21398				if err != nil {
21399					return err
21400				}
21401				sv.CpuCount = ptr.Int32(int32(i64))
21402			}
21403
21404		case "diskSizeInGb":
21405			if value != nil {
21406				jtv, ok := value.(json.Number)
21407				if !ok {
21408					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21409				}
21410				i64, err := jtv.Int64()
21411				if err != nil {
21412					return err
21413				}
21414				sv.DiskSizeInGb = ptr.Int32(int32(i64))
21415			}
21416
21417		case "instanceType":
21418			if value != nil {
21419				jtv, ok := value.(string)
21420				if !ok {
21421					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21422				}
21423				sv.InstanceType = ptr.String(jtv)
21424			}
21425
21426		case "isActive":
21427			if value != nil {
21428				jtv, ok := value.(bool)
21429				if !ok {
21430					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21431				}
21432				sv.IsActive = ptr.Bool(jtv)
21433			}
21434
21435		case "name":
21436			if value != nil {
21437				jtv, ok := value.(string)
21438				if !ok {
21439					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21440				}
21441				sv.Name = ptr.String(jtv)
21442			}
21443
21444		case "power":
21445			if value != nil {
21446				jtv, ok := value.(json.Number)
21447				if !ok {
21448					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21449				}
21450				i64, err := jtv.Int64()
21451				if err != nil {
21452					return err
21453				}
21454				sv.Power = ptr.Int32(int32(i64))
21455			}
21456
21457		case "price":
21458			if value != nil {
21459				switch jtv := value.(type) {
21460				case json.Number:
21461					f64, err := jtv.Float64()
21462					if err != nil {
21463						return err
21464					}
21465					sv.Price = ptr.Float32(float32(f64))
21466
21467				case string:
21468					var f64 float64
21469					switch {
21470					case strings.EqualFold(jtv, "NaN"):
21471						f64 = math.NaN()
21472
21473					case strings.EqualFold(jtv, "Infinity"):
21474						f64 = math.Inf(1)
21475
21476					case strings.EqualFold(jtv, "-Infinity"):
21477						f64 = math.Inf(-1)
21478
21479					default:
21480						return fmt.Errorf("unknown JSON number value: %s", jtv)
21481
21482					}
21483					sv.Price = ptr.Float32(float32(f64))
21484
21485				default:
21486					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
21487
21488				}
21489			}
21490
21491		case "ramSizeInGb":
21492			if value != nil {
21493				switch jtv := value.(type) {
21494				case json.Number:
21495					f64, err := jtv.Float64()
21496					if err != nil {
21497						return err
21498					}
21499					sv.RamSizeInGb = ptr.Float32(float32(f64))
21500
21501				case string:
21502					var f64 float64
21503					switch {
21504					case strings.EqualFold(jtv, "NaN"):
21505						f64 = math.NaN()
21506
21507					case strings.EqualFold(jtv, "Infinity"):
21508						f64 = math.Inf(1)
21509
21510					case strings.EqualFold(jtv, "-Infinity"):
21511						f64 = math.Inf(-1)
21512
21513					default:
21514						return fmt.Errorf("unknown JSON number value: %s", jtv)
21515
21516					}
21517					sv.RamSizeInGb = ptr.Float32(float32(f64))
21518
21519				default:
21520					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
21521
21522				}
21523			}
21524
21525		case "supportedPlatforms":
21526			if err := awsAwsjson11_deserializeDocumentInstancePlatformList(&sv.SupportedPlatforms, value); err != nil {
21527				return err
21528			}
21529
21530		case "transferPerMonthInGb":
21531			if value != nil {
21532				jtv, ok := value.(json.Number)
21533				if !ok {
21534					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21535				}
21536				i64, err := jtv.Int64()
21537				if err != nil {
21538					return err
21539				}
21540				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
21541			}
21542
21543		default:
21544			_, _ = key, value
21545
21546		}
21547	}
21548	*v = sv
21549	return nil
21550}
21551
21552func awsAwsjson11_deserializeDocumentBundleList(v *[]types.Bundle, value interface{}) error {
21553	if v == nil {
21554		return fmt.Errorf("unexpected nil of type %T", v)
21555	}
21556	if value == nil {
21557		return nil
21558	}
21559
21560	shape, ok := value.([]interface{})
21561	if !ok {
21562		return fmt.Errorf("unexpected JSON type %v", value)
21563	}
21564
21565	var cv []types.Bundle
21566	if *v == nil {
21567		cv = []types.Bundle{}
21568	} else {
21569		cv = *v
21570	}
21571
21572	for _, value := range shape {
21573		var col types.Bundle
21574		destAddr := &col
21575		if err := awsAwsjson11_deserializeDocumentBundle(&destAddr, value); err != nil {
21576			return err
21577		}
21578		col = *destAddr
21579		cv = append(cv, col)
21580
21581	}
21582	*v = cv
21583	return nil
21584}
21585
21586func awsAwsjson11_deserializeDocumentCacheBehavior(v **types.CacheBehavior, value interface{}) error {
21587	if v == nil {
21588		return fmt.Errorf("unexpected nil of type %T", v)
21589	}
21590	if value == nil {
21591		return nil
21592	}
21593
21594	shape, ok := value.(map[string]interface{})
21595	if !ok {
21596		return fmt.Errorf("unexpected JSON type %v", value)
21597	}
21598
21599	var sv *types.CacheBehavior
21600	if *v == nil {
21601		sv = &types.CacheBehavior{}
21602	} else {
21603		sv = *v
21604	}
21605
21606	for key, value := range shape {
21607		switch key {
21608		case "behavior":
21609			if value != nil {
21610				jtv, ok := value.(string)
21611				if !ok {
21612					return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
21613				}
21614				sv.Behavior = types.BehaviorEnum(jtv)
21615			}
21616
21617		default:
21618			_, _ = key, value
21619
21620		}
21621	}
21622	*v = sv
21623	return nil
21624}
21625
21626func awsAwsjson11_deserializeDocumentCacheBehaviorList(v *[]types.CacheBehaviorPerPath, value interface{}) error {
21627	if v == nil {
21628		return fmt.Errorf("unexpected nil of type %T", v)
21629	}
21630	if value == nil {
21631		return nil
21632	}
21633
21634	shape, ok := value.([]interface{})
21635	if !ok {
21636		return fmt.Errorf("unexpected JSON type %v", value)
21637	}
21638
21639	var cv []types.CacheBehaviorPerPath
21640	if *v == nil {
21641		cv = []types.CacheBehaviorPerPath{}
21642	} else {
21643		cv = *v
21644	}
21645
21646	for _, value := range shape {
21647		var col types.CacheBehaviorPerPath
21648		destAddr := &col
21649		if err := awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(&destAddr, value); err != nil {
21650			return err
21651		}
21652		col = *destAddr
21653		cv = append(cv, col)
21654
21655	}
21656	*v = cv
21657	return nil
21658}
21659
21660func awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(v **types.CacheBehaviorPerPath, value interface{}) error {
21661	if v == nil {
21662		return fmt.Errorf("unexpected nil of type %T", v)
21663	}
21664	if value == nil {
21665		return nil
21666	}
21667
21668	shape, ok := value.(map[string]interface{})
21669	if !ok {
21670		return fmt.Errorf("unexpected JSON type %v", value)
21671	}
21672
21673	var sv *types.CacheBehaviorPerPath
21674	if *v == nil {
21675		sv = &types.CacheBehaviorPerPath{}
21676	} else {
21677		sv = *v
21678	}
21679
21680	for key, value := range shape {
21681		switch key {
21682		case "behavior":
21683			if value != nil {
21684				jtv, ok := value.(string)
21685				if !ok {
21686					return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
21687				}
21688				sv.Behavior = types.BehaviorEnum(jtv)
21689			}
21690
21691		case "path":
21692			if value != nil {
21693				jtv, ok := value.(string)
21694				if !ok {
21695					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21696				}
21697				sv.Path = ptr.String(jtv)
21698			}
21699
21700		default:
21701			_, _ = key, value
21702
21703		}
21704	}
21705	*v = sv
21706	return nil
21707}
21708
21709func awsAwsjson11_deserializeDocumentCacheSettings(v **types.CacheSettings, value interface{}) error {
21710	if v == nil {
21711		return fmt.Errorf("unexpected nil of type %T", v)
21712	}
21713	if value == nil {
21714		return nil
21715	}
21716
21717	shape, ok := value.(map[string]interface{})
21718	if !ok {
21719		return fmt.Errorf("unexpected JSON type %v", value)
21720	}
21721
21722	var sv *types.CacheSettings
21723	if *v == nil {
21724		sv = &types.CacheSettings{}
21725	} else {
21726		sv = *v
21727	}
21728
21729	for key, value := range shape {
21730		switch key {
21731		case "allowedHTTPMethods":
21732			if value != nil {
21733				jtv, ok := value.(string)
21734				if !ok {
21735					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21736				}
21737				sv.AllowedHTTPMethods = ptr.String(jtv)
21738			}
21739
21740		case "cachedHTTPMethods":
21741			if value != nil {
21742				jtv, ok := value.(string)
21743				if !ok {
21744					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21745				}
21746				sv.CachedHTTPMethods = ptr.String(jtv)
21747			}
21748
21749		case "defaultTTL":
21750			if value != nil {
21751				jtv, ok := value.(json.Number)
21752				if !ok {
21753					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
21754				}
21755				i64, err := jtv.Int64()
21756				if err != nil {
21757					return err
21758				}
21759				sv.DefaultTTL = ptr.Int64(i64)
21760			}
21761
21762		case "forwardedCookies":
21763			if err := awsAwsjson11_deserializeDocumentCookieObject(&sv.ForwardedCookies, value); err != nil {
21764				return err
21765			}
21766
21767		case "forwardedHeaders":
21768			if err := awsAwsjson11_deserializeDocumentHeaderObject(&sv.ForwardedHeaders, value); err != nil {
21769				return err
21770			}
21771
21772		case "forwardedQueryStrings":
21773			if err := awsAwsjson11_deserializeDocumentQueryStringObject(&sv.ForwardedQueryStrings, value); err != nil {
21774				return err
21775			}
21776
21777		case "maximumTTL":
21778			if value != nil {
21779				jtv, ok := value.(json.Number)
21780				if !ok {
21781					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
21782				}
21783				i64, err := jtv.Int64()
21784				if err != nil {
21785					return err
21786				}
21787				sv.MaximumTTL = ptr.Int64(i64)
21788			}
21789
21790		case "minimumTTL":
21791			if value != nil {
21792				jtv, ok := value.(json.Number)
21793				if !ok {
21794					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
21795				}
21796				i64, err := jtv.Int64()
21797				if err != nil {
21798					return err
21799				}
21800				sv.MinimumTTL = ptr.Int64(i64)
21801			}
21802
21803		default:
21804			_, _ = key, value
21805
21806		}
21807	}
21808	*v = sv
21809	return nil
21810}
21811
21812func awsAwsjson11_deserializeDocumentCertificate(v **types.Certificate, value interface{}) error {
21813	if v == nil {
21814		return fmt.Errorf("unexpected nil of type %T", v)
21815	}
21816	if value == nil {
21817		return nil
21818	}
21819
21820	shape, ok := value.(map[string]interface{})
21821	if !ok {
21822		return fmt.Errorf("unexpected JSON type %v", value)
21823	}
21824
21825	var sv *types.Certificate
21826	if *v == nil {
21827		sv = &types.Certificate{}
21828	} else {
21829		sv = *v
21830	}
21831
21832	for key, value := range shape {
21833		switch key {
21834		case "arn":
21835			if value != nil {
21836				jtv, ok := value.(string)
21837				if !ok {
21838					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21839				}
21840				sv.Arn = ptr.String(jtv)
21841			}
21842
21843		case "createdAt":
21844			if value != nil {
21845				switch jtv := value.(type) {
21846				case json.Number:
21847					f64, err := jtv.Float64()
21848					if err != nil {
21849						return err
21850					}
21851					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21852
21853				default:
21854					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21855
21856				}
21857			}
21858
21859		case "domainName":
21860			if value != nil {
21861				jtv, ok := value.(string)
21862				if !ok {
21863					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
21864				}
21865				sv.DomainName = ptr.String(jtv)
21866			}
21867
21868		case "domainValidationRecords":
21869			if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
21870				return err
21871			}
21872
21873		case "eligibleToRenew":
21874			if value != nil {
21875				jtv, ok := value.(string)
21876				if !ok {
21877					return fmt.Errorf("expected EligibleToRenew to be of type string, got %T instead", value)
21878				}
21879				sv.EligibleToRenew = ptr.String(jtv)
21880			}
21881
21882		case "inUseResourceCount":
21883			if value != nil {
21884				jtv, ok := value.(json.Number)
21885				if !ok {
21886					return fmt.Errorf("expected InUseResourceCount to be json.Number, got %T instead", value)
21887				}
21888				i64, err := jtv.Int64()
21889				if err != nil {
21890					return err
21891				}
21892				sv.InUseResourceCount = int32(i64)
21893			}
21894
21895		case "issuedAt":
21896			if value != nil {
21897				switch jtv := value.(type) {
21898				case json.Number:
21899					f64, err := jtv.Float64()
21900					if err != nil {
21901						return err
21902					}
21903					sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21904
21905				default:
21906					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21907
21908				}
21909			}
21910
21911		case "issuerCA":
21912			if value != nil {
21913				jtv, ok := value.(string)
21914				if !ok {
21915					return fmt.Errorf("expected IssuerCA to be of type string, got %T instead", value)
21916				}
21917				sv.IssuerCA = ptr.String(jtv)
21918			}
21919
21920		case "keyAlgorithm":
21921			if value != nil {
21922				jtv, ok := value.(string)
21923				if !ok {
21924					return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
21925				}
21926				sv.KeyAlgorithm = ptr.String(jtv)
21927			}
21928
21929		case "name":
21930			if value != nil {
21931				jtv, ok := value.(string)
21932				if !ok {
21933					return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
21934				}
21935				sv.Name = ptr.String(jtv)
21936			}
21937
21938		case "notAfter":
21939			if value != nil {
21940				switch jtv := value.(type) {
21941				case json.Number:
21942					f64, err := jtv.Float64()
21943					if err != nil {
21944						return err
21945					}
21946					sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
21947
21948				default:
21949					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21950
21951				}
21952			}
21953
21954		case "notBefore":
21955			if value != nil {
21956				switch jtv := value.(type) {
21957				case json.Number:
21958					f64, err := jtv.Float64()
21959					if err != nil {
21960						return err
21961					}
21962					sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
21963
21964				default:
21965					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
21966
21967				}
21968			}
21969
21970		case "renewalSummary":
21971			if err := awsAwsjson11_deserializeDocumentRenewalSummary(&sv.RenewalSummary, value); err != nil {
21972				return err
21973			}
21974
21975		case "requestFailureReason":
21976			if value != nil {
21977				jtv, ok := value.(string)
21978				if !ok {
21979					return fmt.Errorf("expected RequestFailureReason to be of type string, got %T instead", value)
21980				}
21981				sv.RequestFailureReason = ptr.String(jtv)
21982			}
21983
21984		case "revocationReason":
21985			if value != nil {
21986				jtv, ok := value.(string)
21987				if !ok {
21988					return fmt.Errorf("expected RevocationReason to be of type string, got %T instead", value)
21989				}
21990				sv.RevocationReason = ptr.String(jtv)
21991			}
21992
21993		case "revokedAt":
21994			if value != nil {
21995				switch jtv := value.(type) {
21996				case json.Number:
21997					f64, err := jtv.Float64()
21998					if err != nil {
21999						return err
22000					}
22001					sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22002
22003				default:
22004					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22005
22006				}
22007			}
22008
22009		case "serialNumber":
22010			if value != nil {
22011				jtv, ok := value.(string)
22012				if !ok {
22013					return fmt.Errorf("expected SerialNumber to be of type string, got %T instead", value)
22014				}
22015				sv.SerialNumber = ptr.String(jtv)
22016			}
22017
22018		case "status":
22019			if value != nil {
22020				jtv, ok := value.(string)
22021				if !ok {
22022					return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value)
22023				}
22024				sv.Status = types.CertificateStatus(jtv)
22025			}
22026
22027		case "subjectAlternativeNames":
22028			if err := awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(&sv.SubjectAlternativeNames, value); err != nil {
22029				return err
22030			}
22031
22032		case "supportCode":
22033			if value != nil {
22034				jtv, ok := value.(string)
22035				if !ok {
22036					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22037				}
22038				sv.SupportCode = ptr.String(jtv)
22039			}
22040
22041		case "tags":
22042			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22043				return err
22044			}
22045
22046		default:
22047			_, _ = key, value
22048
22049		}
22050	}
22051	*v = sv
22052	return nil
22053}
22054
22055func awsAwsjson11_deserializeDocumentCertificateSummary(v **types.CertificateSummary, value interface{}) error {
22056	if v == nil {
22057		return fmt.Errorf("unexpected nil of type %T", v)
22058	}
22059	if value == nil {
22060		return nil
22061	}
22062
22063	shape, ok := value.(map[string]interface{})
22064	if !ok {
22065		return fmt.Errorf("unexpected JSON type %v", value)
22066	}
22067
22068	var sv *types.CertificateSummary
22069	if *v == nil {
22070		sv = &types.CertificateSummary{}
22071	} else {
22072		sv = *v
22073	}
22074
22075	for key, value := range shape {
22076		switch key {
22077		case "certificateArn":
22078			if value != nil {
22079				jtv, ok := value.(string)
22080				if !ok {
22081					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22082				}
22083				sv.CertificateArn = ptr.String(jtv)
22084			}
22085
22086		case "certificateDetail":
22087			if err := awsAwsjson11_deserializeDocumentCertificate(&sv.CertificateDetail, value); err != nil {
22088				return err
22089			}
22090
22091		case "certificateName":
22092			if value != nil {
22093				jtv, ok := value.(string)
22094				if !ok {
22095					return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
22096				}
22097				sv.CertificateName = ptr.String(jtv)
22098			}
22099
22100		case "domainName":
22101			if value != nil {
22102				jtv, ok := value.(string)
22103				if !ok {
22104					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
22105				}
22106				sv.DomainName = ptr.String(jtv)
22107			}
22108
22109		case "tags":
22110			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22111				return err
22112			}
22113
22114		default:
22115			_, _ = key, value
22116
22117		}
22118	}
22119	*v = sv
22120	return nil
22121}
22122
22123func awsAwsjson11_deserializeDocumentCertificateSummaryList(v *[]types.CertificateSummary, value interface{}) error {
22124	if v == nil {
22125		return fmt.Errorf("unexpected nil of type %T", v)
22126	}
22127	if value == nil {
22128		return nil
22129	}
22130
22131	shape, ok := value.([]interface{})
22132	if !ok {
22133		return fmt.Errorf("unexpected JSON type %v", value)
22134	}
22135
22136	var cv []types.CertificateSummary
22137	if *v == nil {
22138		cv = []types.CertificateSummary{}
22139	} else {
22140		cv = *v
22141	}
22142
22143	for _, value := range shape {
22144		var col types.CertificateSummary
22145		destAddr := &col
22146		if err := awsAwsjson11_deserializeDocumentCertificateSummary(&destAddr, value); err != nil {
22147			return err
22148		}
22149		col = *destAddr
22150		cv = append(cv, col)
22151
22152	}
22153	*v = cv
22154	return nil
22155}
22156
22157func awsAwsjson11_deserializeDocumentCloudFormationStackRecord(v **types.CloudFormationStackRecord, value interface{}) error {
22158	if v == nil {
22159		return fmt.Errorf("unexpected nil of type %T", v)
22160	}
22161	if value == nil {
22162		return nil
22163	}
22164
22165	shape, ok := value.(map[string]interface{})
22166	if !ok {
22167		return fmt.Errorf("unexpected JSON type %v", value)
22168	}
22169
22170	var sv *types.CloudFormationStackRecord
22171	if *v == nil {
22172		sv = &types.CloudFormationStackRecord{}
22173	} else {
22174		sv = *v
22175	}
22176
22177	for key, value := range shape {
22178		switch key {
22179		case "arn":
22180			if value != nil {
22181				jtv, ok := value.(string)
22182				if !ok {
22183					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22184				}
22185				sv.Arn = ptr.String(jtv)
22186			}
22187
22188		case "createdAt":
22189			if value != nil {
22190				switch jtv := value.(type) {
22191				case json.Number:
22192					f64, err := jtv.Float64()
22193					if err != nil {
22194						return err
22195					}
22196					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22197
22198				default:
22199					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22200
22201				}
22202			}
22203
22204		case "destinationInfo":
22205			if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
22206				return err
22207			}
22208
22209		case "location":
22210			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22211				return err
22212			}
22213
22214		case "name":
22215			if value != nil {
22216				jtv, ok := value.(string)
22217				if !ok {
22218					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22219				}
22220				sv.Name = ptr.String(jtv)
22221			}
22222
22223		case "resourceType":
22224			if value != nil {
22225				jtv, ok := value.(string)
22226				if !ok {
22227					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22228				}
22229				sv.ResourceType = types.ResourceType(jtv)
22230			}
22231
22232		case "sourceInfo":
22233			if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(&sv.SourceInfo, value); err != nil {
22234				return err
22235			}
22236
22237		case "state":
22238			if value != nil {
22239				jtv, ok := value.(string)
22240				if !ok {
22241					return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
22242				}
22243				sv.State = types.RecordState(jtv)
22244			}
22245
22246		default:
22247			_, _ = key, value
22248
22249		}
22250	}
22251	*v = sv
22252	return nil
22253}
22254
22255func awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(v *[]types.CloudFormationStackRecord, value interface{}) error {
22256	if v == nil {
22257		return fmt.Errorf("unexpected nil of type %T", v)
22258	}
22259	if value == nil {
22260		return nil
22261	}
22262
22263	shape, ok := value.([]interface{})
22264	if !ok {
22265		return fmt.Errorf("unexpected JSON type %v", value)
22266	}
22267
22268	var cv []types.CloudFormationStackRecord
22269	if *v == nil {
22270		cv = []types.CloudFormationStackRecord{}
22271	} else {
22272		cv = *v
22273	}
22274
22275	for _, value := range shape {
22276		var col types.CloudFormationStackRecord
22277		destAddr := &col
22278		if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecord(&destAddr, value); err != nil {
22279			return err
22280		}
22281		col = *destAddr
22282		cv = append(cv, col)
22283
22284	}
22285	*v = cv
22286	return nil
22287}
22288
22289func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(v **types.CloudFormationStackRecordSourceInfo, value interface{}) error {
22290	if v == nil {
22291		return fmt.Errorf("unexpected nil of type %T", v)
22292	}
22293	if value == nil {
22294		return nil
22295	}
22296
22297	shape, ok := value.(map[string]interface{})
22298	if !ok {
22299		return fmt.Errorf("unexpected JSON type %v", value)
22300	}
22301
22302	var sv *types.CloudFormationStackRecordSourceInfo
22303	if *v == nil {
22304		sv = &types.CloudFormationStackRecordSourceInfo{}
22305	} else {
22306		sv = *v
22307	}
22308
22309	for key, value := range shape {
22310		switch key {
22311		case "arn":
22312			if value != nil {
22313				jtv, ok := value.(string)
22314				if !ok {
22315					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22316				}
22317				sv.Arn = ptr.String(jtv)
22318			}
22319
22320		case "name":
22321			if value != nil {
22322				jtv, ok := value.(string)
22323				if !ok {
22324					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22325				}
22326				sv.Name = ptr.String(jtv)
22327			}
22328
22329		case "resourceType":
22330			if value != nil {
22331				jtv, ok := value.(string)
22332				if !ok {
22333					return fmt.Errorf("expected CloudFormationStackRecordSourceType to be of type string, got %T instead", value)
22334				}
22335				sv.ResourceType = types.CloudFormationStackRecordSourceType(jtv)
22336			}
22337
22338		default:
22339			_, _ = key, value
22340
22341		}
22342	}
22343	*v = sv
22344	return nil
22345}
22346
22347func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(v *[]types.CloudFormationStackRecordSourceInfo, value interface{}) error {
22348	if v == nil {
22349		return fmt.Errorf("unexpected nil of type %T", v)
22350	}
22351	if value == nil {
22352		return nil
22353	}
22354
22355	shape, ok := value.([]interface{})
22356	if !ok {
22357		return fmt.Errorf("unexpected JSON type %v", value)
22358	}
22359
22360	var cv []types.CloudFormationStackRecordSourceInfo
22361	if *v == nil {
22362		cv = []types.CloudFormationStackRecordSourceInfo{}
22363	} else {
22364		cv = *v
22365	}
22366
22367	for _, value := range shape {
22368		var col types.CloudFormationStackRecordSourceInfo
22369		destAddr := &col
22370		if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(&destAddr, value); err != nil {
22371			return err
22372		}
22373		col = *destAddr
22374		cv = append(cv, col)
22375
22376	}
22377	*v = cv
22378	return nil
22379}
22380
22381func awsAwsjson11_deserializeDocumentContactMethod(v **types.ContactMethod, value interface{}) error {
22382	if v == nil {
22383		return fmt.Errorf("unexpected nil of type %T", v)
22384	}
22385	if value == nil {
22386		return nil
22387	}
22388
22389	shape, ok := value.(map[string]interface{})
22390	if !ok {
22391		return fmt.Errorf("unexpected JSON type %v", value)
22392	}
22393
22394	var sv *types.ContactMethod
22395	if *v == nil {
22396		sv = &types.ContactMethod{}
22397	} else {
22398		sv = *v
22399	}
22400
22401	for key, value := range shape {
22402		switch key {
22403		case "arn":
22404			if value != nil {
22405				jtv, ok := value.(string)
22406				if !ok {
22407					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22408				}
22409				sv.Arn = ptr.String(jtv)
22410			}
22411
22412		case "contactEndpoint":
22413			if value != nil {
22414				jtv, ok := value.(string)
22415				if !ok {
22416					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22417				}
22418				sv.ContactEndpoint = ptr.String(jtv)
22419			}
22420
22421		case "createdAt":
22422			if value != nil {
22423				switch jtv := value.(type) {
22424				case json.Number:
22425					f64, err := jtv.Float64()
22426					if err != nil {
22427						return err
22428					}
22429					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22430
22431				default:
22432					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22433
22434				}
22435			}
22436
22437		case "location":
22438			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22439				return err
22440			}
22441
22442		case "name":
22443			if value != nil {
22444				jtv, ok := value.(string)
22445				if !ok {
22446					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22447				}
22448				sv.Name = ptr.String(jtv)
22449			}
22450
22451		case "protocol":
22452			if value != nil {
22453				jtv, ok := value.(string)
22454				if !ok {
22455					return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
22456				}
22457				sv.Protocol = types.ContactProtocol(jtv)
22458			}
22459
22460		case "resourceType":
22461			if value != nil {
22462				jtv, ok := value.(string)
22463				if !ok {
22464					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22465				}
22466				sv.ResourceType = types.ResourceType(jtv)
22467			}
22468
22469		case "status":
22470			if value != nil {
22471				jtv, ok := value.(string)
22472				if !ok {
22473					return fmt.Errorf("expected ContactMethodStatus to be of type string, got %T instead", value)
22474				}
22475				sv.Status = types.ContactMethodStatus(jtv)
22476			}
22477
22478		case "supportCode":
22479			if value != nil {
22480				jtv, ok := value.(string)
22481				if !ok {
22482					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22483				}
22484				sv.SupportCode = ptr.String(jtv)
22485			}
22486
22487		default:
22488			_, _ = key, value
22489
22490		}
22491	}
22492	*v = sv
22493	return nil
22494}
22495
22496func awsAwsjson11_deserializeDocumentContactMethodsList(v *[]types.ContactMethod, value interface{}) error {
22497	if v == nil {
22498		return fmt.Errorf("unexpected nil of type %T", v)
22499	}
22500	if value == nil {
22501		return nil
22502	}
22503
22504	shape, ok := value.([]interface{})
22505	if !ok {
22506		return fmt.Errorf("unexpected JSON type %v", value)
22507	}
22508
22509	var cv []types.ContactMethod
22510	if *v == nil {
22511		cv = []types.ContactMethod{}
22512	} else {
22513		cv = *v
22514	}
22515
22516	for _, value := range shape {
22517		var col types.ContactMethod
22518		destAddr := &col
22519		if err := awsAwsjson11_deserializeDocumentContactMethod(&destAddr, value); err != nil {
22520			return err
22521		}
22522		col = *destAddr
22523		cv = append(cv, col)
22524
22525	}
22526	*v = cv
22527	return nil
22528}
22529
22530func awsAwsjson11_deserializeDocumentContactProtocolsList(v *[]types.ContactProtocol, value interface{}) error {
22531	if v == nil {
22532		return fmt.Errorf("unexpected nil of type %T", v)
22533	}
22534	if value == nil {
22535		return nil
22536	}
22537
22538	shape, ok := value.([]interface{})
22539	if !ok {
22540		return fmt.Errorf("unexpected JSON type %v", value)
22541	}
22542
22543	var cv []types.ContactProtocol
22544	if *v == nil {
22545		cv = []types.ContactProtocol{}
22546	} else {
22547		cv = *v
22548	}
22549
22550	for _, value := range shape {
22551		var col types.ContactProtocol
22552		if value != nil {
22553			jtv, ok := value.(string)
22554			if !ok {
22555				return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
22556			}
22557			col = types.ContactProtocol(jtv)
22558		}
22559		cv = append(cv, col)
22560
22561	}
22562	*v = cv
22563	return nil
22564}
22565
22566func awsAwsjson11_deserializeDocumentContainer(v **types.Container, value interface{}) error {
22567	if v == nil {
22568		return fmt.Errorf("unexpected nil of type %T", v)
22569	}
22570	if value == nil {
22571		return nil
22572	}
22573
22574	shape, ok := value.(map[string]interface{})
22575	if !ok {
22576		return fmt.Errorf("unexpected JSON type %v", value)
22577	}
22578
22579	var sv *types.Container
22580	if *v == nil {
22581		sv = &types.Container{}
22582	} else {
22583		sv = *v
22584	}
22585
22586	for key, value := range shape {
22587		switch key {
22588		case "command":
22589			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
22590				return err
22591			}
22592
22593		case "environment":
22594			if err := awsAwsjson11_deserializeDocumentEnvironment(&sv.Environment, value); err != nil {
22595				return err
22596			}
22597
22598		case "image":
22599			if value != nil {
22600				jtv, ok := value.(string)
22601				if !ok {
22602					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22603				}
22604				sv.Image = ptr.String(jtv)
22605			}
22606
22607		case "ports":
22608			if err := awsAwsjson11_deserializeDocumentPortMap(&sv.Ports, value); err != nil {
22609				return err
22610			}
22611
22612		default:
22613			_, _ = key, value
22614
22615		}
22616	}
22617	*v = sv
22618	return nil
22619}
22620
22621func awsAwsjson11_deserializeDocumentContainerImage(v **types.ContainerImage, value interface{}) error {
22622	if v == nil {
22623		return fmt.Errorf("unexpected nil of type %T", v)
22624	}
22625	if value == nil {
22626		return nil
22627	}
22628
22629	shape, ok := value.(map[string]interface{})
22630	if !ok {
22631		return fmt.Errorf("unexpected JSON type %v", value)
22632	}
22633
22634	var sv *types.ContainerImage
22635	if *v == nil {
22636		sv = &types.ContainerImage{}
22637	} else {
22638		sv = *v
22639	}
22640
22641	for key, value := range shape {
22642		switch key {
22643		case "createdAt":
22644			if value != nil {
22645				switch jtv := value.(type) {
22646				case json.Number:
22647					f64, err := jtv.Float64()
22648					if err != nil {
22649						return err
22650					}
22651					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22652
22653				default:
22654					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22655
22656				}
22657			}
22658
22659		case "digest":
22660			if value != nil {
22661				jtv, ok := value.(string)
22662				if !ok {
22663					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22664				}
22665				sv.Digest = ptr.String(jtv)
22666			}
22667
22668		case "image":
22669			if value != nil {
22670				jtv, ok := value.(string)
22671				if !ok {
22672					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22673				}
22674				sv.Image = ptr.String(jtv)
22675			}
22676
22677		default:
22678			_, _ = key, value
22679
22680		}
22681	}
22682	*v = sv
22683	return nil
22684}
22685
22686func awsAwsjson11_deserializeDocumentContainerImageList(v *[]types.ContainerImage, value interface{}) error {
22687	if v == nil {
22688		return fmt.Errorf("unexpected nil of type %T", v)
22689	}
22690	if value == nil {
22691		return nil
22692	}
22693
22694	shape, ok := value.([]interface{})
22695	if !ok {
22696		return fmt.Errorf("unexpected JSON type %v", value)
22697	}
22698
22699	var cv []types.ContainerImage
22700	if *v == nil {
22701		cv = []types.ContainerImage{}
22702	} else {
22703		cv = *v
22704	}
22705
22706	for _, value := range shape {
22707		var col types.ContainerImage
22708		destAddr := &col
22709		if err := awsAwsjson11_deserializeDocumentContainerImage(&destAddr, value); err != nil {
22710			return err
22711		}
22712		col = *destAddr
22713		cv = append(cv, col)
22714
22715	}
22716	*v = cv
22717	return nil
22718}
22719
22720func awsAwsjson11_deserializeDocumentContainerMap(v *map[string]types.Container, value interface{}) error {
22721	if v == nil {
22722		return fmt.Errorf("unexpected nil of type %T", v)
22723	}
22724	if value == nil {
22725		return nil
22726	}
22727
22728	shape, ok := value.(map[string]interface{})
22729	if !ok {
22730		return fmt.Errorf("unexpected JSON type %v", value)
22731	}
22732
22733	var mv map[string]types.Container
22734	if *v == nil {
22735		mv = map[string]types.Container{}
22736	} else {
22737		mv = *v
22738	}
22739
22740	for key, value := range shape {
22741		var parsedVal types.Container
22742		mapVar := parsedVal
22743		destAddr := &mapVar
22744		if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil {
22745			return err
22746		}
22747		parsedVal = *destAddr
22748		mv[key] = parsedVal
22749
22750	}
22751	*v = mv
22752	return nil
22753}
22754
22755func awsAwsjson11_deserializeDocumentContainerService(v **types.ContainerService, value interface{}) error {
22756	if v == nil {
22757		return fmt.Errorf("unexpected nil of type %T", v)
22758	}
22759	if value == nil {
22760		return nil
22761	}
22762
22763	shape, ok := value.(map[string]interface{})
22764	if !ok {
22765		return fmt.Errorf("unexpected JSON type %v", value)
22766	}
22767
22768	var sv *types.ContainerService
22769	if *v == nil {
22770		sv = &types.ContainerService{}
22771	} else {
22772		sv = *v
22773	}
22774
22775	for key, value := range shape {
22776		switch key {
22777		case "arn":
22778			if value != nil {
22779				jtv, ok := value.(string)
22780				if !ok {
22781					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22782				}
22783				sv.Arn = ptr.String(jtv)
22784			}
22785
22786		case "containerServiceName":
22787			if value != nil {
22788				jtv, ok := value.(string)
22789				if !ok {
22790					return fmt.Errorf("expected ContainerServiceName to be of type string, got %T instead", value)
22791				}
22792				sv.ContainerServiceName = ptr.String(jtv)
22793			}
22794
22795		case "createdAt":
22796			if value != nil {
22797				switch jtv := value.(type) {
22798				case json.Number:
22799					f64, err := jtv.Float64()
22800					if err != nil {
22801						return err
22802					}
22803					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22804
22805				default:
22806					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22807
22808				}
22809			}
22810
22811		case "currentDeployment":
22812			if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.CurrentDeployment, value); err != nil {
22813				return err
22814			}
22815
22816		case "isDisabled":
22817			if value != nil {
22818				jtv, ok := value.(bool)
22819				if !ok {
22820					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22821				}
22822				sv.IsDisabled = ptr.Bool(jtv)
22823			}
22824
22825		case "location":
22826			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22827				return err
22828			}
22829
22830		case "nextDeployment":
22831			if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.NextDeployment, value); err != nil {
22832				return err
22833			}
22834
22835		case "power":
22836			if value != nil {
22837				jtv, ok := value.(string)
22838				if !ok {
22839					return fmt.Errorf("expected ContainerServicePowerName to be of type string, got %T instead", value)
22840				}
22841				sv.Power = types.ContainerServicePowerName(jtv)
22842			}
22843
22844		case "powerId":
22845			if value != nil {
22846				jtv, ok := value.(string)
22847				if !ok {
22848					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22849				}
22850				sv.PowerId = ptr.String(jtv)
22851			}
22852
22853		case "principalArn":
22854			if value != nil {
22855				jtv, ok := value.(string)
22856				if !ok {
22857					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22858				}
22859				sv.PrincipalArn = ptr.String(jtv)
22860			}
22861
22862		case "privateDomainName":
22863			if value != nil {
22864				jtv, ok := value.(string)
22865				if !ok {
22866					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22867				}
22868				sv.PrivateDomainName = ptr.String(jtv)
22869			}
22870
22871		case "publicDomainNames":
22872			if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomains(&sv.PublicDomainNames, value); err != nil {
22873				return err
22874			}
22875
22876		case "resourceType":
22877			if value != nil {
22878				jtv, ok := value.(string)
22879				if !ok {
22880					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22881				}
22882				sv.ResourceType = types.ResourceType(jtv)
22883			}
22884
22885		case "scale":
22886			if value != nil {
22887				jtv, ok := value.(json.Number)
22888				if !ok {
22889					return fmt.Errorf("expected ContainerServiceScale to be json.Number, got %T instead", value)
22890				}
22891				i64, err := jtv.Int64()
22892				if err != nil {
22893					return err
22894				}
22895				sv.Scale = ptr.Int32(int32(i64))
22896			}
22897
22898		case "state":
22899			if value != nil {
22900				jtv, ok := value.(string)
22901				if !ok {
22902					return fmt.Errorf("expected ContainerServiceState to be of type string, got %T instead", value)
22903				}
22904				sv.State = types.ContainerServiceState(jtv)
22905			}
22906
22907		case "stateDetail":
22908			if err := awsAwsjson11_deserializeDocumentContainerServiceStateDetail(&sv.StateDetail, value); err != nil {
22909				return err
22910			}
22911
22912		case "tags":
22913			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22914				return err
22915			}
22916
22917		case "url":
22918			if value != nil {
22919				jtv, ok := value.(string)
22920				if !ok {
22921					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22922				}
22923				sv.Url = ptr.String(jtv)
22924			}
22925
22926		default:
22927			_, _ = key, value
22928
22929		}
22930	}
22931	*v = sv
22932	return nil
22933}
22934
22935func awsAwsjson11_deserializeDocumentContainerServiceDeployment(v **types.ContainerServiceDeployment, value interface{}) error {
22936	if v == nil {
22937		return fmt.Errorf("unexpected nil of type %T", v)
22938	}
22939	if value == nil {
22940		return nil
22941	}
22942
22943	shape, ok := value.(map[string]interface{})
22944	if !ok {
22945		return fmt.Errorf("unexpected JSON type %v", value)
22946	}
22947
22948	var sv *types.ContainerServiceDeployment
22949	if *v == nil {
22950		sv = &types.ContainerServiceDeployment{}
22951	} else {
22952		sv = *v
22953	}
22954
22955	for key, value := range shape {
22956		switch key {
22957		case "containers":
22958			if err := awsAwsjson11_deserializeDocumentContainerMap(&sv.Containers, value); err != nil {
22959				return err
22960			}
22961
22962		case "createdAt":
22963			if value != nil {
22964				switch jtv := value.(type) {
22965				case json.Number:
22966					f64, err := jtv.Float64()
22967					if err != nil {
22968						return err
22969					}
22970					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22971
22972				default:
22973					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
22974
22975				}
22976			}
22977
22978		case "publicEndpoint":
22979			if err := awsAwsjson11_deserializeDocumentContainerServiceEndpoint(&sv.PublicEndpoint, value); err != nil {
22980				return err
22981			}
22982
22983		case "state":
22984			if value != nil {
22985				jtv, ok := value.(string)
22986				if !ok {
22987					return fmt.Errorf("expected ContainerServiceDeploymentState to be of type string, got %T instead", value)
22988				}
22989				sv.State = types.ContainerServiceDeploymentState(jtv)
22990			}
22991
22992		case "version":
22993			if value != nil {
22994				jtv, ok := value.(json.Number)
22995				if !ok {
22996					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22997				}
22998				i64, err := jtv.Int64()
22999				if err != nil {
23000					return err
23001				}
23002				sv.Version = ptr.Int32(int32(i64))
23003			}
23004
23005		default:
23006			_, _ = key, value
23007
23008		}
23009	}
23010	*v = sv
23011	return nil
23012}
23013
23014func awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(v *[]types.ContainerServiceDeployment, value interface{}) error {
23015	if v == nil {
23016		return fmt.Errorf("unexpected nil of type %T", v)
23017	}
23018	if value == nil {
23019		return nil
23020	}
23021
23022	shape, ok := value.([]interface{})
23023	if !ok {
23024		return fmt.Errorf("unexpected JSON type %v", value)
23025	}
23026
23027	var cv []types.ContainerServiceDeployment
23028	if *v == nil {
23029		cv = []types.ContainerServiceDeployment{}
23030	} else {
23031		cv = *v
23032	}
23033
23034	for _, value := range shape {
23035		var col types.ContainerServiceDeployment
23036		destAddr := &col
23037		if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&destAddr, value); err != nil {
23038			return err
23039		}
23040		col = *destAddr
23041		cv = append(cv, col)
23042
23043	}
23044	*v = cv
23045	return nil
23046}
23047
23048func awsAwsjson11_deserializeDocumentContainerServiceEndpoint(v **types.ContainerServiceEndpoint, value interface{}) error {
23049	if v == nil {
23050		return fmt.Errorf("unexpected nil of type %T", v)
23051	}
23052	if value == nil {
23053		return nil
23054	}
23055
23056	shape, ok := value.(map[string]interface{})
23057	if !ok {
23058		return fmt.Errorf("unexpected JSON type %v", value)
23059	}
23060
23061	var sv *types.ContainerServiceEndpoint
23062	if *v == nil {
23063		sv = &types.ContainerServiceEndpoint{}
23064	} else {
23065		sv = *v
23066	}
23067
23068	for key, value := range shape {
23069		switch key {
23070		case "containerName":
23071			if value != nil {
23072				jtv, ok := value.(string)
23073				if !ok {
23074					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23075				}
23076				sv.ContainerName = ptr.String(jtv)
23077			}
23078
23079		case "containerPort":
23080			if value != nil {
23081				jtv, ok := value.(json.Number)
23082				if !ok {
23083					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23084				}
23085				i64, err := jtv.Int64()
23086				if err != nil {
23087					return err
23088				}
23089				sv.ContainerPort = ptr.Int32(int32(i64))
23090			}
23091
23092		case "healthCheck":
23093			if err := awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(&sv.HealthCheck, value); err != nil {
23094				return err
23095			}
23096
23097		default:
23098			_, _ = key, value
23099
23100		}
23101	}
23102	*v = sv
23103	return nil
23104}
23105
23106func awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(v **types.ContainerServiceHealthCheckConfig, value interface{}) error {
23107	if v == nil {
23108		return fmt.Errorf("unexpected nil of type %T", v)
23109	}
23110	if value == nil {
23111		return nil
23112	}
23113
23114	shape, ok := value.(map[string]interface{})
23115	if !ok {
23116		return fmt.Errorf("unexpected JSON type %v", value)
23117	}
23118
23119	var sv *types.ContainerServiceHealthCheckConfig
23120	if *v == nil {
23121		sv = &types.ContainerServiceHealthCheckConfig{}
23122	} else {
23123		sv = *v
23124	}
23125
23126	for key, value := range shape {
23127		switch key {
23128		case "healthyThreshold":
23129			if value != nil {
23130				jtv, ok := value.(json.Number)
23131				if !ok {
23132					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23133				}
23134				i64, err := jtv.Int64()
23135				if err != nil {
23136					return err
23137				}
23138				sv.HealthyThreshold = ptr.Int32(int32(i64))
23139			}
23140
23141		case "intervalSeconds":
23142			if value != nil {
23143				jtv, ok := value.(json.Number)
23144				if !ok {
23145					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23146				}
23147				i64, err := jtv.Int64()
23148				if err != nil {
23149					return err
23150				}
23151				sv.IntervalSeconds = ptr.Int32(int32(i64))
23152			}
23153
23154		case "path":
23155			if value != nil {
23156				jtv, ok := value.(string)
23157				if !ok {
23158					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23159				}
23160				sv.Path = ptr.String(jtv)
23161			}
23162
23163		case "successCodes":
23164			if value != nil {
23165				jtv, ok := value.(string)
23166				if !ok {
23167					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23168				}
23169				sv.SuccessCodes = ptr.String(jtv)
23170			}
23171
23172		case "timeoutSeconds":
23173			if value != nil {
23174				jtv, ok := value.(json.Number)
23175				if !ok {
23176					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23177				}
23178				i64, err := jtv.Int64()
23179				if err != nil {
23180					return err
23181				}
23182				sv.TimeoutSeconds = ptr.Int32(int32(i64))
23183			}
23184
23185		case "unhealthyThreshold":
23186			if value != nil {
23187				jtv, ok := value.(json.Number)
23188				if !ok {
23189					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23190				}
23191				i64, err := jtv.Int64()
23192				if err != nil {
23193					return err
23194				}
23195				sv.UnhealthyThreshold = ptr.Int32(int32(i64))
23196			}
23197
23198		default:
23199			_, _ = key, value
23200
23201		}
23202	}
23203	*v = sv
23204	return nil
23205}
23206
23207func awsAwsjson11_deserializeDocumentContainerServiceList(v *[]types.ContainerService, value interface{}) error {
23208	if v == nil {
23209		return fmt.Errorf("unexpected nil of type %T", v)
23210	}
23211	if value == nil {
23212		return nil
23213	}
23214
23215	shape, ok := value.([]interface{})
23216	if !ok {
23217		return fmt.Errorf("unexpected JSON type %v", value)
23218	}
23219
23220	var cv []types.ContainerService
23221	if *v == nil {
23222		cv = []types.ContainerService{}
23223	} else {
23224		cv = *v
23225	}
23226
23227	for _, value := range shape {
23228		var col types.ContainerService
23229		destAddr := &col
23230		if err := awsAwsjson11_deserializeDocumentContainerService(&destAddr, value); err != nil {
23231			return err
23232		}
23233		col = *destAddr
23234		cv = append(cv, col)
23235
23236	}
23237	*v = cv
23238	return nil
23239}
23240
23241func awsAwsjson11_deserializeDocumentContainerServiceLogEvent(v **types.ContainerServiceLogEvent, value interface{}) error {
23242	if v == nil {
23243		return fmt.Errorf("unexpected nil of type %T", v)
23244	}
23245	if value == nil {
23246		return nil
23247	}
23248
23249	shape, ok := value.(map[string]interface{})
23250	if !ok {
23251		return fmt.Errorf("unexpected JSON type %v", value)
23252	}
23253
23254	var sv *types.ContainerServiceLogEvent
23255	if *v == nil {
23256		sv = &types.ContainerServiceLogEvent{}
23257	} else {
23258		sv = *v
23259	}
23260
23261	for key, value := range shape {
23262		switch key {
23263		case "createdAt":
23264			if value != nil {
23265				switch jtv := value.(type) {
23266				case json.Number:
23267					f64, err := jtv.Float64()
23268					if err != nil {
23269						return err
23270					}
23271					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23272
23273				default:
23274					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23275
23276				}
23277			}
23278
23279		case "message":
23280			if value != nil {
23281				jtv, ok := value.(string)
23282				if !ok {
23283					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23284				}
23285				sv.Message = ptr.String(jtv)
23286			}
23287
23288		default:
23289			_, _ = key, value
23290
23291		}
23292	}
23293	*v = sv
23294	return nil
23295}
23296
23297func awsAwsjson11_deserializeDocumentContainerServiceLogEventList(v *[]types.ContainerServiceLogEvent, value interface{}) error {
23298	if v == nil {
23299		return fmt.Errorf("unexpected nil of type %T", v)
23300	}
23301	if value == nil {
23302		return nil
23303	}
23304
23305	shape, ok := value.([]interface{})
23306	if !ok {
23307		return fmt.Errorf("unexpected JSON type %v", value)
23308	}
23309
23310	var cv []types.ContainerServiceLogEvent
23311	if *v == nil {
23312		cv = []types.ContainerServiceLogEvent{}
23313	} else {
23314		cv = *v
23315	}
23316
23317	for _, value := range shape {
23318		var col types.ContainerServiceLogEvent
23319		destAddr := &col
23320		if err := awsAwsjson11_deserializeDocumentContainerServiceLogEvent(&destAddr, value); err != nil {
23321			return err
23322		}
23323		col = *destAddr
23324		cv = append(cv, col)
23325
23326	}
23327	*v = cv
23328	return nil
23329}
23330
23331func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(v *map[string]string, value interface{}) error {
23332	if v == nil {
23333		return fmt.Errorf("unexpected nil of type %T", v)
23334	}
23335	if value == nil {
23336		return nil
23337	}
23338
23339	shape, ok := value.(map[string]interface{})
23340	if !ok {
23341		return fmt.Errorf("unexpected JSON type %v", value)
23342	}
23343
23344	var mv map[string]string
23345	if *v == nil {
23346		mv = map[string]string{}
23347	} else {
23348		mv = *v
23349	}
23350
23351	for key, value := range shape {
23352		var parsedVal string
23353		if value != nil {
23354			jtv, ok := value.(string)
23355			if !ok {
23356				return fmt.Errorf("expected string to be of type string, got %T instead", value)
23357			}
23358			parsedVal = jtv
23359		}
23360		mv[key] = parsedVal
23361
23362	}
23363	*v = mv
23364	return nil
23365}
23366
23367func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(v *[]map[string]string, value interface{}) error {
23368	if v == nil {
23369		return fmt.Errorf("unexpected nil of type %T", v)
23370	}
23371	if value == nil {
23372		return nil
23373	}
23374
23375	shape, ok := value.([]interface{})
23376	if !ok {
23377		return fmt.Errorf("unexpected JSON type %v", value)
23378	}
23379
23380	var cv []map[string]string
23381	if *v == nil {
23382		cv = []map[string]string{}
23383	} else {
23384		cv = *v
23385	}
23386
23387	for _, value := range shape {
23388		var col map[string]string
23389		if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(&col, value); err != nil {
23390			return err
23391		}
23392		cv = append(cv, col)
23393
23394	}
23395	*v = cv
23396	return nil
23397}
23398
23399func awsAwsjson11_deserializeDocumentContainerServicePower(v **types.ContainerServicePower, value interface{}) error {
23400	if v == nil {
23401		return fmt.Errorf("unexpected nil of type %T", v)
23402	}
23403	if value == nil {
23404		return nil
23405	}
23406
23407	shape, ok := value.(map[string]interface{})
23408	if !ok {
23409		return fmt.Errorf("unexpected JSON type %v", value)
23410	}
23411
23412	var sv *types.ContainerServicePower
23413	if *v == nil {
23414		sv = &types.ContainerServicePower{}
23415	} else {
23416		sv = *v
23417	}
23418
23419	for key, value := range shape {
23420		switch key {
23421		case "cpuCount":
23422			if value != nil {
23423				switch jtv := value.(type) {
23424				case json.Number:
23425					f64, err := jtv.Float64()
23426					if err != nil {
23427						return err
23428					}
23429					sv.CpuCount = ptr.Float32(float32(f64))
23430
23431				case string:
23432					var f64 float64
23433					switch {
23434					case strings.EqualFold(jtv, "NaN"):
23435						f64 = math.NaN()
23436
23437					case strings.EqualFold(jtv, "Infinity"):
23438						f64 = math.Inf(1)
23439
23440					case strings.EqualFold(jtv, "-Infinity"):
23441						f64 = math.Inf(-1)
23442
23443					default:
23444						return fmt.Errorf("unknown JSON number value: %s", jtv)
23445
23446					}
23447					sv.CpuCount = ptr.Float32(float32(f64))
23448
23449				default:
23450					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
23451
23452				}
23453			}
23454
23455		case "isActive":
23456			if value != nil {
23457				jtv, ok := value.(bool)
23458				if !ok {
23459					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
23460				}
23461				sv.IsActive = ptr.Bool(jtv)
23462			}
23463
23464		case "name":
23465			if value != nil {
23466				jtv, ok := value.(string)
23467				if !ok {
23468					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23469				}
23470				sv.Name = ptr.String(jtv)
23471			}
23472
23473		case "powerId":
23474			if value != nil {
23475				jtv, ok := value.(string)
23476				if !ok {
23477					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23478				}
23479				sv.PowerId = ptr.String(jtv)
23480			}
23481
23482		case "price":
23483			if value != nil {
23484				switch jtv := value.(type) {
23485				case json.Number:
23486					f64, err := jtv.Float64()
23487					if err != nil {
23488						return err
23489					}
23490					sv.Price = ptr.Float32(float32(f64))
23491
23492				case string:
23493					var f64 float64
23494					switch {
23495					case strings.EqualFold(jtv, "NaN"):
23496						f64 = math.NaN()
23497
23498					case strings.EqualFold(jtv, "Infinity"):
23499						f64 = math.Inf(1)
23500
23501					case strings.EqualFold(jtv, "-Infinity"):
23502						f64 = math.Inf(-1)
23503
23504					default:
23505						return fmt.Errorf("unknown JSON number value: %s", jtv)
23506
23507					}
23508					sv.Price = ptr.Float32(float32(f64))
23509
23510				default:
23511					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
23512
23513				}
23514			}
23515
23516		case "ramSizeInGb":
23517			if value != nil {
23518				switch jtv := value.(type) {
23519				case json.Number:
23520					f64, err := jtv.Float64()
23521					if err != nil {
23522						return err
23523					}
23524					sv.RamSizeInGb = ptr.Float32(float32(f64))
23525
23526				case string:
23527					var f64 float64
23528					switch {
23529					case strings.EqualFold(jtv, "NaN"):
23530						f64 = math.NaN()
23531
23532					case strings.EqualFold(jtv, "Infinity"):
23533						f64 = math.Inf(1)
23534
23535					case strings.EqualFold(jtv, "-Infinity"):
23536						f64 = math.Inf(-1)
23537
23538					default:
23539						return fmt.Errorf("unknown JSON number value: %s", jtv)
23540
23541					}
23542					sv.RamSizeInGb = ptr.Float32(float32(f64))
23543
23544				default:
23545					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
23546
23547				}
23548			}
23549
23550		default:
23551			_, _ = key, value
23552
23553		}
23554	}
23555	*v = sv
23556	return nil
23557}
23558
23559func awsAwsjson11_deserializeDocumentContainerServicePowerList(v *[]types.ContainerServicePower, value interface{}) error {
23560	if v == nil {
23561		return fmt.Errorf("unexpected nil of type %T", v)
23562	}
23563	if value == nil {
23564		return nil
23565	}
23566
23567	shape, ok := value.([]interface{})
23568	if !ok {
23569		return fmt.Errorf("unexpected JSON type %v", value)
23570	}
23571
23572	var cv []types.ContainerServicePower
23573	if *v == nil {
23574		cv = []types.ContainerServicePower{}
23575	} else {
23576		cv = *v
23577	}
23578
23579	for _, value := range shape {
23580		var col types.ContainerServicePower
23581		destAddr := &col
23582		if err := awsAwsjson11_deserializeDocumentContainerServicePower(&destAddr, value); err != nil {
23583			return err
23584		}
23585		col = *destAddr
23586		cv = append(cv, col)
23587
23588	}
23589	*v = cv
23590	return nil
23591}
23592
23593func awsAwsjson11_deserializeDocumentContainerServicePublicDomains(v *map[string][]string, value interface{}) error {
23594	if v == nil {
23595		return fmt.Errorf("unexpected nil of type %T", v)
23596	}
23597	if value == nil {
23598		return nil
23599	}
23600
23601	shape, ok := value.(map[string]interface{})
23602	if !ok {
23603		return fmt.Errorf("unexpected JSON type %v", value)
23604	}
23605
23606	var mv map[string][]string
23607	if *v == nil {
23608		mv = map[string][]string{}
23609	} else {
23610		mv = *v
23611	}
23612
23613	for key, value := range shape {
23614		var parsedVal []string
23615		mapVar := parsedVal
23616		if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(&mapVar, value); err != nil {
23617			return err
23618		}
23619		parsedVal = mapVar
23620		mv[key] = parsedVal
23621
23622	}
23623	*v = mv
23624	return nil
23625}
23626
23627func awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(v *[]string, value interface{}) error {
23628	if v == nil {
23629		return fmt.Errorf("unexpected nil of type %T", v)
23630	}
23631	if value == nil {
23632		return nil
23633	}
23634
23635	shape, ok := value.([]interface{})
23636	if !ok {
23637		return fmt.Errorf("unexpected JSON type %v", value)
23638	}
23639
23640	var cv []string
23641	if *v == nil {
23642		cv = []string{}
23643	} else {
23644		cv = *v
23645	}
23646
23647	for _, value := range shape {
23648		var col string
23649		if value != nil {
23650			jtv, ok := value.(string)
23651			if !ok {
23652				return fmt.Errorf("expected string to be of type string, got %T instead", value)
23653			}
23654			col = jtv
23655		}
23656		cv = append(cv, col)
23657
23658	}
23659	*v = cv
23660	return nil
23661}
23662
23663func awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(v **types.ContainerServiceRegistryLogin, value interface{}) error {
23664	if v == nil {
23665		return fmt.Errorf("unexpected nil of type %T", v)
23666	}
23667	if value == nil {
23668		return nil
23669	}
23670
23671	shape, ok := value.(map[string]interface{})
23672	if !ok {
23673		return fmt.Errorf("unexpected JSON type %v", value)
23674	}
23675
23676	var sv *types.ContainerServiceRegistryLogin
23677	if *v == nil {
23678		sv = &types.ContainerServiceRegistryLogin{}
23679	} else {
23680		sv = *v
23681	}
23682
23683	for key, value := range shape {
23684		switch key {
23685		case "expiresAt":
23686			if value != nil {
23687				switch jtv := value.(type) {
23688				case json.Number:
23689					f64, err := jtv.Float64()
23690					if err != nil {
23691						return err
23692					}
23693					sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23694
23695				default:
23696					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23697
23698				}
23699			}
23700
23701		case "password":
23702			if value != nil {
23703				jtv, ok := value.(string)
23704				if !ok {
23705					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23706				}
23707				sv.Password = ptr.String(jtv)
23708			}
23709
23710		case "registry":
23711			if value != nil {
23712				jtv, ok := value.(string)
23713				if !ok {
23714					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23715				}
23716				sv.Registry = ptr.String(jtv)
23717			}
23718
23719		case "username":
23720			if value != nil {
23721				jtv, ok := value.(string)
23722				if !ok {
23723					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23724				}
23725				sv.Username = ptr.String(jtv)
23726			}
23727
23728		default:
23729			_, _ = key, value
23730
23731		}
23732	}
23733	*v = sv
23734	return nil
23735}
23736
23737func awsAwsjson11_deserializeDocumentContainerServiceStateDetail(v **types.ContainerServiceStateDetail, value interface{}) error {
23738	if v == nil {
23739		return fmt.Errorf("unexpected nil of type %T", v)
23740	}
23741	if value == nil {
23742		return nil
23743	}
23744
23745	shape, ok := value.(map[string]interface{})
23746	if !ok {
23747		return fmt.Errorf("unexpected JSON type %v", value)
23748	}
23749
23750	var sv *types.ContainerServiceStateDetail
23751	if *v == nil {
23752		sv = &types.ContainerServiceStateDetail{}
23753	} else {
23754		sv = *v
23755	}
23756
23757	for key, value := range shape {
23758		switch key {
23759		case "code":
23760			if value != nil {
23761				jtv, ok := value.(string)
23762				if !ok {
23763					return fmt.Errorf("expected ContainerServiceStateDetailCode to be of type string, got %T instead", value)
23764				}
23765				sv.Code = types.ContainerServiceStateDetailCode(jtv)
23766			}
23767
23768		case "message":
23769			if value != nil {
23770				jtv, ok := value.(string)
23771				if !ok {
23772					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23773				}
23774				sv.Message = ptr.String(jtv)
23775			}
23776
23777		default:
23778			_, _ = key, value
23779
23780		}
23781	}
23782	*v = sv
23783	return nil
23784}
23785
23786func awsAwsjson11_deserializeDocumentCookieObject(v **types.CookieObject, value interface{}) error {
23787	if v == nil {
23788		return fmt.Errorf("unexpected nil of type %T", v)
23789	}
23790	if value == nil {
23791		return nil
23792	}
23793
23794	shape, ok := value.(map[string]interface{})
23795	if !ok {
23796		return fmt.Errorf("unexpected JSON type %v", value)
23797	}
23798
23799	var sv *types.CookieObject
23800	if *v == nil {
23801		sv = &types.CookieObject{}
23802	} else {
23803		sv = *v
23804	}
23805
23806	for key, value := range shape {
23807		switch key {
23808		case "cookiesAllowList":
23809			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CookiesAllowList, value); err != nil {
23810				return err
23811			}
23812
23813		case "option":
23814			if value != nil {
23815				jtv, ok := value.(string)
23816				if !ok {
23817					return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
23818				}
23819				sv.Option = types.ForwardValues(jtv)
23820			}
23821
23822		default:
23823			_, _ = key, value
23824
23825		}
23826	}
23827	*v = sv
23828	return nil
23829}
23830
23831func awsAwsjson11_deserializeDocumentDestinationInfo(v **types.DestinationInfo, value interface{}) error {
23832	if v == nil {
23833		return fmt.Errorf("unexpected nil of type %T", v)
23834	}
23835	if value == nil {
23836		return nil
23837	}
23838
23839	shape, ok := value.(map[string]interface{})
23840	if !ok {
23841		return fmt.Errorf("unexpected JSON type %v", value)
23842	}
23843
23844	var sv *types.DestinationInfo
23845	if *v == nil {
23846		sv = &types.DestinationInfo{}
23847	} else {
23848		sv = *v
23849	}
23850
23851	for key, value := range shape {
23852		switch key {
23853		case "id":
23854			if value != nil {
23855				jtv, ok := value.(string)
23856				if !ok {
23857					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23858				}
23859				sv.Id = ptr.String(jtv)
23860			}
23861
23862		case "service":
23863			if value != nil {
23864				jtv, ok := value.(string)
23865				if !ok {
23866					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23867				}
23868				sv.Service = ptr.String(jtv)
23869			}
23870
23871		default:
23872			_, _ = key, value
23873
23874		}
23875	}
23876	*v = sv
23877	return nil
23878}
23879
23880func awsAwsjson11_deserializeDocumentDisk(v **types.Disk, value interface{}) error {
23881	if v == nil {
23882		return fmt.Errorf("unexpected nil of type %T", v)
23883	}
23884	if value == nil {
23885		return nil
23886	}
23887
23888	shape, ok := value.(map[string]interface{})
23889	if !ok {
23890		return fmt.Errorf("unexpected JSON type %v", value)
23891	}
23892
23893	var sv *types.Disk
23894	if *v == nil {
23895		sv = &types.Disk{}
23896	} else {
23897		sv = *v
23898	}
23899
23900	for key, value := range shape {
23901		switch key {
23902		case "addOns":
23903			if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
23904				return err
23905			}
23906
23907		case "arn":
23908			if value != nil {
23909				jtv, ok := value.(string)
23910				if !ok {
23911					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23912				}
23913				sv.Arn = ptr.String(jtv)
23914			}
23915
23916		case "attachedTo":
23917			if value != nil {
23918				jtv, ok := value.(string)
23919				if !ok {
23920					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
23921				}
23922				sv.AttachedTo = ptr.String(jtv)
23923			}
23924
23925		case "attachmentState":
23926			if value != nil {
23927				jtv, ok := value.(string)
23928				if !ok {
23929					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23930				}
23931				sv.AttachmentState = ptr.String(jtv)
23932			}
23933
23934		case "createdAt":
23935			if value != nil {
23936				switch jtv := value.(type) {
23937				case json.Number:
23938					f64, err := jtv.Float64()
23939					if err != nil {
23940						return err
23941					}
23942					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23943
23944				default:
23945					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
23946
23947				}
23948			}
23949
23950		case "gbInUse":
23951			if value != nil {
23952				jtv, ok := value.(json.Number)
23953				if !ok {
23954					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23955				}
23956				i64, err := jtv.Int64()
23957				if err != nil {
23958					return err
23959				}
23960				sv.GbInUse = ptr.Int32(int32(i64))
23961			}
23962
23963		case "iops":
23964			if value != nil {
23965				jtv, ok := value.(json.Number)
23966				if !ok {
23967					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23968				}
23969				i64, err := jtv.Int64()
23970				if err != nil {
23971					return err
23972				}
23973				sv.Iops = ptr.Int32(int32(i64))
23974			}
23975
23976		case "isAttached":
23977			if value != nil {
23978				jtv, ok := value.(bool)
23979				if !ok {
23980					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
23981				}
23982				sv.IsAttached = ptr.Bool(jtv)
23983			}
23984
23985		case "isSystemDisk":
23986			if value != nil {
23987				jtv, ok := value.(bool)
23988				if !ok {
23989					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
23990				}
23991				sv.IsSystemDisk = ptr.Bool(jtv)
23992			}
23993
23994		case "location":
23995			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
23996				return err
23997			}
23998
23999		case "name":
24000			if value != nil {
24001				jtv, ok := value.(string)
24002				if !ok {
24003					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24004				}
24005				sv.Name = ptr.String(jtv)
24006			}
24007
24008		case "path":
24009			if value != nil {
24010				jtv, ok := value.(string)
24011				if !ok {
24012					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24013				}
24014				sv.Path = ptr.String(jtv)
24015			}
24016
24017		case "resourceType":
24018			if value != nil {
24019				jtv, ok := value.(string)
24020				if !ok {
24021					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24022				}
24023				sv.ResourceType = types.ResourceType(jtv)
24024			}
24025
24026		case "sizeInGb":
24027			if value != nil {
24028				jtv, ok := value.(json.Number)
24029				if !ok {
24030					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24031				}
24032				i64, err := jtv.Int64()
24033				if err != nil {
24034					return err
24035				}
24036				sv.SizeInGb = ptr.Int32(int32(i64))
24037			}
24038
24039		case "state":
24040			if value != nil {
24041				jtv, ok := value.(string)
24042				if !ok {
24043					return fmt.Errorf("expected DiskState to be of type string, got %T instead", value)
24044				}
24045				sv.State = types.DiskState(jtv)
24046			}
24047
24048		case "supportCode":
24049			if value != nil {
24050				jtv, ok := value.(string)
24051				if !ok {
24052					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24053				}
24054				sv.SupportCode = ptr.String(jtv)
24055			}
24056
24057		case "tags":
24058			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24059				return err
24060			}
24061
24062		default:
24063			_, _ = key, value
24064
24065		}
24066	}
24067	*v = sv
24068	return nil
24069}
24070
24071func awsAwsjson11_deserializeDocumentDiskInfo(v **types.DiskInfo, value interface{}) error {
24072	if v == nil {
24073		return fmt.Errorf("unexpected nil of type %T", v)
24074	}
24075	if value == nil {
24076		return nil
24077	}
24078
24079	shape, ok := value.(map[string]interface{})
24080	if !ok {
24081		return fmt.Errorf("unexpected JSON type %v", value)
24082	}
24083
24084	var sv *types.DiskInfo
24085	if *v == nil {
24086		sv = &types.DiskInfo{}
24087	} else {
24088		sv = *v
24089	}
24090
24091	for key, value := range shape {
24092		switch key {
24093		case "isSystemDisk":
24094			if value != nil {
24095				jtv, ok := value.(bool)
24096				if !ok {
24097					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24098				}
24099				sv.IsSystemDisk = ptr.Bool(jtv)
24100			}
24101
24102		case "name":
24103			if value != nil {
24104				jtv, ok := value.(string)
24105				if !ok {
24106					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24107				}
24108				sv.Name = ptr.String(jtv)
24109			}
24110
24111		case "path":
24112			if value != nil {
24113				jtv, ok := value.(string)
24114				if !ok {
24115					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24116				}
24117				sv.Path = ptr.String(jtv)
24118			}
24119
24120		case "sizeInGb":
24121			if value != nil {
24122				jtv, ok := value.(json.Number)
24123				if !ok {
24124					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24125				}
24126				i64, err := jtv.Int64()
24127				if err != nil {
24128					return err
24129				}
24130				sv.SizeInGb = ptr.Int32(int32(i64))
24131			}
24132
24133		default:
24134			_, _ = key, value
24135
24136		}
24137	}
24138	*v = sv
24139	return nil
24140}
24141
24142func awsAwsjson11_deserializeDocumentDiskInfoList(v *[]types.DiskInfo, value interface{}) error {
24143	if v == nil {
24144		return fmt.Errorf("unexpected nil of type %T", v)
24145	}
24146	if value == nil {
24147		return nil
24148	}
24149
24150	shape, ok := value.([]interface{})
24151	if !ok {
24152		return fmt.Errorf("unexpected JSON type %v", value)
24153	}
24154
24155	var cv []types.DiskInfo
24156	if *v == nil {
24157		cv = []types.DiskInfo{}
24158	} else {
24159		cv = *v
24160	}
24161
24162	for _, value := range shape {
24163		var col types.DiskInfo
24164		destAddr := &col
24165		if err := awsAwsjson11_deserializeDocumentDiskInfo(&destAddr, value); err != nil {
24166			return err
24167		}
24168		col = *destAddr
24169		cv = append(cv, col)
24170
24171	}
24172	*v = cv
24173	return nil
24174}
24175
24176func awsAwsjson11_deserializeDocumentDiskList(v *[]types.Disk, value interface{}) error {
24177	if v == nil {
24178		return fmt.Errorf("unexpected nil of type %T", v)
24179	}
24180	if value == nil {
24181		return nil
24182	}
24183
24184	shape, ok := value.([]interface{})
24185	if !ok {
24186		return fmt.Errorf("unexpected JSON type %v", value)
24187	}
24188
24189	var cv []types.Disk
24190	if *v == nil {
24191		cv = []types.Disk{}
24192	} else {
24193		cv = *v
24194	}
24195
24196	for _, value := range shape {
24197		var col types.Disk
24198		destAddr := &col
24199		if err := awsAwsjson11_deserializeDocumentDisk(&destAddr, value); err != nil {
24200			return err
24201		}
24202		col = *destAddr
24203		cv = append(cv, col)
24204
24205	}
24206	*v = cv
24207	return nil
24208}
24209
24210func awsAwsjson11_deserializeDocumentDiskSnapshot(v **types.DiskSnapshot, value interface{}) error {
24211	if v == nil {
24212		return fmt.Errorf("unexpected nil of type %T", v)
24213	}
24214	if value == nil {
24215		return nil
24216	}
24217
24218	shape, ok := value.(map[string]interface{})
24219	if !ok {
24220		return fmt.Errorf("unexpected JSON type %v", value)
24221	}
24222
24223	var sv *types.DiskSnapshot
24224	if *v == nil {
24225		sv = &types.DiskSnapshot{}
24226	} else {
24227		sv = *v
24228	}
24229
24230	for key, value := range shape {
24231		switch key {
24232		case "arn":
24233			if value != nil {
24234				jtv, ok := value.(string)
24235				if !ok {
24236					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24237				}
24238				sv.Arn = ptr.String(jtv)
24239			}
24240
24241		case "createdAt":
24242			if value != nil {
24243				switch jtv := value.(type) {
24244				case json.Number:
24245					f64, err := jtv.Float64()
24246					if err != nil {
24247						return err
24248					}
24249					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24250
24251				default:
24252					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24253
24254				}
24255			}
24256
24257		case "fromDiskArn":
24258			if value != nil {
24259				jtv, ok := value.(string)
24260				if !ok {
24261					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24262				}
24263				sv.FromDiskArn = ptr.String(jtv)
24264			}
24265
24266		case "fromDiskName":
24267			if value != nil {
24268				jtv, ok := value.(string)
24269				if !ok {
24270					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24271				}
24272				sv.FromDiskName = ptr.String(jtv)
24273			}
24274
24275		case "fromInstanceArn":
24276			if value != nil {
24277				jtv, ok := value.(string)
24278				if !ok {
24279					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24280				}
24281				sv.FromInstanceArn = ptr.String(jtv)
24282			}
24283
24284		case "fromInstanceName":
24285			if value != nil {
24286				jtv, ok := value.(string)
24287				if !ok {
24288					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24289				}
24290				sv.FromInstanceName = ptr.String(jtv)
24291			}
24292
24293		case "isFromAutoSnapshot":
24294			if value != nil {
24295				jtv, ok := value.(bool)
24296				if !ok {
24297					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24298				}
24299				sv.IsFromAutoSnapshot = ptr.Bool(jtv)
24300			}
24301
24302		case "location":
24303			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24304				return err
24305			}
24306
24307		case "name":
24308			if value != nil {
24309				jtv, ok := value.(string)
24310				if !ok {
24311					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24312				}
24313				sv.Name = ptr.String(jtv)
24314			}
24315
24316		case "progress":
24317			if value != nil {
24318				jtv, ok := value.(string)
24319				if !ok {
24320					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24321				}
24322				sv.Progress = ptr.String(jtv)
24323			}
24324
24325		case "resourceType":
24326			if value != nil {
24327				jtv, ok := value.(string)
24328				if !ok {
24329					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24330				}
24331				sv.ResourceType = types.ResourceType(jtv)
24332			}
24333
24334		case "sizeInGb":
24335			if value != nil {
24336				jtv, ok := value.(json.Number)
24337				if !ok {
24338					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24339				}
24340				i64, err := jtv.Int64()
24341				if err != nil {
24342					return err
24343				}
24344				sv.SizeInGb = ptr.Int32(int32(i64))
24345			}
24346
24347		case "state":
24348			if value != nil {
24349				jtv, ok := value.(string)
24350				if !ok {
24351					return fmt.Errorf("expected DiskSnapshotState to be of type string, got %T instead", value)
24352				}
24353				sv.State = types.DiskSnapshotState(jtv)
24354			}
24355
24356		case "supportCode":
24357			if value != nil {
24358				jtv, ok := value.(string)
24359				if !ok {
24360					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24361				}
24362				sv.SupportCode = ptr.String(jtv)
24363			}
24364
24365		case "tags":
24366			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24367				return err
24368			}
24369
24370		default:
24371			_, _ = key, value
24372
24373		}
24374	}
24375	*v = sv
24376	return nil
24377}
24378
24379func awsAwsjson11_deserializeDocumentDiskSnapshotInfo(v **types.DiskSnapshotInfo, value interface{}) error {
24380	if v == nil {
24381		return fmt.Errorf("unexpected nil of type %T", v)
24382	}
24383	if value == nil {
24384		return nil
24385	}
24386
24387	shape, ok := value.(map[string]interface{})
24388	if !ok {
24389		return fmt.Errorf("unexpected JSON type %v", value)
24390	}
24391
24392	var sv *types.DiskSnapshotInfo
24393	if *v == nil {
24394		sv = &types.DiskSnapshotInfo{}
24395	} else {
24396		sv = *v
24397	}
24398
24399	for key, value := range shape {
24400		switch key {
24401		case "sizeInGb":
24402			if value != nil {
24403				jtv, ok := value.(json.Number)
24404				if !ok {
24405					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24406				}
24407				i64, err := jtv.Int64()
24408				if err != nil {
24409					return err
24410				}
24411				sv.SizeInGb = ptr.Int32(int32(i64))
24412			}
24413
24414		default:
24415			_, _ = key, value
24416
24417		}
24418	}
24419	*v = sv
24420	return nil
24421}
24422
24423func awsAwsjson11_deserializeDocumentDiskSnapshotList(v *[]types.DiskSnapshot, value interface{}) error {
24424	if v == nil {
24425		return fmt.Errorf("unexpected nil of type %T", v)
24426	}
24427	if value == nil {
24428		return nil
24429	}
24430
24431	shape, ok := value.([]interface{})
24432	if !ok {
24433		return fmt.Errorf("unexpected JSON type %v", value)
24434	}
24435
24436	var cv []types.DiskSnapshot
24437	if *v == nil {
24438		cv = []types.DiskSnapshot{}
24439	} else {
24440		cv = *v
24441	}
24442
24443	for _, value := range shape {
24444		var col types.DiskSnapshot
24445		destAddr := &col
24446		if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&destAddr, value); err != nil {
24447			return err
24448		}
24449		col = *destAddr
24450		cv = append(cv, col)
24451
24452	}
24453	*v = cv
24454	return nil
24455}
24456
24457func awsAwsjson11_deserializeDocumentDistributionBundle(v **types.DistributionBundle, value interface{}) error {
24458	if v == nil {
24459		return fmt.Errorf("unexpected nil of type %T", v)
24460	}
24461	if value == nil {
24462		return nil
24463	}
24464
24465	shape, ok := value.(map[string]interface{})
24466	if !ok {
24467		return fmt.Errorf("unexpected JSON type %v", value)
24468	}
24469
24470	var sv *types.DistributionBundle
24471	if *v == nil {
24472		sv = &types.DistributionBundle{}
24473	} else {
24474		sv = *v
24475	}
24476
24477	for key, value := range shape {
24478		switch key {
24479		case "bundleId":
24480			if value != nil {
24481				jtv, ok := value.(string)
24482				if !ok {
24483					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24484				}
24485				sv.BundleId = ptr.String(jtv)
24486			}
24487
24488		case "isActive":
24489			if value != nil {
24490				jtv, ok := value.(bool)
24491				if !ok {
24492					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24493				}
24494				sv.IsActive = ptr.Bool(jtv)
24495			}
24496
24497		case "name":
24498			if value != nil {
24499				jtv, ok := value.(string)
24500				if !ok {
24501					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24502				}
24503				sv.Name = ptr.String(jtv)
24504			}
24505
24506		case "price":
24507			if value != nil {
24508				switch jtv := value.(type) {
24509				case json.Number:
24510					f64, err := jtv.Float64()
24511					if err != nil {
24512						return err
24513					}
24514					sv.Price = ptr.Float32(float32(f64))
24515
24516				case string:
24517					var f64 float64
24518					switch {
24519					case strings.EqualFold(jtv, "NaN"):
24520						f64 = math.NaN()
24521
24522					case strings.EqualFold(jtv, "Infinity"):
24523						f64 = math.Inf(1)
24524
24525					case strings.EqualFold(jtv, "-Infinity"):
24526						f64 = math.Inf(-1)
24527
24528					default:
24529						return fmt.Errorf("unknown JSON number value: %s", jtv)
24530
24531					}
24532					sv.Price = ptr.Float32(float32(f64))
24533
24534				default:
24535					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
24536
24537				}
24538			}
24539
24540		case "transferPerMonthInGb":
24541			if value != nil {
24542				jtv, ok := value.(json.Number)
24543				if !ok {
24544					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24545				}
24546				i64, err := jtv.Int64()
24547				if err != nil {
24548					return err
24549				}
24550				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
24551			}
24552
24553		default:
24554			_, _ = key, value
24555
24556		}
24557	}
24558	*v = sv
24559	return nil
24560}
24561
24562func awsAwsjson11_deserializeDocumentDistributionBundleList(v *[]types.DistributionBundle, value interface{}) error {
24563	if v == nil {
24564		return fmt.Errorf("unexpected nil of type %T", v)
24565	}
24566	if value == nil {
24567		return nil
24568	}
24569
24570	shape, ok := value.([]interface{})
24571	if !ok {
24572		return fmt.Errorf("unexpected JSON type %v", value)
24573	}
24574
24575	var cv []types.DistributionBundle
24576	if *v == nil {
24577		cv = []types.DistributionBundle{}
24578	} else {
24579		cv = *v
24580	}
24581
24582	for _, value := range shape {
24583		var col types.DistributionBundle
24584		destAddr := &col
24585		if err := awsAwsjson11_deserializeDocumentDistributionBundle(&destAddr, value); err != nil {
24586			return err
24587		}
24588		col = *destAddr
24589		cv = append(cv, col)
24590
24591	}
24592	*v = cv
24593	return nil
24594}
24595
24596func awsAwsjson11_deserializeDocumentDistributionList(v *[]types.LightsailDistribution, value interface{}) error {
24597	if v == nil {
24598		return fmt.Errorf("unexpected nil of type %T", v)
24599	}
24600	if value == nil {
24601		return nil
24602	}
24603
24604	shape, ok := value.([]interface{})
24605	if !ok {
24606		return fmt.Errorf("unexpected JSON type %v", value)
24607	}
24608
24609	var cv []types.LightsailDistribution
24610	if *v == nil {
24611		cv = []types.LightsailDistribution{}
24612	} else {
24613		cv = *v
24614	}
24615
24616	for _, value := range shape {
24617		var col types.LightsailDistribution
24618		destAddr := &col
24619		if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&destAddr, value); err != nil {
24620			return err
24621		}
24622		col = *destAddr
24623		cv = append(cv, col)
24624
24625	}
24626	*v = cv
24627	return nil
24628}
24629
24630func awsAwsjson11_deserializeDocumentDomain(v **types.Domain, value interface{}) error {
24631	if v == nil {
24632		return fmt.Errorf("unexpected nil of type %T", v)
24633	}
24634	if value == nil {
24635		return nil
24636	}
24637
24638	shape, ok := value.(map[string]interface{})
24639	if !ok {
24640		return fmt.Errorf("unexpected JSON type %v", value)
24641	}
24642
24643	var sv *types.Domain
24644	if *v == nil {
24645		sv = &types.Domain{}
24646	} else {
24647		sv = *v
24648	}
24649
24650	for key, value := range shape {
24651		switch key {
24652		case "arn":
24653			if value != nil {
24654				jtv, ok := value.(string)
24655				if !ok {
24656					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24657				}
24658				sv.Arn = ptr.String(jtv)
24659			}
24660
24661		case "createdAt":
24662			if value != nil {
24663				switch jtv := value.(type) {
24664				case json.Number:
24665					f64, err := jtv.Float64()
24666					if err != nil {
24667						return err
24668					}
24669					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24670
24671				default:
24672					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
24673
24674				}
24675			}
24676
24677		case "domainEntries":
24678			if err := awsAwsjson11_deserializeDocumentDomainEntryList(&sv.DomainEntries, value); err != nil {
24679				return err
24680			}
24681
24682		case "location":
24683			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24684				return err
24685			}
24686
24687		case "name":
24688			if value != nil {
24689				jtv, ok := value.(string)
24690				if !ok {
24691					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24692				}
24693				sv.Name = ptr.String(jtv)
24694			}
24695
24696		case "resourceType":
24697			if value != nil {
24698				jtv, ok := value.(string)
24699				if !ok {
24700					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24701				}
24702				sv.ResourceType = types.ResourceType(jtv)
24703			}
24704
24705		case "supportCode":
24706			if value != nil {
24707				jtv, ok := value.(string)
24708				if !ok {
24709					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24710				}
24711				sv.SupportCode = ptr.String(jtv)
24712			}
24713
24714		case "tags":
24715			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24716				return err
24717			}
24718
24719		default:
24720			_, _ = key, value
24721
24722		}
24723	}
24724	*v = sv
24725	return nil
24726}
24727
24728func awsAwsjson11_deserializeDocumentDomainEntry(v **types.DomainEntry, value interface{}) error {
24729	if v == nil {
24730		return fmt.Errorf("unexpected nil of type %T", v)
24731	}
24732	if value == nil {
24733		return nil
24734	}
24735
24736	shape, ok := value.(map[string]interface{})
24737	if !ok {
24738		return fmt.Errorf("unexpected JSON type %v", value)
24739	}
24740
24741	var sv *types.DomainEntry
24742	if *v == nil {
24743		sv = &types.DomainEntry{}
24744	} else {
24745		sv = *v
24746	}
24747
24748	for key, value := range shape {
24749		switch key {
24750		case "id":
24751			if value != nil {
24752				jtv, ok := value.(string)
24753				if !ok {
24754					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24755				}
24756				sv.Id = ptr.String(jtv)
24757			}
24758
24759		case "isAlias":
24760			if value != nil {
24761				jtv, ok := value.(bool)
24762				if !ok {
24763					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24764				}
24765				sv.IsAlias = ptr.Bool(jtv)
24766			}
24767
24768		case "name":
24769			if value != nil {
24770				jtv, ok := value.(string)
24771				if !ok {
24772					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
24773				}
24774				sv.Name = ptr.String(jtv)
24775			}
24776
24777		case "options":
24778			if err := awsAwsjson11_deserializeDocumentDomainEntryOptions(&sv.Options, value); err != nil {
24779				return err
24780			}
24781
24782		case "target":
24783			if value != nil {
24784				jtv, ok := value.(string)
24785				if !ok {
24786					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24787				}
24788				sv.Target = ptr.String(jtv)
24789			}
24790
24791		case "type":
24792			if value != nil {
24793				jtv, ok := value.(string)
24794				if !ok {
24795					return fmt.Errorf("expected DomainEntryType to be of type string, got %T instead", value)
24796				}
24797				sv.Type = ptr.String(jtv)
24798			}
24799
24800		default:
24801			_, _ = key, value
24802
24803		}
24804	}
24805	*v = sv
24806	return nil
24807}
24808
24809func awsAwsjson11_deserializeDocumentDomainEntryList(v *[]types.DomainEntry, value interface{}) error {
24810	if v == nil {
24811		return fmt.Errorf("unexpected nil of type %T", v)
24812	}
24813	if value == nil {
24814		return nil
24815	}
24816
24817	shape, ok := value.([]interface{})
24818	if !ok {
24819		return fmt.Errorf("unexpected JSON type %v", value)
24820	}
24821
24822	var cv []types.DomainEntry
24823	if *v == nil {
24824		cv = []types.DomainEntry{}
24825	} else {
24826		cv = *v
24827	}
24828
24829	for _, value := range shape {
24830		var col types.DomainEntry
24831		destAddr := &col
24832		if err := awsAwsjson11_deserializeDocumentDomainEntry(&destAddr, value); err != nil {
24833			return err
24834		}
24835		col = *destAddr
24836		cv = append(cv, col)
24837
24838	}
24839	*v = cv
24840	return nil
24841}
24842
24843func awsAwsjson11_deserializeDocumentDomainEntryOptions(v *map[string]string, value interface{}) error {
24844	if v == nil {
24845		return fmt.Errorf("unexpected nil of type %T", v)
24846	}
24847	if value == nil {
24848		return nil
24849	}
24850
24851	shape, ok := value.(map[string]interface{})
24852	if !ok {
24853		return fmt.Errorf("unexpected JSON type %v", value)
24854	}
24855
24856	var mv map[string]string
24857	if *v == nil {
24858		mv = map[string]string{}
24859	} else {
24860		mv = *v
24861	}
24862
24863	for key, value := range shape {
24864		var parsedVal string
24865		if value != nil {
24866			jtv, ok := value.(string)
24867			if !ok {
24868				return fmt.Errorf("expected string to be of type string, got %T instead", value)
24869			}
24870			parsedVal = jtv
24871		}
24872		mv[key] = parsedVal
24873
24874	}
24875	*v = mv
24876	return nil
24877}
24878
24879func awsAwsjson11_deserializeDocumentDomainList(v *[]types.Domain, value interface{}) error {
24880	if v == nil {
24881		return fmt.Errorf("unexpected nil of type %T", v)
24882	}
24883	if value == nil {
24884		return nil
24885	}
24886
24887	shape, ok := value.([]interface{})
24888	if !ok {
24889		return fmt.Errorf("unexpected JSON type %v", value)
24890	}
24891
24892	var cv []types.Domain
24893	if *v == nil {
24894		cv = []types.Domain{}
24895	} else {
24896		cv = *v
24897	}
24898
24899	for _, value := range shape {
24900		var col types.Domain
24901		destAddr := &col
24902		if err := awsAwsjson11_deserializeDocumentDomain(&destAddr, value); err != nil {
24903			return err
24904		}
24905		col = *destAddr
24906		cv = append(cv, col)
24907
24908	}
24909	*v = cv
24910	return nil
24911}
24912
24913func awsAwsjson11_deserializeDocumentDomainValidationRecord(v **types.DomainValidationRecord, value interface{}) error {
24914	if v == nil {
24915		return fmt.Errorf("unexpected nil of type %T", v)
24916	}
24917	if value == nil {
24918		return nil
24919	}
24920
24921	shape, ok := value.(map[string]interface{})
24922	if !ok {
24923		return fmt.Errorf("unexpected JSON type %v", value)
24924	}
24925
24926	var sv *types.DomainValidationRecord
24927	if *v == nil {
24928		sv = &types.DomainValidationRecord{}
24929	} else {
24930		sv = *v
24931	}
24932
24933	for key, value := range shape {
24934		switch key {
24935		case "domainName":
24936			if value != nil {
24937				jtv, ok := value.(string)
24938				if !ok {
24939					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
24940				}
24941				sv.DomainName = ptr.String(jtv)
24942			}
24943
24944		case "resourceRecord":
24945			if err := awsAwsjson11_deserializeDocumentResourceRecord(&sv.ResourceRecord, value); err != nil {
24946				return err
24947			}
24948
24949		default:
24950			_, _ = key, value
24951
24952		}
24953	}
24954	*v = sv
24955	return nil
24956}
24957
24958func awsAwsjson11_deserializeDocumentDomainValidationRecordList(v *[]types.DomainValidationRecord, value interface{}) error {
24959	if v == nil {
24960		return fmt.Errorf("unexpected nil of type %T", v)
24961	}
24962	if value == nil {
24963		return nil
24964	}
24965
24966	shape, ok := value.([]interface{})
24967	if !ok {
24968		return fmt.Errorf("unexpected JSON type %v", value)
24969	}
24970
24971	var cv []types.DomainValidationRecord
24972	if *v == nil {
24973		cv = []types.DomainValidationRecord{}
24974	} else {
24975		cv = *v
24976	}
24977
24978	for _, value := range shape {
24979		var col types.DomainValidationRecord
24980		destAddr := &col
24981		if err := awsAwsjson11_deserializeDocumentDomainValidationRecord(&destAddr, value); err != nil {
24982			return err
24983		}
24984		col = *destAddr
24985		cv = append(cv, col)
24986
24987	}
24988	*v = cv
24989	return nil
24990}
24991
24992func awsAwsjson11_deserializeDocumentEnvironment(v *map[string]string, value interface{}) error {
24993	if v == nil {
24994		return fmt.Errorf("unexpected nil of type %T", v)
24995	}
24996	if value == nil {
24997		return nil
24998	}
24999
25000	shape, ok := value.(map[string]interface{})
25001	if !ok {
25002		return fmt.Errorf("unexpected JSON type %v", value)
25003	}
25004
25005	var mv map[string]string
25006	if *v == nil {
25007		mv = map[string]string{}
25008	} else {
25009		mv = *v
25010	}
25011
25012	for key, value := range shape {
25013		var parsedVal string
25014		if value != nil {
25015			jtv, ok := value.(string)
25016			if !ok {
25017				return fmt.Errorf("expected string to be of type string, got %T instead", value)
25018			}
25019			parsedVal = jtv
25020		}
25021		mv[key] = parsedVal
25022
25023	}
25024	*v = mv
25025	return nil
25026}
25027
25028func awsAwsjson11_deserializeDocumentExportSnapshotRecord(v **types.ExportSnapshotRecord, value interface{}) error {
25029	if v == nil {
25030		return fmt.Errorf("unexpected nil of type %T", v)
25031	}
25032	if value == nil {
25033		return nil
25034	}
25035
25036	shape, ok := value.(map[string]interface{})
25037	if !ok {
25038		return fmt.Errorf("unexpected JSON type %v", value)
25039	}
25040
25041	var sv *types.ExportSnapshotRecord
25042	if *v == nil {
25043		sv = &types.ExportSnapshotRecord{}
25044	} else {
25045		sv = *v
25046	}
25047
25048	for key, value := range shape {
25049		switch key {
25050		case "arn":
25051			if value != nil {
25052				jtv, ok := value.(string)
25053				if !ok {
25054					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25055				}
25056				sv.Arn = ptr.String(jtv)
25057			}
25058
25059		case "createdAt":
25060			if value != nil {
25061				switch jtv := value.(type) {
25062				case json.Number:
25063					f64, err := jtv.Float64()
25064					if err != nil {
25065						return err
25066					}
25067					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25068
25069				default:
25070					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25071
25072				}
25073			}
25074
25075		case "destinationInfo":
25076			if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
25077				return err
25078			}
25079
25080		case "location":
25081			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
25082				return err
25083			}
25084
25085		case "name":
25086			if value != nil {
25087				jtv, ok := value.(string)
25088				if !ok {
25089					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25090				}
25091				sv.Name = ptr.String(jtv)
25092			}
25093
25094		case "resourceType":
25095			if value != nil {
25096				jtv, ok := value.(string)
25097				if !ok {
25098					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
25099				}
25100				sv.ResourceType = types.ResourceType(jtv)
25101			}
25102
25103		case "sourceInfo":
25104			if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(&sv.SourceInfo, value); err != nil {
25105				return err
25106			}
25107
25108		case "state":
25109			if value != nil {
25110				jtv, ok := value.(string)
25111				if !ok {
25112					return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
25113				}
25114				sv.State = types.RecordState(jtv)
25115			}
25116
25117		default:
25118			_, _ = key, value
25119
25120		}
25121	}
25122	*v = sv
25123	return nil
25124}
25125
25126func awsAwsjson11_deserializeDocumentExportSnapshotRecordList(v *[]types.ExportSnapshotRecord, value interface{}) error {
25127	if v == nil {
25128		return fmt.Errorf("unexpected nil of type %T", v)
25129	}
25130	if value == nil {
25131		return nil
25132	}
25133
25134	shape, ok := value.([]interface{})
25135	if !ok {
25136		return fmt.Errorf("unexpected JSON type %v", value)
25137	}
25138
25139	var cv []types.ExportSnapshotRecord
25140	if *v == nil {
25141		cv = []types.ExportSnapshotRecord{}
25142	} else {
25143		cv = *v
25144	}
25145
25146	for _, value := range shape {
25147		var col types.ExportSnapshotRecord
25148		destAddr := &col
25149		if err := awsAwsjson11_deserializeDocumentExportSnapshotRecord(&destAddr, value); err != nil {
25150			return err
25151		}
25152		col = *destAddr
25153		cv = append(cv, col)
25154
25155	}
25156	*v = cv
25157	return nil
25158}
25159
25160func awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(v **types.ExportSnapshotRecordSourceInfo, value interface{}) error {
25161	if v == nil {
25162		return fmt.Errorf("unexpected nil of type %T", v)
25163	}
25164	if value == nil {
25165		return nil
25166	}
25167
25168	shape, ok := value.(map[string]interface{})
25169	if !ok {
25170		return fmt.Errorf("unexpected JSON type %v", value)
25171	}
25172
25173	var sv *types.ExportSnapshotRecordSourceInfo
25174	if *v == nil {
25175		sv = &types.ExportSnapshotRecordSourceInfo{}
25176	} else {
25177		sv = *v
25178	}
25179
25180	for key, value := range shape {
25181		switch key {
25182		case "arn":
25183			if value != nil {
25184				jtv, ok := value.(string)
25185				if !ok {
25186					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25187				}
25188				sv.Arn = ptr.String(jtv)
25189			}
25190
25191		case "createdAt":
25192			if value != nil {
25193				switch jtv := value.(type) {
25194				case json.Number:
25195					f64, err := jtv.Float64()
25196					if err != nil {
25197						return err
25198					}
25199					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25200
25201				default:
25202					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25203
25204				}
25205			}
25206
25207		case "diskSnapshotInfo":
25208			if err := awsAwsjson11_deserializeDocumentDiskSnapshotInfo(&sv.DiskSnapshotInfo, value); err != nil {
25209				return err
25210			}
25211
25212		case "fromResourceArn":
25213			if value != nil {
25214				jtv, ok := value.(string)
25215				if !ok {
25216					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25217				}
25218				sv.FromResourceArn = ptr.String(jtv)
25219			}
25220
25221		case "fromResourceName":
25222			if value != nil {
25223				jtv, ok := value.(string)
25224				if !ok {
25225					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25226				}
25227				sv.FromResourceName = ptr.String(jtv)
25228			}
25229
25230		case "instanceSnapshotInfo":
25231			if err := awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(&sv.InstanceSnapshotInfo, value); err != nil {
25232				return err
25233			}
25234
25235		case "name":
25236			if value != nil {
25237				jtv, ok := value.(string)
25238				if !ok {
25239					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25240				}
25241				sv.Name = ptr.String(jtv)
25242			}
25243
25244		case "resourceType":
25245			if value != nil {
25246				jtv, ok := value.(string)
25247				if !ok {
25248					return fmt.Errorf("expected ExportSnapshotRecordSourceType to be of type string, got %T instead", value)
25249				}
25250				sv.ResourceType = types.ExportSnapshotRecordSourceType(jtv)
25251			}
25252
25253		default:
25254			_, _ = key, value
25255
25256		}
25257	}
25258	*v = sv
25259	return nil
25260}
25261
25262func awsAwsjson11_deserializeDocumentHeaderForwardList(v *[]types.HeaderEnum, value interface{}) error {
25263	if v == nil {
25264		return fmt.Errorf("unexpected nil of type %T", v)
25265	}
25266	if value == nil {
25267		return nil
25268	}
25269
25270	shape, ok := value.([]interface{})
25271	if !ok {
25272		return fmt.Errorf("unexpected JSON type %v", value)
25273	}
25274
25275	var cv []types.HeaderEnum
25276	if *v == nil {
25277		cv = []types.HeaderEnum{}
25278	} else {
25279		cv = *v
25280	}
25281
25282	for _, value := range shape {
25283		var col types.HeaderEnum
25284		if value != nil {
25285			jtv, ok := value.(string)
25286			if !ok {
25287				return fmt.Errorf("expected HeaderEnum to be of type string, got %T instead", value)
25288			}
25289			col = types.HeaderEnum(jtv)
25290		}
25291		cv = append(cv, col)
25292
25293	}
25294	*v = cv
25295	return nil
25296}
25297
25298func awsAwsjson11_deserializeDocumentHeaderObject(v **types.HeaderObject, value interface{}) error {
25299	if v == nil {
25300		return fmt.Errorf("unexpected nil of type %T", v)
25301	}
25302	if value == nil {
25303		return nil
25304	}
25305
25306	shape, ok := value.(map[string]interface{})
25307	if !ok {
25308		return fmt.Errorf("unexpected JSON type %v", value)
25309	}
25310
25311	var sv *types.HeaderObject
25312	if *v == nil {
25313		sv = &types.HeaderObject{}
25314	} else {
25315		sv = *v
25316	}
25317
25318	for key, value := range shape {
25319		switch key {
25320		case "headersAllowList":
25321			if err := awsAwsjson11_deserializeDocumentHeaderForwardList(&sv.HeadersAllowList, value); err != nil {
25322				return err
25323			}
25324
25325		case "option":
25326			if value != nil {
25327				jtv, ok := value.(string)
25328				if !ok {
25329					return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
25330				}
25331				sv.Option = types.ForwardValues(jtv)
25332			}
25333
25334		default:
25335			_, _ = key, value
25336
25337		}
25338	}
25339	*v = sv
25340	return nil
25341}
25342
25343func awsAwsjson11_deserializeDocumentHostKeyAttributes(v **types.HostKeyAttributes, value interface{}) error {
25344	if v == nil {
25345		return fmt.Errorf("unexpected nil of type %T", v)
25346	}
25347	if value == nil {
25348		return nil
25349	}
25350
25351	shape, ok := value.(map[string]interface{})
25352	if !ok {
25353		return fmt.Errorf("unexpected JSON type %v", value)
25354	}
25355
25356	var sv *types.HostKeyAttributes
25357	if *v == nil {
25358		sv = &types.HostKeyAttributes{}
25359	} else {
25360		sv = *v
25361	}
25362
25363	for key, value := range shape {
25364		switch key {
25365		case "algorithm":
25366			if value != nil {
25367				jtv, ok := value.(string)
25368				if !ok {
25369					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25370				}
25371				sv.Algorithm = ptr.String(jtv)
25372			}
25373
25374		case "fingerprintSHA1":
25375			if value != nil {
25376				jtv, ok := value.(string)
25377				if !ok {
25378					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25379				}
25380				sv.FingerprintSHA1 = ptr.String(jtv)
25381			}
25382
25383		case "fingerprintSHA256":
25384			if value != nil {
25385				jtv, ok := value.(string)
25386				if !ok {
25387					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25388				}
25389				sv.FingerprintSHA256 = ptr.String(jtv)
25390			}
25391
25392		case "notValidAfter":
25393			if value != nil {
25394				switch jtv := value.(type) {
25395				case json.Number:
25396					f64, err := jtv.Float64()
25397					if err != nil {
25398						return err
25399					}
25400					sv.NotValidAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
25401
25402				default:
25403					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25404
25405				}
25406			}
25407
25408		case "notValidBefore":
25409			if value != nil {
25410				switch jtv := value.(type) {
25411				case json.Number:
25412					f64, err := jtv.Float64()
25413					if err != nil {
25414						return err
25415					}
25416					sv.NotValidBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
25417
25418				default:
25419					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25420
25421				}
25422			}
25423
25424		case "publicKey":
25425			if value != nil {
25426				jtv, ok := value.(string)
25427				if !ok {
25428					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25429				}
25430				sv.PublicKey = ptr.String(jtv)
25431			}
25432
25433		case "witnessedAt":
25434			if value != nil {
25435				switch jtv := value.(type) {
25436				case json.Number:
25437					f64, err := jtv.Float64()
25438					if err != nil {
25439						return err
25440					}
25441					sv.WitnessedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25442
25443				default:
25444					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25445
25446				}
25447			}
25448
25449		default:
25450			_, _ = key, value
25451
25452		}
25453	}
25454	*v = sv
25455	return nil
25456}
25457
25458func awsAwsjson11_deserializeDocumentHostKeysList(v *[]types.HostKeyAttributes, value interface{}) error {
25459	if v == nil {
25460		return fmt.Errorf("unexpected nil of type %T", v)
25461	}
25462	if value == nil {
25463		return nil
25464	}
25465
25466	shape, ok := value.([]interface{})
25467	if !ok {
25468		return fmt.Errorf("unexpected JSON type %v", value)
25469	}
25470
25471	var cv []types.HostKeyAttributes
25472	if *v == nil {
25473		cv = []types.HostKeyAttributes{}
25474	} else {
25475		cv = *v
25476	}
25477
25478	for _, value := range shape {
25479		var col types.HostKeyAttributes
25480		destAddr := &col
25481		if err := awsAwsjson11_deserializeDocumentHostKeyAttributes(&destAddr, value); err != nil {
25482			return err
25483		}
25484		col = *destAddr
25485		cv = append(cv, col)
25486
25487	}
25488	*v = cv
25489	return nil
25490}
25491
25492func awsAwsjson11_deserializeDocumentInstance(v **types.Instance, value interface{}) error {
25493	if v == nil {
25494		return fmt.Errorf("unexpected nil of type %T", v)
25495	}
25496	if value == nil {
25497		return nil
25498	}
25499
25500	shape, ok := value.(map[string]interface{})
25501	if !ok {
25502		return fmt.Errorf("unexpected JSON type %v", value)
25503	}
25504
25505	var sv *types.Instance
25506	if *v == nil {
25507		sv = &types.Instance{}
25508	} else {
25509		sv = *v
25510	}
25511
25512	for key, value := range shape {
25513		switch key {
25514		case "addOns":
25515			if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
25516				return err
25517			}
25518
25519		case "arn":
25520			if value != nil {
25521				jtv, ok := value.(string)
25522				if !ok {
25523					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25524				}
25525				sv.Arn = ptr.String(jtv)
25526			}
25527
25528		case "blueprintId":
25529			if value != nil {
25530				jtv, ok := value.(string)
25531				if !ok {
25532					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25533				}
25534				sv.BlueprintId = ptr.String(jtv)
25535			}
25536
25537		case "blueprintName":
25538			if value != nil {
25539				jtv, ok := value.(string)
25540				if !ok {
25541					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25542				}
25543				sv.BlueprintName = ptr.String(jtv)
25544			}
25545
25546		case "bundleId":
25547			if value != nil {
25548				jtv, ok := value.(string)
25549				if !ok {
25550					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25551				}
25552				sv.BundleId = ptr.String(jtv)
25553			}
25554
25555		case "createdAt":
25556			if value != nil {
25557				switch jtv := value.(type) {
25558				case json.Number:
25559					f64, err := jtv.Float64()
25560					if err != nil {
25561						return err
25562					}
25563					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25564
25565				default:
25566					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25567
25568				}
25569			}
25570
25571		case "hardware":
25572			if err := awsAwsjson11_deserializeDocumentInstanceHardware(&sv.Hardware, value); err != nil {
25573				return err
25574			}
25575
25576		case "ipAddressType":
25577			if value != nil {
25578				jtv, ok := value.(string)
25579				if !ok {
25580					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
25581				}
25582				sv.IpAddressType = types.IpAddressType(jtv)
25583			}
25584
25585		case "ipv6Addresses":
25586			if err := awsAwsjson11_deserializeDocumentIpv6AddressList(&sv.Ipv6Addresses, value); err != nil {
25587				return err
25588			}
25589
25590		case "isStaticIp":
25591			if value != nil {
25592				jtv, ok := value.(bool)
25593				if !ok {
25594					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
25595				}
25596				sv.IsStaticIp = ptr.Bool(jtv)
25597			}
25598
25599		case "location":
25600			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
25601				return err
25602			}
25603
25604		case "name":
25605			if value != nil {
25606				jtv, ok := value.(string)
25607				if !ok {
25608					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25609				}
25610				sv.Name = ptr.String(jtv)
25611			}
25612
25613		case "networking":
25614			if err := awsAwsjson11_deserializeDocumentInstanceNetworking(&sv.Networking, value); err != nil {
25615				return err
25616			}
25617
25618		case "privateIpAddress":
25619			if value != nil {
25620				jtv, ok := value.(string)
25621				if !ok {
25622					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
25623				}
25624				sv.PrivateIpAddress = ptr.String(jtv)
25625			}
25626
25627		case "publicIpAddress":
25628			if value != nil {
25629				jtv, ok := value.(string)
25630				if !ok {
25631					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
25632				}
25633				sv.PublicIpAddress = ptr.String(jtv)
25634			}
25635
25636		case "resourceType":
25637			if value != nil {
25638				jtv, ok := value.(string)
25639				if !ok {
25640					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
25641				}
25642				sv.ResourceType = types.ResourceType(jtv)
25643			}
25644
25645		case "sshKeyName":
25646			if value != nil {
25647				jtv, ok := value.(string)
25648				if !ok {
25649					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25650				}
25651				sv.SshKeyName = ptr.String(jtv)
25652			}
25653
25654		case "state":
25655			if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
25656				return err
25657			}
25658
25659		case "supportCode":
25660			if value != nil {
25661				jtv, ok := value.(string)
25662				if !ok {
25663					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25664				}
25665				sv.SupportCode = ptr.String(jtv)
25666			}
25667
25668		case "tags":
25669			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
25670				return err
25671			}
25672
25673		case "username":
25674			if value != nil {
25675				jtv, ok := value.(string)
25676				if !ok {
25677					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25678				}
25679				sv.Username = ptr.String(jtv)
25680			}
25681
25682		default:
25683			_, _ = key, value
25684
25685		}
25686	}
25687	*v = sv
25688	return nil
25689}
25690
25691func awsAwsjson11_deserializeDocumentInstanceAccessDetails(v **types.InstanceAccessDetails, value interface{}) error {
25692	if v == nil {
25693		return fmt.Errorf("unexpected nil of type %T", v)
25694	}
25695	if value == nil {
25696		return nil
25697	}
25698
25699	shape, ok := value.(map[string]interface{})
25700	if !ok {
25701		return fmt.Errorf("unexpected JSON type %v", value)
25702	}
25703
25704	var sv *types.InstanceAccessDetails
25705	if *v == nil {
25706		sv = &types.InstanceAccessDetails{}
25707	} else {
25708		sv = *v
25709	}
25710
25711	for key, value := range shape {
25712		switch key {
25713		case "certKey":
25714			if value != nil {
25715				jtv, ok := value.(string)
25716				if !ok {
25717					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25718				}
25719				sv.CertKey = ptr.String(jtv)
25720			}
25721
25722		case "expiresAt":
25723			if value != nil {
25724				switch jtv := value.(type) {
25725				case json.Number:
25726					f64, err := jtv.Float64()
25727					if err != nil {
25728						return err
25729					}
25730					sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25731
25732				default:
25733					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
25734
25735				}
25736			}
25737
25738		case "hostKeys":
25739			if err := awsAwsjson11_deserializeDocumentHostKeysList(&sv.HostKeys, value); err != nil {
25740				return err
25741			}
25742
25743		case "instanceName":
25744			if value != nil {
25745				jtv, ok := value.(string)
25746				if !ok {
25747					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25748				}
25749				sv.InstanceName = ptr.String(jtv)
25750			}
25751
25752		case "ipAddress":
25753			if value != nil {
25754				jtv, ok := value.(string)
25755				if !ok {
25756					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
25757				}
25758				sv.IpAddress = ptr.String(jtv)
25759			}
25760
25761		case "password":
25762			if value != nil {
25763				jtv, ok := value.(string)
25764				if !ok {
25765					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25766				}
25767				sv.Password = ptr.String(jtv)
25768			}
25769
25770		case "passwordData":
25771			if err := awsAwsjson11_deserializeDocumentPasswordData(&sv.PasswordData, value); err != nil {
25772				return err
25773			}
25774
25775		case "privateKey":
25776			if value != nil {
25777				jtv, ok := value.(string)
25778				if !ok {
25779					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25780				}
25781				sv.PrivateKey = ptr.String(jtv)
25782			}
25783
25784		case "protocol":
25785			if value != nil {
25786				jtv, ok := value.(string)
25787				if !ok {
25788					return fmt.Errorf("expected InstanceAccessProtocol to be of type string, got %T instead", value)
25789				}
25790				sv.Protocol = types.InstanceAccessProtocol(jtv)
25791			}
25792
25793		case "username":
25794			if value != nil {
25795				jtv, ok := value.(string)
25796				if !ok {
25797					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25798				}
25799				sv.Username = ptr.String(jtv)
25800			}
25801
25802		default:
25803			_, _ = key, value
25804
25805		}
25806	}
25807	*v = sv
25808	return nil
25809}
25810
25811func awsAwsjson11_deserializeDocumentInstanceHardware(v **types.InstanceHardware, value interface{}) error {
25812	if v == nil {
25813		return fmt.Errorf("unexpected nil of type %T", v)
25814	}
25815	if value == nil {
25816		return nil
25817	}
25818
25819	shape, ok := value.(map[string]interface{})
25820	if !ok {
25821		return fmt.Errorf("unexpected JSON type %v", value)
25822	}
25823
25824	var sv *types.InstanceHardware
25825	if *v == nil {
25826		sv = &types.InstanceHardware{}
25827	} else {
25828		sv = *v
25829	}
25830
25831	for key, value := range shape {
25832		switch key {
25833		case "cpuCount":
25834			if value != nil {
25835				jtv, ok := value.(json.Number)
25836				if !ok {
25837					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
25838				}
25839				i64, err := jtv.Int64()
25840				if err != nil {
25841					return err
25842				}
25843				sv.CpuCount = ptr.Int32(int32(i64))
25844			}
25845
25846		case "disks":
25847			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
25848				return err
25849			}
25850
25851		case "ramSizeInGb":
25852			if value != nil {
25853				switch jtv := value.(type) {
25854				case json.Number:
25855					f64, err := jtv.Float64()
25856					if err != nil {
25857						return err
25858					}
25859					sv.RamSizeInGb = ptr.Float32(float32(f64))
25860
25861				case string:
25862					var f64 float64
25863					switch {
25864					case strings.EqualFold(jtv, "NaN"):
25865						f64 = math.NaN()
25866
25867					case strings.EqualFold(jtv, "Infinity"):
25868						f64 = math.Inf(1)
25869
25870					case strings.EqualFold(jtv, "-Infinity"):
25871						f64 = math.Inf(-1)
25872
25873					default:
25874						return fmt.Errorf("unknown JSON number value: %s", jtv)
25875
25876					}
25877					sv.RamSizeInGb = ptr.Float32(float32(f64))
25878
25879				default:
25880					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
25881
25882				}
25883			}
25884
25885		default:
25886			_, _ = key, value
25887
25888		}
25889	}
25890	*v = sv
25891	return nil
25892}
25893
25894func awsAwsjson11_deserializeDocumentInstanceHealthSummary(v **types.InstanceHealthSummary, value interface{}) error {
25895	if v == nil {
25896		return fmt.Errorf("unexpected nil of type %T", v)
25897	}
25898	if value == nil {
25899		return nil
25900	}
25901
25902	shape, ok := value.(map[string]interface{})
25903	if !ok {
25904		return fmt.Errorf("unexpected JSON type %v", value)
25905	}
25906
25907	var sv *types.InstanceHealthSummary
25908	if *v == nil {
25909		sv = &types.InstanceHealthSummary{}
25910	} else {
25911		sv = *v
25912	}
25913
25914	for key, value := range shape {
25915		switch key {
25916		case "instanceHealth":
25917			if value != nil {
25918				jtv, ok := value.(string)
25919				if !ok {
25920					return fmt.Errorf("expected InstanceHealthState to be of type string, got %T instead", value)
25921				}
25922				sv.InstanceHealth = types.InstanceHealthState(jtv)
25923			}
25924
25925		case "instanceHealthReason":
25926			if value != nil {
25927				jtv, ok := value.(string)
25928				if !ok {
25929					return fmt.Errorf("expected InstanceHealthReason to be of type string, got %T instead", value)
25930				}
25931				sv.InstanceHealthReason = types.InstanceHealthReason(jtv)
25932			}
25933
25934		case "instanceName":
25935			if value != nil {
25936				jtv, ok := value.(string)
25937				if !ok {
25938					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25939				}
25940				sv.InstanceName = ptr.String(jtv)
25941			}
25942
25943		default:
25944			_, _ = key, value
25945
25946		}
25947	}
25948	*v = sv
25949	return nil
25950}
25951
25952func awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(v *[]types.InstanceHealthSummary, value interface{}) error {
25953	if v == nil {
25954		return fmt.Errorf("unexpected nil of type %T", v)
25955	}
25956	if value == nil {
25957		return nil
25958	}
25959
25960	shape, ok := value.([]interface{})
25961	if !ok {
25962		return fmt.Errorf("unexpected JSON type %v", value)
25963	}
25964
25965	var cv []types.InstanceHealthSummary
25966	if *v == nil {
25967		cv = []types.InstanceHealthSummary{}
25968	} else {
25969		cv = *v
25970	}
25971
25972	for _, value := range shape {
25973		var col types.InstanceHealthSummary
25974		destAddr := &col
25975		if err := awsAwsjson11_deserializeDocumentInstanceHealthSummary(&destAddr, value); err != nil {
25976			return err
25977		}
25978		col = *destAddr
25979		cv = append(cv, col)
25980
25981	}
25982	*v = cv
25983	return nil
25984}
25985
25986func awsAwsjson11_deserializeDocumentInstanceList(v *[]types.Instance, value interface{}) error {
25987	if v == nil {
25988		return fmt.Errorf("unexpected nil of type %T", v)
25989	}
25990	if value == nil {
25991		return nil
25992	}
25993
25994	shape, ok := value.([]interface{})
25995	if !ok {
25996		return fmt.Errorf("unexpected JSON type %v", value)
25997	}
25998
25999	var cv []types.Instance
26000	if *v == nil {
26001		cv = []types.Instance{}
26002	} else {
26003		cv = *v
26004	}
26005
26006	for _, value := range shape {
26007		var col types.Instance
26008		destAddr := &col
26009		if err := awsAwsjson11_deserializeDocumentInstance(&destAddr, value); err != nil {
26010			return err
26011		}
26012		col = *destAddr
26013		cv = append(cv, col)
26014
26015	}
26016	*v = cv
26017	return nil
26018}
26019
26020func awsAwsjson11_deserializeDocumentInstanceNetworking(v **types.InstanceNetworking, value interface{}) error {
26021	if v == nil {
26022		return fmt.Errorf("unexpected nil of type %T", v)
26023	}
26024	if value == nil {
26025		return nil
26026	}
26027
26028	shape, ok := value.(map[string]interface{})
26029	if !ok {
26030		return fmt.Errorf("unexpected JSON type %v", value)
26031	}
26032
26033	var sv *types.InstanceNetworking
26034	if *v == nil {
26035		sv = &types.InstanceNetworking{}
26036	} else {
26037		sv = *v
26038	}
26039
26040	for key, value := range shape {
26041		switch key {
26042		case "monthlyTransfer":
26043			if err := awsAwsjson11_deserializeDocumentMonthlyTransfer(&sv.MonthlyTransfer, value); err != nil {
26044				return err
26045			}
26046
26047		case "ports":
26048			if err := awsAwsjson11_deserializeDocumentInstancePortInfoList(&sv.Ports, value); err != nil {
26049				return err
26050			}
26051
26052		default:
26053			_, _ = key, value
26054
26055		}
26056	}
26057	*v = sv
26058	return nil
26059}
26060
26061func awsAwsjson11_deserializeDocumentInstancePlatformList(v *[]types.InstancePlatform, value interface{}) error {
26062	if v == nil {
26063		return fmt.Errorf("unexpected nil of type %T", v)
26064	}
26065	if value == nil {
26066		return nil
26067	}
26068
26069	shape, ok := value.([]interface{})
26070	if !ok {
26071		return fmt.Errorf("unexpected JSON type %v", value)
26072	}
26073
26074	var cv []types.InstancePlatform
26075	if *v == nil {
26076		cv = []types.InstancePlatform{}
26077	} else {
26078		cv = *v
26079	}
26080
26081	for _, value := range shape {
26082		var col types.InstancePlatform
26083		if value != nil {
26084			jtv, ok := value.(string)
26085			if !ok {
26086				return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
26087			}
26088			col = types.InstancePlatform(jtv)
26089		}
26090		cv = append(cv, col)
26091
26092	}
26093	*v = cv
26094	return nil
26095}
26096
26097func awsAwsjson11_deserializeDocumentInstancePortInfo(v **types.InstancePortInfo, value interface{}) error {
26098	if v == nil {
26099		return fmt.Errorf("unexpected nil of type %T", v)
26100	}
26101	if value == nil {
26102		return nil
26103	}
26104
26105	shape, ok := value.(map[string]interface{})
26106	if !ok {
26107		return fmt.Errorf("unexpected JSON type %v", value)
26108	}
26109
26110	var sv *types.InstancePortInfo
26111	if *v == nil {
26112		sv = &types.InstancePortInfo{}
26113	} else {
26114		sv = *v
26115	}
26116
26117	for key, value := range shape {
26118		switch key {
26119		case "accessDirection":
26120			if value != nil {
26121				jtv, ok := value.(string)
26122				if !ok {
26123					return fmt.Errorf("expected AccessDirection to be of type string, got %T instead", value)
26124				}
26125				sv.AccessDirection = types.AccessDirection(jtv)
26126			}
26127
26128		case "accessFrom":
26129			if value != nil {
26130				jtv, ok := value.(string)
26131				if !ok {
26132					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26133				}
26134				sv.AccessFrom = ptr.String(jtv)
26135			}
26136
26137		case "accessType":
26138			if value != nil {
26139				jtv, ok := value.(string)
26140				if !ok {
26141					return fmt.Errorf("expected PortAccessType to be of type string, got %T instead", value)
26142				}
26143				sv.AccessType = types.PortAccessType(jtv)
26144			}
26145
26146		case "cidrListAliases":
26147			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
26148				return err
26149			}
26150
26151		case "cidrs":
26152			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
26153				return err
26154			}
26155
26156		case "commonName":
26157			if value != nil {
26158				jtv, ok := value.(string)
26159				if !ok {
26160					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26161				}
26162				sv.CommonName = ptr.String(jtv)
26163			}
26164
26165		case "fromPort":
26166			if value != nil {
26167				jtv, ok := value.(json.Number)
26168				if !ok {
26169					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
26170				}
26171				i64, err := jtv.Int64()
26172				if err != nil {
26173					return err
26174				}
26175				sv.FromPort = int32(i64)
26176			}
26177
26178		case "ipv6Cidrs":
26179			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
26180				return err
26181			}
26182
26183		case "protocol":
26184			if value != nil {
26185				jtv, ok := value.(string)
26186				if !ok {
26187					return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
26188				}
26189				sv.Protocol = types.NetworkProtocol(jtv)
26190			}
26191
26192		case "toPort":
26193			if value != nil {
26194				jtv, ok := value.(json.Number)
26195				if !ok {
26196					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
26197				}
26198				i64, err := jtv.Int64()
26199				if err != nil {
26200					return err
26201				}
26202				sv.ToPort = int32(i64)
26203			}
26204
26205		default:
26206			_, _ = key, value
26207
26208		}
26209	}
26210	*v = sv
26211	return nil
26212}
26213
26214func awsAwsjson11_deserializeDocumentInstancePortInfoList(v *[]types.InstancePortInfo, value interface{}) error {
26215	if v == nil {
26216		return fmt.Errorf("unexpected nil of type %T", v)
26217	}
26218	if value == nil {
26219		return nil
26220	}
26221
26222	shape, ok := value.([]interface{})
26223	if !ok {
26224		return fmt.Errorf("unexpected JSON type %v", value)
26225	}
26226
26227	var cv []types.InstancePortInfo
26228	if *v == nil {
26229		cv = []types.InstancePortInfo{}
26230	} else {
26231		cv = *v
26232	}
26233
26234	for _, value := range shape {
26235		var col types.InstancePortInfo
26236		destAddr := &col
26237		if err := awsAwsjson11_deserializeDocumentInstancePortInfo(&destAddr, value); err != nil {
26238			return err
26239		}
26240		col = *destAddr
26241		cv = append(cv, col)
26242
26243	}
26244	*v = cv
26245	return nil
26246}
26247
26248func awsAwsjson11_deserializeDocumentInstancePortState(v **types.InstancePortState, value interface{}) error {
26249	if v == nil {
26250		return fmt.Errorf("unexpected nil of type %T", v)
26251	}
26252	if value == nil {
26253		return nil
26254	}
26255
26256	shape, ok := value.(map[string]interface{})
26257	if !ok {
26258		return fmt.Errorf("unexpected JSON type %v", value)
26259	}
26260
26261	var sv *types.InstancePortState
26262	if *v == nil {
26263		sv = &types.InstancePortState{}
26264	} else {
26265		sv = *v
26266	}
26267
26268	for key, value := range shape {
26269		switch key {
26270		case "cidrListAliases":
26271			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
26272				return err
26273			}
26274
26275		case "cidrs":
26276			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
26277				return err
26278			}
26279
26280		case "fromPort":
26281			if value != nil {
26282				jtv, ok := value.(json.Number)
26283				if !ok {
26284					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
26285				}
26286				i64, err := jtv.Int64()
26287				if err != nil {
26288					return err
26289				}
26290				sv.FromPort = int32(i64)
26291			}
26292
26293		case "ipv6Cidrs":
26294			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
26295				return err
26296			}
26297
26298		case "protocol":
26299			if value != nil {
26300				jtv, ok := value.(string)
26301				if !ok {
26302					return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
26303				}
26304				sv.Protocol = types.NetworkProtocol(jtv)
26305			}
26306
26307		case "state":
26308			if value != nil {
26309				jtv, ok := value.(string)
26310				if !ok {
26311					return fmt.Errorf("expected PortState to be of type string, got %T instead", value)
26312				}
26313				sv.State = types.PortState(jtv)
26314			}
26315
26316		case "toPort":
26317			if value != nil {
26318				jtv, ok := value.(json.Number)
26319				if !ok {
26320					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
26321				}
26322				i64, err := jtv.Int64()
26323				if err != nil {
26324					return err
26325				}
26326				sv.ToPort = int32(i64)
26327			}
26328
26329		default:
26330			_, _ = key, value
26331
26332		}
26333	}
26334	*v = sv
26335	return nil
26336}
26337
26338func awsAwsjson11_deserializeDocumentInstancePortStateList(v *[]types.InstancePortState, value interface{}) error {
26339	if v == nil {
26340		return fmt.Errorf("unexpected nil of type %T", v)
26341	}
26342	if value == nil {
26343		return nil
26344	}
26345
26346	shape, ok := value.([]interface{})
26347	if !ok {
26348		return fmt.Errorf("unexpected JSON type %v", value)
26349	}
26350
26351	var cv []types.InstancePortState
26352	if *v == nil {
26353		cv = []types.InstancePortState{}
26354	} else {
26355		cv = *v
26356	}
26357
26358	for _, value := range shape {
26359		var col types.InstancePortState
26360		destAddr := &col
26361		if err := awsAwsjson11_deserializeDocumentInstancePortState(&destAddr, value); err != nil {
26362			return err
26363		}
26364		col = *destAddr
26365		cv = append(cv, col)
26366
26367	}
26368	*v = cv
26369	return nil
26370}
26371
26372func awsAwsjson11_deserializeDocumentInstanceSnapshot(v **types.InstanceSnapshot, value interface{}) error {
26373	if v == nil {
26374		return fmt.Errorf("unexpected nil of type %T", v)
26375	}
26376	if value == nil {
26377		return nil
26378	}
26379
26380	shape, ok := value.(map[string]interface{})
26381	if !ok {
26382		return fmt.Errorf("unexpected JSON type %v", value)
26383	}
26384
26385	var sv *types.InstanceSnapshot
26386	if *v == nil {
26387		sv = &types.InstanceSnapshot{}
26388	} else {
26389		sv = *v
26390	}
26391
26392	for key, value := range shape {
26393		switch key {
26394		case "arn":
26395			if value != nil {
26396				jtv, ok := value.(string)
26397				if !ok {
26398					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26399				}
26400				sv.Arn = ptr.String(jtv)
26401			}
26402
26403		case "createdAt":
26404			if value != nil {
26405				switch jtv := value.(type) {
26406				case json.Number:
26407					f64, err := jtv.Float64()
26408					if err != nil {
26409						return err
26410					}
26411					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26412
26413				default:
26414					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
26415
26416				}
26417			}
26418
26419		case "fromAttachedDisks":
26420			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.FromAttachedDisks, value); err != nil {
26421				return err
26422			}
26423
26424		case "fromBlueprintId":
26425			if value != nil {
26426				jtv, ok := value.(string)
26427				if !ok {
26428					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26429				}
26430				sv.FromBlueprintId = ptr.String(jtv)
26431			}
26432
26433		case "fromBundleId":
26434			if value != nil {
26435				jtv, ok := value.(string)
26436				if !ok {
26437					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26438				}
26439				sv.FromBundleId = ptr.String(jtv)
26440			}
26441
26442		case "fromInstanceArn":
26443			if value != nil {
26444				jtv, ok := value.(string)
26445				if !ok {
26446					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26447				}
26448				sv.FromInstanceArn = ptr.String(jtv)
26449			}
26450
26451		case "fromInstanceName":
26452			if value != nil {
26453				jtv, ok := value.(string)
26454				if !ok {
26455					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26456				}
26457				sv.FromInstanceName = ptr.String(jtv)
26458			}
26459
26460		case "isFromAutoSnapshot":
26461			if value != nil {
26462				jtv, ok := value.(bool)
26463				if !ok {
26464					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26465				}
26466				sv.IsFromAutoSnapshot = ptr.Bool(jtv)
26467			}
26468
26469		case "location":
26470			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26471				return err
26472			}
26473
26474		case "name":
26475			if value != nil {
26476				jtv, ok := value.(string)
26477				if !ok {
26478					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26479				}
26480				sv.Name = ptr.String(jtv)
26481			}
26482
26483		case "progress":
26484			if value != nil {
26485				jtv, ok := value.(string)
26486				if !ok {
26487					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26488				}
26489				sv.Progress = ptr.String(jtv)
26490			}
26491
26492		case "resourceType":
26493			if value != nil {
26494				jtv, ok := value.(string)
26495				if !ok {
26496					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26497				}
26498				sv.ResourceType = types.ResourceType(jtv)
26499			}
26500
26501		case "sizeInGb":
26502			if value != nil {
26503				jtv, ok := value.(json.Number)
26504				if !ok {
26505					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26506				}
26507				i64, err := jtv.Int64()
26508				if err != nil {
26509					return err
26510				}
26511				sv.SizeInGb = ptr.Int32(int32(i64))
26512			}
26513
26514		case "state":
26515			if value != nil {
26516				jtv, ok := value.(string)
26517				if !ok {
26518					return fmt.Errorf("expected InstanceSnapshotState to be of type string, got %T instead", value)
26519				}
26520				sv.State = types.InstanceSnapshotState(jtv)
26521			}
26522
26523		case "supportCode":
26524			if value != nil {
26525				jtv, ok := value.(string)
26526				if !ok {
26527					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26528				}
26529				sv.SupportCode = ptr.String(jtv)
26530			}
26531
26532		case "tags":
26533			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
26534				return err
26535			}
26536
26537		default:
26538			_, _ = key, value
26539
26540		}
26541	}
26542	*v = sv
26543	return nil
26544}
26545
26546func awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(v **types.InstanceSnapshotInfo, value interface{}) error {
26547	if v == nil {
26548		return fmt.Errorf("unexpected nil of type %T", v)
26549	}
26550	if value == nil {
26551		return nil
26552	}
26553
26554	shape, ok := value.(map[string]interface{})
26555	if !ok {
26556		return fmt.Errorf("unexpected JSON type %v", value)
26557	}
26558
26559	var sv *types.InstanceSnapshotInfo
26560	if *v == nil {
26561		sv = &types.InstanceSnapshotInfo{}
26562	} else {
26563		sv = *v
26564	}
26565
26566	for key, value := range shape {
26567		switch key {
26568		case "fromBlueprintId":
26569			if value != nil {
26570				jtv, ok := value.(string)
26571				if !ok {
26572					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26573				}
26574				sv.FromBlueprintId = ptr.String(jtv)
26575			}
26576
26577		case "fromBundleId":
26578			if value != nil {
26579				jtv, ok := value.(string)
26580				if !ok {
26581					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26582				}
26583				sv.FromBundleId = ptr.String(jtv)
26584			}
26585
26586		case "fromDiskInfo":
26587			if err := awsAwsjson11_deserializeDocumentDiskInfoList(&sv.FromDiskInfo, value); err != nil {
26588				return err
26589			}
26590
26591		default:
26592			_, _ = key, value
26593
26594		}
26595	}
26596	*v = sv
26597	return nil
26598}
26599
26600func awsAwsjson11_deserializeDocumentInstanceSnapshotList(v *[]types.InstanceSnapshot, value interface{}) error {
26601	if v == nil {
26602		return fmt.Errorf("unexpected nil of type %T", v)
26603	}
26604	if value == nil {
26605		return nil
26606	}
26607
26608	shape, ok := value.([]interface{})
26609	if !ok {
26610		return fmt.Errorf("unexpected JSON type %v", value)
26611	}
26612
26613	var cv []types.InstanceSnapshot
26614	if *v == nil {
26615		cv = []types.InstanceSnapshot{}
26616	} else {
26617		cv = *v
26618	}
26619
26620	for _, value := range shape {
26621		var col types.InstanceSnapshot
26622		destAddr := &col
26623		if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&destAddr, value); err != nil {
26624			return err
26625		}
26626		col = *destAddr
26627		cv = append(cv, col)
26628
26629	}
26630	*v = cv
26631	return nil
26632}
26633
26634func awsAwsjson11_deserializeDocumentInstanceState(v **types.InstanceState, value interface{}) error {
26635	if v == nil {
26636		return fmt.Errorf("unexpected nil of type %T", v)
26637	}
26638	if value == nil {
26639		return nil
26640	}
26641
26642	shape, ok := value.(map[string]interface{})
26643	if !ok {
26644		return fmt.Errorf("unexpected JSON type %v", value)
26645	}
26646
26647	var sv *types.InstanceState
26648	if *v == nil {
26649		sv = &types.InstanceState{}
26650	} else {
26651		sv = *v
26652	}
26653
26654	for key, value := range shape {
26655		switch key {
26656		case "code":
26657			if value != nil {
26658				jtv, ok := value.(json.Number)
26659				if !ok {
26660					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26661				}
26662				i64, err := jtv.Int64()
26663				if err != nil {
26664					return err
26665				}
26666				sv.Code = ptr.Int32(int32(i64))
26667			}
26668
26669		case "name":
26670			if value != nil {
26671				jtv, ok := value.(string)
26672				if !ok {
26673					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26674				}
26675				sv.Name = ptr.String(jtv)
26676			}
26677
26678		default:
26679			_, _ = key, value
26680
26681		}
26682	}
26683	*v = sv
26684	return nil
26685}
26686
26687func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
26688	if v == nil {
26689		return fmt.Errorf("unexpected nil of type %T", v)
26690	}
26691	if value == nil {
26692		return nil
26693	}
26694
26695	shape, ok := value.(map[string]interface{})
26696	if !ok {
26697		return fmt.Errorf("unexpected JSON type %v", value)
26698	}
26699
26700	var sv *types.InvalidInputException
26701	if *v == nil {
26702		sv = &types.InvalidInputException{}
26703	} else {
26704		sv = *v
26705	}
26706
26707	for key, value := range shape {
26708		switch key {
26709		case "code":
26710			if value != nil {
26711				jtv, ok := value.(string)
26712				if !ok {
26713					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26714				}
26715				sv.Code = ptr.String(jtv)
26716			}
26717
26718		case "docs":
26719			if value != nil {
26720				jtv, ok := value.(string)
26721				if !ok {
26722					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26723				}
26724				sv.Docs = ptr.String(jtv)
26725			}
26726
26727		case "message":
26728			if value != nil {
26729				jtv, ok := value.(string)
26730				if !ok {
26731					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26732				}
26733				sv.Message = ptr.String(jtv)
26734			}
26735
26736		case "tip":
26737			if value != nil {
26738				jtv, ok := value.(string)
26739				if !ok {
26740					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26741				}
26742				sv.Tip = ptr.String(jtv)
26743			}
26744
26745		default:
26746			_, _ = key, value
26747
26748		}
26749	}
26750	*v = sv
26751	return nil
26752}
26753
26754func awsAwsjson11_deserializeDocumentIpv6AddressList(v *[]string, value interface{}) error {
26755	if v == nil {
26756		return fmt.Errorf("unexpected nil of type %T", v)
26757	}
26758	if value == nil {
26759		return nil
26760	}
26761
26762	shape, ok := value.([]interface{})
26763	if !ok {
26764		return fmt.Errorf("unexpected JSON type %v", value)
26765	}
26766
26767	var cv []string
26768	if *v == nil {
26769		cv = []string{}
26770	} else {
26771		cv = *v
26772	}
26773
26774	for _, value := range shape {
26775		var col string
26776		if value != nil {
26777			jtv, ok := value.(string)
26778			if !ok {
26779				return fmt.Errorf("expected Ipv6Address to be of type string, got %T instead", value)
26780			}
26781			col = jtv
26782		}
26783		cv = append(cv, col)
26784
26785	}
26786	*v = cv
26787	return nil
26788}
26789
26790func awsAwsjson11_deserializeDocumentKeyPair(v **types.KeyPair, value interface{}) error {
26791	if v == nil {
26792		return fmt.Errorf("unexpected nil of type %T", v)
26793	}
26794	if value == nil {
26795		return nil
26796	}
26797
26798	shape, ok := value.(map[string]interface{})
26799	if !ok {
26800		return fmt.Errorf("unexpected JSON type %v", value)
26801	}
26802
26803	var sv *types.KeyPair
26804	if *v == nil {
26805		sv = &types.KeyPair{}
26806	} else {
26807		sv = *v
26808	}
26809
26810	for key, value := range shape {
26811		switch key {
26812		case "arn":
26813			if value != nil {
26814				jtv, ok := value.(string)
26815				if !ok {
26816					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26817				}
26818				sv.Arn = ptr.String(jtv)
26819			}
26820
26821		case "createdAt":
26822			if value != nil {
26823				switch jtv := value.(type) {
26824				case json.Number:
26825					f64, err := jtv.Float64()
26826					if err != nil {
26827						return err
26828					}
26829					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26830
26831				default:
26832					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
26833
26834				}
26835			}
26836
26837		case "fingerprint":
26838			if value != nil {
26839				jtv, ok := value.(string)
26840				if !ok {
26841					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
26842				}
26843				sv.Fingerprint = ptr.String(jtv)
26844			}
26845
26846		case "location":
26847			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26848				return err
26849			}
26850
26851		case "name":
26852			if value != nil {
26853				jtv, ok := value.(string)
26854				if !ok {
26855					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26856				}
26857				sv.Name = ptr.String(jtv)
26858			}
26859
26860		case "resourceType":
26861			if value != nil {
26862				jtv, ok := value.(string)
26863				if !ok {
26864					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26865				}
26866				sv.ResourceType = types.ResourceType(jtv)
26867			}
26868
26869		case "supportCode":
26870			if value != nil {
26871				jtv, ok := value.(string)
26872				if !ok {
26873					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26874				}
26875				sv.SupportCode = ptr.String(jtv)
26876			}
26877
26878		case "tags":
26879			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
26880				return err
26881			}
26882
26883		default:
26884			_, _ = key, value
26885
26886		}
26887	}
26888	*v = sv
26889	return nil
26890}
26891
26892func awsAwsjson11_deserializeDocumentKeyPairList(v *[]types.KeyPair, value interface{}) error {
26893	if v == nil {
26894		return fmt.Errorf("unexpected nil of type %T", v)
26895	}
26896	if value == nil {
26897		return nil
26898	}
26899
26900	shape, ok := value.([]interface{})
26901	if !ok {
26902		return fmt.Errorf("unexpected JSON type %v", value)
26903	}
26904
26905	var cv []types.KeyPair
26906	if *v == nil {
26907		cv = []types.KeyPair{}
26908	} else {
26909		cv = *v
26910	}
26911
26912	for _, value := range shape {
26913		var col types.KeyPair
26914		destAddr := &col
26915		if err := awsAwsjson11_deserializeDocumentKeyPair(&destAddr, value); err != nil {
26916			return err
26917		}
26918		col = *destAddr
26919		cv = append(cv, col)
26920
26921	}
26922	*v = cv
26923	return nil
26924}
26925
26926func awsAwsjson11_deserializeDocumentLightsailDistribution(v **types.LightsailDistribution, value interface{}) error {
26927	if v == nil {
26928		return fmt.Errorf("unexpected nil of type %T", v)
26929	}
26930	if value == nil {
26931		return nil
26932	}
26933
26934	shape, ok := value.(map[string]interface{})
26935	if !ok {
26936		return fmt.Errorf("unexpected JSON type %v", value)
26937	}
26938
26939	var sv *types.LightsailDistribution
26940	if *v == nil {
26941		sv = &types.LightsailDistribution{}
26942	} else {
26943		sv = *v
26944	}
26945
26946	for key, value := range shape {
26947		switch key {
26948		case "ableToUpdateBundle":
26949			if value != nil {
26950				jtv, ok := value.(bool)
26951				if !ok {
26952					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26953				}
26954				sv.AbleToUpdateBundle = ptr.Bool(jtv)
26955			}
26956
26957		case "alternativeDomainNames":
26958			if err := awsAwsjson11_deserializeDocumentStringList(&sv.AlternativeDomainNames, value); err != nil {
26959				return err
26960			}
26961
26962		case "arn":
26963			if value != nil {
26964				jtv, ok := value.(string)
26965				if !ok {
26966					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26967				}
26968				sv.Arn = ptr.String(jtv)
26969			}
26970
26971		case "bundleId":
26972			if value != nil {
26973				jtv, ok := value.(string)
26974				if !ok {
26975					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26976				}
26977				sv.BundleId = ptr.String(jtv)
26978			}
26979
26980		case "cacheBehaviors":
26981			if err := awsAwsjson11_deserializeDocumentCacheBehaviorList(&sv.CacheBehaviors, value); err != nil {
26982				return err
26983			}
26984
26985		case "cacheBehaviorSettings":
26986			if err := awsAwsjson11_deserializeDocumentCacheSettings(&sv.CacheBehaviorSettings, value); err != nil {
26987				return err
26988			}
26989
26990		case "certificateName":
26991			if value != nil {
26992				jtv, ok := value.(string)
26993				if !ok {
26994					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26995				}
26996				sv.CertificateName = ptr.String(jtv)
26997			}
26998
26999		case "createdAt":
27000			if value != nil {
27001				switch jtv := value.(type) {
27002				case json.Number:
27003					f64, err := jtv.Float64()
27004					if err != nil {
27005						return err
27006					}
27007					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27008
27009				default:
27010					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27011
27012				}
27013			}
27014
27015		case "defaultCacheBehavior":
27016			if err := awsAwsjson11_deserializeDocumentCacheBehavior(&sv.DefaultCacheBehavior, value); err != nil {
27017				return err
27018			}
27019
27020		case "domainName":
27021			if value != nil {
27022				jtv, ok := value.(string)
27023				if !ok {
27024					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27025				}
27026				sv.DomainName = ptr.String(jtv)
27027			}
27028
27029		case "ipAddressType":
27030			if value != nil {
27031				jtv, ok := value.(string)
27032				if !ok {
27033					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
27034				}
27035				sv.IpAddressType = types.IpAddressType(jtv)
27036			}
27037
27038		case "isEnabled":
27039			if value != nil {
27040				jtv, ok := value.(bool)
27041				if !ok {
27042					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27043				}
27044				sv.IsEnabled = ptr.Bool(jtv)
27045			}
27046
27047		case "location":
27048			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27049				return err
27050			}
27051
27052		case "name":
27053			if value != nil {
27054				jtv, ok := value.(string)
27055				if !ok {
27056					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27057				}
27058				sv.Name = ptr.String(jtv)
27059			}
27060
27061		case "origin":
27062			if err := awsAwsjson11_deserializeDocumentOrigin(&sv.Origin, value); err != nil {
27063				return err
27064			}
27065
27066		case "originPublicDNS":
27067			if value != nil {
27068				jtv, ok := value.(string)
27069				if !ok {
27070					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27071				}
27072				sv.OriginPublicDNS = ptr.String(jtv)
27073			}
27074
27075		case "resourceType":
27076			if value != nil {
27077				jtv, ok := value.(string)
27078				if !ok {
27079					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27080				}
27081				sv.ResourceType = types.ResourceType(jtv)
27082			}
27083
27084		case "status":
27085			if value != nil {
27086				jtv, ok := value.(string)
27087				if !ok {
27088					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27089				}
27090				sv.Status = ptr.String(jtv)
27091			}
27092
27093		case "supportCode":
27094			if value != nil {
27095				jtv, ok := value.(string)
27096				if !ok {
27097					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27098				}
27099				sv.SupportCode = ptr.String(jtv)
27100			}
27101
27102		case "tags":
27103			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
27104				return err
27105			}
27106
27107		default:
27108			_, _ = key, value
27109
27110		}
27111	}
27112	*v = sv
27113	return nil
27114}
27115
27116func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, value interface{}) error {
27117	if v == nil {
27118		return fmt.Errorf("unexpected nil of type %T", v)
27119	}
27120	if value == nil {
27121		return nil
27122	}
27123
27124	shape, ok := value.(map[string]interface{})
27125	if !ok {
27126		return fmt.Errorf("unexpected JSON type %v", value)
27127	}
27128
27129	var sv *types.LoadBalancer
27130	if *v == nil {
27131		sv = &types.LoadBalancer{}
27132	} else {
27133		sv = *v
27134	}
27135
27136	for key, value := range shape {
27137		switch key {
27138		case "arn":
27139			if value != nil {
27140				jtv, ok := value.(string)
27141				if !ok {
27142					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27143				}
27144				sv.Arn = ptr.String(jtv)
27145			}
27146
27147		case "configurationOptions":
27148			if err := awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(&sv.ConfigurationOptions, value); err != nil {
27149				return err
27150			}
27151
27152		case "createdAt":
27153			if value != nil {
27154				switch jtv := value.(type) {
27155				case json.Number:
27156					f64, err := jtv.Float64()
27157					if err != nil {
27158						return err
27159					}
27160					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27161
27162				default:
27163					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27164
27165				}
27166			}
27167
27168		case "dnsName":
27169			if value != nil {
27170				jtv, ok := value.(string)
27171				if !ok {
27172					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27173				}
27174				sv.DnsName = ptr.String(jtv)
27175			}
27176
27177		case "healthCheckPath":
27178			if value != nil {
27179				jtv, ok := value.(string)
27180				if !ok {
27181					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27182				}
27183				sv.HealthCheckPath = ptr.String(jtv)
27184			}
27185
27186		case "instanceHealthSummary":
27187			if err := awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(&sv.InstanceHealthSummary, value); err != nil {
27188				return err
27189			}
27190
27191		case "instancePort":
27192			if value != nil {
27193				jtv, ok := value.(json.Number)
27194				if !ok {
27195					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27196				}
27197				i64, err := jtv.Int64()
27198				if err != nil {
27199					return err
27200				}
27201				sv.InstancePort = ptr.Int32(int32(i64))
27202			}
27203
27204		case "ipAddressType":
27205			if value != nil {
27206				jtv, ok := value.(string)
27207				if !ok {
27208					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
27209				}
27210				sv.IpAddressType = types.IpAddressType(jtv)
27211			}
27212
27213		case "location":
27214			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27215				return err
27216			}
27217
27218		case "name":
27219			if value != nil {
27220				jtv, ok := value.(string)
27221				if !ok {
27222					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27223				}
27224				sv.Name = ptr.String(jtv)
27225			}
27226
27227		case "protocol":
27228			if value != nil {
27229				jtv, ok := value.(string)
27230				if !ok {
27231					return fmt.Errorf("expected LoadBalancerProtocol to be of type string, got %T instead", value)
27232				}
27233				sv.Protocol = types.LoadBalancerProtocol(jtv)
27234			}
27235
27236		case "publicPorts":
27237			if err := awsAwsjson11_deserializeDocumentPortList(&sv.PublicPorts, value); err != nil {
27238				return err
27239			}
27240
27241		case "resourceType":
27242			if value != nil {
27243				jtv, ok := value.(string)
27244				if !ok {
27245					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27246				}
27247				sv.ResourceType = types.ResourceType(jtv)
27248			}
27249
27250		case "state":
27251			if value != nil {
27252				jtv, ok := value.(string)
27253				if !ok {
27254					return fmt.Errorf("expected LoadBalancerState to be of type string, got %T instead", value)
27255				}
27256				sv.State = types.LoadBalancerState(jtv)
27257			}
27258
27259		case "supportCode":
27260			if value != nil {
27261				jtv, ok := value.(string)
27262				if !ok {
27263					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27264				}
27265				sv.SupportCode = ptr.String(jtv)
27266			}
27267
27268		case "tags":
27269			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
27270				return err
27271			}
27272
27273		case "tlsCertificateSummaries":
27274			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(&sv.TlsCertificateSummaries, value); err != nil {
27275				return err
27276			}
27277
27278		default:
27279			_, _ = key, value
27280
27281		}
27282	}
27283	*v = sv
27284	return nil
27285}
27286
27287func awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(v *map[string]string, value interface{}) error {
27288	if v == nil {
27289		return fmt.Errorf("unexpected nil of type %T", v)
27290	}
27291	if value == nil {
27292		return nil
27293	}
27294
27295	shape, ok := value.(map[string]interface{})
27296	if !ok {
27297		return fmt.Errorf("unexpected JSON type %v", value)
27298	}
27299
27300	var mv map[string]string
27301	if *v == nil {
27302		mv = map[string]string{}
27303	} else {
27304		mv = *v
27305	}
27306
27307	for key, value := range shape {
27308		var parsedVal string
27309		if value != nil {
27310			jtv, ok := value.(string)
27311			if !ok {
27312				return fmt.Errorf("expected string to be of type string, got %T instead", value)
27313			}
27314			parsedVal = jtv
27315		}
27316		mv[key] = parsedVal
27317
27318	}
27319	*v = mv
27320	return nil
27321}
27322
27323func awsAwsjson11_deserializeDocumentLoadBalancerList(v *[]types.LoadBalancer, value interface{}) error {
27324	if v == nil {
27325		return fmt.Errorf("unexpected nil of type %T", v)
27326	}
27327	if value == nil {
27328		return nil
27329	}
27330
27331	shape, ok := value.([]interface{})
27332	if !ok {
27333		return fmt.Errorf("unexpected JSON type %v", value)
27334	}
27335
27336	var cv []types.LoadBalancer
27337	if *v == nil {
27338		cv = []types.LoadBalancer{}
27339	} else {
27340		cv = *v
27341	}
27342
27343	for _, value := range shape {
27344		var col types.LoadBalancer
27345		destAddr := &col
27346		if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil {
27347			return err
27348		}
27349		col = *destAddr
27350		cv = append(cv, col)
27351
27352	}
27353	*v = cv
27354	return nil
27355}
27356
27357func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(v **types.LoadBalancerTlsCertificate, value interface{}) error {
27358	if v == nil {
27359		return fmt.Errorf("unexpected nil of type %T", v)
27360	}
27361	if value == nil {
27362		return nil
27363	}
27364
27365	shape, ok := value.(map[string]interface{})
27366	if !ok {
27367		return fmt.Errorf("unexpected JSON type %v", value)
27368	}
27369
27370	var sv *types.LoadBalancerTlsCertificate
27371	if *v == nil {
27372		sv = &types.LoadBalancerTlsCertificate{}
27373	} else {
27374		sv = *v
27375	}
27376
27377	for key, value := range shape {
27378		switch key {
27379		case "arn":
27380			if value != nil {
27381				jtv, ok := value.(string)
27382				if !ok {
27383					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27384				}
27385				sv.Arn = ptr.String(jtv)
27386			}
27387
27388		case "createdAt":
27389			if value != nil {
27390				switch jtv := value.(type) {
27391				case json.Number:
27392					f64, err := jtv.Float64()
27393					if err != nil {
27394						return err
27395					}
27396					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27397
27398				default:
27399					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27400
27401				}
27402			}
27403
27404		case "domainName":
27405			if value != nil {
27406				jtv, ok := value.(string)
27407				if !ok {
27408					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
27409				}
27410				sv.DomainName = ptr.String(jtv)
27411			}
27412
27413		case "domainValidationRecords":
27414			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
27415				return err
27416			}
27417
27418		case "failureReason":
27419			if value != nil {
27420				jtv, ok := value.(string)
27421				if !ok {
27422					return fmt.Errorf("expected LoadBalancerTlsCertificateFailureReason to be of type string, got %T instead", value)
27423				}
27424				sv.FailureReason = types.LoadBalancerTlsCertificateFailureReason(jtv)
27425			}
27426
27427		case "isAttached":
27428			if value != nil {
27429				jtv, ok := value.(bool)
27430				if !ok {
27431					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27432				}
27433				sv.IsAttached = ptr.Bool(jtv)
27434			}
27435
27436		case "issuedAt":
27437			if value != nil {
27438				switch jtv := value.(type) {
27439				case json.Number:
27440					f64, err := jtv.Float64()
27441					if err != nil {
27442						return err
27443					}
27444					sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27445
27446				default:
27447					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27448
27449				}
27450			}
27451
27452		case "issuer":
27453			if value != nil {
27454				jtv, ok := value.(string)
27455				if !ok {
27456					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27457				}
27458				sv.Issuer = ptr.String(jtv)
27459			}
27460
27461		case "keyAlgorithm":
27462			if value != nil {
27463				jtv, ok := value.(string)
27464				if !ok {
27465					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27466				}
27467				sv.KeyAlgorithm = ptr.String(jtv)
27468			}
27469
27470		case "loadBalancerName":
27471			if value != nil {
27472				jtv, ok := value.(string)
27473				if !ok {
27474					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27475				}
27476				sv.LoadBalancerName = ptr.String(jtv)
27477			}
27478
27479		case "location":
27480			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27481				return err
27482			}
27483
27484		case "name":
27485			if value != nil {
27486				jtv, ok := value.(string)
27487				if !ok {
27488					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27489				}
27490				sv.Name = ptr.String(jtv)
27491			}
27492
27493		case "notAfter":
27494			if value != nil {
27495				switch jtv := value.(type) {
27496				case json.Number:
27497					f64, err := jtv.Float64()
27498					if err != nil {
27499						return err
27500					}
27501					sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
27502
27503				default:
27504					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27505
27506				}
27507			}
27508
27509		case "notBefore":
27510			if value != nil {
27511				switch jtv := value.(type) {
27512				case json.Number:
27513					f64, err := jtv.Float64()
27514					if err != nil {
27515						return err
27516					}
27517					sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
27518
27519				default:
27520					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27521
27522				}
27523			}
27524
27525		case "renewalSummary":
27526			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(&sv.RenewalSummary, value); err != nil {
27527				return err
27528			}
27529
27530		case "resourceType":
27531			if value != nil {
27532				jtv, ok := value.(string)
27533				if !ok {
27534					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27535				}
27536				sv.ResourceType = types.ResourceType(jtv)
27537			}
27538
27539		case "revocationReason":
27540			if value != nil {
27541				jtv, ok := value.(string)
27542				if !ok {
27543					return fmt.Errorf("expected LoadBalancerTlsCertificateRevocationReason to be of type string, got %T instead", value)
27544				}
27545				sv.RevocationReason = types.LoadBalancerTlsCertificateRevocationReason(jtv)
27546			}
27547
27548		case "revokedAt":
27549			if value != nil {
27550				switch jtv := value.(type) {
27551				case json.Number:
27552					f64, err := jtv.Float64()
27553					if err != nil {
27554						return err
27555					}
27556					sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27557
27558				default:
27559					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
27560
27561				}
27562			}
27563
27564		case "serial":
27565			if value != nil {
27566				jtv, ok := value.(string)
27567				if !ok {
27568					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27569				}
27570				sv.Serial = ptr.String(jtv)
27571			}
27572
27573		case "signatureAlgorithm":
27574			if value != nil {
27575				jtv, ok := value.(string)
27576				if !ok {
27577					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27578				}
27579				sv.SignatureAlgorithm = ptr.String(jtv)
27580			}
27581
27582		case "status":
27583			if value != nil {
27584				jtv, ok := value.(string)
27585				if !ok {
27586					return fmt.Errorf("expected LoadBalancerTlsCertificateStatus to be of type string, got %T instead", value)
27587				}
27588				sv.Status = types.LoadBalancerTlsCertificateStatus(jtv)
27589			}
27590
27591		case "subject":
27592			if value != nil {
27593				jtv, ok := value.(string)
27594				if !ok {
27595					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27596				}
27597				sv.Subject = ptr.String(jtv)
27598			}
27599
27600		case "subjectAlternativeNames":
27601			if err := awsAwsjson11_deserializeDocumentStringList(&sv.SubjectAlternativeNames, value); err != nil {
27602				return err
27603			}
27604
27605		case "supportCode":
27606			if value != nil {
27607				jtv, ok := value.(string)
27608				if !ok {
27609					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27610				}
27611				sv.SupportCode = ptr.String(jtv)
27612			}
27613
27614		case "tags":
27615			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
27616				return err
27617			}
27618
27619		default:
27620			_, _ = key, value
27621
27622		}
27623	}
27624	*v = sv
27625	return nil
27626}
27627
27628func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(v **types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
27629	if v == nil {
27630		return fmt.Errorf("unexpected nil of type %T", v)
27631	}
27632	if value == nil {
27633		return nil
27634	}
27635
27636	shape, ok := value.(map[string]interface{})
27637	if !ok {
27638		return fmt.Errorf("unexpected JSON type %v", value)
27639	}
27640
27641	var sv *types.LoadBalancerTlsCertificateDomainValidationOption
27642	if *v == nil {
27643		sv = &types.LoadBalancerTlsCertificateDomainValidationOption{}
27644	} else {
27645		sv = *v
27646	}
27647
27648	for key, value := range shape {
27649		switch key {
27650		case "domainName":
27651			if value != nil {
27652				jtv, ok := value.(string)
27653				if !ok {
27654					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
27655				}
27656				sv.DomainName = ptr.String(jtv)
27657			}
27658
27659		case "validationStatus":
27660			if value != nil {
27661				jtv, ok := value.(string)
27662				if !ok {
27663					return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
27664				}
27665				sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
27666			}
27667
27668		default:
27669			_, _ = key, value
27670
27671		}
27672	}
27673	*v = sv
27674	return nil
27675}
27676
27677func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(v *[]types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
27678	if v == nil {
27679		return fmt.Errorf("unexpected nil of type %T", v)
27680	}
27681	if value == nil {
27682		return nil
27683	}
27684
27685	shape, ok := value.([]interface{})
27686	if !ok {
27687		return fmt.Errorf("unexpected JSON type %v", value)
27688	}
27689
27690	var cv []types.LoadBalancerTlsCertificateDomainValidationOption
27691	if *v == nil {
27692		cv = []types.LoadBalancerTlsCertificateDomainValidationOption{}
27693	} else {
27694		cv = *v
27695	}
27696
27697	for _, value := range shape {
27698		var col types.LoadBalancerTlsCertificateDomainValidationOption
27699		destAddr := &col
27700		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(&destAddr, value); err != nil {
27701			return err
27702		}
27703		col = *destAddr
27704		cv = append(cv, col)
27705
27706	}
27707	*v = cv
27708	return nil
27709}
27710
27711func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(v **types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
27712	if v == nil {
27713		return fmt.Errorf("unexpected nil of type %T", v)
27714	}
27715	if value == nil {
27716		return nil
27717	}
27718
27719	shape, ok := value.(map[string]interface{})
27720	if !ok {
27721		return fmt.Errorf("unexpected JSON type %v", value)
27722	}
27723
27724	var sv *types.LoadBalancerTlsCertificateDomainValidationRecord
27725	if *v == nil {
27726		sv = &types.LoadBalancerTlsCertificateDomainValidationRecord{}
27727	} else {
27728		sv = *v
27729	}
27730
27731	for key, value := range shape {
27732		switch key {
27733		case "domainName":
27734			if value != nil {
27735				jtv, ok := value.(string)
27736				if !ok {
27737					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
27738				}
27739				sv.DomainName = ptr.String(jtv)
27740			}
27741
27742		case "name":
27743			if value != nil {
27744				jtv, ok := value.(string)
27745				if !ok {
27746					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27747				}
27748				sv.Name = ptr.String(jtv)
27749			}
27750
27751		case "type":
27752			if value != nil {
27753				jtv, ok := value.(string)
27754				if !ok {
27755					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27756				}
27757				sv.Type = ptr.String(jtv)
27758			}
27759
27760		case "validationStatus":
27761			if value != nil {
27762				jtv, ok := value.(string)
27763				if !ok {
27764					return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
27765				}
27766				sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
27767			}
27768
27769		case "value":
27770			if value != nil {
27771				jtv, ok := value.(string)
27772				if !ok {
27773					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27774				}
27775				sv.Value = ptr.String(jtv)
27776			}
27777
27778		default:
27779			_, _ = key, value
27780
27781		}
27782	}
27783	*v = sv
27784	return nil
27785}
27786
27787func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(v *[]types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
27788	if v == nil {
27789		return fmt.Errorf("unexpected nil of type %T", v)
27790	}
27791	if value == nil {
27792		return nil
27793	}
27794
27795	shape, ok := value.([]interface{})
27796	if !ok {
27797		return fmt.Errorf("unexpected JSON type %v", value)
27798	}
27799
27800	var cv []types.LoadBalancerTlsCertificateDomainValidationRecord
27801	if *v == nil {
27802		cv = []types.LoadBalancerTlsCertificateDomainValidationRecord{}
27803	} else {
27804		cv = *v
27805	}
27806
27807	for _, value := range shape {
27808		var col types.LoadBalancerTlsCertificateDomainValidationRecord
27809		destAddr := &col
27810		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(&destAddr, value); err != nil {
27811			return err
27812		}
27813		col = *destAddr
27814		cv = append(cv, col)
27815
27816	}
27817	*v = cv
27818	return nil
27819}
27820
27821func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(v *[]types.LoadBalancerTlsCertificate, value interface{}) error {
27822	if v == nil {
27823		return fmt.Errorf("unexpected nil of type %T", v)
27824	}
27825	if value == nil {
27826		return nil
27827	}
27828
27829	shape, ok := value.([]interface{})
27830	if !ok {
27831		return fmt.Errorf("unexpected JSON type %v", value)
27832	}
27833
27834	var cv []types.LoadBalancerTlsCertificate
27835	if *v == nil {
27836		cv = []types.LoadBalancerTlsCertificate{}
27837	} else {
27838		cv = *v
27839	}
27840
27841	for _, value := range shape {
27842		var col types.LoadBalancerTlsCertificate
27843		destAddr := &col
27844		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(&destAddr, value); err != nil {
27845			return err
27846		}
27847		col = *destAddr
27848		cv = append(cv, col)
27849
27850	}
27851	*v = cv
27852	return nil
27853}
27854
27855func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(v **types.LoadBalancerTlsCertificateRenewalSummary, value interface{}) error {
27856	if v == nil {
27857		return fmt.Errorf("unexpected nil of type %T", v)
27858	}
27859	if value == nil {
27860		return nil
27861	}
27862
27863	shape, ok := value.(map[string]interface{})
27864	if !ok {
27865		return fmt.Errorf("unexpected JSON type %v", value)
27866	}
27867
27868	var sv *types.LoadBalancerTlsCertificateRenewalSummary
27869	if *v == nil {
27870		sv = &types.LoadBalancerTlsCertificateRenewalSummary{}
27871	} else {
27872		sv = *v
27873	}
27874
27875	for key, value := range shape {
27876		switch key {
27877		case "domainValidationOptions":
27878			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(&sv.DomainValidationOptions, value); err != nil {
27879				return err
27880			}
27881
27882		case "renewalStatus":
27883			if value != nil {
27884				jtv, ok := value.(string)
27885				if !ok {
27886					return fmt.Errorf("expected LoadBalancerTlsCertificateRenewalStatus to be of type string, got %T instead", value)
27887				}
27888				sv.RenewalStatus = types.LoadBalancerTlsCertificateRenewalStatus(jtv)
27889			}
27890
27891		default:
27892			_, _ = key, value
27893
27894		}
27895	}
27896	*v = sv
27897	return nil
27898}
27899
27900func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(v **types.LoadBalancerTlsCertificateSummary, value interface{}) error {
27901	if v == nil {
27902		return fmt.Errorf("unexpected nil of type %T", v)
27903	}
27904	if value == nil {
27905		return nil
27906	}
27907
27908	shape, ok := value.(map[string]interface{})
27909	if !ok {
27910		return fmt.Errorf("unexpected JSON type %v", value)
27911	}
27912
27913	var sv *types.LoadBalancerTlsCertificateSummary
27914	if *v == nil {
27915		sv = &types.LoadBalancerTlsCertificateSummary{}
27916	} else {
27917		sv = *v
27918	}
27919
27920	for key, value := range shape {
27921		switch key {
27922		case "isAttached":
27923			if value != nil {
27924				jtv, ok := value.(bool)
27925				if !ok {
27926					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27927				}
27928				sv.IsAttached = ptr.Bool(jtv)
27929			}
27930
27931		case "name":
27932			if value != nil {
27933				jtv, ok := value.(string)
27934				if !ok {
27935					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27936				}
27937				sv.Name = ptr.String(jtv)
27938			}
27939
27940		default:
27941			_, _ = key, value
27942
27943		}
27944	}
27945	*v = sv
27946	return nil
27947}
27948
27949func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(v *[]types.LoadBalancerTlsCertificateSummary, value interface{}) error {
27950	if v == nil {
27951		return fmt.Errorf("unexpected nil of type %T", v)
27952	}
27953	if value == nil {
27954		return nil
27955	}
27956
27957	shape, ok := value.([]interface{})
27958	if !ok {
27959		return fmt.Errorf("unexpected JSON type %v", value)
27960	}
27961
27962	var cv []types.LoadBalancerTlsCertificateSummary
27963	if *v == nil {
27964		cv = []types.LoadBalancerTlsCertificateSummary{}
27965	} else {
27966		cv = *v
27967	}
27968
27969	for _, value := range shape {
27970		var col types.LoadBalancerTlsCertificateSummary
27971		destAddr := &col
27972		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(&destAddr, value); err != nil {
27973			return err
27974		}
27975		col = *destAddr
27976		cv = append(cv, col)
27977
27978	}
27979	*v = cv
27980	return nil
27981}
27982
27983func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interface{}) error {
27984	if v == nil {
27985		return fmt.Errorf("unexpected nil of type %T", v)
27986	}
27987	if value == nil {
27988		return nil
27989	}
27990
27991	shape, ok := value.(map[string]interface{})
27992	if !ok {
27993		return fmt.Errorf("unexpected JSON type %v", value)
27994	}
27995
27996	var sv *types.LogEvent
27997	if *v == nil {
27998		sv = &types.LogEvent{}
27999	} else {
28000		sv = *v
28001	}
28002
28003	for key, value := range shape {
28004		switch key {
28005		case "createdAt":
28006			if value != nil {
28007				switch jtv := value.(type) {
28008				case json.Number:
28009					f64, err := jtv.Float64()
28010					if err != nil {
28011						return err
28012					}
28013					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28014
28015				default:
28016					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28017
28018				}
28019			}
28020
28021		case "message":
28022			if value != nil {
28023				jtv, ok := value.(string)
28024				if !ok {
28025					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28026				}
28027				sv.Message = ptr.String(jtv)
28028			}
28029
28030		default:
28031			_, _ = key, value
28032
28033		}
28034	}
28035	*v = sv
28036	return nil
28037}
28038
28039func awsAwsjson11_deserializeDocumentLogEventList(v *[]types.LogEvent, value interface{}) error {
28040	if v == nil {
28041		return fmt.Errorf("unexpected nil of type %T", v)
28042	}
28043	if value == nil {
28044		return nil
28045	}
28046
28047	shape, ok := value.([]interface{})
28048	if !ok {
28049		return fmt.Errorf("unexpected JSON type %v", value)
28050	}
28051
28052	var cv []types.LogEvent
28053	if *v == nil {
28054		cv = []types.LogEvent{}
28055	} else {
28056		cv = *v
28057	}
28058
28059	for _, value := range shape {
28060		var col types.LogEvent
28061		destAddr := &col
28062		if err := awsAwsjson11_deserializeDocumentLogEvent(&destAddr, value); err != nil {
28063			return err
28064		}
28065		col = *destAddr
28066		cv = append(cv, col)
28067
28068	}
28069	*v = cv
28070	return nil
28071}
28072
28073func awsAwsjson11_deserializeDocumentMetricDatapoint(v **types.MetricDatapoint, value interface{}) error {
28074	if v == nil {
28075		return fmt.Errorf("unexpected nil of type %T", v)
28076	}
28077	if value == nil {
28078		return nil
28079	}
28080
28081	shape, ok := value.(map[string]interface{})
28082	if !ok {
28083		return fmt.Errorf("unexpected JSON type %v", value)
28084	}
28085
28086	var sv *types.MetricDatapoint
28087	if *v == nil {
28088		sv = &types.MetricDatapoint{}
28089	} else {
28090		sv = *v
28091	}
28092
28093	for key, value := range shape {
28094		switch key {
28095		case "average":
28096			if value != nil {
28097				switch jtv := value.(type) {
28098				case json.Number:
28099					f64, err := jtv.Float64()
28100					if err != nil {
28101						return err
28102					}
28103					sv.Average = ptr.Float64(f64)
28104
28105				case string:
28106					var f64 float64
28107					switch {
28108					case strings.EqualFold(jtv, "NaN"):
28109						f64 = math.NaN()
28110
28111					case strings.EqualFold(jtv, "Infinity"):
28112						f64 = math.Inf(1)
28113
28114					case strings.EqualFold(jtv, "-Infinity"):
28115						f64 = math.Inf(-1)
28116
28117					default:
28118						return fmt.Errorf("unknown JSON number value: %s", jtv)
28119
28120					}
28121					sv.Average = ptr.Float64(f64)
28122
28123				default:
28124					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
28125
28126				}
28127			}
28128
28129		case "maximum":
28130			if value != nil {
28131				switch jtv := value.(type) {
28132				case json.Number:
28133					f64, err := jtv.Float64()
28134					if err != nil {
28135						return err
28136					}
28137					sv.Maximum = ptr.Float64(f64)
28138
28139				case string:
28140					var f64 float64
28141					switch {
28142					case strings.EqualFold(jtv, "NaN"):
28143						f64 = math.NaN()
28144
28145					case strings.EqualFold(jtv, "Infinity"):
28146						f64 = math.Inf(1)
28147
28148					case strings.EqualFold(jtv, "-Infinity"):
28149						f64 = math.Inf(-1)
28150
28151					default:
28152						return fmt.Errorf("unknown JSON number value: %s", jtv)
28153
28154					}
28155					sv.Maximum = ptr.Float64(f64)
28156
28157				default:
28158					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
28159
28160				}
28161			}
28162
28163		case "minimum":
28164			if value != nil {
28165				switch jtv := value.(type) {
28166				case json.Number:
28167					f64, err := jtv.Float64()
28168					if err != nil {
28169						return err
28170					}
28171					sv.Minimum = ptr.Float64(f64)
28172
28173				case string:
28174					var f64 float64
28175					switch {
28176					case strings.EqualFold(jtv, "NaN"):
28177						f64 = math.NaN()
28178
28179					case strings.EqualFold(jtv, "Infinity"):
28180						f64 = math.Inf(1)
28181
28182					case strings.EqualFold(jtv, "-Infinity"):
28183						f64 = math.Inf(-1)
28184
28185					default:
28186						return fmt.Errorf("unknown JSON number value: %s", jtv)
28187
28188					}
28189					sv.Minimum = ptr.Float64(f64)
28190
28191				default:
28192					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
28193
28194				}
28195			}
28196
28197		case "sampleCount":
28198			if value != nil {
28199				switch jtv := value.(type) {
28200				case json.Number:
28201					f64, err := jtv.Float64()
28202					if err != nil {
28203						return err
28204					}
28205					sv.SampleCount = ptr.Float64(f64)
28206
28207				case string:
28208					var f64 float64
28209					switch {
28210					case strings.EqualFold(jtv, "NaN"):
28211						f64 = math.NaN()
28212
28213					case strings.EqualFold(jtv, "Infinity"):
28214						f64 = math.Inf(1)
28215
28216					case strings.EqualFold(jtv, "-Infinity"):
28217						f64 = math.Inf(-1)
28218
28219					default:
28220						return fmt.Errorf("unknown JSON number value: %s", jtv)
28221
28222					}
28223					sv.SampleCount = ptr.Float64(f64)
28224
28225				default:
28226					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
28227
28228				}
28229			}
28230
28231		case "sum":
28232			if value != nil {
28233				switch jtv := value.(type) {
28234				case json.Number:
28235					f64, err := jtv.Float64()
28236					if err != nil {
28237						return err
28238					}
28239					sv.Sum = ptr.Float64(f64)
28240
28241				case string:
28242					var f64 float64
28243					switch {
28244					case strings.EqualFold(jtv, "NaN"):
28245						f64 = math.NaN()
28246
28247					case strings.EqualFold(jtv, "Infinity"):
28248						f64 = math.Inf(1)
28249
28250					case strings.EqualFold(jtv, "-Infinity"):
28251						f64 = math.Inf(-1)
28252
28253					default:
28254						return fmt.Errorf("unknown JSON number value: %s", jtv)
28255
28256					}
28257					sv.Sum = ptr.Float64(f64)
28258
28259				default:
28260					return fmt.Errorf("expected double to be a JSON Number, got %T instead", value)
28261
28262				}
28263			}
28264
28265		case "timestamp":
28266			if value != nil {
28267				switch jtv := value.(type) {
28268				case json.Number:
28269					f64, err := jtv.Float64()
28270					if err != nil {
28271						return err
28272					}
28273					sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
28274
28275				default:
28276					return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value)
28277
28278				}
28279			}
28280
28281		case "unit":
28282			if value != nil {
28283				jtv, ok := value.(string)
28284				if !ok {
28285					return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
28286				}
28287				sv.Unit = types.MetricUnit(jtv)
28288			}
28289
28290		default:
28291			_, _ = key, value
28292
28293		}
28294	}
28295	*v = sv
28296	return nil
28297}
28298
28299func awsAwsjson11_deserializeDocumentMetricDatapointList(v *[]types.MetricDatapoint, value interface{}) error {
28300	if v == nil {
28301		return fmt.Errorf("unexpected nil of type %T", v)
28302	}
28303	if value == nil {
28304		return nil
28305	}
28306
28307	shape, ok := value.([]interface{})
28308	if !ok {
28309		return fmt.Errorf("unexpected JSON type %v", value)
28310	}
28311
28312	var cv []types.MetricDatapoint
28313	if *v == nil {
28314		cv = []types.MetricDatapoint{}
28315	} else {
28316		cv = *v
28317	}
28318
28319	for _, value := range shape {
28320		var col types.MetricDatapoint
28321		destAddr := &col
28322		if err := awsAwsjson11_deserializeDocumentMetricDatapoint(&destAddr, value); err != nil {
28323			return err
28324		}
28325		col = *destAddr
28326		cv = append(cv, col)
28327
28328	}
28329	*v = cv
28330	return nil
28331}
28332
28333func awsAwsjson11_deserializeDocumentMonitoredResourceInfo(v **types.MonitoredResourceInfo, value interface{}) error {
28334	if v == nil {
28335		return fmt.Errorf("unexpected nil of type %T", v)
28336	}
28337	if value == nil {
28338		return nil
28339	}
28340
28341	shape, ok := value.(map[string]interface{})
28342	if !ok {
28343		return fmt.Errorf("unexpected JSON type %v", value)
28344	}
28345
28346	var sv *types.MonitoredResourceInfo
28347	if *v == nil {
28348		sv = &types.MonitoredResourceInfo{}
28349	} else {
28350		sv = *v
28351	}
28352
28353	for key, value := range shape {
28354		switch key {
28355		case "arn":
28356			if value != nil {
28357				jtv, ok := value.(string)
28358				if !ok {
28359					return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
28360				}
28361				sv.Arn = ptr.String(jtv)
28362			}
28363
28364		case "name":
28365			if value != nil {
28366				jtv, ok := value.(string)
28367				if !ok {
28368					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28369				}
28370				sv.Name = ptr.String(jtv)
28371			}
28372
28373		case "resourceType":
28374			if value != nil {
28375				jtv, ok := value.(string)
28376				if !ok {
28377					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
28378				}
28379				sv.ResourceType = types.ResourceType(jtv)
28380			}
28381
28382		default:
28383			_, _ = key, value
28384
28385		}
28386	}
28387	*v = sv
28388	return nil
28389}
28390
28391func awsAwsjson11_deserializeDocumentMonthlyTransfer(v **types.MonthlyTransfer, value interface{}) error {
28392	if v == nil {
28393		return fmt.Errorf("unexpected nil of type %T", v)
28394	}
28395	if value == nil {
28396		return nil
28397	}
28398
28399	shape, ok := value.(map[string]interface{})
28400	if !ok {
28401		return fmt.Errorf("unexpected JSON type %v", value)
28402	}
28403
28404	var sv *types.MonthlyTransfer
28405	if *v == nil {
28406		sv = &types.MonthlyTransfer{}
28407	} else {
28408		sv = *v
28409	}
28410
28411	for key, value := range shape {
28412		switch key {
28413		case "gbPerMonthAllocated":
28414			if value != nil {
28415				jtv, ok := value.(json.Number)
28416				if !ok {
28417					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
28418				}
28419				i64, err := jtv.Int64()
28420				if err != nil {
28421					return err
28422				}
28423				sv.GbPerMonthAllocated = ptr.Int32(int32(i64))
28424			}
28425
28426		default:
28427			_, _ = key, value
28428
28429		}
28430	}
28431	*v = sv
28432	return nil
28433}
28434
28435func awsAwsjson11_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error {
28436	if v == nil {
28437		return fmt.Errorf("unexpected nil of type %T", v)
28438	}
28439	if value == nil {
28440		return nil
28441	}
28442
28443	shape, ok := value.(map[string]interface{})
28444	if !ok {
28445		return fmt.Errorf("unexpected JSON type %v", value)
28446	}
28447
28448	var sv *types.NotFoundException
28449	if *v == nil {
28450		sv = &types.NotFoundException{}
28451	} else {
28452		sv = *v
28453	}
28454
28455	for key, value := range shape {
28456		switch key {
28457		case "code":
28458			if value != nil {
28459				jtv, ok := value.(string)
28460				if !ok {
28461					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28462				}
28463				sv.Code = ptr.String(jtv)
28464			}
28465
28466		case "docs":
28467			if value != nil {
28468				jtv, ok := value.(string)
28469				if !ok {
28470					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28471				}
28472				sv.Docs = ptr.String(jtv)
28473			}
28474
28475		case "message":
28476			if value != nil {
28477				jtv, ok := value.(string)
28478				if !ok {
28479					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28480				}
28481				sv.Message = ptr.String(jtv)
28482			}
28483
28484		case "tip":
28485			if value != nil {
28486				jtv, ok := value.(string)
28487				if !ok {
28488					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28489				}
28490				sv.Tip = ptr.String(jtv)
28491			}
28492
28493		default:
28494			_, _ = key, value
28495
28496		}
28497	}
28498	*v = sv
28499	return nil
28500}
28501
28502func awsAwsjson11_deserializeDocumentNotificationTriggerList(v *[]types.AlarmState, value interface{}) error {
28503	if v == nil {
28504		return fmt.Errorf("unexpected nil of type %T", v)
28505	}
28506	if value == nil {
28507		return nil
28508	}
28509
28510	shape, ok := value.([]interface{})
28511	if !ok {
28512		return fmt.Errorf("unexpected JSON type %v", value)
28513	}
28514
28515	var cv []types.AlarmState
28516	if *v == nil {
28517		cv = []types.AlarmState{}
28518	} else {
28519		cv = *v
28520	}
28521
28522	for _, value := range shape {
28523		var col types.AlarmState
28524		if value != nil {
28525			jtv, ok := value.(string)
28526			if !ok {
28527				return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
28528			}
28529			col = types.AlarmState(jtv)
28530		}
28531		cv = append(cv, col)
28532
28533	}
28534	*v = cv
28535	return nil
28536}
28537
28538func awsAwsjson11_deserializeDocumentOperation(v **types.Operation, value interface{}) error {
28539	if v == nil {
28540		return fmt.Errorf("unexpected nil of type %T", v)
28541	}
28542	if value == nil {
28543		return nil
28544	}
28545
28546	shape, ok := value.(map[string]interface{})
28547	if !ok {
28548		return fmt.Errorf("unexpected JSON type %v", value)
28549	}
28550
28551	var sv *types.Operation
28552	if *v == nil {
28553		sv = &types.Operation{}
28554	} else {
28555		sv = *v
28556	}
28557
28558	for key, value := range shape {
28559		switch key {
28560		case "createdAt":
28561			if value != nil {
28562				switch jtv := value.(type) {
28563				case json.Number:
28564					f64, err := jtv.Float64()
28565					if err != nil {
28566						return err
28567					}
28568					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28569
28570				default:
28571					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28572
28573				}
28574			}
28575
28576		case "errorCode":
28577			if value != nil {
28578				jtv, ok := value.(string)
28579				if !ok {
28580					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28581				}
28582				sv.ErrorCode = ptr.String(jtv)
28583			}
28584
28585		case "errorDetails":
28586			if value != nil {
28587				jtv, ok := value.(string)
28588				if !ok {
28589					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28590				}
28591				sv.ErrorDetails = ptr.String(jtv)
28592			}
28593
28594		case "id":
28595			if value != nil {
28596				jtv, ok := value.(string)
28597				if !ok {
28598					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28599				}
28600				sv.Id = ptr.String(jtv)
28601			}
28602
28603		case "isTerminal":
28604			if value != nil {
28605				jtv, ok := value.(bool)
28606				if !ok {
28607					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
28608				}
28609				sv.IsTerminal = ptr.Bool(jtv)
28610			}
28611
28612		case "location":
28613			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
28614				return err
28615			}
28616
28617		case "operationDetails":
28618			if value != nil {
28619				jtv, ok := value.(string)
28620				if !ok {
28621					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28622				}
28623				sv.OperationDetails = ptr.String(jtv)
28624			}
28625
28626		case "operationType":
28627			if value != nil {
28628				jtv, ok := value.(string)
28629				if !ok {
28630					return fmt.Errorf("expected OperationType to be of type string, got %T instead", value)
28631				}
28632				sv.OperationType = types.OperationType(jtv)
28633			}
28634
28635		case "resourceName":
28636			if value != nil {
28637				jtv, ok := value.(string)
28638				if !ok {
28639					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28640				}
28641				sv.ResourceName = ptr.String(jtv)
28642			}
28643
28644		case "resourceType":
28645			if value != nil {
28646				jtv, ok := value.(string)
28647				if !ok {
28648					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
28649				}
28650				sv.ResourceType = types.ResourceType(jtv)
28651			}
28652
28653		case "status":
28654			if value != nil {
28655				jtv, ok := value.(string)
28656				if !ok {
28657					return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value)
28658				}
28659				sv.Status = types.OperationStatus(jtv)
28660			}
28661
28662		case "statusChangedAt":
28663			if value != nil {
28664				switch jtv := value.(type) {
28665				case json.Number:
28666					f64, err := jtv.Float64()
28667					if err != nil {
28668						return err
28669					}
28670					sv.StatusChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28671
28672				default:
28673					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28674
28675				}
28676			}
28677
28678		default:
28679			_, _ = key, value
28680
28681		}
28682	}
28683	*v = sv
28684	return nil
28685}
28686
28687func awsAwsjson11_deserializeDocumentOperationFailureException(v **types.OperationFailureException, value interface{}) error {
28688	if v == nil {
28689		return fmt.Errorf("unexpected nil of type %T", v)
28690	}
28691	if value == nil {
28692		return nil
28693	}
28694
28695	shape, ok := value.(map[string]interface{})
28696	if !ok {
28697		return fmt.Errorf("unexpected JSON type %v", value)
28698	}
28699
28700	var sv *types.OperationFailureException
28701	if *v == nil {
28702		sv = &types.OperationFailureException{}
28703	} else {
28704		sv = *v
28705	}
28706
28707	for key, value := range shape {
28708		switch key {
28709		case "code":
28710			if value != nil {
28711				jtv, ok := value.(string)
28712				if !ok {
28713					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28714				}
28715				sv.Code = ptr.String(jtv)
28716			}
28717
28718		case "docs":
28719			if value != nil {
28720				jtv, ok := value.(string)
28721				if !ok {
28722					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28723				}
28724				sv.Docs = ptr.String(jtv)
28725			}
28726
28727		case "message":
28728			if value != nil {
28729				jtv, ok := value.(string)
28730				if !ok {
28731					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28732				}
28733				sv.Message = ptr.String(jtv)
28734			}
28735
28736		case "tip":
28737			if value != nil {
28738				jtv, ok := value.(string)
28739				if !ok {
28740					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28741				}
28742				sv.Tip = ptr.String(jtv)
28743			}
28744
28745		default:
28746			_, _ = key, value
28747
28748		}
28749	}
28750	*v = sv
28751	return nil
28752}
28753
28754func awsAwsjson11_deserializeDocumentOperationList(v *[]types.Operation, value interface{}) error {
28755	if v == nil {
28756		return fmt.Errorf("unexpected nil of type %T", v)
28757	}
28758	if value == nil {
28759		return nil
28760	}
28761
28762	shape, ok := value.([]interface{})
28763	if !ok {
28764		return fmt.Errorf("unexpected JSON type %v", value)
28765	}
28766
28767	var cv []types.Operation
28768	if *v == nil {
28769		cv = []types.Operation{}
28770	} else {
28771		cv = *v
28772	}
28773
28774	for _, value := range shape {
28775		var col types.Operation
28776		destAddr := &col
28777		if err := awsAwsjson11_deserializeDocumentOperation(&destAddr, value); err != nil {
28778			return err
28779		}
28780		col = *destAddr
28781		cv = append(cv, col)
28782
28783	}
28784	*v = cv
28785	return nil
28786}
28787
28788func awsAwsjson11_deserializeDocumentOrigin(v **types.Origin, value interface{}) error {
28789	if v == nil {
28790		return fmt.Errorf("unexpected nil of type %T", v)
28791	}
28792	if value == nil {
28793		return nil
28794	}
28795
28796	shape, ok := value.(map[string]interface{})
28797	if !ok {
28798		return fmt.Errorf("unexpected JSON type %v", value)
28799	}
28800
28801	var sv *types.Origin
28802	if *v == nil {
28803		sv = &types.Origin{}
28804	} else {
28805		sv = *v
28806	}
28807
28808	for key, value := range shape {
28809		switch key {
28810		case "name":
28811			if value != nil {
28812				jtv, ok := value.(string)
28813				if !ok {
28814					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28815				}
28816				sv.Name = ptr.String(jtv)
28817			}
28818
28819		case "protocolPolicy":
28820			if value != nil {
28821				jtv, ok := value.(string)
28822				if !ok {
28823					return fmt.Errorf("expected OriginProtocolPolicyEnum to be of type string, got %T instead", value)
28824				}
28825				sv.ProtocolPolicy = types.OriginProtocolPolicyEnum(jtv)
28826			}
28827
28828		case "regionName":
28829			if value != nil {
28830				jtv, ok := value.(string)
28831				if !ok {
28832					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
28833				}
28834				sv.RegionName = types.RegionName(jtv)
28835			}
28836
28837		case "resourceType":
28838			if value != nil {
28839				jtv, ok := value.(string)
28840				if !ok {
28841					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
28842				}
28843				sv.ResourceType = types.ResourceType(jtv)
28844			}
28845
28846		default:
28847			_, _ = key, value
28848
28849		}
28850	}
28851	*v = sv
28852	return nil
28853}
28854
28855func awsAwsjson11_deserializeDocumentPartnerIdList(v *[]string, value interface{}) error {
28856	if v == nil {
28857		return fmt.Errorf("unexpected nil of type %T", v)
28858	}
28859	if value == nil {
28860		return nil
28861	}
28862
28863	shape, ok := value.([]interface{})
28864	if !ok {
28865		return fmt.Errorf("unexpected JSON type %v", value)
28866	}
28867
28868	var cv []string
28869	if *v == nil {
28870		cv = []string{}
28871	} else {
28872		cv = *v
28873	}
28874
28875	for _, value := range shape {
28876		var col string
28877		if value != nil {
28878			jtv, ok := value.(string)
28879			if !ok {
28880				return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28881			}
28882			col = jtv
28883		}
28884		cv = append(cv, col)
28885
28886	}
28887	*v = cv
28888	return nil
28889}
28890
28891func awsAwsjson11_deserializeDocumentPasswordData(v **types.PasswordData, value interface{}) error {
28892	if v == nil {
28893		return fmt.Errorf("unexpected nil of type %T", v)
28894	}
28895	if value == nil {
28896		return nil
28897	}
28898
28899	shape, ok := value.(map[string]interface{})
28900	if !ok {
28901		return fmt.Errorf("unexpected JSON type %v", value)
28902	}
28903
28904	var sv *types.PasswordData
28905	if *v == nil {
28906		sv = &types.PasswordData{}
28907	} else {
28908		sv = *v
28909	}
28910
28911	for key, value := range shape {
28912		switch key {
28913		case "ciphertext":
28914			if value != nil {
28915				jtv, ok := value.(string)
28916				if !ok {
28917					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28918				}
28919				sv.Ciphertext = ptr.String(jtv)
28920			}
28921
28922		case "keyPairName":
28923			if value != nil {
28924				jtv, ok := value.(string)
28925				if !ok {
28926					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28927				}
28928				sv.KeyPairName = ptr.String(jtv)
28929			}
28930
28931		default:
28932			_, _ = key, value
28933
28934		}
28935	}
28936	*v = sv
28937	return nil
28938}
28939
28940func awsAwsjson11_deserializeDocumentPendingMaintenanceAction(v **types.PendingMaintenanceAction, value interface{}) error {
28941	if v == nil {
28942		return fmt.Errorf("unexpected nil of type %T", v)
28943	}
28944	if value == nil {
28945		return nil
28946	}
28947
28948	shape, ok := value.(map[string]interface{})
28949	if !ok {
28950		return fmt.Errorf("unexpected JSON type %v", value)
28951	}
28952
28953	var sv *types.PendingMaintenanceAction
28954	if *v == nil {
28955		sv = &types.PendingMaintenanceAction{}
28956	} else {
28957		sv = *v
28958	}
28959
28960	for key, value := range shape {
28961		switch key {
28962		case "action":
28963			if value != nil {
28964				jtv, ok := value.(string)
28965				if !ok {
28966					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28967				}
28968				sv.Action = ptr.String(jtv)
28969			}
28970
28971		case "currentApplyDate":
28972			if value != nil {
28973				switch jtv := value.(type) {
28974				case json.Number:
28975					f64, err := jtv.Float64()
28976					if err != nil {
28977						return err
28978					}
28979					sv.CurrentApplyDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
28980
28981				default:
28982					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
28983
28984				}
28985			}
28986
28987		case "description":
28988			if value != nil {
28989				jtv, ok := value.(string)
28990				if !ok {
28991					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28992				}
28993				sv.Description = ptr.String(jtv)
28994			}
28995
28996		default:
28997			_, _ = key, value
28998
28999		}
29000	}
29001	*v = sv
29002	return nil
29003}
29004
29005func awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(v *[]types.PendingMaintenanceAction, value interface{}) error {
29006	if v == nil {
29007		return fmt.Errorf("unexpected nil of type %T", v)
29008	}
29009	if value == nil {
29010		return nil
29011	}
29012
29013	shape, ok := value.([]interface{})
29014	if !ok {
29015		return fmt.Errorf("unexpected JSON type %v", value)
29016	}
29017
29018	var cv []types.PendingMaintenanceAction
29019	if *v == nil {
29020		cv = []types.PendingMaintenanceAction{}
29021	} else {
29022		cv = *v
29023	}
29024
29025	for _, value := range shape {
29026		var col types.PendingMaintenanceAction
29027		destAddr := &col
29028		if err := awsAwsjson11_deserializeDocumentPendingMaintenanceAction(&destAddr, value); err != nil {
29029			return err
29030		}
29031		col = *destAddr
29032		cv = append(cv, col)
29033
29034	}
29035	*v = cv
29036	return nil
29037}
29038
29039func awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(v **types.PendingModifiedRelationalDatabaseValues, value interface{}) error {
29040	if v == nil {
29041		return fmt.Errorf("unexpected nil of type %T", v)
29042	}
29043	if value == nil {
29044		return nil
29045	}
29046
29047	shape, ok := value.(map[string]interface{})
29048	if !ok {
29049		return fmt.Errorf("unexpected JSON type %v", value)
29050	}
29051
29052	var sv *types.PendingModifiedRelationalDatabaseValues
29053	if *v == nil {
29054		sv = &types.PendingModifiedRelationalDatabaseValues{}
29055	} else {
29056		sv = *v
29057	}
29058
29059	for key, value := range shape {
29060		switch key {
29061		case "backupRetentionEnabled":
29062			if value != nil {
29063				jtv, ok := value.(bool)
29064				if !ok {
29065					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29066				}
29067				sv.BackupRetentionEnabled = ptr.Bool(jtv)
29068			}
29069
29070		case "engineVersion":
29071			if value != nil {
29072				jtv, ok := value.(string)
29073				if !ok {
29074					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29075				}
29076				sv.EngineVersion = ptr.String(jtv)
29077			}
29078
29079		case "masterUserPassword":
29080			if value != nil {
29081				jtv, ok := value.(string)
29082				if !ok {
29083					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29084				}
29085				sv.MasterUserPassword = ptr.String(jtv)
29086			}
29087
29088		default:
29089			_, _ = key, value
29090
29091		}
29092	}
29093	*v = sv
29094	return nil
29095}
29096
29097func awsAwsjson11_deserializeDocumentPortList(v *[]int32, value interface{}) error {
29098	if v == nil {
29099		return fmt.Errorf("unexpected nil of type %T", v)
29100	}
29101	if value == nil {
29102		return nil
29103	}
29104
29105	shape, ok := value.([]interface{})
29106	if !ok {
29107		return fmt.Errorf("unexpected JSON type %v", value)
29108	}
29109
29110	var cv []int32
29111	if *v == nil {
29112		cv = []int32{}
29113	} else {
29114		cv = *v
29115	}
29116
29117	for _, value := range shape {
29118		var col int32
29119		if value != nil {
29120			jtv, ok := value.(json.Number)
29121			if !ok {
29122				return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
29123			}
29124			i64, err := jtv.Int64()
29125			if err != nil {
29126				return err
29127			}
29128			col = int32(i64)
29129		}
29130		cv = append(cv, col)
29131
29132	}
29133	*v = cv
29134	return nil
29135}
29136
29137func awsAwsjson11_deserializeDocumentPortMap(v *map[string]types.ContainerServiceProtocol, value interface{}) error {
29138	if v == nil {
29139		return fmt.Errorf("unexpected nil of type %T", v)
29140	}
29141	if value == nil {
29142		return nil
29143	}
29144
29145	shape, ok := value.(map[string]interface{})
29146	if !ok {
29147		return fmt.Errorf("unexpected JSON type %v", value)
29148	}
29149
29150	var mv map[string]types.ContainerServiceProtocol
29151	if *v == nil {
29152		mv = map[string]types.ContainerServiceProtocol{}
29153	} else {
29154		mv = *v
29155	}
29156
29157	for key, value := range shape {
29158		var parsedVal types.ContainerServiceProtocol
29159		if value != nil {
29160			jtv, ok := value.(string)
29161			if !ok {
29162				return fmt.Errorf("expected ContainerServiceProtocol to be of type string, got %T instead", value)
29163			}
29164			parsedVal = types.ContainerServiceProtocol(jtv)
29165		}
29166		mv[key] = parsedVal
29167
29168	}
29169	*v = mv
29170	return nil
29171}
29172
29173func awsAwsjson11_deserializeDocumentQueryStringObject(v **types.QueryStringObject, value interface{}) error {
29174	if v == nil {
29175		return fmt.Errorf("unexpected nil of type %T", v)
29176	}
29177	if value == nil {
29178		return nil
29179	}
29180
29181	shape, ok := value.(map[string]interface{})
29182	if !ok {
29183		return fmt.Errorf("unexpected JSON type %v", value)
29184	}
29185
29186	var sv *types.QueryStringObject
29187	if *v == nil {
29188		sv = &types.QueryStringObject{}
29189	} else {
29190		sv = *v
29191	}
29192
29193	for key, value := range shape {
29194		switch key {
29195		case "option":
29196			if value != nil {
29197				jtv, ok := value.(bool)
29198				if !ok {
29199					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29200				}
29201				sv.Option = ptr.Bool(jtv)
29202			}
29203
29204		case "queryStringsAllowList":
29205			if err := awsAwsjson11_deserializeDocumentStringList(&sv.QueryStringsAllowList, value); err != nil {
29206				return err
29207			}
29208
29209		default:
29210			_, _ = key, value
29211
29212		}
29213	}
29214	*v = sv
29215	return nil
29216}
29217
29218func awsAwsjson11_deserializeDocumentRegion(v **types.Region, value interface{}) error {
29219	if v == nil {
29220		return fmt.Errorf("unexpected nil of type %T", v)
29221	}
29222	if value == nil {
29223		return nil
29224	}
29225
29226	shape, ok := value.(map[string]interface{})
29227	if !ok {
29228		return fmt.Errorf("unexpected JSON type %v", value)
29229	}
29230
29231	var sv *types.Region
29232	if *v == nil {
29233		sv = &types.Region{}
29234	} else {
29235		sv = *v
29236	}
29237
29238	for key, value := range shape {
29239		switch key {
29240		case "availabilityZones":
29241			if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.AvailabilityZones, value); err != nil {
29242				return err
29243			}
29244
29245		case "continentCode":
29246			if value != nil {
29247				jtv, ok := value.(string)
29248				if !ok {
29249					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29250				}
29251				sv.ContinentCode = ptr.String(jtv)
29252			}
29253
29254		case "description":
29255			if value != nil {
29256				jtv, ok := value.(string)
29257				if !ok {
29258					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29259				}
29260				sv.Description = ptr.String(jtv)
29261			}
29262
29263		case "displayName":
29264			if value != nil {
29265				jtv, ok := value.(string)
29266				if !ok {
29267					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29268				}
29269				sv.DisplayName = ptr.String(jtv)
29270			}
29271
29272		case "name":
29273			if value != nil {
29274				jtv, ok := value.(string)
29275				if !ok {
29276					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
29277				}
29278				sv.Name = types.RegionName(jtv)
29279			}
29280
29281		case "relationalDatabaseAvailabilityZones":
29282			if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.RelationalDatabaseAvailabilityZones, value); err != nil {
29283				return err
29284			}
29285
29286		default:
29287			_, _ = key, value
29288
29289		}
29290	}
29291	*v = sv
29292	return nil
29293}
29294
29295func awsAwsjson11_deserializeDocumentRegionList(v *[]types.Region, value interface{}) error {
29296	if v == nil {
29297		return fmt.Errorf("unexpected nil of type %T", v)
29298	}
29299	if value == nil {
29300		return nil
29301	}
29302
29303	shape, ok := value.([]interface{})
29304	if !ok {
29305		return fmt.Errorf("unexpected JSON type %v", value)
29306	}
29307
29308	var cv []types.Region
29309	if *v == nil {
29310		cv = []types.Region{}
29311	} else {
29312		cv = *v
29313	}
29314
29315	for _, value := range shape {
29316		var col types.Region
29317		destAddr := &col
29318		if err := awsAwsjson11_deserializeDocumentRegion(&destAddr, value); err != nil {
29319			return err
29320		}
29321		col = *destAddr
29322		cv = append(cv, col)
29323
29324	}
29325	*v = cv
29326	return nil
29327}
29328
29329func awsAwsjson11_deserializeDocumentRelationalDatabase(v **types.RelationalDatabase, value interface{}) error {
29330	if v == nil {
29331		return fmt.Errorf("unexpected nil of type %T", v)
29332	}
29333	if value == nil {
29334		return nil
29335	}
29336
29337	shape, ok := value.(map[string]interface{})
29338	if !ok {
29339		return fmt.Errorf("unexpected JSON type %v", value)
29340	}
29341
29342	var sv *types.RelationalDatabase
29343	if *v == nil {
29344		sv = &types.RelationalDatabase{}
29345	} else {
29346		sv = *v
29347	}
29348
29349	for key, value := range shape {
29350		switch key {
29351		case "arn":
29352			if value != nil {
29353				jtv, ok := value.(string)
29354				if !ok {
29355					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29356				}
29357				sv.Arn = ptr.String(jtv)
29358			}
29359
29360		case "backupRetentionEnabled":
29361			if value != nil {
29362				jtv, ok := value.(bool)
29363				if !ok {
29364					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29365				}
29366				sv.BackupRetentionEnabled = ptr.Bool(jtv)
29367			}
29368
29369		case "caCertificateIdentifier":
29370			if value != nil {
29371				jtv, ok := value.(string)
29372				if !ok {
29373					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29374				}
29375				sv.CaCertificateIdentifier = ptr.String(jtv)
29376			}
29377
29378		case "createdAt":
29379			if value != nil {
29380				switch jtv := value.(type) {
29381				case json.Number:
29382					f64, err := jtv.Float64()
29383					if err != nil {
29384						return err
29385					}
29386					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29387
29388				default:
29389					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29390
29391				}
29392			}
29393
29394		case "engine":
29395			if value != nil {
29396				jtv, ok := value.(string)
29397				if !ok {
29398					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29399				}
29400				sv.Engine = ptr.String(jtv)
29401			}
29402
29403		case "engineVersion":
29404			if value != nil {
29405				jtv, ok := value.(string)
29406				if !ok {
29407					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29408				}
29409				sv.EngineVersion = ptr.String(jtv)
29410			}
29411
29412		case "hardware":
29413			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(&sv.Hardware, value); err != nil {
29414				return err
29415			}
29416
29417		case "latestRestorableTime":
29418			if value != nil {
29419				switch jtv := value.(type) {
29420				case json.Number:
29421					f64, err := jtv.Float64()
29422					if err != nil {
29423						return err
29424					}
29425					sv.LatestRestorableTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
29426
29427				default:
29428					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29429
29430				}
29431			}
29432
29433		case "location":
29434			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
29435				return err
29436			}
29437
29438		case "masterDatabaseName":
29439			if value != nil {
29440				jtv, ok := value.(string)
29441				if !ok {
29442					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29443				}
29444				sv.MasterDatabaseName = ptr.String(jtv)
29445			}
29446
29447		case "masterEndpoint":
29448			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(&sv.MasterEndpoint, value); err != nil {
29449				return err
29450			}
29451
29452		case "masterUsername":
29453			if value != nil {
29454				jtv, ok := value.(string)
29455				if !ok {
29456					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29457				}
29458				sv.MasterUsername = ptr.String(jtv)
29459			}
29460
29461		case "name":
29462			if value != nil {
29463				jtv, ok := value.(string)
29464				if !ok {
29465					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
29466				}
29467				sv.Name = ptr.String(jtv)
29468			}
29469
29470		case "parameterApplyStatus":
29471			if value != nil {
29472				jtv, ok := value.(string)
29473				if !ok {
29474					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29475				}
29476				sv.ParameterApplyStatus = ptr.String(jtv)
29477			}
29478
29479		case "pendingMaintenanceActions":
29480			if err := awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(&sv.PendingMaintenanceActions, value); err != nil {
29481				return err
29482			}
29483
29484		case "pendingModifiedValues":
29485			if err := awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(&sv.PendingModifiedValues, value); err != nil {
29486				return err
29487			}
29488
29489		case "preferredBackupWindow":
29490			if value != nil {
29491				jtv, ok := value.(string)
29492				if !ok {
29493					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29494				}
29495				sv.PreferredBackupWindow = ptr.String(jtv)
29496			}
29497
29498		case "preferredMaintenanceWindow":
29499			if value != nil {
29500				jtv, ok := value.(string)
29501				if !ok {
29502					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29503				}
29504				sv.PreferredMaintenanceWindow = ptr.String(jtv)
29505			}
29506
29507		case "publiclyAccessible":
29508			if value != nil {
29509				jtv, ok := value.(bool)
29510				if !ok {
29511					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29512				}
29513				sv.PubliclyAccessible = ptr.Bool(jtv)
29514			}
29515
29516		case "relationalDatabaseBlueprintId":
29517			if value != nil {
29518				jtv, ok := value.(string)
29519				if !ok {
29520					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29521				}
29522				sv.RelationalDatabaseBlueprintId = ptr.String(jtv)
29523			}
29524
29525		case "relationalDatabaseBundleId":
29526			if value != nil {
29527				jtv, ok := value.(string)
29528				if !ok {
29529					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29530				}
29531				sv.RelationalDatabaseBundleId = ptr.String(jtv)
29532			}
29533
29534		case "resourceType":
29535			if value != nil {
29536				jtv, ok := value.(string)
29537				if !ok {
29538					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
29539				}
29540				sv.ResourceType = types.ResourceType(jtv)
29541			}
29542
29543		case "secondaryAvailabilityZone":
29544			if value != nil {
29545				jtv, ok := value.(string)
29546				if !ok {
29547					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29548				}
29549				sv.SecondaryAvailabilityZone = ptr.String(jtv)
29550			}
29551
29552		case "state":
29553			if value != nil {
29554				jtv, ok := value.(string)
29555				if !ok {
29556					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29557				}
29558				sv.State = ptr.String(jtv)
29559			}
29560
29561		case "supportCode":
29562			if value != nil {
29563				jtv, ok := value.(string)
29564				if !ok {
29565					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29566				}
29567				sv.SupportCode = ptr.String(jtv)
29568			}
29569
29570		case "tags":
29571			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
29572				return err
29573			}
29574
29575		default:
29576			_, _ = key, value
29577
29578		}
29579	}
29580	*v = sv
29581	return nil
29582}
29583
29584func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(v **types.RelationalDatabaseBlueprint, value interface{}) error {
29585	if v == nil {
29586		return fmt.Errorf("unexpected nil of type %T", v)
29587	}
29588	if value == nil {
29589		return nil
29590	}
29591
29592	shape, ok := value.(map[string]interface{})
29593	if !ok {
29594		return fmt.Errorf("unexpected JSON type %v", value)
29595	}
29596
29597	var sv *types.RelationalDatabaseBlueprint
29598	if *v == nil {
29599		sv = &types.RelationalDatabaseBlueprint{}
29600	} else {
29601		sv = *v
29602	}
29603
29604	for key, value := range shape {
29605		switch key {
29606		case "blueprintId":
29607			if value != nil {
29608				jtv, ok := value.(string)
29609				if !ok {
29610					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29611				}
29612				sv.BlueprintId = ptr.String(jtv)
29613			}
29614
29615		case "engine":
29616			if value != nil {
29617				jtv, ok := value.(string)
29618				if !ok {
29619					return fmt.Errorf("expected RelationalDatabaseEngine to be of type string, got %T instead", value)
29620				}
29621				sv.Engine = types.RelationalDatabaseEngine(jtv)
29622			}
29623
29624		case "engineDescription":
29625			if value != nil {
29626				jtv, ok := value.(string)
29627				if !ok {
29628					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29629				}
29630				sv.EngineDescription = ptr.String(jtv)
29631			}
29632
29633		case "engineVersion":
29634			if value != nil {
29635				jtv, ok := value.(string)
29636				if !ok {
29637					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29638				}
29639				sv.EngineVersion = ptr.String(jtv)
29640			}
29641
29642		case "engineVersionDescription":
29643			if value != nil {
29644				jtv, ok := value.(string)
29645				if !ok {
29646					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29647				}
29648				sv.EngineVersionDescription = ptr.String(jtv)
29649			}
29650
29651		case "isEngineDefault":
29652			if value != nil {
29653				jtv, ok := value.(bool)
29654				if !ok {
29655					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29656				}
29657				sv.IsEngineDefault = ptr.Bool(jtv)
29658			}
29659
29660		default:
29661			_, _ = key, value
29662
29663		}
29664	}
29665	*v = sv
29666	return nil
29667}
29668
29669func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(v *[]types.RelationalDatabaseBlueprint, value interface{}) error {
29670	if v == nil {
29671		return fmt.Errorf("unexpected nil of type %T", v)
29672	}
29673	if value == nil {
29674		return nil
29675	}
29676
29677	shape, ok := value.([]interface{})
29678	if !ok {
29679		return fmt.Errorf("unexpected JSON type %v", value)
29680	}
29681
29682	var cv []types.RelationalDatabaseBlueprint
29683	if *v == nil {
29684		cv = []types.RelationalDatabaseBlueprint{}
29685	} else {
29686		cv = *v
29687	}
29688
29689	for _, value := range shape {
29690		var col types.RelationalDatabaseBlueprint
29691		destAddr := &col
29692		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(&destAddr, value); err != nil {
29693			return err
29694		}
29695		col = *destAddr
29696		cv = append(cv, col)
29697
29698	}
29699	*v = cv
29700	return nil
29701}
29702
29703func awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(v **types.RelationalDatabaseBundle, value interface{}) error {
29704	if v == nil {
29705		return fmt.Errorf("unexpected nil of type %T", v)
29706	}
29707	if value == nil {
29708		return nil
29709	}
29710
29711	shape, ok := value.(map[string]interface{})
29712	if !ok {
29713		return fmt.Errorf("unexpected JSON type %v", value)
29714	}
29715
29716	var sv *types.RelationalDatabaseBundle
29717	if *v == nil {
29718		sv = &types.RelationalDatabaseBundle{}
29719	} else {
29720		sv = *v
29721	}
29722
29723	for key, value := range shape {
29724		switch key {
29725		case "bundleId":
29726			if value != nil {
29727				jtv, ok := value.(string)
29728				if !ok {
29729					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29730				}
29731				sv.BundleId = ptr.String(jtv)
29732			}
29733
29734		case "cpuCount":
29735			if value != nil {
29736				jtv, ok := value.(json.Number)
29737				if !ok {
29738					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29739				}
29740				i64, err := jtv.Int64()
29741				if err != nil {
29742					return err
29743				}
29744				sv.CpuCount = ptr.Int32(int32(i64))
29745			}
29746
29747		case "diskSizeInGb":
29748			if value != nil {
29749				jtv, ok := value.(json.Number)
29750				if !ok {
29751					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29752				}
29753				i64, err := jtv.Int64()
29754				if err != nil {
29755					return err
29756				}
29757				sv.DiskSizeInGb = ptr.Int32(int32(i64))
29758			}
29759
29760		case "isActive":
29761			if value != nil {
29762				jtv, ok := value.(bool)
29763				if !ok {
29764					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29765				}
29766				sv.IsActive = ptr.Bool(jtv)
29767			}
29768
29769		case "isEncrypted":
29770			if value != nil {
29771				jtv, ok := value.(bool)
29772				if !ok {
29773					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
29774				}
29775				sv.IsEncrypted = ptr.Bool(jtv)
29776			}
29777
29778		case "name":
29779			if value != nil {
29780				jtv, ok := value.(string)
29781				if !ok {
29782					return fmt.Errorf("expected string to be of type string, got %T instead", value)
29783				}
29784				sv.Name = ptr.String(jtv)
29785			}
29786
29787		case "price":
29788			if value != nil {
29789				switch jtv := value.(type) {
29790				case json.Number:
29791					f64, err := jtv.Float64()
29792					if err != nil {
29793						return err
29794					}
29795					sv.Price = ptr.Float32(float32(f64))
29796
29797				case string:
29798					var f64 float64
29799					switch {
29800					case strings.EqualFold(jtv, "NaN"):
29801						f64 = math.NaN()
29802
29803					case strings.EqualFold(jtv, "Infinity"):
29804						f64 = math.Inf(1)
29805
29806					case strings.EqualFold(jtv, "-Infinity"):
29807						f64 = math.Inf(-1)
29808
29809					default:
29810						return fmt.Errorf("unknown JSON number value: %s", jtv)
29811
29812					}
29813					sv.Price = ptr.Float32(float32(f64))
29814
29815				default:
29816					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
29817
29818				}
29819			}
29820
29821		case "ramSizeInGb":
29822			if value != nil {
29823				switch jtv := value.(type) {
29824				case json.Number:
29825					f64, err := jtv.Float64()
29826					if err != nil {
29827						return err
29828					}
29829					sv.RamSizeInGb = ptr.Float32(float32(f64))
29830
29831				case string:
29832					var f64 float64
29833					switch {
29834					case strings.EqualFold(jtv, "NaN"):
29835						f64 = math.NaN()
29836
29837					case strings.EqualFold(jtv, "Infinity"):
29838						f64 = math.Inf(1)
29839
29840					case strings.EqualFold(jtv, "-Infinity"):
29841						f64 = math.Inf(-1)
29842
29843					default:
29844						return fmt.Errorf("unknown JSON number value: %s", jtv)
29845
29846					}
29847					sv.RamSizeInGb = ptr.Float32(float32(f64))
29848
29849				default:
29850					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
29851
29852				}
29853			}
29854
29855		case "transferPerMonthInGb":
29856			if value != nil {
29857				jtv, ok := value.(json.Number)
29858				if !ok {
29859					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29860				}
29861				i64, err := jtv.Int64()
29862				if err != nil {
29863					return err
29864				}
29865				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
29866			}
29867
29868		default:
29869			_, _ = key, value
29870
29871		}
29872	}
29873	*v = sv
29874	return nil
29875}
29876
29877func awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(v *[]types.RelationalDatabaseBundle, value interface{}) error {
29878	if v == nil {
29879		return fmt.Errorf("unexpected nil of type %T", v)
29880	}
29881	if value == nil {
29882		return nil
29883	}
29884
29885	shape, ok := value.([]interface{})
29886	if !ok {
29887		return fmt.Errorf("unexpected JSON type %v", value)
29888	}
29889
29890	var cv []types.RelationalDatabaseBundle
29891	if *v == nil {
29892		cv = []types.RelationalDatabaseBundle{}
29893	} else {
29894		cv = *v
29895	}
29896
29897	for _, value := range shape {
29898		var col types.RelationalDatabaseBundle
29899		destAddr := &col
29900		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(&destAddr, value); err != nil {
29901			return err
29902		}
29903		col = *destAddr
29904		cv = append(cv, col)
29905
29906	}
29907	*v = cv
29908	return nil
29909}
29910
29911func awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(v **types.RelationalDatabaseEndpoint, value interface{}) error {
29912	if v == nil {
29913		return fmt.Errorf("unexpected nil of type %T", v)
29914	}
29915	if value == nil {
29916		return nil
29917	}
29918
29919	shape, ok := value.(map[string]interface{})
29920	if !ok {
29921		return fmt.Errorf("unexpected JSON type %v", value)
29922	}
29923
29924	var sv *types.RelationalDatabaseEndpoint
29925	if *v == nil {
29926		sv = &types.RelationalDatabaseEndpoint{}
29927	} else {
29928		sv = *v
29929	}
29930
29931	for key, value := range shape {
29932		switch key {
29933		case "address":
29934			if value != nil {
29935				jtv, ok := value.(string)
29936				if !ok {
29937					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
29938				}
29939				sv.Address = ptr.String(jtv)
29940			}
29941
29942		case "port":
29943			if value != nil {
29944				jtv, ok := value.(json.Number)
29945				if !ok {
29946					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
29947				}
29948				i64, err := jtv.Int64()
29949				if err != nil {
29950					return err
29951				}
29952				sv.Port = ptr.Int32(int32(i64))
29953			}
29954
29955		default:
29956			_, _ = key, value
29957
29958		}
29959	}
29960	*v = sv
29961	return nil
29962}
29963
29964func awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(v **types.RelationalDatabaseEvent, value interface{}) error {
29965	if v == nil {
29966		return fmt.Errorf("unexpected nil of type %T", v)
29967	}
29968	if value == nil {
29969		return nil
29970	}
29971
29972	shape, ok := value.(map[string]interface{})
29973	if !ok {
29974		return fmt.Errorf("unexpected JSON type %v", value)
29975	}
29976
29977	var sv *types.RelationalDatabaseEvent
29978	if *v == nil {
29979		sv = &types.RelationalDatabaseEvent{}
29980	} else {
29981		sv = *v
29982	}
29983
29984	for key, value := range shape {
29985		switch key {
29986		case "createdAt":
29987			if value != nil {
29988				switch jtv := value.(type) {
29989				case json.Number:
29990					f64, err := jtv.Float64()
29991					if err != nil {
29992						return err
29993					}
29994					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
29995
29996				default:
29997					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
29998
29999				}
30000			}
30001
30002		case "eventCategories":
30003			if err := awsAwsjson11_deserializeDocumentStringList(&sv.EventCategories, value); err != nil {
30004				return err
30005			}
30006
30007		case "message":
30008			if value != nil {
30009				jtv, ok := value.(string)
30010				if !ok {
30011					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30012				}
30013				sv.Message = ptr.String(jtv)
30014			}
30015
30016		case "resource":
30017			if value != nil {
30018				jtv, ok := value.(string)
30019				if !ok {
30020					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30021				}
30022				sv.Resource = ptr.String(jtv)
30023			}
30024
30025		default:
30026			_, _ = key, value
30027
30028		}
30029	}
30030	*v = sv
30031	return nil
30032}
30033
30034func awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(v *[]types.RelationalDatabaseEvent, value interface{}) error {
30035	if v == nil {
30036		return fmt.Errorf("unexpected nil of type %T", v)
30037	}
30038	if value == nil {
30039		return nil
30040	}
30041
30042	shape, ok := value.([]interface{})
30043	if !ok {
30044		return fmt.Errorf("unexpected JSON type %v", value)
30045	}
30046
30047	var cv []types.RelationalDatabaseEvent
30048	if *v == nil {
30049		cv = []types.RelationalDatabaseEvent{}
30050	} else {
30051		cv = *v
30052	}
30053
30054	for _, value := range shape {
30055		var col types.RelationalDatabaseEvent
30056		destAddr := &col
30057		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(&destAddr, value); err != nil {
30058			return err
30059		}
30060		col = *destAddr
30061		cv = append(cv, col)
30062
30063	}
30064	*v = cv
30065	return nil
30066}
30067
30068func awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(v **types.RelationalDatabaseHardware, value interface{}) error {
30069	if v == nil {
30070		return fmt.Errorf("unexpected nil of type %T", v)
30071	}
30072	if value == nil {
30073		return nil
30074	}
30075
30076	shape, ok := value.(map[string]interface{})
30077	if !ok {
30078		return fmt.Errorf("unexpected JSON type %v", value)
30079	}
30080
30081	var sv *types.RelationalDatabaseHardware
30082	if *v == nil {
30083		sv = &types.RelationalDatabaseHardware{}
30084	} else {
30085		sv = *v
30086	}
30087
30088	for key, value := range shape {
30089		switch key {
30090		case "cpuCount":
30091			if value != nil {
30092				jtv, ok := value.(json.Number)
30093				if !ok {
30094					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
30095				}
30096				i64, err := jtv.Int64()
30097				if err != nil {
30098					return err
30099				}
30100				sv.CpuCount = ptr.Int32(int32(i64))
30101			}
30102
30103		case "diskSizeInGb":
30104			if value != nil {
30105				jtv, ok := value.(json.Number)
30106				if !ok {
30107					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
30108				}
30109				i64, err := jtv.Int64()
30110				if err != nil {
30111					return err
30112				}
30113				sv.DiskSizeInGb = ptr.Int32(int32(i64))
30114			}
30115
30116		case "ramSizeInGb":
30117			if value != nil {
30118				switch jtv := value.(type) {
30119				case json.Number:
30120					f64, err := jtv.Float64()
30121					if err != nil {
30122						return err
30123					}
30124					sv.RamSizeInGb = ptr.Float32(float32(f64))
30125
30126				case string:
30127					var f64 float64
30128					switch {
30129					case strings.EqualFold(jtv, "NaN"):
30130						f64 = math.NaN()
30131
30132					case strings.EqualFold(jtv, "Infinity"):
30133						f64 = math.Inf(1)
30134
30135					case strings.EqualFold(jtv, "-Infinity"):
30136						f64 = math.Inf(-1)
30137
30138					default:
30139						return fmt.Errorf("unknown JSON number value: %s", jtv)
30140
30141					}
30142					sv.RamSizeInGb = ptr.Float32(float32(f64))
30143
30144				default:
30145					return fmt.Errorf("expected float to be a JSON Number, got %T instead", value)
30146
30147				}
30148			}
30149
30150		default:
30151			_, _ = key, value
30152
30153		}
30154	}
30155	*v = sv
30156	return nil
30157}
30158
30159func awsAwsjson11_deserializeDocumentRelationalDatabaseList(v *[]types.RelationalDatabase, value interface{}) error {
30160	if v == nil {
30161		return fmt.Errorf("unexpected nil of type %T", v)
30162	}
30163	if value == nil {
30164		return nil
30165	}
30166
30167	shape, ok := value.([]interface{})
30168	if !ok {
30169		return fmt.Errorf("unexpected JSON type %v", value)
30170	}
30171
30172	var cv []types.RelationalDatabase
30173	if *v == nil {
30174		cv = []types.RelationalDatabase{}
30175	} else {
30176		cv = *v
30177	}
30178
30179	for _, value := range shape {
30180		var col types.RelationalDatabase
30181		destAddr := &col
30182		if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&destAddr, value); err != nil {
30183			return err
30184		}
30185		col = *destAddr
30186		cv = append(cv, col)
30187
30188	}
30189	*v = cv
30190	return nil
30191}
30192
30193func awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(v **types.RelationalDatabaseParameter, value interface{}) error {
30194	if v == nil {
30195		return fmt.Errorf("unexpected nil of type %T", v)
30196	}
30197	if value == nil {
30198		return nil
30199	}
30200
30201	shape, ok := value.(map[string]interface{})
30202	if !ok {
30203		return fmt.Errorf("unexpected JSON type %v", value)
30204	}
30205
30206	var sv *types.RelationalDatabaseParameter
30207	if *v == nil {
30208		sv = &types.RelationalDatabaseParameter{}
30209	} else {
30210		sv = *v
30211	}
30212
30213	for key, value := range shape {
30214		switch key {
30215		case "allowedValues":
30216			if value != nil {
30217				jtv, ok := value.(string)
30218				if !ok {
30219					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30220				}
30221				sv.AllowedValues = ptr.String(jtv)
30222			}
30223
30224		case "applyMethod":
30225			if value != nil {
30226				jtv, ok := value.(string)
30227				if !ok {
30228					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30229				}
30230				sv.ApplyMethod = ptr.String(jtv)
30231			}
30232
30233		case "applyType":
30234			if value != nil {
30235				jtv, ok := value.(string)
30236				if !ok {
30237					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30238				}
30239				sv.ApplyType = ptr.String(jtv)
30240			}
30241
30242		case "dataType":
30243			if value != nil {
30244				jtv, ok := value.(string)
30245				if !ok {
30246					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30247				}
30248				sv.DataType = ptr.String(jtv)
30249			}
30250
30251		case "description":
30252			if value != nil {
30253				jtv, ok := value.(string)
30254				if !ok {
30255					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30256				}
30257				sv.Description = ptr.String(jtv)
30258			}
30259
30260		case "isModifiable":
30261			if value != nil {
30262				jtv, ok := value.(bool)
30263				if !ok {
30264					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
30265				}
30266				sv.IsModifiable = ptr.Bool(jtv)
30267			}
30268
30269		case "parameterName":
30270			if value != nil {
30271				jtv, ok := value.(string)
30272				if !ok {
30273					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30274				}
30275				sv.ParameterName = ptr.String(jtv)
30276			}
30277
30278		case "parameterValue":
30279			if value != nil {
30280				jtv, ok := value.(string)
30281				if !ok {
30282					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30283				}
30284				sv.ParameterValue = ptr.String(jtv)
30285			}
30286
30287		default:
30288			_, _ = key, value
30289
30290		}
30291	}
30292	*v = sv
30293	return nil
30294}
30295
30296func awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(v *[]types.RelationalDatabaseParameter, value interface{}) error {
30297	if v == nil {
30298		return fmt.Errorf("unexpected nil of type %T", v)
30299	}
30300	if value == nil {
30301		return nil
30302	}
30303
30304	shape, ok := value.([]interface{})
30305	if !ok {
30306		return fmt.Errorf("unexpected JSON type %v", value)
30307	}
30308
30309	var cv []types.RelationalDatabaseParameter
30310	if *v == nil {
30311		cv = []types.RelationalDatabaseParameter{}
30312	} else {
30313		cv = *v
30314	}
30315
30316	for _, value := range shape {
30317		var col types.RelationalDatabaseParameter
30318		destAddr := &col
30319		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(&destAddr, value); err != nil {
30320			return err
30321		}
30322		col = *destAddr
30323		cv = append(cv, col)
30324
30325	}
30326	*v = cv
30327	return nil
30328}
30329
30330func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(v **types.RelationalDatabaseSnapshot, value interface{}) error {
30331	if v == nil {
30332		return fmt.Errorf("unexpected nil of type %T", v)
30333	}
30334	if value == nil {
30335		return nil
30336	}
30337
30338	shape, ok := value.(map[string]interface{})
30339	if !ok {
30340		return fmt.Errorf("unexpected JSON type %v", value)
30341	}
30342
30343	var sv *types.RelationalDatabaseSnapshot
30344	if *v == nil {
30345		sv = &types.RelationalDatabaseSnapshot{}
30346	} else {
30347		sv = *v
30348	}
30349
30350	for key, value := range shape {
30351		switch key {
30352		case "arn":
30353			if value != nil {
30354				jtv, ok := value.(string)
30355				if !ok {
30356					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30357				}
30358				sv.Arn = ptr.String(jtv)
30359			}
30360
30361		case "createdAt":
30362			if value != nil {
30363				switch jtv := value.(type) {
30364				case json.Number:
30365					f64, err := jtv.Float64()
30366					if err != nil {
30367						return err
30368					}
30369					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
30370
30371				default:
30372					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
30373
30374				}
30375			}
30376
30377		case "engine":
30378			if value != nil {
30379				jtv, ok := value.(string)
30380				if !ok {
30381					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30382				}
30383				sv.Engine = ptr.String(jtv)
30384			}
30385
30386		case "engineVersion":
30387			if value != nil {
30388				jtv, ok := value.(string)
30389				if !ok {
30390					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30391				}
30392				sv.EngineVersion = ptr.String(jtv)
30393			}
30394
30395		case "fromRelationalDatabaseArn":
30396			if value != nil {
30397				jtv, ok := value.(string)
30398				if !ok {
30399					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30400				}
30401				sv.FromRelationalDatabaseArn = ptr.String(jtv)
30402			}
30403
30404		case "fromRelationalDatabaseBlueprintId":
30405			if value != nil {
30406				jtv, ok := value.(string)
30407				if !ok {
30408					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30409				}
30410				sv.FromRelationalDatabaseBlueprintId = ptr.String(jtv)
30411			}
30412
30413		case "fromRelationalDatabaseBundleId":
30414			if value != nil {
30415				jtv, ok := value.(string)
30416				if !ok {
30417					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30418				}
30419				sv.FromRelationalDatabaseBundleId = ptr.String(jtv)
30420			}
30421
30422		case "fromRelationalDatabaseName":
30423			if value != nil {
30424				jtv, ok := value.(string)
30425				if !ok {
30426					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30427				}
30428				sv.FromRelationalDatabaseName = ptr.String(jtv)
30429			}
30430
30431		case "location":
30432			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
30433				return err
30434			}
30435
30436		case "name":
30437			if value != nil {
30438				jtv, ok := value.(string)
30439				if !ok {
30440					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30441				}
30442				sv.Name = ptr.String(jtv)
30443			}
30444
30445		case "resourceType":
30446			if value != nil {
30447				jtv, ok := value.(string)
30448				if !ok {
30449					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
30450				}
30451				sv.ResourceType = types.ResourceType(jtv)
30452			}
30453
30454		case "sizeInGb":
30455			if value != nil {
30456				jtv, ok := value.(json.Number)
30457				if !ok {
30458					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
30459				}
30460				i64, err := jtv.Int64()
30461				if err != nil {
30462					return err
30463				}
30464				sv.SizeInGb = ptr.Int32(int32(i64))
30465			}
30466
30467		case "state":
30468			if value != nil {
30469				jtv, ok := value.(string)
30470				if !ok {
30471					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30472				}
30473				sv.State = ptr.String(jtv)
30474			}
30475
30476		case "supportCode":
30477			if value != nil {
30478				jtv, ok := value.(string)
30479				if !ok {
30480					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30481				}
30482				sv.SupportCode = ptr.String(jtv)
30483			}
30484
30485		case "tags":
30486			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
30487				return err
30488			}
30489
30490		default:
30491			_, _ = key, value
30492
30493		}
30494	}
30495	*v = sv
30496	return nil
30497}
30498
30499func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(v *[]types.RelationalDatabaseSnapshot, value interface{}) error {
30500	if v == nil {
30501		return fmt.Errorf("unexpected nil of type %T", v)
30502	}
30503	if value == nil {
30504		return nil
30505	}
30506
30507	shape, ok := value.([]interface{})
30508	if !ok {
30509		return fmt.Errorf("unexpected JSON type %v", value)
30510	}
30511
30512	var cv []types.RelationalDatabaseSnapshot
30513	if *v == nil {
30514		cv = []types.RelationalDatabaseSnapshot{}
30515	} else {
30516		cv = *v
30517	}
30518
30519	for _, value := range shape {
30520		var col types.RelationalDatabaseSnapshot
30521		destAddr := &col
30522		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&destAddr, value); err != nil {
30523			return err
30524		}
30525		col = *destAddr
30526		cv = append(cv, col)
30527
30528	}
30529	*v = cv
30530	return nil
30531}
30532
30533func awsAwsjson11_deserializeDocumentRenewalSummary(v **types.RenewalSummary, value interface{}) error {
30534	if v == nil {
30535		return fmt.Errorf("unexpected nil of type %T", v)
30536	}
30537	if value == nil {
30538		return nil
30539	}
30540
30541	shape, ok := value.(map[string]interface{})
30542	if !ok {
30543		return fmt.Errorf("unexpected JSON type %v", value)
30544	}
30545
30546	var sv *types.RenewalSummary
30547	if *v == nil {
30548		sv = &types.RenewalSummary{}
30549	} else {
30550		sv = *v
30551	}
30552
30553	for key, value := range shape {
30554		switch key {
30555		case "domainValidationRecords":
30556			if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
30557				return err
30558			}
30559
30560		case "renewalStatus":
30561			if value != nil {
30562				jtv, ok := value.(string)
30563				if !ok {
30564					return fmt.Errorf("expected RenewalStatus to be of type string, got %T instead", value)
30565				}
30566				sv.RenewalStatus = types.RenewalStatus(jtv)
30567			}
30568
30569		case "renewalStatusReason":
30570			if value != nil {
30571				jtv, ok := value.(string)
30572				if !ok {
30573					return fmt.Errorf("expected RenewalStatusReason to be of type string, got %T instead", value)
30574				}
30575				sv.RenewalStatusReason = ptr.String(jtv)
30576			}
30577
30578		case "updatedAt":
30579			if value != nil {
30580				switch jtv := value.(type) {
30581				case json.Number:
30582					f64, err := jtv.Float64()
30583					if err != nil {
30584						return err
30585					}
30586					sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
30587
30588				default:
30589					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
30590
30591				}
30592			}
30593
30594		default:
30595			_, _ = key, value
30596
30597		}
30598	}
30599	*v = sv
30600	return nil
30601}
30602
30603func awsAwsjson11_deserializeDocumentResourceLocation(v **types.ResourceLocation, value interface{}) error {
30604	if v == nil {
30605		return fmt.Errorf("unexpected nil of type %T", v)
30606	}
30607	if value == nil {
30608		return nil
30609	}
30610
30611	shape, ok := value.(map[string]interface{})
30612	if !ok {
30613		return fmt.Errorf("unexpected JSON type %v", value)
30614	}
30615
30616	var sv *types.ResourceLocation
30617	if *v == nil {
30618		sv = &types.ResourceLocation{}
30619	} else {
30620		sv = *v
30621	}
30622
30623	for key, value := range shape {
30624		switch key {
30625		case "availabilityZone":
30626			if value != nil {
30627				jtv, ok := value.(string)
30628				if !ok {
30629					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30630				}
30631				sv.AvailabilityZone = ptr.String(jtv)
30632			}
30633
30634		case "regionName":
30635			if value != nil {
30636				jtv, ok := value.(string)
30637				if !ok {
30638					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
30639				}
30640				sv.RegionName = types.RegionName(jtv)
30641			}
30642
30643		default:
30644			_, _ = key, value
30645
30646		}
30647	}
30648	*v = sv
30649	return nil
30650}
30651
30652func awsAwsjson11_deserializeDocumentResourceReceivingAccess(v **types.ResourceReceivingAccess, value interface{}) error {
30653	if v == nil {
30654		return fmt.Errorf("unexpected nil of type %T", v)
30655	}
30656	if value == nil {
30657		return nil
30658	}
30659
30660	shape, ok := value.(map[string]interface{})
30661	if !ok {
30662		return fmt.Errorf("unexpected JSON type %v", value)
30663	}
30664
30665	var sv *types.ResourceReceivingAccess
30666	if *v == nil {
30667		sv = &types.ResourceReceivingAccess{}
30668	} else {
30669		sv = *v
30670	}
30671
30672	for key, value := range shape {
30673		switch key {
30674		case "name":
30675			if value != nil {
30676				jtv, ok := value.(string)
30677				if !ok {
30678					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30679				}
30680				sv.Name = ptr.String(jtv)
30681			}
30682
30683		case "resourceType":
30684			if value != nil {
30685				jtv, ok := value.(string)
30686				if !ok {
30687					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30688				}
30689				sv.ResourceType = ptr.String(jtv)
30690			}
30691
30692		default:
30693			_, _ = key, value
30694
30695		}
30696	}
30697	*v = sv
30698	return nil
30699}
30700
30701func awsAwsjson11_deserializeDocumentResourceRecord(v **types.ResourceRecord, value interface{}) error {
30702	if v == nil {
30703		return fmt.Errorf("unexpected nil of type %T", v)
30704	}
30705	if value == nil {
30706		return nil
30707	}
30708
30709	shape, ok := value.(map[string]interface{})
30710	if !ok {
30711		return fmt.Errorf("unexpected JSON type %v", value)
30712	}
30713
30714	var sv *types.ResourceRecord
30715	if *v == nil {
30716		sv = &types.ResourceRecord{}
30717	} else {
30718		sv = *v
30719	}
30720
30721	for key, value := range shape {
30722		switch key {
30723		case "name":
30724			if value != nil {
30725				jtv, ok := value.(string)
30726				if !ok {
30727					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30728				}
30729				sv.Name = ptr.String(jtv)
30730			}
30731
30732		case "type":
30733			if value != nil {
30734				jtv, ok := value.(string)
30735				if !ok {
30736					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30737				}
30738				sv.Type = ptr.String(jtv)
30739			}
30740
30741		case "value":
30742			if value != nil {
30743				jtv, ok := value.(string)
30744				if !ok {
30745					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30746				}
30747				sv.Value = ptr.String(jtv)
30748			}
30749
30750		default:
30751			_, _ = key, value
30752
30753		}
30754	}
30755	*v = sv
30756	return nil
30757}
30758
30759func awsAwsjson11_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error {
30760	if v == nil {
30761		return fmt.Errorf("unexpected nil of type %T", v)
30762	}
30763	if value == nil {
30764		return nil
30765	}
30766
30767	shape, ok := value.(map[string]interface{})
30768	if !ok {
30769		return fmt.Errorf("unexpected JSON type %v", value)
30770	}
30771
30772	var sv *types.ServiceException
30773	if *v == nil {
30774		sv = &types.ServiceException{}
30775	} else {
30776		sv = *v
30777	}
30778
30779	for key, value := range shape {
30780		switch key {
30781		case "code":
30782			if value != nil {
30783				jtv, ok := value.(string)
30784				if !ok {
30785					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30786				}
30787				sv.Code = ptr.String(jtv)
30788			}
30789
30790		case "docs":
30791			if value != nil {
30792				jtv, ok := value.(string)
30793				if !ok {
30794					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30795				}
30796				sv.Docs = ptr.String(jtv)
30797			}
30798
30799		case "message":
30800			if value != nil {
30801				jtv, ok := value.(string)
30802				if !ok {
30803					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30804				}
30805				sv.Message = ptr.String(jtv)
30806			}
30807
30808		case "tip":
30809			if value != nil {
30810				jtv, ok := value.(string)
30811				if !ok {
30812					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30813				}
30814				sv.Tip = ptr.String(jtv)
30815			}
30816
30817		default:
30818			_, _ = key, value
30819
30820		}
30821	}
30822	*v = sv
30823	return nil
30824}
30825
30826func awsAwsjson11_deserializeDocumentStaticIp(v **types.StaticIp, value interface{}) error {
30827	if v == nil {
30828		return fmt.Errorf("unexpected nil of type %T", v)
30829	}
30830	if value == nil {
30831		return nil
30832	}
30833
30834	shape, ok := value.(map[string]interface{})
30835	if !ok {
30836		return fmt.Errorf("unexpected JSON type %v", value)
30837	}
30838
30839	var sv *types.StaticIp
30840	if *v == nil {
30841		sv = &types.StaticIp{}
30842	} else {
30843		sv = *v
30844	}
30845
30846	for key, value := range shape {
30847		switch key {
30848		case "arn":
30849			if value != nil {
30850				jtv, ok := value.(string)
30851				if !ok {
30852					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
30853				}
30854				sv.Arn = ptr.String(jtv)
30855			}
30856
30857		case "attachedTo":
30858			if value != nil {
30859				jtv, ok := value.(string)
30860				if !ok {
30861					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30862				}
30863				sv.AttachedTo = ptr.String(jtv)
30864			}
30865
30866		case "createdAt":
30867			if value != nil {
30868				switch jtv := value.(type) {
30869				case json.Number:
30870					f64, err := jtv.Float64()
30871					if err != nil {
30872						return err
30873					}
30874					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
30875
30876				default:
30877					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
30878
30879				}
30880			}
30881
30882		case "ipAddress":
30883			if value != nil {
30884				jtv, ok := value.(string)
30885				if !ok {
30886					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
30887				}
30888				sv.IpAddress = ptr.String(jtv)
30889			}
30890
30891		case "isAttached":
30892			if value != nil {
30893				jtv, ok := value.(bool)
30894				if !ok {
30895					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
30896				}
30897				sv.IsAttached = ptr.Bool(jtv)
30898			}
30899
30900		case "location":
30901			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
30902				return err
30903			}
30904
30905		case "name":
30906			if value != nil {
30907				jtv, ok := value.(string)
30908				if !ok {
30909					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30910				}
30911				sv.Name = ptr.String(jtv)
30912			}
30913
30914		case "resourceType":
30915			if value != nil {
30916				jtv, ok := value.(string)
30917				if !ok {
30918					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
30919				}
30920				sv.ResourceType = types.ResourceType(jtv)
30921			}
30922
30923		case "supportCode":
30924			if value != nil {
30925				jtv, ok := value.(string)
30926				if !ok {
30927					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30928				}
30929				sv.SupportCode = ptr.String(jtv)
30930			}
30931
30932		default:
30933			_, _ = key, value
30934
30935		}
30936	}
30937	*v = sv
30938	return nil
30939}
30940
30941func awsAwsjson11_deserializeDocumentStaticIpList(v *[]types.StaticIp, value interface{}) error {
30942	if v == nil {
30943		return fmt.Errorf("unexpected nil of type %T", v)
30944	}
30945	if value == nil {
30946		return nil
30947	}
30948
30949	shape, ok := value.([]interface{})
30950	if !ok {
30951		return fmt.Errorf("unexpected JSON type %v", value)
30952	}
30953
30954	var cv []types.StaticIp
30955	if *v == nil {
30956		cv = []types.StaticIp{}
30957	} else {
30958		cv = *v
30959	}
30960
30961	for _, value := range shape {
30962		var col types.StaticIp
30963		destAddr := &col
30964		if err := awsAwsjson11_deserializeDocumentStaticIp(&destAddr, value); err != nil {
30965			return err
30966		}
30967		col = *destAddr
30968		cv = append(cv, col)
30969
30970	}
30971	*v = cv
30972	return nil
30973}
30974
30975func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error {
30976	if v == nil {
30977		return fmt.Errorf("unexpected nil of type %T", v)
30978	}
30979	if value == nil {
30980		return nil
30981	}
30982
30983	shape, ok := value.([]interface{})
30984	if !ok {
30985		return fmt.Errorf("unexpected JSON type %v", value)
30986	}
30987
30988	var cv []string
30989	if *v == nil {
30990		cv = []string{}
30991	} else {
30992		cv = *v
30993	}
30994
30995	for _, value := range shape {
30996		var col string
30997		if value != nil {
30998			jtv, ok := value.(string)
30999			if !ok {
31000				return fmt.Errorf("expected string to be of type string, got %T instead", value)
31001			}
31002			col = jtv
31003		}
31004		cv = append(cv, col)
31005
31006	}
31007	*v = cv
31008	return nil
31009}
31010
31011func awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(v *[]string, value interface{}) error {
31012	if v == nil {
31013		return fmt.Errorf("unexpected nil of type %T", v)
31014	}
31015	if value == nil {
31016		return nil
31017	}
31018
31019	shape, ok := value.([]interface{})
31020	if !ok {
31021		return fmt.Errorf("unexpected JSON type %v", value)
31022	}
31023
31024	var cv []string
31025	if *v == nil {
31026		cv = []string{}
31027	} else {
31028		cv = *v
31029	}
31030
31031	for _, value := range shape {
31032		var col string
31033		if value != nil {
31034			jtv, ok := value.(string)
31035			if !ok {
31036				return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
31037			}
31038			col = jtv
31039		}
31040		cv = append(cv, col)
31041
31042	}
31043	*v = cv
31044	return nil
31045}
31046
31047func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
31048	if v == nil {
31049		return fmt.Errorf("unexpected nil of type %T", v)
31050	}
31051	if value == nil {
31052		return nil
31053	}
31054
31055	shape, ok := value.(map[string]interface{})
31056	if !ok {
31057		return fmt.Errorf("unexpected JSON type %v", value)
31058	}
31059
31060	var sv *types.Tag
31061	if *v == nil {
31062		sv = &types.Tag{}
31063	} else {
31064		sv = *v
31065	}
31066
31067	for key, value := range shape {
31068		switch key {
31069		case "key":
31070			if value != nil {
31071				jtv, ok := value.(string)
31072				if !ok {
31073					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
31074				}
31075				sv.Key = ptr.String(jtv)
31076			}
31077
31078		case "value":
31079			if value != nil {
31080				jtv, ok := value.(string)
31081				if !ok {
31082					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
31083				}
31084				sv.Value = ptr.String(jtv)
31085			}
31086
31087		default:
31088			_, _ = key, value
31089
31090		}
31091	}
31092	*v = sv
31093	return nil
31094}
31095
31096func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
31097	if v == nil {
31098		return fmt.Errorf("unexpected nil of type %T", v)
31099	}
31100	if value == nil {
31101		return nil
31102	}
31103
31104	shape, ok := value.([]interface{})
31105	if !ok {
31106		return fmt.Errorf("unexpected JSON type %v", value)
31107	}
31108
31109	var cv []types.Tag
31110	if *v == nil {
31111		cv = []types.Tag{}
31112	} else {
31113		cv = *v
31114	}
31115
31116	for _, value := range shape {
31117		var col types.Tag
31118		destAddr := &col
31119		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
31120			return err
31121		}
31122		col = *destAddr
31123		cv = append(cv, col)
31124
31125	}
31126	*v = cv
31127	return nil
31128}
31129
31130func awsAwsjson11_deserializeDocumentUnauthenticatedException(v **types.UnauthenticatedException, value interface{}) error {
31131	if v == nil {
31132		return fmt.Errorf("unexpected nil of type %T", v)
31133	}
31134	if value == nil {
31135		return nil
31136	}
31137
31138	shape, ok := value.(map[string]interface{})
31139	if !ok {
31140		return fmt.Errorf("unexpected JSON type %v", value)
31141	}
31142
31143	var sv *types.UnauthenticatedException
31144	if *v == nil {
31145		sv = &types.UnauthenticatedException{}
31146	} else {
31147		sv = *v
31148	}
31149
31150	for key, value := range shape {
31151		switch key {
31152		case "code":
31153			if value != nil {
31154				jtv, ok := value.(string)
31155				if !ok {
31156					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31157				}
31158				sv.Code = ptr.String(jtv)
31159			}
31160
31161		case "docs":
31162			if value != nil {
31163				jtv, ok := value.(string)
31164				if !ok {
31165					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31166				}
31167				sv.Docs = ptr.String(jtv)
31168			}
31169
31170		case "message":
31171			if value != nil {
31172				jtv, ok := value.(string)
31173				if !ok {
31174					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31175				}
31176				sv.Message = ptr.String(jtv)
31177			}
31178
31179		case "tip":
31180			if value != nil {
31181				jtv, ok := value.(string)
31182				if !ok {
31183					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31184				}
31185				sv.Tip = ptr.String(jtv)
31186			}
31187
31188		default:
31189			_, _ = key, value
31190
31191		}
31192	}
31193	*v = sv
31194	return nil
31195}
31196
31197func awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(v **AllocateStaticIpOutput, value interface{}) error {
31198	if v == nil {
31199		return fmt.Errorf("unexpected nil of type %T", v)
31200	}
31201	if value == nil {
31202		return nil
31203	}
31204
31205	shape, ok := value.(map[string]interface{})
31206	if !ok {
31207		return fmt.Errorf("unexpected JSON type %v", value)
31208	}
31209
31210	var sv *AllocateStaticIpOutput
31211	if *v == nil {
31212		sv = &AllocateStaticIpOutput{}
31213	} else {
31214		sv = *v
31215	}
31216
31217	for key, value := range shape {
31218		switch key {
31219		case "operations":
31220			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31221				return err
31222			}
31223
31224		default:
31225			_, _ = key, value
31226
31227		}
31228	}
31229	*v = sv
31230	return nil
31231}
31232
31233func awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(v **AttachCertificateToDistributionOutput, value interface{}) error {
31234	if v == nil {
31235		return fmt.Errorf("unexpected nil of type %T", v)
31236	}
31237	if value == nil {
31238		return nil
31239	}
31240
31241	shape, ok := value.(map[string]interface{})
31242	if !ok {
31243		return fmt.Errorf("unexpected JSON type %v", value)
31244	}
31245
31246	var sv *AttachCertificateToDistributionOutput
31247	if *v == nil {
31248		sv = &AttachCertificateToDistributionOutput{}
31249	} else {
31250		sv = *v
31251	}
31252
31253	for key, value := range shape {
31254		switch key {
31255		case "operation":
31256			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
31257				return err
31258			}
31259
31260		default:
31261			_, _ = key, value
31262
31263		}
31264	}
31265	*v = sv
31266	return nil
31267}
31268
31269func awsAwsjson11_deserializeOpDocumentAttachDiskOutput(v **AttachDiskOutput, value interface{}) error {
31270	if v == nil {
31271		return fmt.Errorf("unexpected nil of type %T", v)
31272	}
31273	if value == nil {
31274		return nil
31275	}
31276
31277	shape, ok := value.(map[string]interface{})
31278	if !ok {
31279		return fmt.Errorf("unexpected JSON type %v", value)
31280	}
31281
31282	var sv *AttachDiskOutput
31283	if *v == nil {
31284		sv = &AttachDiskOutput{}
31285	} else {
31286		sv = *v
31287	}
31288
31289	for key, value := range shape {
31290		switch key {
31291		case "operations":
31292			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31293				return err
31294			}
31295
31296		default:
31297			_, _ = key, value
31298
31299		}
31300	}
31301	*v = sv
31302	return nil
31303}
31304
31305func awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(v **AttachInstancesToLoadBalancerOutput, value interface{}) error {
31306	if v == nil {
31307		return fmt.Errorf("unexpected nil of type %T", v)
31308	}
31309	if value == nil {
31310		return nil
31311	}
31312
31313	shape, ok := value.(map[string]interface{})
31314	if !ok {
31315		return fmt.Errorf("unexpected JSON type %v", value)
31316	}
31317
31318	var sv *AttachInstancesToLoadBalancerOutput
31319	if *v == nil {
31320		sv = &AttachInstancesToLoadBalancerOutput{}
31321	} else {
31322		sv = *v
31323	}
31324
31325	for key, value := range shape {
31326		switch key {
31327		case "operations":
31328			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31329				return err
31330			}
31331
31332		default:
31333			_, _ = key, value
31334
31335		}
31336	}
31337	*v = sv
31338	return nil
31339}
31340
31341func awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(v **AttachLoadBalancerTlsCertificateOutput, value interface{}) error {
31342	if v == nil {
31343		return fmt.Errorf("unexpected nil of type %T", v)
31344	}
31345	if value == nil {
31346		return nil
31347	}
31348
31349	shape, ok := value.(map[string]interface{})
31350	if !ok {
31351		return fmt.Errorf("unexpected JSON type %v", value)
31352	}
31353
31354	var sv *AttachLoadBalancerTlsCertificateOutput
31355	if *v == nil {
31356		sv = &AttachLoadBalancerTlsCertificateOutput{}
31357	} else {
31358		sv = *v
31359	}
31360
31361	for key, value := range shape {
31362		switch key {
31363		case "operations":
31364			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31365				return err
31366			}
31367
31368		default:
31369			_, _ = key, value
31370
31371		}
31372	}
31373	*v = sv
31374	return nil
31375}
31376
31377func awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(v **AttachStaticIpOutput, value interface{}) error {
31378	if v == nil {
31379		return fmt.Errorf("unexpected nil of type %T", v)
31380	}
31381	if value == nil {
31382		return nil
31383	}
31384
31385	shape, ok := value.(map[string]interface{})
31386	if !ok {
31387		return fmt.Errorf("unexpected JSON type %v", value)
31388	}
31389
31390	var sv *AttachStaticIpOutput
31391	if *v == nil {
31392		sv = &AttachStaticIpOutput{}
31393	} else {
31394		sv = *v
31395	}
31396
31397	for key, value := range shape {
31398		switch key {
31399		case "operations":
31400			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31401				return err
31402			}
31403
31404		default:
31405			_, _ = key, value
31406
31407		}
31408	}
31409	*v = sv
31410	return nil
31411}
31412
31413func awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(v **CloseInstancePublicPortsOutput, value interface{}) error {
31414	if v == nil {
31415		return fmt.Errorf("unexpected nil of type %T", v)
31416	}
31417	if value == nil {
31418		return nil
31419	}
31420
31421	shape, ok := value.(map[string]interface{})
31422	if !ok {
31423		return fmt.Errorf("unexpected JSON type %v", value)
31424	}
31425
31426	var sv *CloseInstancePublicPortsOutput
31427	if *v == nil {
31428		sv = &CloseInstancePublicPortsOutput{}
31429	} else {
31430		sv = *v
31431	}
31432
31433	for key, value := range shape {
31434		switch key {
31435		case "operation":
31436			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
31437				return err
31438			}
31439
31440		default:
31441			_, _ = key, value
31442
31443		}
31444	}
31445	*v = sv
31446	return nil
31447}
31448
31449func awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(v **CopySnapshotOutput, value interface{}) error {
31450	if v == nil {
31451		return fmt.Errorf("unexpected nil of type %T", v)
31452	}
31453	if value == nil {
31454		return nil
31455	}
31456
31457	shape, ok := value.(map[string]interface{})
31458	if !ok {
31459		return fmt.Errorf("unexpected JSON type %v", value)
31460	}
31461
31462	var sv *CopySnapshotOutput
31463	if *v == nil {
31464		sv = &CopySnapshotOutput{}
31465	} else {
31466		sv = *v
31467	}
31468
31469	for key, value := range shape {
31470		switch key {
31471		case "operations":
31472			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31473				return err
31474			}
31475
31476		default:
31477			_, _ = key, value
31478
31479		}
31480	}
31481	*v = sv
31482	return nil
31483}
31484
31485func awsAwsjson11_deserializeOpDocumentCreateBucketAccessKeyOutput(v **CreateBucketAccessKeyOutput, value interface{}) error {
31486	if v == nil {
31487		return fmt.Errorf("unexpected nil of type %T", v)
31488	}
31489	if value == nil {
31490		return nil
31491	}
31492
31493	shape, ok := value.(map[string]interface{})
31494	if !ok {
31495		return fmt.Errorf("unexpected JSON type %v", value)
31496	}
31497
31498	var sv *CreateBucketAccessKeyOutput
31499	if *v == nil {
31500		sv = &CreateBucketAccessKeyOutput{}
31501	} else {
31502		sv = *v
31503	}
31504
31505	for key, value := range shape {
31506		switch key {
31507		case "accessKey":
31508			if err := awsAwsjson11_deserializeDocumentAccessKey(&sv.AccessKey, value); err != nil {
31509				return err
31510			}
31511
31512		case "operations":
31513			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31514				return err
31515			}
31516
31517		default:
31518			_, _ = key, value
31519
31520		}
31521	}
31522	*v = sv
31523	return nil
31524}
31525
31526func awsAwsjson11_deserializeOpDocumentCreateBucketOutput(v **CreateBucketOutput, value interface{}) error {
31527	if v == nil {
31528		return fmt.Errorf("unexpected nil of type %T", v)
31529	}
31530	if value == nil {
31531		return nil
31532	}
31533
31534	shape, ok := value.(map[string]interface{})
31535	if !ok {
31536		return fmt.Errorf("unexpected JSON type %v", value)
31537	}
31538
31539	var sv *CreateBucketOutput
31540	if *v == nil {
31541		sv = &CreateBucketOutput{}
31542	} else {
31543		sv = *v
31544	}
31545
31546	for key, value := range shape {
31547		switch key {
31548		case "bucket":
31549			if err := awsAwsjson11_deserializeDocumentBucket(&sv.Bucket, value); err != nil {
31550				return err
31551			}
31552
31553		case "operations":
31554			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31555				return err
31556			}
31557
31558		default:
31559			_, _ = key, value
31560
31561		}
31562	}
31563	*v = sv
31564	return nil
31565}
31566
31567func awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(v **CreateCertificateOutput, value interface{}) error {
31568	if v == nil {
31569		return fmt.Errorf("unexpected nil of type %T", v)
31570	}
31571	if value == nil {
31572		return nil
31573	}
31574
31575	shape, ok := value.(map[string]interface{})
31576	if !ok {
31577		return fmt.Errorf("unexpected JSON type %v", value)
31578	}
31579
31580	var sv *CreateCertificateOutput
31581	if *v == nil {
31582		sv = &CreateCertificateOutput{}
31583	} else {
31584		sv = *v
31585	}
31586
31587	for key, value := range shape {
31588		switch key {
31589		case "certificate":
31590			if err := awsAwsjson11_deserializeDocumentCertificateSummary(&sv.Certificate, value); err != nil {
31591				return err
31592			}
31593
31594		case "operations":
31595			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31596				return err
31597			}
31598
31599		default:
31600			_, _ = key, value
31601
31602		}
31603	}
31604	*v = sv
31605	return nil
31606}
31607
31608func awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(v **CreateCloudFormationStackOutput, value interface{}) error {
31609	if v == nil {
31610		return fmt.Errorf("unexpected nil of type %T", v)
31611	}
31612	if value == nil {
31613		return nil
31614	}
31615
31616	shape, ok := value.(map[string]interface{})
31617	if !ok {
31618		return fmt.Errorf("unexpected JSON type %v", value)
31619	}
31620
31621	var sv *CreateCloudFormationStackOutput
31622	if *v == nil {
31623		sv = &CreateCloudFormationStackOutput{}
31624	} else {
31625		sv = *v
31626	}
31627
31628	for key, value := range shape {
31629		switch key {
31630		case "operations":
31631			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31632				return err
31633			}
31634
31635		default:
31636			_, _ = key, value
31637
31638		}
31639	}
31640	*v = sv
31641	return nil
31642}
31643
31644func awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(v **CreateContactMethodOutput, value interface{}) error {
31645	if v == nil {
31646		return fmt.Errorf("unexpected nil of type %T", v)
31647	}
31648	if value == nil {
31649		return nil
31650	}
31651
31652	shape, ok := value.(map[string]interface{})
31653	if !ok {
31654		return fmt.Errorf("unexpected JSON type %v", value)
31655	}
31656
31657	var sv *CreateContactMethodOutput
31658	if *v == nil {
31659		sv = &CreateContactMethodOutput{}
31660	} else {
31661		sv = *v
31662	}
31663
31664	for key, value := range shape {
31665		switch key {
31666		case "operations":
31667			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31668				return err
31669			}
31670
31671		default:
31672			_, _ = key, value
31673
31674		}
31675	}
31676	*v = sv
31677	return nil
31678}
31679
31680func awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(v **CreateContainerServiceDeploymentOutput, value interface{}) error {
31681	if v == nil {
31682		return fmt.Errorf("unexpected nil of type %T", v)
31683	}
31684	if value == nil {
31685		return nil
31686	}
31687
31688	shape, ok := value.(map[string]interface{})
31689	if !ok {
31690		return fmt.Errorf("unexpected JSON type %v", value)
31691	}
31692
31693	var sv *CreateContainerServiceDeploymentOutput
31694	if *v == nil {
31695		sv = &CreateContainerServiceDeploymentOutput{}
31696	} else {
31697		sv = *v
31698	}
31699
31700	for key, value := range shape {
31701		switch key {
31702		case "containerService":
31703			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
31704				return err
31705			}
31706
31707		default:
31708			_, _ = key, value
31709
31710		}
31711	}
31712	*v = sv
31713	return nil
31714}
31715
31716func awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(v **CreateContainerServiceOutput, value interface{}) error {
31717	if v == nil {
31718		return fmt.Errorf("unexpected nil of type %T", v)
31719	}
31720	if value == nil {
31721		return nil
31722	}
31723
31724	shape, ok := value.(map[string]interface{})
31725	if !ok {
31726		return fmt.Errorf("unexpected JSON type %v", value)
31727	}
31728
31729	var sv *CreateContainerServiceOutput
31730	if *v == nil {
31731		sv = &CreateContainerServiceOutput{}
31732	} else {
31733		sv = *v
31734	}
31735
31736	for key, value := range shape {
31737		switch key {
31738		case "containerService":
31739			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
31740				return err
31741			}
31742
31743		default:
31744			_, _ = key, value
31745
31746		}
31747	}
31748	*v = sv
31749	return nil
31750}
31751
31752func awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(v **CreateContainerServiceRegistryLoginOutput, value interface{}) error {
31753	if v == nil {
31754		return fmt.Errorf("unexpected nil of type %T", v)
31755	}
31756	if value == nil {
31757		return nil
31758	}
31759
31760	shape, ok := value.(map[string]interface{})
31761	if !ok {
31762		return fmt.Errorf("unexpected JSON type %v", value)
31763	}
31764
31765	var sv *CreateContainerServiceRegistryLoginOutput
31766	if *v == nil {
31767		sv = &CreateContainerServiceRegistryLoginOutput{}
31768	} else {
31769		sv = *v
31770	}
31771
31772	for key, value := range shape {
31773		switch key {
31774		case "registryLogin":
31775			if err := awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(&sv.RegistryLogin, value); err != nil {
31776				return err
31777			}
31778
31779		default:
31780			_, _ = key, value
31781
31782		}
31783	}
31784	*v = sv
31785	return nil
31786}
31787
31788func awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(v **CreateDiskFromSnapshotOutput, value interface{}) error {
31789	if v == nil {
31790		return fmt.Errorf("unexpected nil of type %T", v)
31791	}
31792	if value == nil {
31793		return nil
31794	}
31795
31796	shape, ok := value.(map[string]interface{})
31797	if !ok {
31798		return fmt.Errorf("unexpected JSON type %v", value)
31799	}
31800
31801	var sv *CreateDiskFromSnapshotOutput
31802	if *v == nil {
31803		sv = &CreateDiskFromSnapshotOutput{}
31804	} else {
31805		sv = *v
31806	}
31807
31808	for key, value := range shape {
31809		switch key {
31810		case "operations":
31811			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31812				return err
31813			}
31814
31815		default:
31816			_, _ = key, value
31817
31818		}
31819	}
31820	*v = sv
31821	return nil
31822}
31823
31824func awsAwsjson11_deserializeOpDocumentCreateDiskOutput(v **CreateDiskOutput, value interface{}) error {
31825	if v == nil {
31826		return fmt.Errorf("unexpected nil of type %T", v)
31827	}
31828	if value == nil {
31829		return nil
31830	}
31831
31832	shape, ok := value.(map[string]interface{})
31833	if !ok {
31834		return fmt.Errorf("unexpected JSON type %v", value)
31835	}
31836
31837	var sv *CreateDiskOutput
31838	if *v == nil {
31839		sv = &CreateDiskOutput{}
31840	} else {
31841		sv = *v
31842	}
31843
31844	for key, value := range shape {
31845		switch key {
31846		case "operations":
31847			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31848				return err
31849			}
31850
31851		default:
31852			_, _ = key, value
31853
31854		}
31855	}
31856	*v = sv
31857	return nil
31858}
31859
31860func awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(v **CreateDiskSnapshotOutput, value interface{}) error {
31861	if v == nil {
31862		return fmt.Errorf("unexpected nil of type %T", v)
31863	}
31864	if value == nil {
31865		return nil
31866	}
31867
31868	shape, ok := value.(map[string]interface{})
31869	if !ok {
31870		return fmt.Errorf("unexpected JSON type %v", value)
31871	}
31872
31873	var sv *CreateDiskSnapshotOutput
31874	if *v == nil {
31875		sv = &CreateDiskSnapshotOutput{}
31876	} else {
31877		sv = *v
31878	}
31879
31880	for key, value := range shape {
31881		switch key {
31882		case "operations":
31883			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
31884				return err
31885			}
31886
31887		default:
31888			_, _ = key, value
31889
31890		}
31891	}
31892	*v = sv
31893	return nil
31894}
31895
31896func awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(v **CreateDistributionOutput, value interface{}) error {
31897	if v == nil {
31898		return fmt.Errorf("unexpected nil of type %T", v)
31899	}
31900	if value == nil {
31901		return nil
31902	}
31903
31904	shape, ok := value.(map[string]interface{})
31905	if !ok {
31906		return fmt.Errorf("unexpected JSON type %v", value)
31907	}
31908
31909	var sv *CreateDistributionOutput
31910	if *v == nil {
31911		sv = &CreateDistributionOutput{}
31912	} else {
31913		sv = *v
31914	}
31915
31916	for key, value := range shape {
31917		switch key {
31918		case "distribution":
31919			if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&sv.Distribution, value); err != nil {
31920				return err
31921			}
31922
31923		case "operation":
31924			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
31925				return err
31926			}
31927
31928		default:
31929			_, _ = key, value
31930
31931		}
31932	}
31933	*v = sv
31934	return nil
31935}
31936
31937func awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(v **CreateDomainEntryOutput, value interface{}) error {
31938	if v == nil {
31939		return fmt.Errorf("unexpected nil of type %T", v)
31940	}
31941	if value == nil {
31942		return nil
31943	}
31944
31945	shape, ok := value.(map[string]interface{})
31946	if !ok {
31947		return fmt.Errorf("unexpected JSON type %v", value)
31948	}
31949
31950	var sv *CreateDomainEntryOutput
31951	if *v == nil {
31952		sv = &CreateDomainEntryOutput{}
31953	} else {
31954		sv = *v
31955	}
31956
31957	for key, value := range shape {
31958		switch key {
31959		case "operation":
31960			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
31961				return err
31962			}
31963
31964		default:
31965			_, _ = key, value
31966
31967		}
31968	}
31969	*v = sv
31970	return nil
31971}
31972
31973func awsAwsjson11_deserializeOpDocumentCreateDomainOutput(v **CreateDomainOutput, value interface{}) error {
31974	if v == nil {
31975		return fmt.Errorf("unexpected nil of type %T", v)
31976	}
31977	if value == nil {
31978		return nil
31979	}
31980
31981	shape, ok := value.(map[string]interface{})
31982	if !ok {
31983		return fmt.Errorf("unexpected JSON type %v", value)
31984	}
31985
31986	var sv *CreateDomainOutput
31987	if *v == nil {
31988		sv = &CreateDomainOutput{}
31989	} else {
31990		sv = *v
31991	}
31992
31993	for key, value := range shape {
31994		switch key {
31995		case "operation":
31996			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
31997				return err
31998			}
31999
32000		default:
32001			_, _ = key, value
32002
32003		}
32004	}
32005	*v = sv
32006	return nil
32007}
32008
32009func awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(v **CreateInstancesFromSnapshotOutput, value interface{}) error {
32010	if v == nil {
32011		return fmt.Errorf("unexpected nil of type %T", v)
32012	}
32013	if value == nil {
32014		return nil
32015	}
32016
32017	shape, ok := value.(map[string]interface{})
32018	if !ok {
32019		return fmt.Errorf("unexpected JSON type %v", value)
32020	}
32021
32022	var sv *CreateInstancesFromSnapshotOutput
32023	if *v == nil {
32024		sv = &CreateInstancesFromSnapshotOutput{}
32025	} else {
32026		sv = *v
32027	}
32028
32029	for key, value := range shape {
32030		switch key {
32031		case "operations":
32032			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32033				return err
32034			}
32035
32036		default:
32037			_, _ = key, value
32038
32039		}
32040	}
32041	*v = sv
32042	return nil
32043}
32044
32045func awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(v **CreateInstanceSnapshotOutput, value interface{}) error {
32046	if v == nil {
32047		return fmt.Errorf("unexpected nil of type %T", v)
32048	}
32049	if value == nil {
32050		return nil
32051	}
32052
32053	shape, ok := value.(map[string]interface{})
32054	if !ok {
32055		return fmt.Errorf("unexpected JSON type %v", value)
32056	}
32057
32058	var sv *CreateInstanceSnapshotOutput
32059	if *v == nil {
32060		sv = &CreateInstanceSnapshotOutput{}
32061	} else {
32062		sv = *v
32063	}
32064
32065	for key, value := range shape {
32066		switch key {
32067		case "operations":
32068			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32069				return err
32070			}
32071
32072		default:
32073			_, _ = key, value
32074
32075		}
32076	}
32077	*v = sv
32078	return nil
32079}
32080
32081func awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(v **CreateInstancesOutput, value interface{}) error {
32082	if v == nil {
32083		return fmt.Errorf("unexpected nil of type %T", v)
32084	}
32085	if value == nil {
32086		return nil
32087	}
32088
32089	shape, ok := value.(map[string]interface{})
32090	if !ok {
32091		return fmt.Errorf("unexpected JSON type %v", value)
32092	}
32093
32094	var sv *CreateInstancesOutput
32095	if *v == nil {
32096		sv = &CreateInstancesOutput{}
32097	} else {
32098		sv = *v
32099	}
32100
32101	for key, value := range shape {
32102		switch key {
32103		case "operations":
32104			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32105				return err
32106			}
32107
32108		default:
32109			_, _ = key, value
32110
32111		}
32112	}
32113	*v = sv
32114	return nil
32115}
32116
32117func awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(v **CreateKeyPairOutput, value interface{}) error {
32118	if v == nil {
32119		return fmt.Errorf("unexpected nil of type %T", v)
32120	}
32121	if value == nil {
32122		return nil
32123	}
32124
32125	shape, ok := value.(map[string]interface{})
32126	if !ok {
32127		return fmt.Errorf("unexpected JSON type %v", value)
32128	}
32129
32130	var sv *CreateKeyPairOutput
32131	if *v == nil {
32132		sv = &CreateKeyPairOutput{}
32133	} else {
32134		sv = *v
32135	}
32136
32137	for key, value := range shape {
32138		switch key {
32139		case "keyPair":
32140			if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
32141				return err
32142			}
32143
32144		case "operation":
32145			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32146				return err
32147			}
32148
32149		case "privateKeyBase64":
32150			if value != nil {
32151				jtv, ok := value.(string)
32152				if !ok {
32153					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
32154				}
32155				sv.PrivateKeyBase64 = ptr.String(jtv)
32156			}
32157
32158		case "publicKeyBase64":
32159			if value != nil {
32160				jtv, ok := value.(string)
32161				if !ok {
32162					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
32163				}
32164				sv.PublicKeyBase64 = ptr.String(jtv)
32165			}
32166
32167		default:
32168			_, _ = key, value
32169
32170		}
32171	}
32172	*v = sv
32173	return nil
32174}
32175
32176func awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(v **CreateLoadBalancerOutput, value interface{}) error {
32177	if v == nil {
32178		return fmt.Errorf("unexpected nil of type %T", v)
32179	}
32180	if value == nil {
32181		return nil
32182	}
32183
32184	shape, ok := value.(map[string]interface{})
32185	if !ok {
32186		return fmt.Errorf("unexpected JSON type %v", value)
32187	}
32188
32189	var sv *CreateLoadBalancerOutput
32190	if *v == nil {
32191		sv = &CreateLoadBalancerOutput{}
32192	} else {
32193		sv = *v
32194	}
32195
32196	for key, value := range shape {
32197		switch key {
32198		case "operations":
32199			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32200				return err
32201			}
32202
32203		default:
32204			_, _ = key, value
32205
32206		}
32207	}
32208	*v = sv
32209	return nil
32210}
32211
32212func awsAwsjson11_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(v **CreateLoadBalancerTlsCertificateOutput, value interface{}) error {
32213	if v == nil {
32214		return fmt.Errorf("unexpected nil of type %T", v)
32215	}
32216	if value == nil {
32217		return nil
32218	}
32219
32220	shape, ok := value.(map[string]interface{})
32221	if !ok {
32222		return fmt.Errorf("unexpected JSON type %v", value)
32223	}
32224
32225	var sv *CreateLoadBalancerTlsCertificateOutput
32226	if *v == nil {
32227		sv = &CreateLoadBalancerTlsCertificateOutput{}
32228	} else {
32229		sv = *v
32230	}
32231
32232	for key, value := range shape {
32233		switch key {
32234		case "operations":
32235			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32236				return err
32237			}
32238
32239		default:
32240			_, _ = key, value
32241
32242		}
32243	}
32244	*v = sv
32245	return nil
32246}
32247
32248func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(v **CreateRelationalDatabaseFromSnapshotOutput, value interface{}) error {
32249	if v == nil {
32250		return fmt.Errorf("unexpected nil of type %T", v)
32251	}
32252	if value == nil {
32253		return nil
32254	}
32255
32256	shape, ok := value.(map[string]interface{})
32257	if !ok {
32258		return fmt.Errorf("unexpected JSON type %v", value)
32259	}
32260
32261	var sv *CreateRelationalDatabaseFromSnapshotOutput
32262	if *v == nil {
32263		sv = &CreateRelationalDatabaseFromSnapshotOutput{}
32264	} else {
32265		sv = *v
32266	}
32267
32268	for key, value := range shape {
32269		switch key {
32270		case "operations":
32271			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32272				return err
32273			}
32274
32275		default:
32276			_, _ = key, value
32277
32278		}
32279	}
32280	*v = sv
32281	return nil
32282}
32283
32284func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(v **CreateRelationalDatabaseOutput, value interface{}) error {
32285	if v == nil {
32286		return fmt.Errorf("unexpected nil of type %T", v)
32287	}
32288	if value == nil {
32289		return nil
32290	}
32291
32292	shape, ok := value.(map[string]interface{})
32293	if !ok {
32294		return fmt.Errorf("unexpected JSON type %v", value)
32295	}
32296
32297	var sv *CreateRelationalDatabaseOutput
32298	if *v == nil {
32299		sv = &CreateRelationalDatabaseOutput{}
32300	} else {
32301		sv = *v
32302	}
32303
32304	for key, value := range shape {
32305		switch key {
32306		case "operations":
32307			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32308				return err
32309			}
32310
32311		default:
32312			_, _ = key, value
32313
32314		}
32315	}
32316	*v = sv
32317	return nil
32318}
32319
32320func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(v **CreateRelationalDatabaseSnapshotOutput, value interface{}) error {
32321	if v == nil {
32322		return fmt.Errorf("unexpected nil of type %T", v)
32323	}
32324	if value == nil {
32325		return nil
32326	}
32327
32328	shape, ok := value.(map[string]interface{})
32329	if !ok {
32330		return fmt.Errorf("unexpected JSON type %v", value)
32331	}
32332
32333	var sv *CreateRelationalDatabaseSnapshotOutput
32334	if *v == nil {
32335		sv = &CreateRelationalDatabaseSnapshotOutput{}
32336	} else {
32337		sv = *v
32338	}
32339
32340	for key, value := range shape {
32341		switch key {
32342		case "operations":
32343			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32344				return err
32345			}
32346
32347		default:
32348			_, _ = key, value
32349
32350		}
32351	}
32352	*v = sv
32353	return nil
32354}
32355
32356func awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(v **DeleteAlarmOutput, value interface{}) error {
32357	if v == nil {
32358		return fmt.Errorf("unexpected nil of type %T", v)
32359	}
32360	if value == nil {
32361		return nil
32362	}
32363
32364	shape, ok := value.(map[string]interface{})
32365	if !ok {
32366		return fmt.Errorf("unexpected JSON type %v", value)
32367	}
32368
32369	var sv *DeleteAlarmOutput
32370	if *v == nil {
32371		sv = &DeleteAlarmOutput{}
32372	} else {
32373		sv = *v
32374	}
32375
32376	for key, value := range shape {
32377		switch key {
32378		case "operations":
32379			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32380				return err
32381			}
32382
32383		default:
32384			_, _ = key, value
32385
32386		}
32387	}
32388	*v = sv
32389	return nil
32390}
32391
32392func awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(v **DeleteAutoSnapshotOutput, value interface{}) error {
32393	if v == nil {
32394		return fmt.Errorf("unexpected nil of type %T", v)
32395	}
32396	if value == nil {
32397		return nil
32398	}
32399
32400	shape, ok := value.(map[string]interface{})
32401	if !ok {
32402		return fmt.Errorf("unexpected JSON type %v", value)
32403	}
32404
32405	var sv *DeleteAutoSnapshotOutput
32406	if *v == nil {
32407		sv = &DeleteAutoSnapshotOutput{}
32408	} else {
32409		sv = *v
32410	}
32411
32412	for key, value := range shape {
32413		switch key {
32414		case "operations":
32415			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32416				return err
32417			}
32418
32419		default:
32420			_, _ = key, value
32421
32422		}
32423	}
32424	*v = sv
32425	return nil
32426}
32427
32428func awsAwsjson11_deserializeOpDocumentDeleteBucketAccessKeyOutput(v **DeleteBucketAccessKeyOutput, value interface{}) error {
32429	if v == nil {
32430		return fmt.Errorf("unexpected nil of type %T", v)
32431	}
32432	if value == nil {
32433		return nil
32434	}
32435
32436	shape, ok := value.(map[string]interface{})
32437	if !ok {
32438		return fmt.Errorf("unexpected JSON type %v", value)
32439	}
32440
32441	var sv *DeleteBucketAccessKeyOutput
32442	if *v == nil {
32443		sv = &DeleteBucketAccessKeyOutput{}
32444	} else {
32445		sv = *v
32446	}
32447
32448	for key, value := range shape {
32449		switch key {
32450		case "operations":
32451			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32452				return err
32453			}
32454
32455		default:
32456			_, _ = key, value
32457
32458		}
32459	}
32460	*v = sv
32461	return nil
32462}
32463
32464func awsAwsjson11_deserializeOpDocumentDeleteBucketOutput(v **DeleteBucketOutput, value interface{}) error {
32465	if v == nil {
32466		return fmt.Errorf("unexpected nil of type %T", v)
32467	}
32468	if value == nil {
32469		return nil
32470	}
32471
32472	shape, ok := value.(map[string]interface{})
32473	if !ok {
32474		return fmt.Errorf("unexpected JSON type %v", value)
32475	}
32476
32477	var sv *DeleteBucketOutput
32478	if *v == nil {
32479		sv = &DeleteBucketOutput{}
32480	} else {
32481		sv = *v
32482	}
32483
32484	for key, value := range shape {
32485		switch key {
32486		case "operations":
32487			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32488				return err
32489			}
32490
32491		default:
32492			_, _ = key, value
32493
32494		}
32495	}
32496	*v = sv
32497	return nil
32498}
32499
32500func awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(v **DeleteCertificateOutput, value interface{}) error {
32501	if v == nil {
32502		return fmt.Errorf("unexpected nil of type %T", v)
32503	}
32504	if value == nil {
32505		return nil
32506	}
32507
32508	shape, ok := value.(map[string]interface{})
32509	if !ok {
32510		return fmt.Errorf("unexpected JSON type %v", value)
32511	}
32512
32513	var sv *DeleteCertificateOutput
32514	if *v == nil {
32515		sv = &DeleteCertificateOutput{}
32516	} else {
32517		sv = *v
32518	}
32519
32520	for key, value := range shape {
32521		switch key {
32522		case "operations":
32523			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32524				return err
32525			}
32526
32527		default:
32528			_, _ = key, value
32529
32530		}
32531	}
32532	*v = sv
32533	return nil
32534}
32535
32536func awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(v **DeleteContactMethodOutput, value interface{}) error {
32537	if v == nil {
32538		return fmt.Errorf("unexpected nil of type %T", v)
32539	}
32540	if value == nil {
32541		return nil
32542	}
32543
32544	shape, ok := value.(map[string]interface{})
32545	if !ok {
32546		return fmt.Errorf("unexpected JSON type %v", value)
32547	}
32548
32549	var sv *DeleteContactMethodOutput
32550	if *v == nil {
32551		sv = &DeleteContactMethodOutput{}
32552	} else {
32553		sv = *v
32554	}
32555
32556	for key, value := range shape {
32557		switch key {
32558		case "operations":
32559			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32560				return err
32561			}
32562
32563		default:
32564			_, _ = key, value
32565
32566		}
32567	}
32568	*v = sv
32569	return nil
32570}
32571
32572func awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(v **DeleteContainerImageOutput, value interface{}) error {
32573	if v == nil {
32574		return fmt.Errorf("unexpected nil of type %T", v)
32575	}
32576	if value == nil {
32577		return nil
32578	}
32579
32580	shape, ok := value.(map[string]interface{})
32581	if !ok {
32582		return fmt.Errorf("unexpected JSON type %v", value)
32583	}
32584
32585	var sv *DeleteContainerImageOutput
32586	if *v == nil {
32587		sv = &DeleteContainerImageOutput{}
32588	} else {
32589		sv = *v
32590	}
32591
32592	for key, value := range shape {
32593		switch key {
32594		default:
32595			_, _ = key, value
32596
32597		}
32598	}
32599	*v = sv
32600	return nil
32601}
32602
32603func awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(v **DeleteContainerServiceOutput, value interface{}) error {
32604	if v == nil {
32605		return fmt.Errorf("unexpected nil of type %T", v)
32606	}
32607	if value == nil {
32608		return nil
32609	}
32610
32611	shape, ok := value.(map[string]interface{})
32612	if !ok {
32613		return fmt.Errorf("unexpected JSON type %v", value)
32614	}
32615
32616	var sv *DeleteContainerServiceOutput
32617	if *v == nil {
32618		sv = &DeleteContainerServiceOutput{}
32619	} else {
32620		sv = *v
32621	}
32622
32623	for key, value := range shape {
32624		switch key {
32625		default:
32626			_, _ = key, value
32627
32628		}
32629	}
32630	*v = sv
32631	return nil
32632}
32633
32634func awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(v **DeleteDiskOutput, value interface{}) error {
32635	if v == nil {
32636		return fmt.Errorf("unexpected nil of type %T", v)
32637	}
32638	if value == nil {
32639		return nil
32640	}
32641
32642	shape, ok := value.(map[string]interface{})
32643	if !ok {
32644		return fmt.Errorf("unexpected JSON type %v", value)
32645	}
32646
32647	var sv *DeleteDiskOutput
32648	if *v == nil {
32649		sv = &DeleteDiskOutput{}
32650	} else {
32651		sv = *v
32652	}
32653
32654	for key, value := range shape {
32655		switch key {
32656		case "operations":
32657			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32658				return err
32659			}
32660
32661		default:
32662			_, _ = key, value
32663
32664		}
32665	}
32666	*v = sv
32667	return nil
32668}
32669
32670func awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(v **DeleteDiskSnapshotOutput, value interface{}) error {
32671	if v == nil {
32672		return fmt.Errorf("unexpected nil of type %T", v)
32673	}
32674	if value == nil {
32675		return nil
32676	}
32677
32678	shape, ok := value.(map[string]interface{})
32679	if !ok {
32680		return fmt.Errorf("unexpected JSON type %v", value)
32681	}
32682
32683	var sv *DeleteDiskSnapshotOutput
32684	if *v == nil {
32685		sv = &DeleteDiskSnapshotOutput{}
32686	} else {
32687		sv = *v
32688	}
32689
32690	for key, value := range shape {
32691		switch key {
32692		case "operations":
32693			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32694				return err
32695			}
32696
32697		default:
32698			_, _ = key, value
32699
32700		}
32701	}
32702	*v = sv
32703	return nil
32704}
32705
32706func awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(v **DeleteDistributionOutput, value interface{}) error {
32707	if v == nil {
32708		return fmt.Errorf("unexpected nil of type %T", v)
32709	}
32710	if value == nil {
32711		return nil
32712	}
32713
32714	shape, ok := value.(map[string]interface{})
32715	if !ok {
32716		return fmt.Errorf("unexpected JSON type %v", value)
32717	}
32718
32719	var sv *DeleteDistributionOutput
32720	if *v == nil {
32721		sv = &DeleteDistributionOutput{}
32722	} else {
32723		sv = *v
32724	}
32725
32726	for key, value := range shape {
32727		switch key {
32728		case "operation":
32729			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32730				return err
32731			}
32732
32733		default:
32734			_, _ = key, value
32735
32736		}
32737	}
32738	*v = sv
32739	return nil
32740}
32741
32742func awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(v **DeleteDomainEntryOutput, value interface{}) error {
32743	if v == nil {
32744		return fmt.Errorf("unexpected nil of type %T", v)
32745	}
32746	if value == nil {
32747		return nil
32748	}
32749
32750	shape, ok := value.(map[string]interface{})
32751	if !ok {
32752		return fmt.Errorf("unexpected JSON type %v", value)
32753	}
32754
32755	var sv *DeleteDomainEntryOutput
32756	if *v == nil {
32757		sv = &DeleteDomainEntryOutput{}
32758	} else {
32759		sv = *v
32760	}
32761
32762	for key, value := range shape {
32763		switch key {
32764		case "operation":
32765			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32766				return err
32767			}
32768
32769		default:
32770			_, _ = key, value
32771
32772		}
32773	}
32774	*v = sv
32775	return nil
32776}
32777
32778func awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(v **DeleteDomainOutput, value interface{}) error {
32779	if v == nil {
32780		return fmt.Errorf("unexpected nil of type %T", v)
32781	}
32782	if value == nil {
32783		return nil
32784	}
32785
32786	shape, ok := value.(map[string]interface{})
32787	if !ok {
32788		return fmt.Errorf("unexpected JSON type %v", value)
32789	}
32790
32791	var sv *DeleteDomainOutput
32792	if *v == nil {
32793		sv = &DeleteDomainOutput{}
32794	} else {
32795		sv = *v
32796	}
32797
32798	for key, value := range shape {
32799		switch key {
32800		case "operation":
32801			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32802				return err
32803			}
32804
32805		default:
32806			_, _ = key, value
32807
32808		}
32809	}
32810	*v = sv
32811	return nil
32812}
32813
32814func awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(v **DeleteInstanceOutput, value interface{}) error {
32815	if v == nil {
32816		return fmt.Errorf("unexpected nil of type %T", v)
32817	}
32818	if value == nil {
32819		return nil
32820	}
32821
32822	shape, ok := value.(map[string]interface{})
32823	if !ok {
32824		return fmt.Errorf("unexpected JSON type %v", value)
32825	}
32826
32827	var sv *DeleteInstanceOutput
32828	if *v == nil {
32829		sv = &DeleteInstanceOutput{}
32830	} else {
32831		sv = *v
32832	}
32833
32834	for key, value := range shape {
32835		switch key {
32836		case "operations":
32837			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32838				return err
32839			}
32840
32841		default:
32842			_, _ = key, value
32843
32844		}
32845	}
32846	*v = sv
32847	return nil
32848}
32849
32850func awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(v **DeleteInstanceSnapshotOutput, value interface{}) error {
32851	if v == nil {
32852		return fmt.Errorf("unexpected nil of type %T", v)
32853	}
32854	if value == nil {
32855		return nil
32856	}
32857
32858	shape, ok := value.(map[string]interface{})
32859	if !ok {
32860		return fmt.Errorf("unexpected JSON type %v", value)
32861	}
32862
32863	var sv *DeleteInstanceSnapshotOutput
32864	if *v == nil {
32865		sv = &DeleteInstanceSnapshotOutput{}
32866	} else {
32867		sv = *v
32868	}
32869
32870	for key, value := range shape {
32871		switch key {
32872		case "operations":
32873			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32874				return err
32875			}
32876
32877		default:
32878			_, _ = key, value
32879
32880		}
32881	}
32882	*v = sv
32883	return nil
32884}
32885
32886func awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(v **DeleteKeyPairOutput, value interface{}) error {
32887	if v == nil {
32888		return fmt.Errorf("unexpected nil of type %T", v)
32889	}
32890	if value == nil {
32891		return nil
32892	}
32893
32894	shape, ok := value.(map[string]interface{})
32895	if !ok {
32896		return fmt.Errorf("unexpected JSON type %v", value)
32897	}
32898
32899	var sv *DeleteKeyPairOutput
32900	if *v == nil {
32901		sv = &DeleteKeyPairOutput{}
32902	} else {
32903		sv = *v
32904	}
32905
32906	for key, value := range shape {
32907		switch key {
32908		case "operation":
32909			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32910				return err
32911			}
32912
32913		default:
32914			_, _ = key, value
32915
32916		}
32917	}
32918	*v = sv
32919	return nil
32920}
32921
32922func awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(v **DeleteKnownHostKeysOutput, value interface{}) error {
32923	if v == nil {
32924		return fmt.Errorf("unexpected nil of type %T", v)
32925	}
32926	if value == nil {
32927		return nil
32928	}
32929
32930	shape, ok := value.(map[string]interface{})
32931	if !ok {
32932		return fmt.Errorf("unexpected JSON type %v", value)
32933	}
32934
32935	var sv *DeleteKnownHostKeysOutput
32936	if *v == nil {
32937		sv = &DeleteKnownHostKeysOutput{}
32938	} else {
32939		sv = *v
32940	}
32941
32942	for key, value := range shape {
32943		switch key {
32944		case "operations":
32945			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32946				return err
32947			}
32948
32949		default:
32950			_, _ = key, value
32951
32952		}
32953	}
32954	*v = sv
32955	return nil
32956}
32957
32958func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(v **DeleteLoadBalancerOutput, value interface{}) error {
32959	if v == nil {
32960		return fmt.Errorf("unexpected nil of type %T", v)
32961	}
32962	if value == nil {
32963		return nil
32964	}
32965
32966	shape, ok := value.(map[string]interface{})
32967	if !ok {
32968		return fmt.Errorf("unexpected JSON type %v", value)
32969	}
32970
32971	var sv *DeleteLoadBalancerOutput
32972	if *v == nil {
32973		sv = &DeleteLoadBalancerOutput{}
32974	} else {
32975		sv = *v
32976	}
32977
32978	for key, value := range shape {
32979		switch key {
32980		case "operations":
32981			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32982				return err
32983			}
32984
32985		default:
32986			_, _ = key, value
32987
32988		}
32989	}
32990	*v = sv
32991	return nil
32992}
32993
32994func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(v **DeleteLoadBalancerTlsCertificateOutput, value interface{}) error {
32995	if v == nil {
32996		return fmt.Errorf("unexpected nil of type %T", v)
32997	}
32998	if value == nil {
32999		return nil
33000	}
33001
33002	shape, ok := value.(map[string]interface{})
33003	if !ok {
33004		return fmt.Errorf("unexpected JSON type %v", value)
33005	}
33006
33007	var sv *DeleteLoadBalancerTlsCertificateOutput
33008	if *v == nil {
33009		sv = &DeleteLoadBalancerTlsCertificateOutput{}
33010	} else {
33011		sv = *v
33012	}
33013
33014	for key, value := range shape {
33015		switch key {
33016		case "operations":
33017			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33018				return err
33019			}
33020
33021		default:
33022			_, _ = key, value
33023
33024		}
33025	}
33026	*v = sv
33027	return nil
33028}
33029
33030func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(v **DeleteRelationalDatabaseOutput, value interface{}) error {
33031	if v == nil {
33032		return fmt.Errorf("unexpected nil of type %T", v)
33033	}
33034	if value == nil {
33035		return nil
33036	}
33037
33038	shape, ok := value.(map[string]interface{})
33039	if !ok {
33040		return fmt.Errorf("unexpected JSON type %v", value)
33041	}
33042
33043	var sv *DeleteRelationalDatabaseOutput
33044	if *v == nil {
33045		sv = &DeleteRelationalDatabaseOutput{}
33046	} else {
33047		sv = *v
33048	}
33049
33050	for key, value := range shape {
33051		switch key {
33052		case "operations":
33053			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33054				return err
33055			}
33056
33057		default:
33058			_, _ = key, value
33059
33060		}
33061	}
33062	*v = sv
33063	return nil
33064}
33065
33066func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(v **DeleteRelationalDatabaseSnapshotOutput, value interface{}) error {
33067	if v == nil {
33068		return fmt.Errorf("unexpected nil of type %T", v)
33069	}
33070	if value == nil {
33071		return nil
33072	}
33073
33074	shape, ok := value.(map[string]interface{})
33075	if !ok {
33076		return fmt.Errorf("unexpected JSON type %v", value)
33077	}
33078
33079	var sv *DeleteRelationalDatabaseSnapshotOutput
33080	if *v == nil {
33081		sv = &DeleteRelationalDatabaseSnapshotOutput{}
33082	} else {
33083		sv = *v
33084	}
33085
33086	for key, value := range shape {
33087		switch key {
33088		case "operations":
33089			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33090				return err
33091			}
33092
33093		default:
33094			_, _ = key, value
33095
33096		}
33097	}
33098	*v = sv
33099	return nil
33100}
33101
33102func awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(v **DetachCertificateFromDistributionOutput, value interface{}) error {
33103	if v == nil {
33104		return fmt.Errorf("unexpected nil of type %T", v)
33105	}
33106	if value == nil {
33107		return nil
33108	}
33109
33110	shape, ok := value.(map[string]interface{})
33111	if !ok {
33112		return fmt.Errorf("unexpected JSON type %v", value)
33113	}
33114
33115	var sv *DetachCertificateFromDistributionOutput
33116	if *v == nil {
33117		sv = &DetachCertificateFromDistributionOutput{}
33118	} else {
33119		sv = *v
33120	}
33121
33122	for key, value := range shape {
33123		switch key {
33124		case "operation":
33125			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33126				return err
33127			}
33128
33129		default:
33130			_, _ = key, value
33131
33132		}
33133	}
33134	*v = sv
33135	return nil
33136}
33137
33138func awsAwsjson11_deserializeOpDocumentDetachDiskOutput(v **DetachDiskOutput, value interface{}) error {
33139	if v == nil {
33140		return fmt.Errorf("unexpected nil of type %T", v)
33141	}
33142	if value == nil {
33143		return nil
33144	}
33145
33146	shape, ok := value.(map[string]interface{})
33147	if !ok {
33148		return fmt.Errorf("unexpected JSON type %v", value)
33149	}
33150
33151	var sv *DetachDiskOutput
33152	if *v == nil {
33153		sv = &DetachDiskOutput{}
33154	} else {
33155		sv = *v
33156	}
33157
33158	for key, value := range shape {
33159		switch key {
33160		case "operations":
33161			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33162				return err
33163			}
33164
33165		default:
33166			_, _ = key, value
33167
33168		}
33169	}
33170	*v = sv
33171	return nil
33172}
33173
33174func awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(v **DetachInstancesFromLoadBalancerOutput, value interface{}) error {
33175	if v == nil {
33176		return fmt.Errorf("unexpected nil of type %T", v)
33177	}
33178	if value == nil {
33179		return nil
33180	}
33181
33182	shape, ok := value.(map[string]interface{})
33183	if !ok {
33184		return fmt.Errorf("unexpected JSON type %v", value)
33185	}
33186
33187	var sv *DetachInstancesFromLoadBalancerOutput
33188	if *v == nil {
33189		sv = &DetachInstancesFromLoadBalancerOutput{}
33190	} else {
33191		sv = *v
33192	}
33193
33194	for key, value := range shape {
33195		switch key {
33196		case "operations":
33197			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33198				return err
33199			}
33200
33201		default:
33202			_, _ = key, value
33203
33204		}
33205	}
33206	*v = sv
33207	return nil
33208}
33209
33210func awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(v **DetachStaticIpOutput, value interface{}) error {
33211	if v == nil {
33212		return fmt.Errorf("unexpected nil of type %T", v)
33213	}
33214	if value == nil {
33215		return nil
33216	}
33217
33218	shape, ok := value.(map[string]interface{})
33219	if !ok {
33220		return fmt.Errorf("unexpected JSON type %v", value)
33221	}
33222
33223	var sv *DetachStaticIpOutput
33224	if *v == nil {
33225		sv = &DetachStaticIpOutput{}
33226	} else {
33227		sv = *v
33228	}
33229
33230	for key, value := range shape {
33231		switch key {
33232		case "operations":
33233			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33234				return err
33235			}
33236
33237		default:
33238			_, _ = key, value
33239
33240		}
33241	}
33242	*v = sv
33243	return nil
33244}
33245
33246func awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(v **DisableAddOnOutput, value interface{}) error {
33247	if v == nil {
33248		return fmt.Errorf("unexpected nil of type %T", v)
33249	}
33250	if value == nil {
33251		return nil
33252	}
33253
33254	shape, ok := value.(map[string]interface{})
33255	if !ok {
33256		return fmt.Errorf("unexpected JSON type %v", value)
33257	}
33258
33259	var sv *DisableAddOnOutput
33260	if *v == nil {
33261		sv = &DisableAddOnOutput{}
33262	} else {
33263		sv = *v
33264	}
33265
33266	for key, value := range shape {
33267		switch key {
33268		case "operations":
33269			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33270				return err
33271			}
33272
33273		default:
33274			_, _ = key, value
33275
33276		}
33277	}
33278	*v = sv
33279	return nil
33280}
33281
33282func awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(v **DownloadDefaultKeyPairOutput, value interface{}) error {
33283	if v == nil {
33284		return fmt.Errorf("unexpected nil of type %T", v)
33285	}
33286	if value == nil {
33287		return nil
33288	}
33289
33290	shape, ok := value.(map[string]interface{})
33291	if !ok {
33292		return fmt.Errorf("unexpected JSON type %v", value)
33293	}
33294
33295	var sv *DownloadDefaultKeyPairOutput
33296	if *v == nil {
33297		sv = &DownloadDefaultKeyPairOutput{}
33298	} else {
33299		sv = *v
33300	}
33301
33302	for key, value := range shape {
33303		switch key {
33304		case "privateKeyBase64":
33305			if value != nil {
33306				jtv, ok := value.(string)
33307				if !ok {
33308					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
33309				}
33310				sv.PrivateKeyBase64 = ptr.String(jtv)
33311			}
33312
33313		case "publicKeyBase64":
33314			if value != nil {
33315				jtv, ok := value.(string)
33316				if !ok {
33317					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
33318				}
33319				sv.PublicKeyBase64 = ptr.String(jtv)
33320			}
33321
33322		default:
33323			_, _ = key, value
33324
33325		}
33326	}
33327	*v = sv
33328	return nil
33329}
33330
33331func awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(v **EnableAddOnOutput, value interface{}) error {
33332	if v == nil {
33333		return fmt.Errorf("unexpected nil of type %T", v)
33334	}
33335	if value == nil {
33336		return nil
33337	}
33338
33339	shape, ok := value.(map[string]interface{})
33340	if !ok {
33341		return fmt.Errorf("unexpected JSON type %v", value)
33342	}
33343
33344	var sv *EnableAddOnOutput
33345	if *v == nil {
33346		sv = &EnableAddOnOutput{}
33347	} else {
33348		sv = *v
33349	}
33350
33351	for key, value := range shape {
33352		switch key {
33353		case "operations":
33354			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33355				return err
33356			}
33357
33358		default:
33359			_, _ = key, value
33360
33361		}
33362	}
33363	*v = sv
33364	return nil
33365}
33366
33367func awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(v **ExportSnapshotOutput, value interface{}) error {
33368	if v == nil {
33369		return fmt.Errorf("unexpected nil of type %T", v)
33370	}
33371	if value == nil {
33372		return nil
33373	}
33374
33375	shape, ok := value.(map[string]interface{})
33376	if !ok {
33377		return fmt.Errorf("unexpected JSON type %v", value)
33378	}
33379
33380	var sv *ExportSnapshotOutput
33381	if *v == nil {
33382		sv = &ExportSnapshotOutput{}
33383	} else {
33384		sv = *v
33385	}
33386
33387	for key, value := range shape {
33388		switch key {
33389		case "operations":
33390			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33391				return err
33392			}
33393
33394		default:
33395			_, _ = key, value
33396
33397		}
33398	}
33399	*v = sv
33400	return nil
33401}
33402
33403func awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(v **GetActiveNamesOutput, value interface{}) error {
33404	if v == nil {
33405		return fmt.Errorf("unexpected nil of type %T", v)
33406	}
33407	if value == nil {
33408		return nil
33409	}
33410
33411	shape, ok := value.(map[string]interface{})
33412	if !ok {
33413		return fmt.Errorf("unexpected JSON type %v", value)
33414	}
33415
33416	var sv *GetActiveNamesOutput
33417	if *v == nil {
33418		sv = &GetActiveNamesOutput{}
33419	} else {
33420		sv = *v
33421	}
33422
33423	for key, value := range shape {
33424		switch key {
33425		case "activeNames":
33426			if err := awsAwsjson11_deserializeDocumentStringList(&sv.ActiveNames, value); err != nil {
33427				return err
33428			}
33429
33430		case "nextPageToken":
33431			if value != nil {
33432				jtv, ok := value.(string)
33433				if !ok {
33434					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33435				}
33436				sv.NextPageToken = ptr.String(jtv)
33437			}
33438
33439		default:
33440			_, _ = key, value
33441
33442		}
33443	}
33444	*v = sv
33445	return nil
33446}
33447
33448func awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(v **GetAlarmsOutput, value interface{}) error {
33449	if v == nil {
33450		return fmt.Errorf("unexpected nil of type %T", v)
33451	}
33452	if value == nil {
33453		return nil
33454	}
33455
33456	shape, ok := value.(map[string]interface{})
33457	if !ok {
33458		return fmt.Errorf("unexpected JSON type %v", value)
33459	}
33460
33461	var sv *GetAlarmsOutput
33462	if *v == nil {
33463		sv = &GetAlarmsOutput{}
33464	} else {
33465		sv = *v
33466	}
33467
33468	for key, value := range shape {
33469		switch key {
33470		case "alarms":
33471			if err := awsAwsjson11_deserializeDocumentAlarmsList(&sv.Alarms, value); err != nil {
33472				return err
33473			}
33474
33475		case "nextPageToken":
33476			if value != nil {
33477				jtv, ok := value.(string)
33478				if !ok {
33479					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33480				}
33481				sv.NextPageToken = ptr.String(jtv)
33482			}
33483
33484		default:
33485			_, _ = key, value
33486
33487		}
33488	}
33489	*v = sv
33490	return nil
33491}
33492
33493func awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(v **GetAutoSnapshotsOutput, value interface{}) error {
33494	if v == nil {
33495		return fmt.Errorf("unexpected nil of type %T", v)
33496	}
33497	if value == nil {
33498		return nil
33499	}
33500
33501	shape, ok := value.(map[string]interface{})
33502	if !ok {
33503		return fmt.Errorf("unexpected JSON type %v", value)
33504	}
33505
33506	var sv *GetAutoSnapshotsOutput
33507	if *v == nil {
33508		sv = &GetAutoSnapshotsOutput{}
33509	} else {
33510		sv = *v
33511	}
33512
33513	for key, value := range shape {
33514		switch key {
33515		case "autoSnapshots":
33516			if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(&sv.AutoSnapshots, value); err != nil {
33517				return err
33518			}
33519
33520		case "resourceName":
33521			if value != nil {
33522				jtv, ok := value.(string)
33523				if !ok {
33524					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
33525				}
33526				sv.ResourceName = ptr.String(jtv)
33527			}
33528
33529		case "resourceType":
33530			if value != nil {
33531				jtv, ok := value.(string)
33532				if !ok {
33533					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
33534				}
33535				sv.ResourceType = types.ResourceType(jtv)
33536			}
33537
33538		default:
33539			_, _ = key, value
33540
33541		}
33542	}
33543	*v = sv
33544	return nil
33545}
33546
33547func awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(v **GetBlueprintsOutput, value interface{}) error {
33548	if v == nil {
33549		return fmt.Errorf("unexpected nil of type %T", v)
33550	}
33551	if value == nil {
33552		return nil
33553	}
33554
33555	shape, ok := value.(map[string]interface{})
33556	if !ok {
33557		return fmt.Errorf("unexpected JSON type %v", value)
33558	}
33559
33560	var sv *GetBlueprintsOutput
33561	if *v == nil {
33562		sv = &GetBlueprintsOutput{}
33563	} else {
33564		sv = *v
33565	}
33566
33567	for key, value := range shape {
33568		switch key {
33569		case "blueprints":
33570			if err := awsAwsjson11_deserializeDocumentBlueprintList(&sv.Blueprints, value); err != nil {
33571				return err
33572			}
33573
33574		case "nextPageToken":
33575			if value != nil {
33576				jtv, ok := value.(string)
33577				if !ok {
33578					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33579				}
33580				sv.NextPageToken = ptr.String(jtv)
33581			}
33582
33583		default:
33584			_, _ = key, value
33585
33586		}
33587	}
33588	*v = sv
33589	return nil
33590}
33591
33592func awsAwsjson11_deserializeOpDocumentGetBucketAccessKeysOutput(v **GetBucketAccessKeysOutput, value interface{}) error {
33593	if v == nil {
33594		return fmt.Errorf("unexpected nil of type %T", v)
33595	}
33596	if value == nil {
33597		return nil
33598	}
33599
33600	shape, ok := value.(map[string]interface{})
33601	if !ok {
33602		return fmt.Errorf("unexpected JSON type %v", value)
33603	}
33604
33605	var sv *GetBucketAccessKeysOutput
33606	if *v == nil {
33607		sv = &GetBucketAccessKeysOutput{}
33608	} else {
33609		sv = *v
33610	}
33611
33612	for key, value := range shape {
33613		switch key {
33614		case "accessKeys":
33615			if err := awsAwsjson11_deserializeDocumentAccessKeyList(&sv.AccessKeys, value); err != nil {
33616				return err
33617			}
33618
33619		default:
33620			_, _ = key, value
33621
33622		}
33623	}
33624	*v = sv
33625	return nil
33626}
33627
33628func awsAwsjson11_deserializeOpDocumentGetBucketBundlesOutput(v **GetBucketBundlesOutput, value interface{}) error {
33629	if v == nil {
33630		return fmt.Errorf("unexpected nil of type %T", v)
33631	}
33632	if value == nil {
33633		return nil
33634	}
33635
33636	shape, ok := value.(map[string]interface{})
33637	if !ok {
33638		return fmt.Errorf("unexpected JSON type %v", value)
33639	}
33640
33641	var sv *GetBucketBundlesOutput
33642	if *v == nil {
33643		sv = &GetBucketBundlesOutput{}
33644	} else {
33645		sv = *v
33646	}
33647
33648	for key, value := range shape {
33649		switch key {
33650		case "bundles":
33651			if err := awsAwsjson11_deserializeDocumentBucketBundleList(&sv.Bundles, value); err != nil {
33652				return err
33653			}
33654
33655		default:
33656			_, _ = key, value
33657
33658		}
33659	}
33660	*v = sv
33661	return nil
33662}
33663
33664func awsAwsjson11_deserializeOpDocumentGetBucketMetricDataOutput(v **GetBucketMetricDataOutput, value interface{}) error {
33665	if v == nil {
33666		return fmt.Errorf("unexpected nil of type %T", v)
33667	}
33668	if value == nil {
33669		return nil
33670	}
33671
33672	shape, ok := value.(map[string]interface{})
33673	if !ok {
33674		return fmt.Errorf("unexpected JSON type %v", value)
33675	}
33676
33677	var sv *GetBucketMetricDataOutput
33678	if *v == nil {
33679		sv = &GetBucketMetricDataOutput{}
33680	} else {
33681		sv = *v
33682	}
33683
33684	for key, value := range shape {
33685		switch key {
33686		case "metricData":
33687			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
33688				return err
33689			}
33690
33691		case "metricName":
33692			if value != nil {
33693				jtv, ok := value.(string)
33694				if !ok {
33695					return fmt.Errorf("expected BucketMetricName to be of type string, got %T instead", value)
33696				}
33697				sv.MetricName = types.BucketMetricName(jtv)
33698			}
33699
33700		default:
33701			_, _ = key, value
33702
33703		}
33704	}
33705	*v = sv
33706	return nil
33707}
33708
33709func awsAwsjson11_deserializeOpDocumentGetBucketsOutput(v **GetBucketsOutput, value interface{}) error {
33710	if v == nil {
33711		return fmt.Errorf("unexpected nil of type %T", v)
33712	}
33713	if value == nil {
33714		return nil
33715	}
33716
33717	shape, ok := value.(map[string]interface{})
33718	if !ok {
33719		return fmt.Errorf("unexpected JSON type %v", value)
33720	}
33721
33722	var sv *GetBucketsOutput
33723	if *v == nil {
33724		sv = &GetBucketsOutput{}
33725	} else {
33726		sv = *v
33727	}
33728
33729	for key, value := range shape {
33730		switch key {
33731		case "buckets":
33732			if err := awsAwsjson11_deserializeDocumentBucketList(&sv.Buckets, value); err != nil {
33733				return err
33734			}
33735
33736		case "nextPageToken":
33737			if value != nil {
33738				jtv, ok := value.(string)
33739				if !ok {
33740					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33741				}
33742				sv.NextPageToken = ptr.String(jtv)
33743			}
33744
33745		default:
33746			_, _ = key, value
33747
33748		}
33749	}
33750	*v = sv
33751	return nil
33752}
33753
33754func awsAwsjson11_deserializeOpDocumentGetBundlesOutput(v **GetBundlesOutput, value interface{}) error {
33755	if v == nil {
33756		return fmt.Errorf("unexpected nil of type %T", v)
33757	}
33758	if value == nil {
33759		return nil
33760	}
33761
33762	shape, ok := value.(map[string]interface{})
33763	if !ok {
33764		return fmt.Errorf("unexpected JSON type %v", value)
33765	}
33766
33767	var sv *GetBundlesOutput
33768	if *v == nil {
33769		sv = &GetBundlesOutput{}
33770	} else {
33771		sv = *v
33772	}
33773
33774	for key, value := range shape {
33775		switch key {
33776		case "bundles":
33777			if err := awsAwsjson11_deserializeDocumentBundleList(&sv.Bundles, value); err != nil {
33778				return err
33779			}
33780
33781		case "nextPageToken":
33782			if value != nil {
33783				jtv, ok := value.(string)
33784				if !ok {
33785					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33786				}
33787				sv.NextPageToken = ptr.String(jtv)
33788			}
33789
33790		default:
33791			_, _ = key, value
33792
33793		}
33794	}
33795	*v = sv
33796	return nil
33797}
33798
33799func awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(v **GetCertificatesOutput, value interface{}) error {
33800	if v == nil {
33801		return fmt.Errorf("unexpected nil of type %T", v)
33802	}
33803	if value == nil {
33804		return nil
33805	}
33806
33807	shape, ok := value.(map[string]interface{})
33808	if !ok {
33809		return fmt.Errorf("unexpected JSON type %v", value)
33810	}
33811
33812	var sv *GetCertificatesOutput
33813	if *v == nil {
33814		sv = &GetCertificatesOutput{}
33815	} else {
33816		sv = *v
33817	}
33818
33819	for key, value := range shape {
33820		switch key {
33821		case "certificates":
33822			if err := awsAwsjson11_deserializeDocumentCertificateSummaryList(&sv.Certificates, value); err != nil {
33823				return err
33824			}
33825
33826		default:
33827			_, _ = key, value
33828
33829		}
33830	}
33831	*v = sv
33832	return nil
33833}
33834
33835func awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(v **GetCloudFormationStackRecordsOutput, value interface{}) error {
33836	if v == nil {
33837		return fmt.Errorf("unexpected nil of type %T", v)
33838	}
33839	if value == nil {
33840		return nil
33841	}
33842
33843	shape, ok := value.(map[string]interface{})
33844	if !ok {
33845		return fmt.Errorf("unexpected JSON type %v", value)
33846	}
33847
33848	var sv *GetCloudFormationStackRecordsOutput
33849	if *v == nil {
33850		sv = &GetCloudFormationStackRecordsOutput{}
33851	} else {
33852		sv = *v
33853	}
33854
33855	for key, value := range shape {
33856		switch key {
33857		case "cloudFormationStackRecords":
33858			if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(&sv.CloudFormationStackRecords, value); err != nil {
33859				return err
33860			}
33861
33862		case "nextPageToken":
33863			if value != nil {
33864				jtv, ok := value.(string)
33865				if !ok {
33866					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33867				}
33868				sv.NextPageToken = ptr.String(jtv)
33869			}
33870
33871		default:
33872			_, _ = key, value
33873
33874		}
33875	}
33876	*v = sv
33877	return nil
33878}
33879
33880func awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(v **GetContactMethodsOutput, value interface{}) error {
33881	if v == nil {
33882		return fmt.Errorf("unexpected nil of type %T", v)
33883	}
33884	if value == nil {
33885		return nil
33886	}
33887
33888	shape, ok := value.(map[string]interface{})
33889	if !ok {
33890		return fmt.Errorf("unexpected JSON type %v", value)
33891	}
33892
33893	var sv *GetContactMethodsOutput
33894	if *v == nil {
33895		sv = &GetContactMethodsOutput{}
33896	} else {
33897		sv = *v
33898	}
33899
33900	for key, value := range shape {
33901		switch key {
33902		case "contactMethods":
33903			if err := awsAwsjson11_deserializeDocumentContactMethodsList(&sv.ContactMethods, value); err != nil {
33904				return err
33905			}
33906
33907		default:
33908			_, _ = key, value
33909
33910		}
33911	}
33912	*v = sv
33913	return nil
33914}
33915
33916func awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(v **GetContainerAPIMetadataOutput, value interface{}) error {
33917	if v == nil {
33918		return fmt.Errorf("unexpected nil of type %T", v)
33919	}
33920	if value == nil {
33921		return nil
33922	}
33923
33924	shape, ok := value.(map[string]interface{})
33925	if !ok {
33926		return fmt.Errorf("unexpected JSON type %v", value)
33927	}
33928
33929	var sv *GetContainerAPIMetadataOutput
33930	if *v == nil {
33931		sv = &GetContainerAPIMetadataOutput{}
33932	} else {
33933		sv = *v
33934	}
33935
33936	for key, value := range shape {
33937		switch key {
33938		case "metadata":
33939			if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(&sv.Metadata, value); err != nil {
33940				return err
33941			}
33942
33943		default:
33944			_, _ = key, value
33945
33946		}
33947	}
33948	*v = sv
33949	return nil
33950}
33951
33952func awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(v **GetContainerImagesOutput, value interface{}) error {
33953	if v == nil {
33954		return fmt.Errorf("unexpected nil of type %T", v)
33955	}
33956	if value == nil {
33957		return nil
33958	}
33959
33960	shape, ok := value.(map[string]interface{})
33961	if !ok {
33962		return fmt.Errorf("unexpected JSON type %v", value)
33963	}
33964
33965	var sv *GetContainerImagesOutput
33966	if *v == nil {
33967		sv = &GetContainerImagesOutput{}
33968	} else {
33969		sv = *v
33970	}
33971
33972	for key, value := range shape {
33973		switch key {
33974		case "containerImages":
33975			if err := awsAwsjson11_deserializeDocumentContainerImageList(&sv.ContainerImages, value); err != nil {
33976				return err
33977			}
33978
33979		default:
33980			_, _ = key, value
33981
33982		}
33983	}
33984	*v = sv
33985	return nil
33986}
33987
33988func awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(v **GetContainerLogOutput, value interface{}) error {
33989	if v == nil {
33990		return fmt.Errorf("unexpected nil of type %T", v)
33991	}
33992	if value == nil {
33993		return nil
33994	}
33995
33996	shape, ok := value.(map[string]interface{})
33997	if !ok {
33998		return fmt.Errorf("unexpected JSON type %v", value)
33999	}
34000
34001	var sv *GetContainerLogOutput
34002	if *v == nil {
34003		sv = &GetContainerLogOutput{}
34004	} else {
34005		sv = *v
34006	}
34007
34008	for key, value := range shape {
34009		switch key {
34010		case "logEvents":
34011			if err := awsAwsjson11_deserializeDocumentContainerServiceLogEventList(&sv.LogEvents, value); err != nil {
34012				return err
34013			}
34014
34015		case "nextPageToken":
34016			if value != nil {
34017				jtv, ok := value.(string)
34018				if !ok {
34019					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34020				}
34021				sv.NextPageToken = ptr.String(jtv)
34022			}
34023
34024		default:
34025			_, _ = key, value
34026
34027		}
34028	}
34029	*v = sv
34030	return nil
34031}
34032
34033func awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(v **GetContainerServiceDeploymentsOutput, value interface{}) error {
34034	if v == nil {
34035		return fmt.Errorf("unexpected nil of type %T", v)
34036	}
34037	if value == nil {
34038		return nil
34039	}
34040
34041	shape, ok := value.(map[string]interface{})
34042	if !ok {
34043		return fmt.Errorf("unexpected JSON type %v", value)
34044	}
34045
34046	var sv *GetContainerServiceDeploymentsOutput
34047	if *v == nil {
34048		sv = &GetContainerServiceDeploymentsOutput{}
34049	} else {
34050		sv = *v
34051	}
34052
34053	for key, value := range shape {
34054		switch key {
34055		case "deployments":
34056			if err := awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(&sv.Deployments, value); err != nil {
34057				return err
34058			}
34059
34060		default:
34061			_, _ = key, value
34062
34063		}
34064	}
34065	*v = sv
34066	return nil
34067}
34068
34069func awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(v **GetContainerServiceMetricDataOutput, value interface{}) error {
34070	if v == nil {
34071		return fmt.Errorf("unexpected nil of type %T", v)
34072	}
34073	if value == nil {
34074		return nil
34075	}
34076
34077	shape, ok := value.(map[string]interface{})
34078	if !ok {
34079		return fmt.Errorf("unexpected JSON type %v", value)
34080	}
34081
34082	var sv *GetContainerServiceMetricDataOutput
34083	if *v == nil {
34084		sv = &GetContainerServiceMetricDataOutput{}
34085	} else {
34086		sv = *v
34087	}
34088
34089	for key, value := range shape {
34090		switch key {
34091		case "metricData":
34092			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
34093				return err
34094			}
34095
34096		case "metricName":
34097			if value != nil {
34098				jtv, ok := value.(string)
34099				if !ok {
34100					return fmt.Errorf("expected ContainerServiceMetricName to be of type string, got %T instead", value)
34101				}
34102				sv.MetricName = types.ContainerServiceMetricName(jtv)
34103			}
34104
34105		default:
34106			_, _ = key, value
34107
34108		}
34109	}
34110	*v = sv
34111	return nil
34112}
34113
34114func awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(v **GetContainerServicePowersOutput, value interface{}) error {
34115	if v == nil {
34116		return fmt.Errorf("unexpected nil of type %T", v)
34117	}
34118	if value == nil {
34119		return nil
34120	}
34121
34122	shape, ok := value.(map[string]interface{})
34123	if !ok {
34124		return fmt.Errorf("unexpected JSON type %v", value)
34125	}
34126
34127	var sv *GetContainerServicePowersOutput
34128	if *v == nil {
34129		sv = &GetContainerServicePowersOutput{}
34130	} else {
34131		sv = *v
34132	}
34133
34134	for key, value := range shape {
34135		switch key {
34136		case "powers":
34137			if err := awsAwsjson11_deserializeDocumentContainerServicePowerList(&sv.Powers, value); err != nil {
34138				return err
34139			}
34140
34141		default:
34142			_, _ = key, value
34143
34144		}
34145	}
34146	*v = sv
34147	return nil
34148}
34149
34150func awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(v **GetContainerServicesOutput, value interface{}) error {
34151	if v == nil {
34152		return fmt.Errorf("unexpected nil of type %T", v)
34153	}
34154	if value == nil {
34155		return nil
34156	}
34157
34158	shape, ok := value.(map[string]interface{})
34159	if !ok {
34160		return fmt.Errorf("unexpected JSON type %v", value)
34161	}
34162
34163	var sv *GetContainerServicesOutput
34164	if *v == nil {
34165		sv = &GetContainerServicesOutput{}
34166	} else {
34167		sv = *v
34168	}
34169
34170	for key, value := range shape {
34171		switch key {
34172		case "containerServices":
34173			if err := awsAwsjson11_deserializeDocumentContainerServiceList(&sv.ContainerServices, value); err != nil {
34174				return err
34175			}
34176
34177		default:
34178			_, _ = key, value
34179
34180		}
34181	}
34182	*v = sv
34183	return nil
34184}
34185
34186func awsAwsjson11_deserializeOpDocumentGetDiskOutput(v **GetDiskOutput, value interface{}) error {
34187	if v == nil {
34188		return fmt.Errorf("unexpected nil of type %T", v)
34189	}
34190	if value == nil {
34191		return nil
34192	}
34193
34194	shape, ok := value.(map[string]interface{})
34195	if !ok {
34196		return fmt.Errorf("unexpected JSON type %v", value)
34197	}
34198
34199	var sv *GetDiskOutput
34200	if *v == nil {
34201		sv = &GetDiskOutput{}
34202	} else {
34203		sv = *v
34204	}
34205
34206	for key, value := range shape {
34207		switch key {
34208		case "disk":
34209			if err := awsAwsjson11_deserializeDocumentDisk(&sv.Disk, value); err != nil {
34210				return err
34211			}
34212
34213		default:
34214			_, _ = key, value
34215
34216		}
34217	}
34218	*v = sv
34219	return nil
34220}
34221
34222func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(v **GetDiskSnapshotOutput, value interface{}) error {
34223	if v == nil {
34224		return fmt.Errorf("unexpected nil of type %T", v)
34225	}
34226	if value == nil {
34227		return nil
34228	}
34229
34230	shape, ok := value.(map[string]interface{})
34231	if !ok {
34232		return fmt.Errorf("unexpected JSON type %v", value)
34233	}
34234
34235	var sv *GetDiskSnapshotOutput
34236	if *v == nil {
34237		sv = &GetDiskSnapshotOutput{}
34238	} else {
34239		sv = *v
34240	}
34241
34242	for key, value := range shape {
34243		switch key {
34244		case "diskSnapshot":
34245			if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&sv.DiskSnapshot, value); err != nil {
34246				return err
34247			}
34248
34249		default:
34250			_, _ = key, value
34251
34252		}
34253	}
34254	*v = sv
34255	return nil
34256}
34257
34258func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(v **GetDiskSnapshotsOutput, value interface{}) error {
34259	if v == nil {
34260		return fmt.Errorf("unexpected nil of type %T", v)
34261	}
34262	if value == nil {
34263		return nil
34264	}
34265
34266	shape, ok := value.(map[string]interface{})
34267	if !ok {
34268		return fmt.Errorf("unexpected JSON type %v", value)
34269	}
34270
34271	var sv *GetDiskSnapshotsOutput
34272	if *v == nil {
34273		sv = &GetDiskSnapshotsOutput{}
34274	} else {
34275		sv = *v
34276	}
34277
34278	for key, value := range shape {
34279		switch key {
34280		case "diskSnapshots":
34281			if err := awsAwsjson11_deserializeDocumentDiskSnapshotList(&sv.DiskSnapshots, value); err != nil {
34282				return err
34283			}
34284
34285		case "nextPageToken":
34286			if value != nil {
34287				jtv, ok := value.(string)
34288				if !ok {
34289					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34290				}
34291				sv.NextPageToken = ptr.String(jtv)
34292			}
34293
34294		default:
34295			_, _ = key, value
34296
34297		}
34298	}
34299	*v = sv
34300	return nil
34301}
34302
34303func awsAwsjson11_deserializeOpDocumentGetDisksOutput(v **GetDisksOutput, value interface{}) error {
34304	if v == nil {
34305		return fmt.Errorf("unexpected nil of type %T", v)
34306	}
34307	if value == nil {
34308		return nil
34309	}
34310
34311	shape, ok := value.(map[string]interface{})
34312	if !ok {
34313		return fmt.Errorf("unexpected JSON type %v", value)
34314	}
34315
34316	var sv *GetDisksOutput
34317	if *v == nil {
34318		sv = &GetDisksOutput{}
34319	} else {
34320		sv = *v
34321	}
34322
34323	for key, value := range shape {
34324		switch key {
34325		case "disks":
34326			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
34327				return err
34328			}
34329
34330		case "nextPageToken":
34331			if value != nil {
34332				jtv, ok := value.(string)
34333				if !ok {
34334					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34335				}
34336				sv.NextPageToken = ptr.String(jtv)
34337			}
34338
34339		default:
34340			_, _ = key, value
34341
34342		}
34343	}
34344	*v = sv
34345	return nil
34346}
34347
34348func awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(v **GetDistributionBundlesOutput, value interface{}) error {
34349	if v == nil {
34350		return fmt.Errorf("unexpected nil of type %T", v)
34351	}
34352	if value == nil {
34353		return nil
34354	}
34355
34356	shape, ok := value.(map[string]interface{})
34357	if !ok {
34358		return fmt.Errorf("unexpected JSON type %v", value)
34359	}
34360
34361	var sv *GetDistributionBundlesOutput
34362	if *v == nil {
34363		sv = &GetDistributionBundlesOutput{}
34364	} else {
34365		sv = *v
34366	}
34367
34368	for key, value := range shape {
34369		switch key {
34370		case "bundles":
34371			if err := awsAwsjson11_deserializeDocumentDistributionBundleList(&sv.Bundles, value); err != nil {
34372				return err
34373			}
34374
34375		default:
34376			_, _ = key, value
34377
34378		}
34379	}
34380	*v = sv
34381	return nil
34382}
34383
34384func awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(v **GetDistributionLatestCacheResetOutput, value interface{}) error {
34385	if v == nil {
34386		return fmt.Errorf("unexpected nil of type %T", v)
34387	}
34388	if value == nil {
34389		return nil
34390	}
34391
34392	shape, ok := value.(map[string]interface{})
34393	if !ok {
34394		return fmt.Errorf("unexpected JSON type %v", value)
34395	}
34396
34397	var sv *GetDistributionLatestCacheResetOutput
34398	if *v == nil {
34399		sv = &GetDistributionLatestCacheResetOutput{}
34400	} else {
34401		sv = *v
34402	}
34403
34404	for key, value := range shape {
34405		switch key {
34406		case "createTime":
34407			if value != nil {
34408				switch jtv := value.(type) {
34409				case json.Number:
34410					f64, err := jtv.Float64()
34411					if err != nil {
34412						return err
34413					}
34414					sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
34415
34416				default:
34417					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
34418
34419				}
34420			}
34421
34422		case "status":
34423			if value != nil {
34424				jtv, ok := value.(string)
34425				if !ok {
34426					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34427				}
34428				sv.Status = ptr.String(jtv)
34429			}
34430
34431		default:
34432			_, _ = key, value
34433
34434		}
34435	}
34436	*v = sv
34437	return nil
34438}
34439
34440func awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(v **GetDistributionMetricDataOutput, value interface{}) error {
34441	if v == nil {
34442		return fmt.Errorf("unexpected nil of type %T", v)
34443	}
34444	if value == nil {
34445		return nil
34446	}
34447
34448	shape, ok := value.(map[string]interface{})
34449	if !ok {
34450		return fmt.Errorf("unexpected JSON type %v", value)
34451	}
34452
34453	var sv *GetDistributionMetricDataOutput
34454	if *v == nil {
34455		sv = &GetDistributionMetricDataOutput{}
34456	} else {
34457		sv = *v
34458	}
34459
34460	for key, value := range shape {
34461		switch key {
34462		case "metricData":
34463			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
34464				return err
34465			}
34466
34467		case "metricName":
34468			if value != nil {
34469				jtv, ok := value.(string)
34470				if !ok {
34471					return fmt.Errorf("expected DistributionMetricName to be of type string, got %T instead", value)
34472				}
34473				sv.MetricName = types.DistributionMetricName(jtv)
34474			}
34475
34476		default:
34477			_, _ = key, value
34478
34479		}
34480	}
34481	*v = sv
34482	return nil
34483}
34484
34485func awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(v **GetDistributionsOutput, value interface{}) error {
34486	if v == nil {
34487		return fmt.Errorf("unexpected nil of type %T", v)
34488	}
34489	if value == nil {
34490		return nil
34491	}
34492
34493	shape, ok := value.(map[string]interface{})
34494	if !ok {
34495		return fmt.Errorf("unexpected JSON type %v", value)
34496	}
34497
34498	var sv *GetDistributionsOutput
34499	if *v == nil {
34500		sv = &GetDistributionsOutput{}
34501	} else {
34502		sv = *v
34503	}
34504
34505	for key, value := range shape {
34506		switch key {
34507		case "distributions":
34508			if err := awsAwsjson11_deserializeDocumentDistributionList(&sv.Distributions, value); err != nil {
34509				return err
34510			}
34511
34512		case "nextPageToken":
34513			if value != nil {
34514				jtv, ok := value.(string)
34515				if !ok {
34516					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34517				}
34518				sv.NextPageToken = ptr.String(jtv)
34519			}
34520
34521		default:
34522			_, _ = key, value
34523
34524		}
34525	}
34526	*v = sv
34527	return nil
34528}
34529
34530func awsAwsjson11_deserializeOpDocumentGetDomainOutput(v **GetDomainOutput, value interface{}) error {
34531	if v == nil {
34532		return fmt.Errorf("unexpected nil of type %T", v)
34533	}
34534	if value == nil {
34535		return nil
34536	}
34537
34538	shape, ok := value.(map[string]interface{})
34539	if !ok {
34540		return fmt.Errorf("unexpected JSON type %v", value)
34541	}
34542
34543	var sv *GetDomainOutput
34544	if *v == nil {
34545		sv = &GetDomainOutput{}
34546	} else {
34547		sv = *v
34548	}
34549
34550	for key, value := range shape {
34551		switch key {
34552		case "domain":
34553			if err := awsAwsjson11_deserializeDocumentDomain(&sv.Domain, value); err != nil {
34554				return err
34555			}
34556
34557		default:
34558			_, _ = key, value
34559
34560		}
34561	}
34562	*v = sv
34563	return nil
34564}
34565
34566func awsAwsjson11_deserializeOpDocumentGetDomainsOutput(v **GetDomainsOutput, value interface{}) error {
34567	if v == nil {
34568		return fmt.Errorf("unexpected nil of type %T", v)
34569	}
34570	if value == nil {
34571		return nil
34572	}
34573
34574	shape, ok := value.(map[string]interface{})
34575	if !ok {
34576		return fmt.Errorf("unexpected JSON type %v", value)
34577	}
34578
34579	var sv *GetDomainsOutput
34580	if *v == nil {
34581		sv = &GetDomainsOutput{}
34582	} else {
34583		sv = *v
34584	}
34585
34586	for key, value := range shape {
34587		switch key {
34588		case "domains":
34589			if err := awsAwsjson11_deserializeDocumentDomainList(&sv.Domains, value); err != nil {
34590				return err
34591			}
34592
34593		case "nextPageToken":
34594			if value != nil {
34595				jtv, ok := value.(string)
34596				if !ok {
34597					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34598				}
34599				sv.NextPageToken = ptr.String(jtv)
34600			}
34601
34602		default:
34603			_, _ = key, value
34604
34605		}
34606	}
34607	*v = sv
34608	return nil
34609}
34610
34611func awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(v **GetExportSnapshotRecordsOutput, value interface{}) error {
34612	if v == nil {
34613		return fmt.Errorf("unexpected nil of type %T", v)
34614	}
34615	if value == nil {
34616		return nil
34617	}
34618
34619	shape, ok := value.(map[string]interface{})
34620	if !ok {
34621		return fmt.Errorf("unexpected JSON type %v", value)
34622	}
34623
34624	var sv *GetExportSnapshotRecordsOutput
34625	if *v == nil {
34626		sv = &GetExportSnapshotRecordsOutput{}
34627	} else {
34628		sv = *v
34629	}
34630
34631	for key, value := range shape {
34632		switch key {
34633		case "exportSnapshotRecords":
34634			if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordList(&sv.ExportSnapshotRecords, value); err != nil {
34635				return err
34636			}
34637
34638		case "nextPageToken":
34639			if value != nil {
34640				jtv, ok := value.(string)
34641				if !ok {
34642					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34643				}
34644				sv.NextPageToken = ptr.String(jtv)
34645			}
34646
34647		default:
34648			_, _ = key, value
34649
34650		}
34651	}
34652	*v = sv
34653	return nil
34654}
34655
34656func awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(v **GetInstanceAccessDetailsOutput, value interface{}) error {
34657	if v == nil {
34658		return fmt.Errorf("unexpected nil of type %T", v)
34659	}
34660	if value == nil {
34661		return nil
34662	}
34663
34664	shape, ok := value.(map[string]interface{})
34665	if !ok {
34666		return fmt.Errorf("unexpected JSON type %v", value)
34667	}
34668
34669	var sv *GetInstanceAccessDetailsOutput
34670	if *v == nil {
34671		sv = &GetInstanceAccessDetailsOutput{}
34672	} else {
34673		sv = *v
34674	}
34675
34676	for key, value := range shape {
34677		switch key {
34678		case "accessDetails":
34679			if err := awsAwsjson11_deserializeDocumentInstanceAccessDetails(&sv.AccessDetails, value); err != nil {
34680				return err
34681			}
34682
34683		default:
34684			_, _ = key, value
34685
34686		}
34687	}
34688	*v = sv
34689	return nil
34690}
34691
34692func awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(v **GetInstanceMetricDataOutput, value interface{}) error {
34693	if v == nil {
34694		return fmt.Errorf("unexpected nil of type %T", v)
34695	}
34696	if value == nil {
34697		return nil
34698	}
34699
34700	shape, ok := value.(map[string]interface{})
34701	if !ok {
34702		return fmt.Errorf("unexpected JSON type %v", value)
34703	}
34704
34705	var sv *GetInstanceMetricDataOutput
34706	if *v == nil {
34707		sv = &GetInstanceMetricDataOutput{}
34708	} else {
34709		sv = *v
34710	}
34711
34712	for key, value := range shape {
34713		switch key {
34714		case "metricData":
34715			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
34716				return err
34717			}
34718
34719		case "metricName":
34720			if value != nil {
34721				jtv, ok := value.(string)
34722				if !ok {
34723					return fmt.Errorf("expected InstanceMetricName to be of type string, got %T instead", value)
34724				}
34725				sv.MetricName = types.InstanceMetricName(jtv)
34726			}
34727
34728		default:
34729			_, _ = key, value
34730
34731		}
34732	}
34733	*v = sv
34734	return nil
34735}
34736
34737func awsAwsjson11_deserializeOpDocumentGetInstanceOutput(v **GetInstanceOutput, value interface{}) error {
34738	if v == nil {
34739		return fmt.Errorf("unexpected nil of type %T", v)
34740	}
34741	if value == nil {
34742		return nil
34743	}
34744
34745	shape, ok := value.(map[string]interface{})
34746	if !ok {
34747		return fmt.Errorf("unexpected JSON type %v", value)
34748	}
34749
34750	var sv *GetInstanceOutput
34751	if *v == nil {
34752		sv = &GetInstanceOutput{}
34753	} else {
34754		sv = *v
34755	}
34756
34757	for key, value := range shape {
34758		switch key {
34759		case "instance":
34760			if err := awsAwsjson11_deserializeDocumentInstance(&sv.Instance, value); err != nil {
34761				return err
34762			}
34763
34764		default:
34765			_, _ = key, value
34766
34767		}
34768	}
34769	*v = sv
34770	return nil
34771}
34772
34773func awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(v **GetInstancePortStatesOutput, value interface{}) error {
34774	if v == nil {
34775		return fmt.Errorf("unexpected nil of type %T", v)
34776	}
34777	if value == nil {
34778		return nil
34779	}
34780
34781	shape, ok := value.(map[string]interface{})
34782	if !ok {
34783		return fmt.Errorf("unexpected JSON type %v", value)
34784	}
34785
34786	var sv *GetInstancePortStatesOutput
34787	if *v == nil {
34788		sv = &GetInstancePortStatesOutput{}
34789	} else {
34790		sv = *v
34791	}
34792
34793	for key, value := range shape {
34794		switch key {
34795		case "portStates":
34796			if err := awsAwsjson11_deserializeDocumentInstancePortStateList(&sv.PortStates, value); err != nil {
34797				return err
34798			}
34799
34800		default:
34801			_, _ = key, value
34802
34803		}
34804	}
34805	*v = sv
34806	return nil
34807}
34808
34809func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(v **GetInstanceSnapshotOutput, value interface{}) error {
34810	if v == nil {
34811		return fmt.Errorf("unexpected nil of type %T", v)
34812	}
34813	if value == nil {
34814		return nil
34815	}
34816
34817	shape, ok := value.(map[string]interface{})
34818	if !ok {
34819		return fmt.Errorf("unexpected JSON type %v", value)
34820	}
34821
34822	var sv *GetInstanceSnapshotOutput
34823	if *v == nil {
34824		sv = &GetInstanceSnapshotOutput{}
34825	} else {
34826		sv = *v
34827	}
34828
34829	for key, value := range shape {
34830		switch key {
34831		case "instanceSnapshot":
34832			if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&sv.InstanceSnapshot, value); err != nil {
34833				return err
34834			}
34835
34836		default:
34837			_, _ = key, value
34838
34839		}
34840	}
34841	*v = sv
34842	return nil
34843}
34844
34845func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(v **GetInstanceSnapshotsOutput, value interface{}) error {
34846	if v == nil {
34847		return fmt.Errorf("unexpected nil of type %T", v)
34848	}
34849	if value == nil {
34850		return nil
34851	}
34852
34853	shape, ok := value.(map[string]interface{})
34854	if !ok {
34855		return fmt.Errorf("unexpected JSON type %v", value)
34856	}
34857
34858	var sv *GetInstanceSnapshotsOutput
34859	if *v == nil {
34860		sv = &GetInstanceSnapshotsOutput{}
34861	} else {
34862		sv = *v
34863	}
34864
34865	for key, value := range shape {
34866		switch key {
34867		case "instanceSnapshots":
34868			if err := awsAwsjson11_deserializeDocumentInstanceSnapshotList(&sv.InstanceSnapshots, value); err != nil {
34869				return err
34870			}
34871
34872		case "nextPageToken":
34873			if value != nil {
34874				jtv, ok := value.(string)
34875				if !ok {
34876					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34877				}
34878				sv.NextPageToken = ptr.String(jtv)
34879			}
34880
34881		default:
34882			_, _ = key, value
34883
34884		}
34885	}
34886	*v = sv
34887	return nil
34888}
34889
34890func awsAwsjson11_deserializeOpDocumentGetInstancesOutput(v **GetInstancesOutput, value interface{}) error {
34891	if v == nil {
34892		return fmt.Errorf("unexpected nil of type %T", v)
34893	}
34894	if value == nil {
34895		return nil
34896	}
34897
34898	shape, ok := value.(map[string]interface{})
34899	if !ok {
34900		return fmt.Errorf("unexpected JSON type %v", value)
34901	}
34902
34903	var sv *GetInstancesOutput
34904	if *v == nil {
34905		sv = &GetInstancesOutput{}
34906	} else {
34907		sv = *v
34908	}
34909
34910	for key, value := range shape {
34911		switch key {
34912		case "instances":
34913			if err := awsAwsjson11_deserializeDocumentInstanceList(&sv.Instances, value); err != nil {
34914				return err
34915			}
34916
34917		case "nextPageToken":
34918			if value != nil {
34919				jtv, ok := value.(string)
34920				if !ok {
34921					return fmt.Errorf("expected string to be of type string, got %T instead", value)
34922				}
34923				sv.NextPageToken = ptr.String(jtv)
34924			}
34925
34926		default:
34927			_, _ = key, value
34928
34929		}
34930	}
34931	*v = sv
34932	return nil
34933}
34934
34935func awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(v **GetInstanceStateOutput, value interface{}) error {
34936	if v == nil {
34937		return fmt.Errorf("unexpected nil of type %T", v)
34938	}
34939	if value == nil {
34940		return nil
34941	}
34942
34943	shape, ok := value.(map[string]interface{})
34944	if !ok {
34945		return fmt.Errorf("unexpected JSON type %v", value)
34946	}
34947
34948	var sv *GetInstanceStateOutput
34949	if *v == nil {
34950		sv = &GetInstanceStateOutput{}
34951	} else {
34952		sv = *v
34953	}
34954
34955	for key, value := range shape {
34956		switch key {
34957		case "state":
34958			if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
34959				return err
34960			}
34961
34962		default:
34963			_, _ = key, value
34964
34965		}
34966	}
34967	*v = sv
34968	return nil
34969}
34970
34971func awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(v **GetKeyPairOutput, value interface{}) error {
34972	if v == nil {
34973		return fmt.Errorf("unexpected nil of type %T", v)
34974	}
34975	if value == nil {
34976		return nil
34977	}
34978
34979	shape, ok := value.(map[string]interface{})
34980	if !ok {
34981		return fmt.Errorf("unexpected JSON type %v", value)
34982	}
34983
34984	var sv *GetKeyPairOutput
34985	if *v == nil {
34986		sv = &GetKeyPairOutput{}
34987	} else {
34988		sv = *v
34989	}
34990
34991	for key, value := range shape {
34992		switch key {
34993		case "keyPair":
34994			if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
34995				return err
34996			}
34997
34998		default:
34999			_, _ = key, value
35000
35001		}
35002	}
35003	*v = sv
35004	return nil
35005}
35006
35007func awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(v **GetKeyPairsOutput, value interface{}) error {
35008	if v == nil {
35009		return fmt.Errorf("unexpected nil of type %T", v)
35010	}
35011	if value == nil {
35012		return nil
35013	}
35014
35015	shape, ok := value.(map[string]interface{})
35016	if !ok {
35017		return fmt.Errorf("unexpected JSON type %v", value)
35018	}
35019
35020	var sv *GetKeyPairsOutput
35021	if *v == nil {
35022		sv = &GetKeyPairsOutput{}
35023	} else {
35024		sv = *v
35025	}
35026
35027	for key, value := range shape {
35028		switch key {
35029		case "keyPairs":
35030			if err := awsAwsjson11_deserializeDocumentKeyPairList(&sv.KeyPairs, value); err != nil {
35031				return err
35032			}
35033
35034		case "nextPageToken":
35035			if value != nil {
35036				jtv, ok := value.(string)
35037				if !ok {
35038					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35039				}
35040				sv.NextPageToken = ptr.String(jtv)
35041			}
35042
35043		default:
35044			_, _ = key, value
35045
35046		}
35047	}
35048	*v = sv
35049	return nil
35050}
35051
35052func awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(v **GetLoadBalancerMetricDataOutput, value interface{}) error {
35053	if v == nil {
35054		return fmt.Errorf("unexpected nil of type %T", v)
35055	}
35056	if value == nil {
35057		return nil
35058	}
35059
35060	shape, ok := value.(map[string]interface{})
35061	if !ok {
35062		return fmt.Errorf("unexpected JSON type %v", value)
35063	}
35064
35065	var sv *GetLoadBalancerMetricDataOutput
35066	if *v == nil {
35067		sv = &GetLoadBalancerMetricDataOutput{}
35068	} else {
35069		sv = *v
35070	}
35071
35072	for key, value := range shape {
35073		switch key {
35074		case "metricData":
35075			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
35076				return err
35077			}
35078
35079		case "metricName":
35080			if value != nil {
35081				jtv, ok := value.(string)
35082				if !ok {
35083					return fmt.Errorf("expected LoadBalancerMetricName to be of type string, got %T instead", value)
35084				}
35085				sv.MetricName = types.LoadBalancerMetricName(jtv)
35086			}
35087
35088		default:
35089			_, _ = key, value
35090
35091		}
35092	}
35093	*v = sv
35094	return nil
35095}
35096
35097func awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(v **GetLoadBalancerOutput, value interface{}) error {
35098	if v == nil {
35099		return fmt.Errorf("unexpected nil of type %T", v)
35100	}
35101	if value == nil {
35102		return nil
35103	}
35104
35105	shape, ok := value.(map[string]interface{})
35106	if !ok {
35107		return fmt.Errorf("unexpected JSON type %v", value)
35108	}
35109
35110	var sv *GetLoadBalancerOutput
35111	if *v == nil {
35112		sv = &GetLoadBalancerOutput{}
35113	} else {
35114		sv = *v
35115	}
35116
35117	for key, value := range shape {
35118		switch key {
35119		case "loadBalancer":
35120			if err := awsAwsjson11_deserializeDocumentLoadBalancer(&sv.LoadBalancer, value); err != nil {
35121				return err
35122			}
35123
35124		default:
35125			_, _ = key, value
35126
35127		}
35128	}
35129	*v = sv
35130	return nil
35131}
35132
35133func awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(v **GetLoadBalancersOutput, value interface{}) error {
35134	if v == nil {
35135		return fmt.Errorf("unexpected nil of type %T", v)
35136	}
35137	if value == nil {
35138		return nil
35139	}
35140
35141	shape, ok := value.(map[string]interface{})
35142	if !ok {
35143		return fmt.Errorf("unexpected JSON type %v", value)
35144	}
35145
35146	var sv *GetLoadBalancersOutput
35147	if *v == nil {
35148		sv = &GetLoadBalancersOutput{}
35149	} else {
35150		sv = *v
35151	}
35152
35153	for key, value := range shape {
35154		switch key {
35155		case "loadBalancers":
35156			if err := awsAwsjson11_deserializeDocumentLoadBalancerList(&sv.LoadBalancers, value); err != nil {
35157				return err
35158			}
35159
35160		case "nextPageToken":
35161			if value != nil {
35162				jtv, ok := value.(string)
35163				if !ok {
35164					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35165				}
35166				sv.NextPageToken = ptr.String(jtv)
35167			}
35168
35169		default:
35170			_, _ = key, value
35171
35172		}
35173	}
35174	*v = sv
35175	return nil
35176}
35177
35178func awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(v **GetLoadBalancerTlsCertificatesOutput, value interface{}) error {
35179	if v == nil {
35180		return fmt.Errorf("unexpected nil of type %T", v)
35181	}
35182	if value == nil {
35183		return nil
35184	}
35185
35186	shape, ok := value.(map[string]interface{})
35187	if !ok {
35188		return fmt.Errorf("unexpected JSON type %v", value)
35189	}
35190
35191	var sv *GetLoadBalancerTlsCertificatesOutput
35192	if *v == nil {
35193		sv = &GetLoadBalancerTlsCertificatesOutput{}
35194	} else {
35195		sv = *v
35196	}
35197
35198	for key, value := range shape {
35199		switch key {
35200		case "tlsCertificates":
35201			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(&sv.TlsCertificates, value); err != nil {
35202				return err
35203			}
35204
35205		default:
35206			_, _ = key, value
35207
35208		}
35209	}
35210	*v = sv
35211	return nil
35212}
35213
35214func awsAwsjson11_deserializeOpDocumentGetOperationOutput(v **GetOperationOutput, value interface{}) error {
35215	if v == nil {
35216		return fmt.Errorf("unexpected nil of type %T", v)
35217	}
35218	if value == nil {
35219		return nil
35220	}
35221
35222	shape, ok := value.(map[string]interface{})
35223	if !ok {
35224		return fmt.Errorf("unexpected JSON type %v", value)
35225	}
35226
35227	var sv *GetOperationOutput
35228	if *v == nil {
35229		sv = &GetOperationOutput{}
35230	} else {
35231		sv = *v
35232	}
35233
35234	for key, value := range shape {
35235		switch key {
35236		case "operation":
35237			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
35238				return err
35239			}
35240
35241		default:
35242			_, _ = key, value
35243
35244		}
35245	}
35246	*v = sv
35247	return nil
35248}
35249
35250func awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(v **GetOperationsForResourceOutput, value interface{}) error {
35251	if v == nil {
35252		return fmt.Errorf("unexpected nil of type %T", v)
35253	}
35254	if value == nil {
35255		return nil
35256	}
35257
35258	shape, ok := value.(map[string]interface{})
35259	if !ok {
35260		return fmt.Errorf("unexpected JSON type %v", value)
35261	}
35262
35263	var sv *GetOperationsForResourceOutput
35264	if *v == nil {
35265		sv = &GetOperationsForResourceOutput{}
35266	} else {
35267		sv = *v
35268	}
35269
35270	for key, value := range shape {
35271		switch key {
35272		case "nextPageCount":
35273			if value != nil {
35274				jtv, ok := value.(string)
35275				if !ok {
35276					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35277				}
35278				sv.NextPageCount = ptr.String(jtv)
35279			}
35280
35281		case "nextPageToken":
35282			if value != nil {
35283				jtv, ok := value.(string)
35284				if !ok {
35285					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35286				}
35287				sv.NextPageToken = ptr.String(jtv)
35288			}
35289
35290		case "operations":
35291			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35292				return err
35293			}
35294
35295		default:
35296			_, _ = key, value
35297
35298		}
35299	}
35300	*v = sv
35301	return nil
35302}
35303
35304func awsAwsjson11_deserializeOpDocumentGetOperationsOutput(v **GetOperationsOutput, value interface{}) error {
35305	if v == nil {
35306		return fmt.Errorf("unexpected nil of type %T", v)
35307	}
35308	if value == nil {
35309		return nil
35310	}
35311
35312	shape, ok := value.(map[string]interface{})
35313	if !ok {
35314		return fmt.Errorf("unexpected JSON type %v", value)
35315	}
35316
35317	var sv *GetOperationsOutput
35318	if *v == nil {
35319		sv = &GetOperationsOutput{}
35320	} else {
35321		sv = *v
35322	}
35323
35324	for key, value := range shape {
35325		switch key {
35326		case "nextPageToken":
35327			if value != nil {
35328				jtv, ok := value.(string)
35329				if !ok {
35330					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35331				}
35332				sv.NextPageToken = ptr.String(jtv)
35333			}
35334
35335		case "operations":
35336			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
35337				return err
35338			}
35339
35340		default:
35341			_, _ = key, value
35342
35343		}
35344	}
35345	*v = sv
35346	return nil
35347}
35348
35349func awsAwsjson11_deserializeOpDocumentGetRegionsOutput(v **GetRegionsOutput, value interface{}) error {
35350	if v == nil {
35351		return fmt.Errorf("unexpected nil of type %T", v)
35352	}
35353	if value == nil {
35354		return nil
35355	}
35356
35357	shape, ok := value.(map[string]interface{})
35358	if !ok {
35359		return fmt.Errorf("unexpected JSON type %v", value)
35360	}
35361
35362	var sv *GetRegionsOutput
35363	if *v == nil {
35364		sv = &GetRegionsOutput{}
35365	} else {
35366		sv = *v
35367	}
35368
35369	for key, value := range shape {
35370		switch key {
35371		case "regions":
35372			if err := awsAwsjson11_deserializeDocumentRegionList(&sv.Regions, value); err != nil {
35373				return err
35374			}
35375
35376		default:
35377			_, _ = key, value
35378
35379		}
35380	}
35381	*v = sv
35382	return nil
35383}
35384
35385func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(v **GetRelationalDatabaseBlueprintsOutput, value interface{}) error {
35386	if v == nil {
35387		return fmt.Errorf("unexpected nil of type %T", v)
35388	}
35389	if value == nil {
35390		return nil
35391	}
35392
35393	shape, ok := value.(map[string]interface{})
35394	if !ok {
35395		return fmt.Errorf("unexpected JSON type %v", value)
35396	}
35397
35398	var sv *GetRelationalDatabaseBlueprintsOutput
35399	if *v == nil {
35400		sv = &GetRelationalDatabaseBlueprintsOutput{}
35401	} else {
35402		sv = *v
35403	}
35404
35405	for key, value := range shape {
35406		switch key {
35407		case "blueprints":
35408			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(&sv.Blueprints, value); err != nil {
35409				return err
35410			}
35411
35412		case "nextPageToken":
35413			if value != nil {
35414				jtv, ok := value.(string)
35415				if !ok {
35416					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35417				}
35418				sv.NextPageToken = ptr.String(jtv)
35419			}
35420
35421		default:
35422			_, _ = key, value
35423
35424		}
35425	}
35426	*v = sv
35427	return nil
35428}
35429
35430func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(v **GetRelationalDatabaseBundlesOutput, value interface{}) error {
35431	if v == nil {
35432		return fmt.Errorf("unexpected nil of type %T", v)
35433	}
35434	if value == nil {
35435		return nil
35436	}
35437
35438	shape, ok := value.(map[string]interface{})
35439	if !ok {
35440		return fmt.Errorf("unexpected JSON type %v", value)
35441	}
35442
35443	var sv *GetRelationalDatabaseBundlesOutput
35444	if *v == nil {
35445		sv = &GetRelationalDatabaseBundlesOutput{}
35446	} else {
35447		sv = *v
35448	}
35449
35450	for key, value := range shape {
35451		switch key {
35452		case "bundles":
35453			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(&sv.Bundles, value); err != nil {
35454				return err
35455			}
35456
35457		case "nextPageToken":
35458			if value != nil {
35459				jtv, ok := value.(string)
35460				if !ok {
35461					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35462				}
35463				sv.NextPageToken = ptr.String(jtv)
35464			}
35465
35466		default:
35467			_, _ = key, value
35468
35469		}
35470	}
35471	*v = sv
35472	return nil
35473}
35474
35475func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(v **GetRelationalDatabaseEventsOutput, value interface{}) error {
35476	if v == nil {
35477		return fmt.Errorf("unexpected nil of type %T", v)
35478	}
35479	if value == nil {
35480		return nil
35481	}
35482
35483	shape, ok := value.(map[string]interface{})
35484	if !ok {
35485		return fmt.Errorf("unexpected JSON type %v", value)
35486	}
35487
35488	var sv *GetRelationalDatabaseEventsOutput
35489	if *v == nil {
35490		sv = &GetRelationalDatabaseEventsOutput{}
35491	} else {
35492		sv = *v
35493	}
35494
35495	for key, value := range shape {
35496		switch key {
35497		case "nextPageToken":
35498			if value != nil {
35499				jtv, ok := value.(string)
35500				if !ok {
35501					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35502				}
35503				sv.NextPageToken = ptr.String(jtv)
35504			}
35505
35506		case "relationalDatabaseEvents":
35507			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(&sv.RelationalDatabaseEvents, value); err != nil {
35508				return err
35509			}
35510
35511		default:
35512			_, _ = key, value
35513
35514		}
35515	}
35516	*v = sv
35517	return nil
35518}
35519
35520func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(v **GetRelationalDatabaseLogEventsOutput, value interface{}) error {
35521	if v == nil {
35522		return fmt.Errorf("unexpected nil of type %T", v)
35523	}
35524	if value == nil {
35525		return nil
35526	}
35527
35528	shape, ok := value.(map[string]interface{})
35529	if !ok {
35530		return fmt.Errorf("unexpected JSON type %v", value)
35531	}
35532
35533	var sv *GetRelationalDatabaseLogEventsOutput
35534	if *v == nil {
35535		sv = &GetRelationalDatabaseLogEventsOutput{}
35536	} else {
35537		sv = *v
35538	}
35539
35540	for key, value := range shape {
35541		switch key {
35542		case "nextBackwardToken":
35543			if value != nil {
35544				jtv, ok := value.(string)
35545				if !ok {
35546					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35547				}
35548				sv.NextBackwardToken = ptr.String(jtv)
35549			}
35550
35551		case "nextForwardToken":
35552			if value != nil {
35553				jtv, ok := value.(string)
35554				if !ok {
35555					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35556				}
35557				sv.NextForwardToken = ptr.String(jtv)
35558			}
35559
35560		case "resourceLogEvents":
35561			if err := awsAwsjson11_deserializeDocumentLogEventList(&sv.ResourceLogEvents, value); err != nil {
35562				return err
35563			}
35564
35565		default:
35566			_, _ = key, value
35567
35568		}
35569	}
35570	*v = sv
35571	return nil
35572}
35573
35574func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(v **GetRelationalDatabaseLogStreamsOutput, value interface{}) error {
35575	if v == nil {
35576		return fmt.Errorf("unexpected nil of type %T", v)
35577	}
35578	if value == nil {
35579		return nil
35580	}
35581
35582	shape, ok := value.(map[string]interface{})
35583	if !ok {
35584		return fmt.Errorf("unexpected JSON type %v", value)
35585	}
35586
35587	var sv *GetRelationalDatabaseLogStreamsOutput
35588	if *v == nil {
35589		sv = &GetRelationalDatabaseLogStreamsOutput{}
35590	} else {
35591		sv = *v
35592	}
35593
35594	for key, value := range shape {
35595		switch key {
35596		case "logStreams":
35597			if err := awsAwsjson11_deserializeDocumentStringList(&sv.LogStreams, value); err != nil {
35598				return err
35599			}
35600
35601		default:
35602			_, _ = key, value
35603
35604		}
35605	}
35606	*v = sv
35607	return nil
35608}
35609
35610func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(v **GetRelationalDatabaseMasterUserPasswordOutput, value interface{}) error {
35611	if v == nil {
35612		return fmt.Errorf("unexpected nil of type %T", v)
35613	}
35614	if value == nil {
35615		return nil
35616	}
35617
35618	shape, ok := value.(map[string]interface{})
35619	if !ok {
35620		return fmt.Errorf("unexpected JSON type %v", value)
35621	}
35622
35623	var sv *GetRelationalDatabaseMasterUserPasswordOutput
35624	if *v == nil {
35625		sv = &GetRelationalDatabaseMasterUserPasswordOutput{}
35626	} else {
35627		sv = *v
35628	}
35629
35630	for key, value := range shape {
35631		switch key {
35632		case "createdAt":
35633			if value != nil {
35634				switch jtv := value.(type) {
35635				case json.Number:
35636					f64, err := jtv.Float64()
35637					if err != nil {
35638						return err
35639					}
35640					sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
35641
35642				default:
35643					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
35644
35645				}
35646			}
35647
35648		case "masterUserPassword":
35649			if value != nil {
35650				jtv, ok := value.(string)
35651				if !ok {
35652					return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
35653				}
35654				sv.MasterUserPassword = ptr.String(jtv)
35655			}
35656
35657		default:
35658			_, _ = key, value
35659
35660		}
35661	}
35662	*v = sv
35663	return nil
35664}
35665
35666func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(v **GetRelationalDatabaseMetricDataOutput, value interface{}) error {
35667	if v == nil {
35668		return fmt.Errorf("unexpected nil of type %T", v)
35669	}
35670	if value == nil {
35671		return nil
35672	}
35673
35674	shape, ok := value.(map[string]interface{})
35675	if !ok {
35676		return fmt.Errorf("unexpected JSON type %v", value)
35677	}
35678
35679	var sv *GetRelationalDatabaseMetricDataOutput
35680	if *v == nil {
35681		sv = &GetRelationalDatabaseMetricDataOutput{}
35682	} else {
35683		sv = *v
35684	}
35685
35686	for key, value := range shape {
35687		switch key {
35688		case "metricData":
35689			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
35690				return err
35691			}
35692
35693		case "metricName":
35694			if value != nil {
35695				jtv, ok := value.(string)
35696				if !ok {
35697					return fmt.Errorf("expected RelationalDatabaseMetricName to be of type string, got %T instead", value)
35698				}
35699				sv.MetricName = types.RelationalDatabaseMetricName(jtv)
35700			}
35701
35702		default:
35703			_, _ = key, value
35704
35705		}
35706	}
35707	*v = sv
35708	return nil
35709}
35710
35711func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(v **GetRelationalDatabaseOutput, value interface{}) error {
35712	if v == nil {
35713		return fmt.Errorf("unexpected nil of type %T", v)
35714	}
35715	if value == nil {
35716		return nil
35717	}
35718
35719	shape, ok := value.(map[string]interface{})
35720	if !ok {
35721		return fmt.Errorf("unexpected JSON type %v", value)
35722	}
35723
35724	var sv *GetRelationalDatabaseOutput
35725	if *v == nil {
35726		sv = &GetRelationalDatabaseOutput{}
35727	} else {
35728		sv = *v
35729	}
35730
35731	for key, value := range shape {
35732		switch key {
35733		case "relationalDatabase":
35734			if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&sv.RelationalDatabase, value); err != nil {
35735				return err
35736			}
35737
35738		default:
35739			_, _ = key, value
35740
35741		}
35742	}
35743	*v = sv
35744	return nil
35745}
35746
35747func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(v **GetRelationalDatabaseParametersOutput, value interface{}) error {
35748	if v == nil {
35749		return fmt.Errorf("unexpected nil of type %T", v)
35750	}
35751	if value == nil {
35752		return nil
35753	}
35754
35755	shape, ok := value.(map[string]interface{})
35756	if !ok {
35757		return fmt.Errorf("unexpected JSON type %v", value)
35758	}
35759
35760	var sv *GetRelationalDatabaseParametersOutput
35761	if *v == nil {
35762		sv = &GetRelationalDatabaseParametersOutput{}
35763	} else {
35764		sv = *v
35765	}
35766
35767	for key, value := range shape {
35768		switch key {
35769		case "nextPageToken":
35770			if value != nil {
35771				jtv, ok := value.(string)
35772				if !ok {
35773					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35774				}
35775				sv.NextPageToken = ptr.String(jtv)
35776			}
35777
35778		case "parameters":
35779			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(&sv.Parameters, value); err != nil {
35780				return err
35781			}
35782
35783		default:
35784			_, _ = key, value
35785
35786		}
35787	}
35788	*v = sv
35789	return nil
35790}
35791
35792func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(v **GetRelationalDatabaseSnapshotOutput, value interface{}) error {
35793	if v == nil {
35794		return fmt.Errorf("unexpected nil of type %T", v)
35795	}
35796	if value == nil {
35797		return nil
35798	}
35799
35800	shape, ok := value.(map[string]interface{})
35801	if !ok {
35802		return fmt.Errorf("unexpected JSON type %v", value)
35803	}
35804
35805	var sv *GetRelationalDatabaseSnapshotOutput
35806	if *v == nil {
35807		sv = &GetRelationalDatabaseSnapshotOutput{}
35808	} else {
35809		sv = *v
35810	}
35811
35812	for key, value := range shape {
35813		switch key {
35814		case "relationalDatabaseSnapshot":
35815			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&sv.RelationalDatabaseSnapshot, value); err != nil {
35816				return err
35817			}
35818
35819		default:
35820			_, _ = key, value
35821
35822		}
35823	}
35824	*v = sv
35825	return nil
35826}
35827
35828func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(v **GetRelationalDatabaseSnapshotsOutput, value interface{}) error {
35829	if v == nil {
35830		return fmt.Errorf("unexpected nil of type %T", v)
35831	}
35832	if value == nil {
35833		return nil
35834	}
35835
35836	shape, ok := value.(map[string]interface{})
35837	if !ok {
35838		return fmt.Errorf("unexpected JSON type %v", value)
35839	}
35840
35841	var sv *GetRelationalDatabaseSnapshotsOutput
35842	if *v == nil {
35843		sv = &GetRelationalDatabaseSnapshotsOutput{}
35844	} else {
35845		sv = *v
35846	}
35847
35848	for key, value := range shape {
35849		switch key {
35850		case "nextPageToken":
35851			if value != nil {
35852				jtv, ok := value.(string)
35853				if !ok {
35854					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35855				}
35856				sv.NextPageToken = ptr.String(jtv)
35857			}
35858
35859		case "relationalDatabaseSnapshots":
35860			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(&sv.RelationalDatabaseSnapshots, value); err != nil {
35861				return err
35862			}
35863
35864		default:
35865			_, _ = key, value
35866
35867		}
35868	}
35869	*v = sv
35870	return nil
35871}
35872
35873func awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(v **GetRelationalDatabasesOutput, value interface{}) error {
35874	if v == nil {
35875		return fmt.Errorf("unexpected nil of type %T", v)
35876	}
35877	if value == nil {
35878		return nil
35879	}
35880
35881	shape, ok := value.(map[string]interface{})
35882	if !ok {
35883		return fmt.Errorf("unexpected JSON type %v", value)
35884	}
35885
35886	var sv *GetRelationalDatabasesOutput
35887	if *v == nil {
35888		sv = &GetRelationalDatabasesOutput{}
35889	} else {
35890		sv = *v
35891	}
35892
35893	for key, value := range shape {
35894		switch key {
35895		case "nextPageToken":
35896			if value != nil {
35897				jtv, ok := value.(string)
35898				if !ok {
35899					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35900				}
35901				sv.NextPageToken = ptr.String(jtv)
35902			}
35903
35904		case "relationalDatabases":
35905			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseList(&sv.RelationalDatabases, value); err != nil {
35906				return err
35907			}
35908
35909		default:
35910			_, _ = key, value
35911
35912		}
35913	}
35914	*v = sv
35915	return nil
35916}
35917
35918func awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(v **GetStaticIpOutput, value interface{}) error {
35919	if v == nil {
35920		return fmt.Errorf("unexpected nil of type %T", v)
35921	}
35922	if value == nil {
35923		return nil
35924	}
35925
35926	shape, ok := value.(map[string]interface{})
35927	if !ok {
35928		return fmt.Errorf("unexpected JSON type %v", value)
35929	}
35930
35931	var sv *GetStaticIpOutput
35932	if *v == nil {
35933		sv = &GetStaticIpOutput{}
35934	} else {
35935		sv = *v
35936	}
35937
35938	for key, value := range shape {
35939		switch key {
35940		case "staticIp":
35941			if err := awsAwsjson11_deserializeDocumentStaticIp(&sv.StaticIp, value); err != nil {
35942				return err
35943			}
35944
35945		default:
35946			_, _ = key, value
35947
35948		}
35949	}
35950	*v = sv
35951	return nil
35952}
35953
35954func awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(v **GetStaticIpsOutput, value interface{}) error {
35955	if v == nil {
35956		return fmt.Errorf("unexpected nil of type %T", v)
35957	}
35958	if value == nil {
35959		return nil
35960	}
35961
35962	shape, ok := value.(map[string]interface{})
35963	if !ok {
35964		return fmt.Errorf("unexpected JSON type %v", value)
35965	}
35966
35967	var sv *GetStaticIpsOutput
35968	if *v == nil {
35969		sv = &GetStaticIpsOutput{}
35970	} else {
35971		sv = *v
35972	}
35973
35974	for key, value := range shape {
35975		switch key {
35976		case "nextPageToken":
35977			if value != nil {
35978				jtv, ok := value.(string)
35979				if !ok {
35980					return fmt.Errorf("expected string to be of type string, got %T instead", value)
35981				}
35982				sv.NextPageToken = ptr.String(jtv)
35983			}
35984
35985		case "staticIps":
35986			if err := awsAwsjson11_deserializeDocumentStaticIpList(&sv.StaticIps, value); err != nil {
35987				return err
35988			}
35989
35990		default:
35991			_, _ = key, value
35992
35993		}
35994	}
35995	*v = sv
35996	return nil
35997}
35998
35999func awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(v **ImportKeyPairOutput, value interface{}) error {
36000	if v == nil {
36001		return fmt.Errorf("unexpected nil of type %T", v)
36002	}
36003	if value == nil {
36004		return nil
36005	}
36006
36007	shape, ok := value.(map[string]interface{})
36008	if !ok {
36009		return fmt.Errorf("unexpected JSON type %v", value)
36010	}
36011
36012	var sv *ImportKeyPairOutput
36013	if *v == nil {
36014		sv = &ImportKeyPairOutput{}
36015	} else {
36016		sv = *v
36017	}
36018
36019	for key, value := range shape {
36020		switch key {
36021		case "operation":
36022			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36023				return err
36024			}
36025
36026		default:
36027			_, _ = key, value
36028
36029		}
36030	}
36031	*v = sv
36032	return nil
36033}
36034
36035func awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(v **IsVpcPeeredOutput, value interface{}) error {
36036	if v == nil {
36037		return fmt.Errorf("unexpected nil of type %T", v)
36038	}
36039	if value == nil {
36040		return nil
36041	}
36042
36043	shape, ok := value.(map[string]interface{})
36044	if !ok {
36045		return fmt.Errorf("unexpected JSON type %v", value)
36046	}
36047
36048	var sv *IsVpcPeeredOutput
36049	if *v == nil {
36050		sv = &IsVpcPeeredOutput{}
36051	} else {
36052		sv = *v
36053	}
36054
36055	for key, value := range shape {
36056		switch key {
36057		case "isPeered":
36058			if value != nil {
36059				jtv, ok := value.(bool)
36060				if !ok {
36061					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
36062				}
36063				sv.IsPeered = ptr.Bool(jtv)
36064			}
36065
36066		default:
36067			_, _ = key, value
36068
36069		}
36070	}
36071	*v = sv
36072	return nil
36073}
36074
36075func awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(v **OpenInstancePublicPortsOutput, value interface{}) error {
36076	if v == nil {
36077		return fmt.Errorf("unexpected nil of type %T", v)
36078	}
36079	if value == nil {
36080		return nil
36081	}
36082
36083	shape, ok := value.(map[string]interface{})
36084	if !ok {
36085		return fmt.Errorf("unexpected JSON type %v", value)
36086	}
36087
36088	var sv *OpenInstancePublicPortsOutput
36089	if *v == nil {
36090		sv = &OpenInstancePublicPortsOutput{}
36091	} else {
36092		sv = *v
36093	}
36094
36095	for key, value := range shape {
36096		switch key {
36097		case "operation":
36098			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36099				return err
36100			}
36101
36102		default:
36103			_, _ = key, value
36104
36105		}
36106	}
36107	*v = sv
36108	return nil
36109}
36110
36111func awsAwsjson11_deserializeOpDocumentPeerVpcOutput(v **PeerVpcOutput, value interface{}) error {
36112	if v == nil {
36113		return fmt.Errorf("unexpected nil of type %T", v)
36114	}
36115	if value == nil {
36116		return nil
36117	}
36118
36119	shape, ok := value.(map[string]interface{})
36120	if !ok {
36121		return fmt.Errorf("unexpected JSON type %v", value)
36122	}
36123
36124	var sv *PeerVpcOutput
36125	if *v == nil {
36126		sv = &PeerVpcOutput{}
36127	} else {
36128		sv = *v
36129	}
36130
36131	for key, value := range shape {
36132		switch key {
36133		case "operation":
36134			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36135				return err
36136			}
36137
36138		default:
36139			_, _ = key, value
36140
36141		}
36142	}
36143	*v = sv
36144	return nil
36145}
36146
36147func awsAwsjson11_deserializeOpDocumentPutAlarmOutput(v **PutAlarmOutput, value interface{}) error {
36148	if v == nil {
36149		return fmt.Errorf("unexpected nil of type %T", v)
36150	}
36151	if value == nil {
36152		return nil
36153	}
36154
36155	shape, ok := value.(map[string]interface{})
36156	if !ok {
36157		return fmt.Errorf("unexpected JSON type %v", value)
36158	}
36159
36160	var sv *PutAlarmOutput
36161	if *v == nil {
36162		sv = &PutAlarmOutput{}
36163	} else {
36164		sv = *v
36165	}
36166
36167	for key, value := range shape {
36168		switch key {
36169		case "operations":
36170			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36171				return err
36172			}
36173
36174		default:
36175			_, _ = key, value
36176
36177		}
36178	}
36179	*v = sv
36180	return nil
36181}
36182
36183func awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(v **PutInstancePublicPortsOutput, value interface{}) error {
36184	if v == nil {
36185		return fmt.Errorf("unexpected nil of type %T", v)
36186	}
36187	if value == nil {
36188		return nil
36189	}
36190
36191	shape, ok := value.(map[string]interface{})
36192	if !ok {
36193		return fmt.Errorf("unexpected JSON type %v", value)
36194	}
36195
36196	var sv *PutInstancePublicPortsOutput
36197	if *v == nil {
36198		sv = &PutInstancePublicPortsOutput{}
36199	} else {
36200		sv = *v
36201	}
36202
36203	for key, value := range shape {
36204		switch key {
36205		case "operation":
36206			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36207				return err
36208			}
36209
36210		default:
36211			_, _ = key, value
36212
36213		}
36214	}
36215	*v = sv
36216	return nil
36217}
36218
36219func awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(v **RebootInstanceOutput, value interface{}) error {
36220	if v == nil {
36221		return fmt.Errorf("unexpected nil of type %T", v)
36222	}
36223	if value == nil {
36224		return nil
36225	}
36226
36227	shape, ok := value.(map[string]interface{})
36228	if !ok {
36229		return fmt.Errorf("unexpected JSON type %v", value)
36230	}
36231
36232	var sv *RebootInstanceOutput
36233	if *v == nil {
36234		sv = &RebootInstanceOutput{}
36235	} else {
36236		sv = *v
36237	}
36238
36239	for key, value := range shape {
36240		switch key {
36241		case "operations":
36242			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36243				return err
36244			}
36245
36246		default:
36247			_, _ = key, value
36248
36249		}
36250	}
36251	*v = sv
36252	return nil
36253}
36254
36255func awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(v **RebootRelationalDatabaseOutput, value interface{}) error {
36256	if v == nil {
36257		return fmt.Errorf("unexpected nil of type %T", v)
36258	}
36259	if value == nil {
36260		return nil
36261	}
36262
36263	shape, ok := value.(map[string]interface{})
36264	if !ok {
36265		return fmt.Errorf("unexpected JSON type %v", value)
36266	}
36267
36268	var sv *RebootRelationalDatabaseOutput
36269	if *v == nil {
36270		sv = &RebootRelationalDatabaseOutput{}
36271	} else {
36272		sv = *v
36273	}
36274
36275	for key, value := range shape {
36276		switch key {
36277		case "operations":
36278			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36279				return err
36280			}
36281
36282		default:
36283			_, _ = key, value
36284
36285		}
36286	}
36287	*v = sv
36288	return nil
36289}
36290
36291func awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(v **RegisterContainerImageOutput, value interface{}) error {
36292	if v == nil {
36293		return fmt.Errorf("unexpected nil of type %T", v)
36294	}
36295	if value == nil {
36296		return nil
36297	}
36298
36299	shape, ok := value.(map[string]interface{})
36300	if !ok {
36301		return fmt.Errorf("unexpected JSON type %v", value)
36302	}
36303
36304	var sv *RegisterContainerImageOutput
36305	if *v == nil {
36306		sv = &RegisterContainerImageOutput{}
36307	} else {
36308		sv = *v
36309	}
36310
36311	for key, value := range shape {
36312		switch key {
36313		case "containerImage":
36314			if err := awsAwsjson11_deserializeDocumentContainerImage(&sv.ContainerImage, value); err != nil {
36315				return err
36316			}
36317
36318		default:
36319			_, _ = key, value
36320
36321		}
36322	}
36323	*v = sv
36324	return nil
36325}
36326
36327func awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(v **ReleaseStaticIpOutput, value interface{}) error {
36328	if v == nil {
36329		return fmt.Errorf("unexpected nil of type %T", v)
36330	}
36331	if value == nil {
36332		return nil
36333	}
36334
36335	shape, ok := value.(map[string]interface{})
36336	if !ok {
36337		return fmt.Errorf("unexpected JSON type %v", value)
36338	}
36339
36340	var sv *ReleaseStaticIpOutput
36341	if *v == nil {
36342		sv = &ReleaseStaticIpOutput{}
36343	} else {
36344		sv = *v
36345	}
36346
36347	for key, value := range shape {
36348		switch key {
36349		case "operations":
36350			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36351				return err
36352			}
36353
36354		default:
36355			_, _ = key, value
36356
36357		}
36358	}
36359	*v = sv
36360	return nil
36361}
36362
36363func awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(v **ResetDistributionCacheOutput, value interface{}) error {
36364	if v == nil {
36365		return fmt.Errorf("unexpected nil of type %T", v)
36366	}
36367	if value == nil {
36368		return nil
36369	}
36370
36371	shape, ok := value.(map[string]interface{})
36372	if !ok {
36373		return fmt.Errorf("unexpected JSON type %v", value)
36374	}
36375
36376	var sv *ResetDistributionCacheOutput
36377	if *v == nil {
36378		sv = &ResetDistributionCacheOutput{}
36379	} else {
36380		sv = *v
36381	}
36382
36383	for key, value := range shape {
36384		switch key {
36385		case "createTime":
36386			if value != nil {
36387				switch jtv := value.(type) {
36388				case json.Number:
36389					f64, err := jtv.Float64()
36390					if err != nil {
36391						return err
36392					}
36393					sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
36394
36395				default:
36396					return fmt.Errorf("expected IsoDate to be a JSON Number, got %T instead", value)
36397
36398				}
36399			}
36400
36401		case "operation":
36402			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36403				return err
36404			}
36405
36406		case "status":
36407			if value != nil {
36408				jtv, ok := value.(string)
36409				if !ok {
36410					return fmt.Errorf("expected string to be of type string, got %T instead", value)
36411				}
36412				sv.Status = ptr.String(jtv)
36413			}
36414
36415		default:
36416			_, _ = key, value
36417
36418		}
36419	}
36420	*v = sv
36421	return nil
36422}
36423
36424func awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(v **SendContactMethodVerificationOutput, value interface{}) error {
36425	if v == nil {
36426		return fmt.Errorf("unexpected nil of type %T", v)
36427	}
36428	if value == nil {
36429		return nil
36430	}
36431
36432	shape, ok := value.(map[string]interface{})
36433	if !ok {
36434		return fmt.Errorf("unexpected JSON type %v", value)
36435	}
36436
36437	var sv *SendContactMethodVerificationOutput
36438	if *v == nil {
36439		sv = &SendContactMethodVerificationOutput{}
36440	} else {
36441		sv = *v
36442	}
36443
36444	for key, value := range shape {
36445		switch key {
36446		case "operations":
36447			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36448				return err
36449			}
36450
36451		default:
36452			_, _ = key, value
36453
36454		}
36455	}
36456	*v = sv
36457	return nil
36458}
36459
36460func awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(v **SetIpAddressTypeOutput, value interface{}) error {
36461	if v == nil {
36462		return fmt.Errorf("unexpected nil of type %T", v)
36463	}
36464	if value == nil {
36465		return nil
36466	}
36467
36468	shape, ok := value.(map[string]interface{})
36469	if !ok {
36470		return fmt.Errorf("unexpected JSON type %v", value)
36471	}
36472
36473	var sv *SetIpAddressTypeOutput
36474	if *v == nil {
36475		sv = &SetIpAddressTypeOutput{}
36476	} else {
36477		sv = *v
36478	}
36479
36480	for key, value := range shape {
36481		switch key {
36482		case "operations":
36483			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36484				return err
36485			}
36486
36487		default:
36488			_, _ = key, value
36489
36490		}
36491	}
36492	*v = sv
36493	return nil
36494}
36495
36496func awsAwsjson11_deserializeOpDocumentSetResourceAccessForBucketOutput(v **SetResourceAccessForBucketOutput, value interface{}) error {
36497	if v == nil {
36498		return fmt.Errorf("unexpected nil of type %T", v)
36499	}
36500	if value == nil {
36501		return nil
36502	}
36503
36504	shape, ok := value.(map[string]interface{})
36505	if !ok {
36506		return fmt.Errorf("unexpected JSON type %v", value)
36507	}
36508
36509	var sv *SetResourceAccessForBucketOutput
36510	if *v == nil {
36511		sv = &SetResourceAccessForBucketOutput{}
36512	} else {
36513		sv = *v
36514	}
36515
36516	for key, value := range shape {
36517		switch key {
36518		case "operations":
36519			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36520				return err
36521			}
36522
36523		default:
36524			_, _ = key, value
36525
36526		}
36527	}
36528	*v = sv
36529	return nil
36530}
36531
36532func awsAwsjson11_deserializeOpDocumentStartInstanceOutput(v **StartInstanceOutput, value interface{}) error {
36533	if v == nil {
36534		return fmt.Errorf("unexpected nil of type %T", v)
36535	}
36536	if value == nil {
36537		return nil
36538	}
36539
36540	shape, ok := value.(map[string]interface{})
36541	if !ok {
36542		return fmt.Errorf("unexpected JSON type %v", value)
36543	}
36544
36545	var sv *StartInstanceOutput
36546	if *v == nil {
36547		sv = &StartInstanceOutput{}
36548	} else {
36549		sv = *v
36550	}
36551
36552	for key, value := range shape {
36553		switch key {
36554		case "operations":
36555			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36556				return err
36557			}
36558
36559		default:
36560			_, _ = key, value
36561
36562		}
36563	}
36564	*v = sv
36565	return nil
36566}
36567
36568func awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(v **StartRelationalDatabaseOutput, value interface{}) error {
36569	if v == nil {
36570		return fmt.Errorf("unexpected nil of type %T", v)
36571	}
36572	if value == nil {
36573		return nil
36574	}
36575
36576	shape, ok := value.(map[string]interface{})
36577	if !ok {
36578		return fmt.Errorf("unexpected JSON type %v", value)
36579	}
36580
36581	var sv *StartRelationalDatabaseOutput
36582	if *v == nil {
36583		sv = &StartRelationalDatabaseOutput{}
36584	} else {
36585		sv = *v
36586	}
36587
36588	for key, value := range shape {
36589		switch key {
36590		case "operations":
36591			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36592				return err
36593			}
36594
36595		default:
36596			_, _ = key, value
36597
36598		}
36599	}
36600	*v = sv
36601	return nil
36602}
36603
36604func awsAwsjson11_deserializeOpDocumentStopInstanceOutput(v **StopInstanceOutput, value interface{}) error {
36605	if v == nil {
36606		return fmt.Errorf("unexpected nil of type %T", v)
36607	}
36608	if value == nil {
36609		return nil
36610	}
36611
36612	shape, ok := value.(map[string]interface{})
36613	if !ok {
36614		return fmt.Errorf("unexpected JSON type %v", value)
36615	}
36616
36617	var sv *StopInstanceOutput
36618	if *v == nil {
36619		sv = &StopInstanceOutput{}
36620	} else {
36621		sv = *v
36622	}
36623
36624	for key, value := range shape {
36625		switch key {
36626		case "operations":
36627			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36628				return err
36629			}
36630
36631		default:
36632			_, _ = key, value
36633
36634		}
36635	}
36636	*v = sv
36637	return nil
36638}
36639
36640func awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(v **StopRelationalDatabaseOutput, value interface{}) error {
36641	if v == nil {
36642		return fmt.Errorf("unexpected nil of type %T", v)
36643	}
36644	if value == nil {
36645		return nil
36646	}
36647
36648	shape, ok := value.(map[string]interface{})
36649	if !ok {
36650		return fmt.Errorf("unexpected JSON type %v", value)
36651	}
36652
36653	var sv *StopRelationalDatabaseOutput
36654	if *v == nil {
36655		sv = &StopRelationalDatabaseOutput{}
36656	} else {
36657		sv = *v
36658	}
36659
36660	for key, value := range shape {
36661		switch key {
36662		case "operations":
36663			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36664				return err
36665			}
36666
36667		default:
36668			_, _ = key, value
36669
36670		}
36671	}
36672	*v = sv
36673	return nil
36674}
36675
36676func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
36677	if v == nil {
36678		return fmt.Errorf("unexpected nil of type %T", v)
36679	}
36680	if value == nil {
36681		return nil
36682	}
36683
36684	shape, ok := value.(map[string]interface{})
36685	if !ok {
36686		return fmt.Errorf("unexpected JSON type %v", value)
36687	}
36688
36689	var sv *TagResourceOutput
36690	if *v == nil {
36691		sv = &TagResourceOutput{}
36692	} else {
36693		sv = *v
36694	}
36695
36696	for key, value := range shape {
36697		switch key {
36698		case "operations":
36699			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36700				return err
36701			}
36702
36703		default:
36704			_, _ = key, value
36705
36706		}
36707	}
36708	*v = sv
36709	return nil
36710}
36711
36712func awsAwsjson11_deserializeOpDocumentTestAlarmOutput(v **TestAlarmOutput, value interface{}) error {
36713	if v == nil {
36714		return fmt.Errorf("unexpected nil of type %T", v)
36715	}
36716	if value == nil {
36717		return nil
36718	}
36719
36720	shape, ok := value.(map[string]interface{})
36721	if !ok {
36722		return fmt.Errorf("unexpected JSON type %v", value)
36723	}
36724
36725	var sv *TestAlarmOutput
36726	if *v == nil {
36727		sv = &TestAlarmOutput{}
36728	} else {
36729		sv = *v
36730	}
36731
36732	for key, value := range shape {
36733		switch key {
36734		case "operations":
36735			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36736				return err
36737			}
36738
36739		default:
36740			_, _ = key, value
36741
36742		}
36743	}
36744	*v = sv
36745	return nil
36746}
36747
36748func awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(v **UnpeerVpcOutput, value interface{}) error {
36749	if v == nil {
36750		return fmt.Errorf("unexpected nil of type %T", v)
36751	}
36752	if value == nil {
36753		return nil
36754	}
36755
36756	shape, ok := value.(map[string]interface{})
36757	if !ok {
36758		return fmt.Errorf("unexpected JSON type %v", value)
36759	}
36760
36761	var sv *UnpeerVpcOutput
36762	if *v == nil {
36763		sv = &UnpeerVpcOutput{}
36764	} else {
36765		sv = *v
36766	}
36767
36768	for key, value := range shape {
36769		switch key {
36770		case "operation":
36771			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36772				return err
36773			}
36774
36775		default:
36776			_, _ = key, value
36777
36778		}
36779	}
36780	*v = sv
36781	return nil
36782}
36783
36784func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
36785	if v == nil {
36786		return fmt.Errorf("unexpected nil of type %T", v)
36787	}
36788	if value == nil {
36789		return nil
36790	}
36791
36792	shape, ok := value.(map[string]interface{})
36793	if !ok {
36794		return fmt.Errorf("unexpected JSON type %v", value)
36795	}
36796
36797	var sv *UntagResourceOutput
36798	if *v == nil {
36799		sv = &UntagResourceOutput{}
36800	} else {
36801		sv = *v
36802	}
36803
36804	for key, value := range shape {
36805		switch key {
36806		case "operations":
36807			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36808				return err
36809			}
36810
36811		default:
36812			_, _ = key, value
36813
36814		}
36815	}
36816	*v = sv
36817	return nil
36818}
36819
36820func awsAwsjson11_deserializeOpDocumentUpdateBucketBundleOutput(v **UpdateBucketBundleOutput, value interface{}) error {
36821	if v == nil {
36822		return fmt.Errorf("unexpected nil of type %T", v)
36823	}
36824	if value == nil {
36825		return nil
36826	}
36827
36828	shape, ok := value.(map[string]interface{})
36829	if !ok {
36830		return fmt.Errorf("unexpected JSON type %v", value)
36831	}
36832
36833	var sv *UpdateBucketBundleOutput
36834	if *v == nil {
36835		sv = &UpdateBucketBundleOutput{}
36836	} else {
36837		sv = *v
36838	}
36839
36840	for key, value := range shape {
36841		switch key {
36842		case "operations":
36843			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36844				return err
36845			}
36846
36847		default:
36848			_, _ = key, value
36849
36850		}
36851	}
36852	*v = sv
36853	return nil
36854}
36855
36856func awsAwsjson11_deserializeOpDocumentUpdateBucketOutput(v **UpdateBucketOutput, value interface{}) error {
36857	if v == nil {
36858		return fmt.Errorf("unexpected nil of type %T", v)
36859	}
36860	if value == nil {
36861		return nil
36862	}
36863
36864	shape, ok := value.(map[string]interface{})
36865	if !ok {
36866		return fmt.Errorf("unexpected JSON type %v", value)
36867	}
36868
36869	var sv *UpdateBucketOutput
36870	if *v == nil {
36871		sv = &UpdateBucketOutput{}
36872	} else {
36873		sv = *v
36874	}
36875
36876	for key, value := range shape {
36877		switch key {
36878		case "bucket":
36879			if err := awsAwsjson11_deserializeDocumentBucket(&sv.Bucket, value); err != nil {
36880				return err
36881			}
36882
36883		case "operations":
36884			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
36885				return err
36886			}
36887
36888		default:
36889			_, _ = key, value
36890
36891		}
36892	}
36893	*v = sv
36894	return nil
36895}
36896
36897func awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(v **UpdateContainerServiceOutput, value interface{}) error {
36898	if v == nil {
36899		return fmt.Errorf("unexpected nil of type %T", v)
36900	}
36901	if value == nil {
36902		return nil
36903	}
36904
36905	shape, ok := value.(map[string]interface{})
36906	if !ok {
36907		return fmt.Errorf("unexpected JSON type %v", value)
36908	}
36909
36910	var sv *UpdateContainerServiceOutput
36911	if *v == nil {
36912		sv = &UpdateContainerServiceOutput{}
36913	} else {
36914		sv = *v
36915	}
36916
36917	for key, value := range shape {
36918		switch key {
36919		case "containerService":
36920			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
36921				return err
36922			}
36923
36924		default:
36925			_, _ = key, value
36926
36927		}
36928	}
36929	*v = sv
36930	return nil
36931}
36932
36933func awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(v **UpdateDistributionBundleOutput, value interface{}) error {
36934	if v == nil {
36935		return fmt.Errorf("unexpected nil of type %T", v)
36936	}
36937	if value == nil {
36938		return nil
36939	}
36940
36941	shape, ok := value.(map[string]interface{})
36942	if !ok {
36943		return fmt.Errorf("unexpected JSON type %v", value)
36944	}
36945
36946	var sv *UpdateDistributionBundleOutput
36947	if *v == nil {
36948		sv = &UpdateDistributionBundleOutput{}
36949	} else {
36950		sv = *v
36951	}
36952
36953	for key, value := range shape {
36954		switch key {
36955		case "operation":
36956			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36957				return err
36958			}
36959
36960		default:
36961			_, _ = key, value
36962
36963		}
36964	}
36965	*v = sv
36966	return nil
36967}
36968
36969func awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(v **UpdateDistributionOutput, value interface{}) error {
36970	if v == nil {
36971		return fmt.Errorf("unexpected nil of type %T", v)
36972	}
36973	if value == nil {
36974		return nil
36975	}
36976
36977	shape, ok := value.(map[string]interface{})
36978	if !ok {
36979		return fmt.Errorf("unexpected JSON type %v", value)
36980	}
36981
36982	var sv *UpdateDistributionOutput
36983	if *v == nil {
36984		sv = &UpdateDistributionOutput{}
36985	} else {
36986		sv = *v
36987	}
36988
36989	for key, value := range shape {
36990		switch key {
36991		case "operation":
36992			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
36993				return err
36994			}
36995
36996		default:
36997			_, _ = key, value
36998
36999		}
37000	}
37001	*v = sv
37002	return nil
37003}
37004
37005func awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(v **UpdateDomainEntryOutput, value interface{}) error {
37006	if v == nil {
37007		return fmt.Errorf("unexpected nil of type %T", v)
37008	}
37009	if value == nil {
37010		return nil
37011	}
37012
37013	shape, ok := value.(map[string]interface{})
37014	if !ok {
37015		return fmt.Errorf("unexpected JSON type %v", value)
37016	}
37017
37018	var sv *UpdateDomainEntryOutput
37019	if *v == nil {
37020		sv = &UpdateDomainEntryOutput{}
37021	} else {
37022		sv = *v
37023	}
37024
37025	for key, value := range shape {
37026		switch key {
37027		case "operations":
37028			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37029				return err
37030			}
37031
37032		default:
37033			_, _ = key, value
37034
37035		}
37036	}
37037	*v = sv
37038	return nil
37039}
37040
37041func awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(v **UpdateLoadBalancerAttributeOutput, value interface{}) error {
37042	if v == nil {
37043		return fmt.Errorf("unexpected nil of type %T", v)
37044	}
37045	if value == nil {
37046		return nil
37047	}
37048
37049	shape, ok := value.(map[string]interface{})
37050	if !ok {
37051		return fmt.Errorf("unexpected JSON type %v", value)
37052	}
37053
37054	var sv *UpdateLoadBalancerAttributeOutput
37055	if *v == nil {
37056		sv = &UpdateLoadBalancerAttributeOutput{}
37057	} else {
37058		sv = *v
37059	}
37060
37061	for key, value := range shape {
37062		switch key {
37063		case "operations":
37064			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37065				return err
37066			}
37067
37068		default:
37069			_, _ = key, value
37070
37071		}
37072	}
37073	*v = sv
37074	return nil
37075}
37076
37077func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(v **UpdateRelationalDatabaseOutput, value interface{}) error {
37078	if v == nil {
37079		return fmt.Errorf("unexpected nil of type %T", v)
37080	}
37081	if value == nil {
37082		return nil
37083	}
37084
37085	shape, ok := value.(map[string]interface{})
37086	if !ok {
37087		return fmt.Errorf("unexpected JSON type %v", value)
37088	}
37089
37090	var sv *UpdateRelationalDatabaseOutput
37091	if *v == nil {
37092		sv = &UpdateRelationalDatabaseOutput{}
37093	} else {
37094		sv = *v
37095	}
37096
37097	for key, value := range shape {
37098		switch key {
37099		case "operations":
37100			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37101				return err
37102			}
37103
37104		default:
37105			_, _ = key, value
37106
37107		}
37108	}
37109	*v = sv
37110	return nil
37111}
37112
37113func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(v **UpdateRelationalDatabaseParametersOutput, value interface{}) error {
37114	if v == nil {
37115		return fmt.Errorf("unexpected nil of type %T", v)
37116	}
37117	if value == nil {
37118		return nil
37119	}
37120
37121	shape, ok := value.(map[string]interface{})
37122	if !ok {
37123		return fmt.Errorf("unexpected JSON type %v", value)
37124	}
37125
37126	var sv *UpdateRelationalDatabaseParametersOutput
37127	if *v == nil {
37128		sv = &UpdateRelationalDatabaseParametersOutput{}
37129	} else {
37130		sv = *v
37131	}
37132
37133	for key, value := range shape {
37134		switch key {
37135		case "operations":
37136			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
37137				return err
37138			}
37139
37140		default:
37141			_, _ = key, value
37142
37143		}
37144	}
37145	*v = sv
37146	return nil
37147}
37148