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	"strings"
20)
21
22type awsAwsjson11_deserializeOpAllocateStaticIp struct {
23}
24
25func (*awsAwsjson11_deserializeOpAllocateStaticIp) ID() string {
26	return "OperationDeserializer"
27}
28
29func (m *awsAwsjson11_deserializeOpAllocateStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
30	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
31) {
32	out, metadata, err = next.HandleDeserialize(ctx, in)
33	if err != nil {
34		return out, metadata, err
35	}
36
37	response, ok := out.RawResponse.(*smithyhttp.Response)
38	if !ok {
39		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
40	}
41
42	if response.StatusCode < 200 || response.StatusCode >= 300 {
43		return out, metadata, awsAwsjson11_deserializeOpErrorAllocateStaticIp(response, &metadata)
44	}
45	output := &AllocateStaticIpOutput{}
46	out.Result = output
47
48	var buff [1024]byte
49	ringBuffer := smithyio.NewRingBuffer(buff[:])
50
51	body := io.TeeReader(response.Body, ringBuffer)
52	decoder := json.NewDecoder(body)
53	decoder.UseNumber()
54	var shape interface{}
55	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
56		var snapshot bytes.Buffer
57		io.Copy(&snapshot, ringBuffer)
58		err = &smithy.DeserializationError{
59			Err:      fmt.Errorf("failed to decode response body, %w", err),
60			Snapshot: snapshot.Bytes(),
61		}
62		return out, metadata, err
63	}
64
65	err = awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(&output, shape)
66	if err != nil {
67		var snapshot bytes.Buffer
68		io.Copy(&snapshot, ringBuffer)
69		err = &smithy.DeserializationError{
70			Err:      fmt.Errorf("failed to decode response body, %w", err),
71			Snapshot: snapshot.Bytes(),
72		}
73		return out, metadata, err
74	}
75
76	return out, metadata, err
77}
78
79func awsAwsjson11_deserializeOpErrorAllocateStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
80	var errorBuffer bytes.Buffer
81	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
82		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
83	}
84	errorBody := bytes.NewReader(errorBuffer.Bytes())
85
86	errorCode := "UnknownError"
87	errorMessage := errorCode
88
89	code := response.Header.Get("X-Amzn-ErrorType")
90	if len(code) != 0 {
91		errorCode = restjson.SanitizeErrorCode(code)
92	}
93
94	var buff [1024]byte
95	ringBuffer := smithyio.NewRingBuffer(buff[:])
96
97	body := io.TeeReader(errorBody, ringBuffer)
98	decoder := json.NewDecoder(body)
99	decoder.UseNumber()
100	code, message, err := restjson.GetErrorInfo(decoder)
101	if err != nil {
102		var snapshot bytes.Buffer
103		io.Copy(&snapshot, ringBuffer)
104		err = &smithy.DeserializationError{
105			Err:      fmt.Errorf("failed to decode response body, %w", err),
106			Snapshot: snapshot.Bytes(),
107		}
108		return err
109	}
110
111	errorBody.Seek(0, io.SeekStart)
112	if len(code) != 0 {
113		errorCode = restjson.SanitizeErrorCode(code)
114	}
115	if len(message) != 0 {
116		errorMessage = message
117	}
118
119	switch {
120	case strings.EqualFold("AccessDeniedException", errorCode):
121		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
122
123	case strings.EqualFold("AccountSetupInProgressException", errorCode):
124		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
125
126	case strings.EqualFold("InvalidInputException", errorCode):
127		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
128
129	case strings.EqualFold("NotFoundException", errorCode):
130		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
131
132	case strings.EqualFold("OperationFailureException", errorCode):
133		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
134
135	case strings.EqualFold("ServiceException", errorCode):
136		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
137
138	case strings.EqualFold("UnauthenticatedException", errorCode):
139		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
140
141	default:
142		genericError := &smithy.GenericAPIError{
143			Code:    errorCode,
144			Message: errorMessage,
145		}
146		return genericError
147
148	}
149}
150
151type awsAwsjson11_deserializeOpAttachCertificateToDistribution struct {
152}
153
154func (*awsAwsjson11_deserializeOpAttachCertificateToDistribution) ID() string {
155	return "OperationDeserializer"
156}
157
158func (m *awsAwsjson11_deserializeOpAttachCertificateToDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
159	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
160) {
161	out, metadata, err = next.HandleDeserialize(ctx, in)
162	if err != nil {
163		return out, metadata, err
164	}
165
166	response, ok := out.RawResponse.(*smithyhttp.Response)
167	if !ok {
168		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
169	}
170
171	if response.StatusCode < 200 || response.StatusCode >= 300 {
172		return out, metadata, awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response, &metadata)
173	}
174	output := &AttachCertificateToDistributionOutput{}
175	out.Result = output
176
177	var buff [1024]byte
178	ringBuffer := smithyio.NewRingBuffer(buff[:])
179
180	body := io.TeeReader(response.Body, ringBuffer)
181	decoder := json.NewDecoder(body)
182	decoder.UseNumber()
183	var shape interface{}
184	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
185		var snapshot bytes.Buffer
186		io.Copy(&snapshot, ringBuffer)
187		err = &smithy.DeserializationError{
188			Err:      fmt.Errorf("failed to decode response body, %w", err),
189			Snapshot: snapshot.Bytes(),
190		}
191		return out, metadata, err
192	}
193
194	err = awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(&output, shape)
195	if err != nil {
196		var snapshot bytes.Buffer
197		io.Copy(&snapshot, ringBuffer)
198		err = &smithy.DeserializationError{
199			Err:      fmt.Errorf("failed to decode response body, %w", err),
200			Snapshot: snapshot.Bytes(),
201		}
202		return out, metadata, err
203	}
204
205	return out, metadata, err
206}
207
208func awsAwsjson11_deserializeOpErrorAttachCertificateToDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
209	var errorBuffer bytes.Buffer
210	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
211		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
212	}
213	errorBody := bytes.NewReader(errorBuffer.Bytes())
214
215	errorCode := "UnknownError"
216	errorMessage := errorCode
217
218	code := response.Header.Get("X-Amzn-ErrorType")
219	if len(code) != 0 {
220		errorCode = restjson.SanitizeErrorCode(code)
221	}
222
223	var buff [1024]byte
224	ringBuffer := smithyio.NewRingBuffer(buff[:])
225
226	body := io.TeeReader(errorBody, ringBuffer)
227	decoder := json.NewDecoder(body)
228	decoder.UseNumber()
229	code, message, err := restjson.GetErrorInfo(decoder)
230	if err != nil {
231		var snapshot bytes.Buffer
232		io.Copy(&snapshot, ringBuffer)
233		err = &smithy.DeserializationError{
234			Err:      fmt.Errorf("failed to decode response body, %w", err),
235			Snapshot: snapshot.Bytes(),
236		}
237		return err
238	}
239
240	errorBody.Seek(0, io.SeekStart)
241	if len(code) != 0 {
242		errorCode = restjson.SanitizeErrorCode(code)
243	}
244	if len(message) != 0 {
245		errorMessage = message
246	}
247
248	switch {
249	case strings.EqualFold("AccessDeniedException", errorCode):
250		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
251
252	case strings.EqualFold("InvalidInputException", errorCode):
253		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
254
255	case strings.EqualFold("NotFoundException", errorCode):
256		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
257
258	case strings.EqualFold("OperationFailureException", errorCode):
259		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
260
261	case strings.EqualFold("ServiceException", errorCode):
262		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
263
264	case strings.EqualFold("UnauthenticatedException", errorCode):
265		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
266
267	default:
268		genericError := &smithy.GenericAPIError{
269			Code:    errorCode,
270			Message: errorMessage,
271		}
272		return genericError
273
274	}
275}
276
277type awsAwsjson11_deserializeOpAttachDisk struct {
278}
279
280func (*awsAwsjson11_deserializeOpAttachDisk) ID() string {
281	return "OperationDeserializer"
282}
283
284func (m *awsAwsjson11_deserializeOpAttachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
285	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
286) {
287	out, metadata, err = next.HandleDeserialize(ctx, in)
288	if err != nil {
289		return out, metadata, err
290	}
291
292	response, ok := out.RawResponse.(*smithyhttp.Response)
293	if !ok {
294		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
295	}
296
297	if response.StatusCode < 200 || response.StatusCode >= 300 {
298		return out, metadata, awsAwsjson11_deserializeOpErrorAttachDisk(response, &metadata)
299	}
300	output := &AttachDiskOutput{}
301	out.Result = output
302
303	var buff [1024]byte
304	ringBuffer := smithyio.NewRingBuffer(buff[:])
305
306	body := io.TeeReader(response.Body, ringBuffer)
307	decoder := json.NewDecoder(body)
308	decoder.UseNumber()
309	var shape interface{}
310	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
311		var snapshot bytes.Buffer
312		io.Copy(&snapshot, ringBuffer)
313		err = &smithy.DeserializationError{
314			Err:      fmt.Errorf("failed to decode response body, %w", err),
315			Snapshot: snapshot.Bytes(),
316		}
317		return out, metadata, err
318	}
319
320	err = awsAwsjson11_deserializeOpDocumentAttachDiskOutput(&output, shape)
321	if err != nil {
322		var snapshot bytes.Buffer
323		io.Copy(&snapshot, ringBuffer)
324		err = &smithy.DeserializationError{
325			Err:      fmt.Errorf("failed to decode response body, %w", err),
326			Snapshot: snapshot.Bytes(),
327		}
328		return out, metadata, err
329	}
330
331	return out, metadata, err
332}
333
334func awsAwsjson11_deserializeOpErrorAttachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
335	var errorBuffer bytes.Buffer
336	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
337		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
338	}
339	errorBody := bytes.NewReader(errorBuffer.Bytes())
340
341	errorCode := "UnknownError"
342	errorMessage := errorCode
343
344	code := response.Header.Get("X-Amzn-ErrorType")
345	if len(code) != 0 {
346		errorCode = restjson.SanitizeErrorCode(code)
347	}
348
349	var buff [1024]byte
350	ringBuffer := smithyio.NewRingBuffer(buff[:])
351
352	body := io.TeeReader(errorBody, ringBuffer)
353	decoder := json.NewDecoder(body)
354	decoder.UseNumber()
355	code, message, err := restjson.GetErrorInfo(decoder)
356	if err != nil {
357		var snapshot bytes.Buffer
358		io.Copy(&snapshot, ringBuffer)
359		err = &smithy.DeserializationError{
360			Err:      fmt.Errorf("failed to decode response body, %w", err),
361			Snapshot: snapshot.Bytes(),
362		}
363		return err
364	}
365
366	errorBody.Seek(0, io.SeekStart)
367	if len(code) != 0 {
368		errorCode = restjson.SanitizeErrorCode(code)
369	}
370	if len(message) != 0 {
371		errorMessage = message
372	}
373
374	switch {
375	case strings.EqualFold("AccessDeniedException", errorCode):
376		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
377
378	case strings.EqualFold("AccountSetupInProgressException", errorCode):
379		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
380
381	case strings.EqualFold("InvalidInputException", errorCode):
382		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
383
384	case strings.EqualFold("NotFoundException", errorCode):
385		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
386
387	case strings.EqualFold("OperationFailureException", errorCode):
388		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
389
390	case strings.EqualFold("ServiceException", errorCode):
391		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
392
393	case strings.EqualFold("UnauthenticatedException", errorCode):
394		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
395
396	default:
397		genericError := &smithy.GenericAPIError{
398			Code:    errorCode,
399			Message: errorMessage,
400		}
401		return genericError
402
403	}
404}
405
406type awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer struct {
407}
408
409func (*awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) ID() string {
410	return "OperationDeserializer"
411}
412
413func (m *awsAwsjson11_deserializeOpAttachInstancesToLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
414	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
415) {
416	out, metadata, err = next.HandleDeserialize(ctx, in)
417	if err != nil {
418		return out, metadata, err
419	}
420
421	response, ok := out.RawResponse.(*smithyhttp.Response)
422	if !ok {
423		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
424	}
425
426	if response.StatusCode < 200 || response.StatusCode >= 300 {
427		return out, metadata, awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response, &metadata)
428	}
429	output := &AttachInstancesToLoadBalancerOutput{}
430	out.Result = output
431
432	var buff [1024]byte
433	ringBuffer := smithyio.NewRingBuffer(buff[:])
434
435	body := io.TeeReader(response.Body, ringBuffer)
436	decoder := json.NewDecoder(body)
437	decoder.UseNumber()
438	var shape interface{}
439	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
440		var snapshot bytes.Buffer
441		io.Copy(&snapshot, ringBuffer)
442		err = &smithy.DeserializationError{
443			Err:      fmt.Errorf("failed to decode response body, %w", err),
444			Snapshot: snapshot.Bytes(),
445		}
446		return out, metadata, err
447	}
448
449	err = awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(&output, shape)
450	if err != nil {
451		var snapshot bytes.Buffer
452		io.Copy(&snapshot, ringBuffer)
453		err = &smithy.DeserializationError{
454			Err:      fmt.Errorf("failed to decode response body, %w", err),
455			Snapshot: snapshot.Bytes(),
456		}
457		return out, metadata, err
458	}
459
460	return out, metadata, err
461}
462
463func awsAwsjson11_deserializeOpErrorAttachInstancesToLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
464	var errorBuffer bytes.Buffer
465	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
466		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
467	}
468	errorBody := bytes.NewReader(errorBuffer.Bytes())
469
470	errorCode := "UnknownError"
471	errorMessage := errorCode
472
473	code := response.Header.Get("X-Amzn-ErrorType")
474	if len(code) != 0 {
475		errorCode = restjson.SanitizeErrorCode(code)
476	}
477
478	var buff [1024]byte
479	ringBuffer := smithyio.NewRingBuffer(buff[:])
480
481	body := io.TeeReader(errorBody, ringBuffer)
482	decoder := json.NewDecoder(body)
483	decoder.UseNumber()
484	code, message, err := restjson.GetErrorInfo(decoder)
485	if err != nil {
486		var snapshot bytes.Buffer
487		io.Copy(&snapshot, ringBuffer)
488		err = &smithy.DeserializationError{
489			Err:      fmt.Errorf("failed to decode response body, %w", err),
490			Snapshot: snapshot.Bytes(),
491		}
492		return err
493	}
494
495	errorBody.Seek(0, io.SeekStart)
496	if len(code) != 0 {
497		errorCode = restjson.SanitizeErrorCode(code)
498	}
499	if len(message) != 0 {
500		errorMessage = message
501	}
502
503	switch {
504	case strings.EqualFold("AccessDeniedException", errorCode):
505		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
506
507	case strings.EqualFold("AccountSetupInProgressException", errorCode):
508		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
509
510	case strings.EqualFold("InvalidInputException", errorCode):
511		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
512
513	case strings.EqualFold("NotFoundException", errorCode):
514		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
515
516	case strings.EqualFold("OperationFailureException", errorCode):
517		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
518
519	case strings.EqualFold("ServiceException", errorCode):
520		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
521
522	case strings.EqualFold("UnauthenticatedException", errorCode):
523		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
524
525	default:
526		genericError := &smithy.GenericAPIError{
527			Code:    errorCode,
528			Message: errorMessage,
529		}
530		return genericError
531
532	}
533}
534
535type awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate struct {
536}
537
538func (*awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) ID() string {
539	return "OperationDeserializer"
540}
541
542func (m *awsAwsjson11_deserializeOpAttachLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
543	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
544) {
545	out, metadata, err = next.HandleDeserialize(ctx, in)
546	if err != nil {
547		return out, metadata, err
548	}
549
550	response, ok := out.RawResponse.(*smithyhttp.Response)
551	if !ok {
552		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
553	}
554
555	if response.StatusCode < 200 || response.StatusCode >= 300 {
556		return out, metadata, awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response, &metadata)
557	}
558	output := &AttachLoadBalancerTlsCertificateOutput{}
559	out.Result = output
560
561	var buff [1024]byte
562	ringBuffer := smithyio.NewRingBuffer(buff[:])
563
564	body := io.TeeReader(response.Body, ringBuffer)
565	decoder := json.NewDecoder(body)
566	decoder.UseNumber()
567	var shape interface{}
568	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
569		var snapshot bytes.Buffer
570		io.Copy(&snapshot, ringBuffer)
571		err = &smithy.DeserializationError{
572			Err:      fmt.Errorf("failed to decode response body, %w", err),
573			Snapshot: snapshot.Bytes(),
574		}
575		return out, metadata, err
576	}
577
578	err = awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(&output, shape)
579	if err != nil {
580		var snapshot bytes.Buffer
581		io.Copy(&snapshot, ringBuffer)
582		err = &smithy.DeserializationError{
583			Err:      fmt.Errorf("failed to decode response body, %w", err),
584			Snapshot: snapshot.Bytes(),
585		}
586		return out, metadata, err
587	}
588
589	return out, metadata, err
590}
591
592func awsAwsjson11_deserializeOpErrorAttachLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
593	var errorBuffer bytes.Buffer
594	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
595		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
596	}
597	errorBody := bytes.NewReader(errorBuffer.Bytes())
598
599	errorCode := "UnknownError"
600	errorMessage := errorCode
601
602	code := response.Header.Get("X-Amzn-ErrorType")
603	if len(code) != 0 {
604		errorCode = restjson.SanitizeErrorCode(code)
605	}
606
607	var buff [1024]byte
608	ringBuffer := smithyio.NewRingBuffer(buff[:])
609
610	body := io.TeeReader(errorBody, ringBuffer)
611	decoder := json.NewDecoder(body)
612	decoder.UseNumber()
613	code, message, err := restjson.GetErrorInfo(decoder)
614	if err != nil {
615		var snapshot bytes.Buffer
616		io.Copy(&snapshot, ringBuffer)
617		err = &smithy.DeserializationError{
618			Err:      fmt.Errorf("failed to decode response body, %w", err),
619			Snapshot: snapshot.Bytes(),
620		}
621		return err
622	}
623
624	errorBody.Seek(0, io.SeekStart)
625	if len(code) != 0 {
626		errorCode = restjson.SanitizeErrorCode(code)
627	}
628	if len(message) != 0 {
629		errorMessage = message
630	}
631
632	switch {
633	case strings.EqualFold("AccessDeniedException", errorCode):
634		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
635
636	case strings.EqualFold("AccountSetupInProgressException", errorCode):
637		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
638
639	case strings.EqualFold("InvalidInputException", errorCode):
640		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
641
642	case strings.EqualFold("NotFoundException", errorCode):
643		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
644
645	case strings.EqualFold("OperationFailureException", errorCode):
646		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
647
648	case strings.EqualFold("ServiceException", errorCode):
649		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
650
651	case strings.EqualFold("UnauthenticatedException", errorCode):
652		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
653
654	default:
655		genericError := &smithy.GenericAPIError{
656			Code:    errorCode,
657			Message: errorMessage,
658		}
659		return genericError
660
661	}
662}
663
664type awsAwsjson11_deserializeOpAttachStaticIp struct {
665}
666
667func (*awsAwsjson11_deserializeOpAttachStaticIp) ID() string {
668	return "OperationDeserializer"
669}
670
671func (m *awsAwsjson11_deserializeOpAttachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
672	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
673) {
674	out, metadata, err = next.HandleDeserialize(ctx, in)
675	if err != nil {
676		return out, metadata, err
677	}
678
679	response, ok := out.RawResponse.(*smithyhttp.Response)
680	if !ok {
681		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
682	}
683
684	if response.StatusCode < 200 || response.StatusCode >= 300 {
685		return out, metadata, awsAwsjson11_deserializeOpErrorAttachStaticIp(response, &metadata)
686	}
687	output := &AttachStaticIpOutput{}
688	out.Result = output
689
690	var buff [1024]byte
691	ringBuffer := smithyio.NewRingBuffer(buff[:])
692
693	body := io.TeeReader(response.Body, ringBuffer)
694	decoder := json.NewDecoder(body)
695	decoder.UseNumber()
696	var shape interface{}
697	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
698		var snapshot bytes.Buffer
699		io.Copy(&snapshot, ringBuffer)
700		err = &smithy.DeserializationError{
701			Err:      fmt.Errorf("failed to decode response body, %w", err),
702			Snapshot: snapshot.Bytes(),
703		}
704		return out, metadata, err
705	}
706
707	err = awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(&output, shape)
708	if err != nil {
709		var snapshot bytes.Buffer
710		io.Copy(&snapshot, ringBuffer)
711		err = &smithy.DeserializationError{
712			Err:      fmt.Errorf("failed to decode response body, %w", err),
713			Snapshot: snapshot.Bytes(),
714		}
715		return out, metadata, err
716	}
717
718	return out, metadata, err
719}
720
721func awsAwsjson11_deserializeOpErrorAttachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
722	var errorBuffer bytes.Buffer
723	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
724		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
725	}
726	errorBody := bytes.NewReader(errorBuffer.Bytes())
727
728	errorCode := "UnknownError"
729	errorMessage := errorCode
730
731	code := response.Header.Get("X-Amzn-ErrorType")
732	if len(code) != 0 {
733		errorCode = restjson.SanitizeErrorCode(code)
734	}
735
736	var buff [1024]byte
737	ringBuffer := smithyio.NewRingBuffer(buff[:])
738
739	body := io.TeeReader(errorBody, ringBuffer)
740	decoder := json.NewDecoder(body)
741	decoder.UseNumber()
742	code, message, err := restjson.GetErrorInfo(decoder)
743	if err != nil {
744		var snapshot bytes.Buffer
745		io.Copy(&snapshot, ringBuffer)
746		err = &smithy.DeserializationError{
747			Err:      fmt.Errorf("failed to decode response body, %w", err),
748			Snapshot: snapshot.Bytes(),
749		}
750		return err
751	}
752
753	errorBody.Seek(0, io.SeekStart)
754	if len(code) != 0 {
755		errorCode = restjson.SanitizeErrorCode(code)
756	}
757	if len(message) != 0 {
758		errorMessage = message
759	}
760
761	switch {
762	case strings.EqualFold("AccessDeniedException", errorCode):
763		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
764
765	case strings.EqualFold("AccountSetupInProgressException", errorCode):
766		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
767
768	case strings.EqualFold("InvalidInputException", errorCode):
769		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
770
771	case strings.EqualFold("NotFoundException", errorCode):
772		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
773
774	case strings.EqualFold("OperationFailureException", errorCode):
775		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
776
777	case strings.EqualFold("ServiceException", errorCode):
778		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
779
780	case strings.EqualFold("UnauthenticatedException", errorCode):
781		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
782
783	default:
784		genericError := &smithy.GenericAPIError{
785			Code:    errorCode,
786			Message: errorMessage,
787		}
788		return genericError
789
790	}
791}
792
793type awsAwsjson11_deserializeOpCloseInstancePublicPorts struct {
794}
795
796func (*awsAwsjson11_deserializeOpCloseInstancePublicPorts) ID() string {
797	return "OperationDeserializer"
798}
799
800func (m *awsAwsjson11_deserializeOpCloseInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
801	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
802) {
803	out, metadata, err = next.HandleDeserialize(ctx, in)
804	if err != nil {
805		return out, metadata, err
806	}
807
808	response, ok := out.RawResponse.(*smithyhttp.Response)
809	if !ok {
810		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
811	}
812
813	if response.StatusCode < 200 || response.StatusCode >= 300 {
814		return out, metadata, awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response, &metadata)
815	}
816	output := &CloseInstancePublicPortsOutput{}
817	out.Result = output
818
819	var buff [1024]byte
820	ringBuffer := smithyio.NewRingBuffer(buff[:])
821
822	body := io.TeeReader(response.Body, ringBuffer)
823	decoder := json.NewDecoder(body)
824	decoder.UseNumber()
825	var shape interface{}
826	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
827		var snapshot bytes.Buffer
828		io.Copy(&snapshot, ringBuffer)
829		err = &smithy.DeserializationError{
830			Err:      fmt.Errorf("failed to decode response body, %w", err),
831			Snapshot: snapshot.Bytes(),
832		}
833		return out, metadata, err
834	}
835
836	err = awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(&output, shape)
837	if err != nil {
838		var snapshot bytes.Buffer
839		io.Copy(&snapshot, ringBuffer)
840		err = &smithy.DeserializationError{
841			Err:      fmt.Errorf("failed to decode response body, %w", err),
842			Snapshot: snapshot.Bytes(),
843		}
844		return out, metadata, err
845	}
846
847	return out, metadata, err
848}
849
850func awsAwsjson11_deserializeOpErrorCloseInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
851	var errorBuffer bytes.Buffer
852	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
853		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
854	}
855	errorBody := bytes.NewReader(errorBuffer.Bytes())
856
857	errorCode := "UnknownError"
858	errorMessage := errorCode
859
860	code := response.Header.Get("X-Amzn-ErrorType")
861	if len(code) != 0 {
862		errorCode = restjson.SanitizeErrorCode(code)
863	}
864
865	var buff [1024]byte
866	ringBuffer := smithyio.NewRingBuffer(buff[:])
867
868	body := io.TeeReader(errorBody, ringBuffer)
869	decoder := json.NewDecoder(body)
870	decoder.UseNumber()
871	code, message, err := restjson.GetErrorInfo(decoder)
872	if err != nil {
873		var snapshot bytes.Buffer
874		io.Copy(&snapshot, ringBuffer)
875		err = &smithy.DeserializationError{
876			Err:      fmt.Errorf("failed to decode response body, %w", err),
877			Snapshot: snapshot.Bytes(),
878		}
879		return err
880	}
881
882	errorBody.Seek(0, io.SeekStart)
883	if len(code) != 0 {
884		errorCode = restjson.SanitizeErrorCode(code)
885	}
886	if len(message) != 0 {
887		errorMessage = message
888	}
889
890	switch {
891	case strings.EqualFold("AccessDeniedException", errorCode):
892		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
893
894	case strings.EqualFold("AccountSetupInProgressException", errorCode):
895		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
896
897	case strings.EqualFold("InvalidInputException", errorCode):
898		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
899
900	case strings.EqualFold("NotFoundException", errorCode):
901		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
902
903	case strings.EqualFold("OperationFailureException", errorCode):
904		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
905
906	case strings.EqualFold("ServiceException", errorCode):
907		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
908
909	case strings.EqualFold("UnauthenticatedException", errorCode):
910		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
911
912	default:
913		genericError := &smithy.GenericAPIError{
914			Code:    errorCode,
915			Message: errorMessage,
916		}
917		return genericError
918
919	}
920}
921
922type awsAwsjson11_deserializeOpCopySnapshot struct {
923}
924
925func (*awsAwsjson11_deserializeOpCopySnapshot) ID() string {
926	return "OperationDeserializer"
927}
928
929func (m *awsAwsjson11_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
930	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
931) {
932	out, metadata, err = next.HandleDeserialize(ctx, in)
933	if err != nil {
934		return out, metadata, err
935	}
936
937	response, ok := out.RawResponse.(*smithyhttp.Response)
938	if !ok {
939		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
940	}
941
942	if response.StatusCode < 200 || response.StatusCode >= 300 {
943		return out, metadata, awsAwsjson11_deserializeOpErrorCopySnapshot(response, &metadata)
944	}
945	output := &CopySnapshotOutput{}
946	out.Result = output
947
948	var buff [1024]byte
949	ringBuffer := smithyio.NewRingBuffer(buff[:])
950
951	body := io.TeeReader(response.Body, ringBuffer)
952	decoder := json.NewDecoder(body)
953	decoder.UseNumber()
954	var shape interface{}
955	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
956		var snapshot bytes.Buffer
957		io.Copy(&snapshot, ringBuffer)
958		err = &smithy.DeserializationError{
959			Err:      fmt.Errorf("failed to decode response body, %w", err),
960			Snapshot: snapshot.Bytes(),
961		}
962		return out, metadata, err
963	}
964
965	err = awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(&output, shape)
966	if err != nil {
967		var snapshot bytes.Buffer
968		io.Copy(&snapshot, ringBuffer)
969		err = &smithy.DeserializationError{
970			Err:      fmt.Errorf("failed to decode response body, %w", err),
971			Snapshot: snapshot.Bytes(),
972		}
973		return out, metadata, err
974	}
975
976	return out, metadata, err
977}
978
979func awsAwsjson11_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
980	var errorBuffer bytes.Buffer
981	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
982		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
983	}
984	errorBody := bytes.NewReader(errorBuffer.Bytes())
985
986	errorCode := "UnknownError"
987	errorMessage := errorCode
988
989	code := response.Header.Get("X-Amzn-ErrorType")
990	if len(code) != 0 {
991		errorCode = restjson.SanitizeErrorCode(code)
992	}
993
994	var buff [1024]byte
995	ringBuffer := smithyio.NewRingBuffer(buff[:])
996
997	body := io.TeeReader(errorBody, ringBuffer)
998	decoder := json.NewDecoder(body)
999	decoder.UseNumber()
1000	code, message, err := restjson.GetErrorInfo(decoder)
1001	if err != nil {
1002		var snapshot bytes.Buffer
1003		io.Copy(&snapshot, ringBuffer)
1004		err = &smithy.DeserializationError{
1005			Err:      fmt.Errorf("failed to decode response body, %w", err),
1006			Snapshot: snapshot.Bytes(),
1007		}
1008		return err
1009	}
1010
1011	errorBody.Seek(0, io.SeekStart)
1012	if len(code) != 0 {
1013		errorCode = restjson.SanitizeErrorCode(code)
1014	}
1015	if len(message) != 0 {
1016		errorMessage = message
1017	}
1018
1019	switch {
1020	case strings.EqualFold("AccessDeniedException", errorCode):
1021		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1022
1023	case strings.EqualFold("AccountSetupInProgressException", errorCode):
1024		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1025
1026	case strings.EqualFold("InvalidInputException", errorCode):
1027		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1028
1029	case strings.EqualFold("NotFoundException", errorCode):
1030		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1031
1032	case strings.EqualFold("OperationFailureException", errorCode):
1033		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1034
1035	case strings.EqualFold("ServiceException", errorCode):
1036		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1037
1038	case strings.EqualFold("UnauthenticatedException", errorCode):
1039		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1040
1041	default:
1042		genericError := &smithy.GenericAPIError{
1043			Code:    errorCode,
1044			Message: errorMessage,
1045		}
1046		return genericError
1047
1048	}
1049}
1050
1051type awsAwsjson11_deserializeOpCreateCertificate struct {
1052}
1053
1054func (*awsAwsjson11_deserializeOpCreateCertificate) ID() string {
1055	return "OperationDeserializer"
1056}
1057
1058func (m *awsAwsjson11_deserializeOpCreateCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1059	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1060) {
1061	out, metadata, err = next.HandleDeserialize(ctx, in)
1062	if err != nil {
1063		return out, metadata, err
1064	}
1065
1066	response, ok := out.RawResponse.(*smithyhttp.Response)
1067	if !ok {
1068		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1069	}
1070
1071	if response.StatusCode < 200 || response.StatusCode >= 300 {
1072		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCertificate(response, &metadata)
1073	}
1074	output := &CreateCertificateOutput{}
1075	out.Result = output
1076
1077	var buff [1024]byte
1078	ringBuffer := smithyio.NewRingBuffer(buff[:])
1079
1080	body := io.TeeReader(response.Body, ringBuffer)
1081	decoder := json.NewDecoder(body)
1082	decoder.UseNumber()
1083	var shape interface{}
1084	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1085		var snapshot bytes.Buffer
1086		io.Copy(&snapshot, ringBuffer)
1087		err = &smithy.DeserializationError{
1088			Err:      fmt.Errorf("failed to decode response body, %w", err),
1089			Snapshot: snapshot.Bytes(),
1090		}
1091		return out, metadata, err
1092	}
1093
1094	err = awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(&output, shape)
1095	if err != nil {
1096		var snapshot bytes.Buffer
1097		io.Copy(&snapshot, ringBuffer)
1098		err = &smithy.DeserializationError{
1099			Err:      fmt.Errorf("failed to decode response body, %w", err),
1100			Snapshot: snapshot.Bytes(),
1101		}
1102		return out, metadata, err
1103	}
1104
1105	return out, metadata, err
1106}
1107
1108func awsAwsjson11_deserializeOpErrorCreateCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1109	var errorBuffer bytes.Buffer
1110	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1111		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1112	}
1113	errorBody := bytes.NewReader(errorBuffer.Bytes())
1114
1115	errorCode := "UnknownError"
1116	errorMessage := errorCode
1117
1118	code := response.Header.Get("X-Amzn-ErrorType")
1119	if len(code) != 0 {
1120		errorCode = restjson.SanitizeErrorCode(code)
1121	}
1122
1123	var buff [1024]byte
1124	ringBuffer := smithyio.NewRingBuffer(buff[:])
1125
1126	body := io.TeeReader(errorBody, ringBuffer)
1127	decoder := json.NewDecoder(body)
1128	decoder.UseNumber()
1129	code, message, err := restjson.GetErrorInfo(decoder)
1130	if err != nil {
1131		var snapshot bytes.Buffer
1132		io.Copy(&snapshot, ringBuffer)
1133		err = &smithy.DeserializationError{
1134			Err:      fmt.Errorf("failed to decode response body, %w", err),
1135			Snapshot: snapshot.Bytes(),
1136		}
1137		return err
1138	}
1139
1140	errorBody.Seek(0, io.SeekStart)
1141	if len(code) != 0 {
1142		errorCode = restjson.SanitizeErrorCode(code)
1143	}
1144	if len(message) != 0 {
1145		errorMessage = message
1146	}
1147
1148	switch {
1149	case strings.EqualFold("AccessDeniedException", errorCode):
1150		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1151
1152	case strings.EqualFold("InvalidInputException", errorCode):
1153		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1154
1155	case strings.EqualFold("NotFoundException", errorCode):
1156		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1157
1158	case strings.EqualFold("ServiceException", errorCode):
1159		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1160
1161	case strings.EqualFold("UnauthenticatedException", errorCode):
1162		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1163
1164	default:
1165		genericError := &smithy.GenericAPIError{
1166			Code:    errorCode,
1167			Message: errorMessage,
1168		}
1169		return genericError
1170
1171	}
1172}
1173
1174type awsAwsjson11_deserializeOpCreateCloudFormationStack struct {
1175}
1176
1177func (*awsAwsjson11_deserializeOpCreateCloudFormationStack) ID() string {
1178	return "OperationDeserializer"
1179}
1180
1181func (m *awsAwsjson11_deserializeOpCreateCloudFormationStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1182	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1183) {
1184	out, metadata, err = next.HandleDeserialize(ctx, in)
1185	if err != nil {
1186		return out, metadata, err
1187	}
1188
1189	response, ok := out.RawResponse.(*smithyhttp.Response)
1190	if !ok {
1191		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1192	}
1193
1194	if response.StatusCode < 200 || response.StatusCode >= 300 {
1195		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response, &metadata)
1196	}
1197	output := &CreateCloudFormationStackOutput{}
1198	out.Result = output
1199
1200	var buff [1024]byte
1201	ringBuffer := smithyio.NewRingBuffer(buff[:])
1202
1203	body := io.TeeReader(response.Body, ringBuffer)
1204	decoder := json.NewDecoder(body)
1205	decoder.UseNumber()
1206	var shape interface{}
1207	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1208		var snapshot bytes.Buffer
1209		io.Copy(&snapshot, ringBuffer)
1210		err = &smithy.DeserializationError{
1211			Err:      fmt.Errorf("failed to decode response body, %w", err),
1212			Snapshot: snapshot.Bytes(),
1213		}
1214		return out, metadata, err
1215	}
1216
1217	err = awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(&output, shape)
1218	if err != nil {
1219		var snapshot bytes.Buffer
1220		io.Copy(&snapshot, ringBuffer)
1221		err = &smithy.DeserializationError{
1222			Err:      fmt.Errorf("failed to decode response body, %w", err),
1223			Snapshot: snapshot.Bytes(),
1224		}
1225		return out, metadata, err
1226	}
1227
1228	return out, metadata, err
1229}
1230
1231func awsAwsjson11_deserializeOpErrorCreateCloudFormationStack(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1232	var errorBuffer bytes.Buffer
1233	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1234		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1235	}
1236	errorBody := bytes.NewReader(errorBuffer.Bytes())
1237
1238	errorCode := "UnknownError"
1239	errorMessage := errorCode
1240
1241	code := response.Header.Get("X-Amzn-ErrorType")
1242	if len(code) != 0 {
1243		errorCode = restjson.SanitizeErrorCode(code)
1244	}
1245
1246	var buff [1024]byte
1247	ringBuffer := smithyio.NewRingBuffer(buff[:])
1248
1249	body := io.TeeReader(errorBody, ringBuffer)
1250	decoder := json.NewDecoder(body)
1251	decoder.UseNumber()
1252	code, message, err := restjson.GetErrorInfo(decoder)
1253	if err != nil {
1254		var snapshot bytes.Buffer
1255		io.Copy(&snapshot, ringBuffer)
1256		err = &smithy.DeserializationError{
1257			Err:      fmt.Errorf("failed to decode response body, %w", err),
1258			Snapshot: snapshot.Bytes(),
1259		}
1260		return err
1261	}
1262
1263	errorBody.Seek(0, io.SeekStart)
1264	if len(code) != 0 {
1265		errorCode = restjson.SanitizeErrorCode(code)
1266	}
1267	if len(message) != 0 {
1268		errorMessage = message
1269	}
1270
1271	switch {
1272	case strings.EqualFold("AccessDeniedException", errorCode):
1273		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1274
1275	case strings.EqualFold("AccountSetupInProgressException", errorCode):
1276		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1277
1278	case strings.EqualFold("InvalidInputException", errorCode):
1279		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1280
1281	case strings.EqualFold("NotFoundException", errorCode):
1282		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1283
1284	case strings.EqualFold("OperationFailureException", errorCode):
1285		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1286
1287	case strings.EqualFold("ServiceException", errorCode):
1288		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1289
1290	case strings.EqualFold("UnauthenticatedException", errorCode):
1291		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1292
1293	default:
1294		genericError := &smithy.GenericAPIError{
1295			Code:    errorCode,
1296			Message: errorMessage,
1297		}
1298		return genericError
1299
1300	}
1301}
1302
1303type awsAwsjson11_deserializeOpCreateContactMethod struct {
1304}
1305
1306func (*awsAwsjson11_deserializeOpCreateContactMethod) ID() string {
1307	return "OperationDeserializer"
1308}
1309
1310func (m *awsAwsjson11_deserializeOpCreateContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1311	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1312) {
1313	out, metadata, err = next.HandleDeserialize(ctx, in)
1314	if err != nil {
1315		return out, metadata, err
1316	}
1317
1318	response, ok := out.RawResponse.(*smithyhttp.Response)
1319	if !ok {
1320		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1321	}
1322
1323	if response.StatusCode < 200 || response.StatusCode >= 300 {
1324		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContactMethod(response, &metadata)
1325	}
1326	output := &CreateContactMethodOutput{}
1327	out.Result = output
1328
1329	var buff [1024]byte
1330	ringBuffer := smithyio.NewRingBuffer(buff[:])
1331
1332	body := io.TeeReader(response.Body, ringBuffer)
1333	decoder := json.NewDecoder(body)
1334	decoder.UseNumber()
1335	var shape interface{}
1336	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1337		var snapshot bytes.Buffer
1338		io.Copy(&snapshot, ringBuffer)
1339		err = &smithy.DeserializationError{
1340			Err:      fmt.Errorf("failed to decode response body, %w", err),
1341			Snapshot: snapshot.Bytes(),
1342		}
1343		return out, metadata, err
1344	}
1345
1346	err = awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(&output, shape)
1347	if err != nil {
1348		var snapshot bytes.Buffer
1349		io.Copy(&snapshot, ringBuffer)
1350		err = &smithy.DeserializationError{
1351			Err:      fmt.Errorf("failed to decode response body, %w", err),
1352			Snapshot: snapshot.Bytes(),
1353		}
1354		return out, metadata, err
1355	}
1356
1357	return out, metadata, err
1358}
1359
1360func awsAwsjson11_deserializeOpErrorCreateContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1361	var errorBuffer bytes.Buffer
1362	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1363		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1364	}
1365	errorBody := bytes.NewReader(errorBuffer.Bytes())
1366
1367	errorCode := "UnknownError"
1368	errorMessage := errorCode
1369
1370	code := response.Header.Get("X-Amzn-ErrorType")
1371	if len(code) != 0 {
1372		errorCode = restjson.SanitizeErrorCode(code)
1373	}
1374
1375	var buff [1024]byte
1376	ringBuffer := smithyio.NewRingBuffer(buff[:])
1377
1378	body := io.TeeReader(errorBody, ringBuffer)
1379	decoder := json.NewDecoder(body)
1380	decoder.UseNumber()
1381	code, message, err := restjson.GetErrorInfo(decoder)
1382	if err != nil {
1383		var snapshot bytes.Buffer
1384		io.Copy(&snapshot, ringBuffer)
1385		err = &smithy.DeserializationError{
1386			Err:      fmt.Errorf("failed to decode response body, %w", err),
1387			Snapshot: snapshot.Bytes(),
1388		}
1389		return err
1390	}
1391
1392	errorBody.Seek(0, io.SeekStart)
1393	if len(code) != 0 {
1394		errorCode = restjson.SanitizeErrorCode(code)
1395	}
1396	if len(message) != 0 {
1397		errorMessage = message
1398	}
1399
1400	switch {
1401	case strings.EqualFold("AccessDeniedException", errorCode):
1402		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1403
1404	case strings.EqualFold("InvalidInputException", errorCode):
1405		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1406
1407	case strings.EqualFold("NotFoundException", errorCode):
1408		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1409
1410	case strings.EqualFold("OperationFailureException", errorCode):
1411		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1412
1413	case strings.EqualFold("ServiceException", errorCode):
1414		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1415
1416	case strings.EqualFold("UnauthenticatedException", errorCode):
1417		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1418
1419	default:
1420		genericError := &smithy.GenericAPIError{
1421			Code:    errorCode,
1422			Message: errorMessage,
1423		}
1424		return genericError
1425
1426	}
1427}
1428
1429type awsAwsjson11_deserializeOpCreateContainerService struct {
1430}
1431
1432func (*awsAwsjson11_deserializeOpCreateContainerService) ID() string {
1433	return "OperationDeserializer"
1434}
1435
1436func (m *awsAwsjson11_deserializeOpCreateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1437	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1438) {
1439	out, metadata, err = next.HandleDeserialize(ctx, in)
1440	if err != nil {
1441		return out, metadata, err
1442	}
1443
1444	response, ok := out.RawResponse.(*smithyhttp.Response)
1445	if !ok {
1446		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1447	}
1448
1449	if response.StatusCode < 200 || response.StatusCode >= 300 {
1450		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerService(response, &metadata)
1451	}
1452	output := &CreateContainerServiceOutput{}
1453	out.Result = output
1454
1455	var buff [1024]byte
1456	ringBuffer := smithyio.NewRingBuffer(buff[:])
1457
1458	body := io.TeeReader(response.Body, ringBuffer)
1459	decoder := json.NewDecoder(body)
1460	decoder.UseNumber()
1461	var shape interface{}
1462	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(&output, shape)
1473	if err != nil {
1474		var snapshot bytes.Buffer
1475		io.Copy(&snapshot, ringBuffer)
1476		err = &smithy.DeserializationError{
1477			Err:      fmt.Errorf("failed to decode response body, %w", err),
1478			Snapshot: snapshot.Bytes(),
1479		}
1480		return out, metadata, err
1481	}
1482
1483	return out, metadata, err
1484}
1485
1486func awsAwsjson11_deserializeOpErrorCreateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1487	var errorBuffer bytes.Buffer
1488	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1489		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1490	}
1491	errorBody := bytes.NewReader(errorBuffer.Bytes())
1492
1493	errorCode := "UnknownError"
1494	errorMessage := errorCode
1495
1496	code := response.Header.Get("X-Amzn-ErrorType")
1497	if len(code) != 0 {
1498		errorCode = restjson.SanitizeErrorCode(code)
1499	}
1500
1501	var buff [1024]byte
1502	ringBuffer := smithyio.NewRingBuffer(buff[:])
1503
1504	body := io.TeeReader(errorBody, ringBuffer)
1505	decoder := json.NewDecoder(body)
1506	decoder.UseNumber()
1507	code, message, err := restjson.GetErrorInfo(decoder)
1508	if err != nil {
1509		var snapshot bytes.Buffer
1510		io.Copy(&snapshot, ringBuffer)
1511		err = &smithy.DeserializationError{
1512			Err:      fmt.Errorf("failed to decode response body, %w", err),
1513			Snapshot: snapshot.Bytes(),
1514		}
1515		return err
1516	}
1517
1518	errorBody.Seek(0, io.SeekStart)
1519	if len(code) != 0 {
1520		errorCode = restjson.SanitizeErrorCode(code)
1521	}
1522	if len(message) != 0 {
1523		errorMessage = message
1524	}
1525
1526	switch {
1527	case strings.EqualFold("AccessDeniedException", errorCode):
1528		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1529
1530	case strings.EqualFold("InvalidInputException", errorCode):
1531		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1532
1533	case strings.EqualFold("NotFoundException", errorCode):
1534		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1535
1536	case strings.EqualFold("ServiceException", errorCode):
1537		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1538
1539	case strings.EqualFold("UnauthenticatedException", errorCode):
1540		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1541
1542	default:
1543		genericError := &smithy.GenericAPIError{
1544			Code:    errorCode,
1545			Message: errorMessage,
1546		}
1547		return genericError
1548
1549	}
1550}
1551
1552type awsAwsjson11_deserializeOpCreateContainerServiceDeployment struct {
1553}
1554
1555func (*awsAwsjson11_deserializeOpCreateContainerServiceDeployment) ID() string {
1556	return "OperationDeserializer"
1557}
1558
1559func (m *awsAwsjson11_deserializeOpCreateContainerServiceDeployment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1560	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1561) {
1562	out, metadata, err = next.HandleDeserialize(ctx, in)
1563	if err != nil {
1564		return out, metadata, err
1565	}
1566
1567	response, ok := out.RawResponse.(*smithyhttp.Response)
1568	if !ok {
1569		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1570	}
1571
1572	if response.StatusCode < 200 || response.StatusCode >= 300 {
1573		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response, &metadata)
1574	}
1575	output := &CreateContainerServiceDeploymentOutput{}
1576	out.Result = output
1577
1578	var buff [1024]byte
1579	ringBuffer := smithyio.NewRingBuffer(buff[:])
1580
1581	body := io.TeeReader(response.Body, ringBuffer)
1582	decoder := json.NewDecoder(body)
1583	decoder.UseNumber()
1584	var shape interface{}
1585	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1586		var snapshot bytes.Buffer
1587		io.Copy(&snapshot, ringBuffer)
1588		err = &smithy.DeserializationError{
1589			Err:      fmt.Errorf("failed to decode response body, %w", err),
1590			Snapshot: snapshot.Bytes(),
1591		}
1592		return out, metadata, err
1593	}
1594
1595	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(&output, shape)
1596	if err != nil {
1597		var snapshot bytes.Buffer
1598		io.Copy(&snapshot, ringBuffer)
1599		err = &smithy.DeserializationError{
1600			Err:      fmt.Errorf("failed to decode response body, %w", err),
1601			Snapshot: snapshot.Bytes(),
1602		}
1603		return out, metadata, err
1604	}
1605
1606	return out, metadata, err
1607}
1608
1609func awsAwsjson11_deserializeOpErrorCreateContainerServiceDeployment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1610	var errorBuffer bytes.Buffer
1611	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1612		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1613	}
1614	errorBody := bytes.NewReader(errorBuffer.Bytes())
1615
1616	errorCode := "UnknownError"
1617	errorMessage := errorCode
1618
1619	code := response.Header.Get("X-Amzn-ErrorType")
1620	if len(code) != 0 {
1621		errorCode = restjson.SanitizeErrorCode(code)
1622	}
1623
1624	var buff [1024]byte
1625	ringBuffer := smithyio.NewRingBuffer(buff[:])
1626
1627	body := io.TeeReader(errorBody, ringBuffer)
1628	decoder := json.NewDecoder(body)
1629	decoder.UseNumber()
1630	code, message, err := restjson.GetErrorInfo(decoder)
1631	if err != nil {
1632		var snapshot bytes.Buffer
1633		io.Copy(&snapshot, ringBuffer)
1634		err = &smithy.DeserializationError{
1635			Err:      fmt.Errorf("failed to decode response body, %w", err),
1636			Snapshot: snapshot.Bytes(),
1637		}
1638		return err
1639	}
1640
1641	errorBody.Seek(0, io.SeekStart)
1642	if len(code) != 0 {
1643		errorCode = restjson.SanitizeErrorCode(code)
1644	}
1645	if len(message) != 0 {
1646		errorMessage = message
1647	}
1648
1649	switch {
1650	case strings.EqualFold("AccessDeniedException", errorCode):
1651		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1652
1653	case strings.EqualFold("InvalidInputException", errorCode):
1654		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1655
1656	case strings.EqualFold("NotFoundException", errorCode):
1657		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1658
1659	case strings.EqualFold("ServiceException", errorCode):
1660		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1661
1662	case strings.EqualFold("UnauthenticatedException", errorCode):
1663		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1664
1665	default:
1666		genericError := &smithy.GenericAPIError{
1667			Code:    errorCode,
1668			Message: errorMessage,
1669		}
1670		return genericError
1671
1672	}
1673}
1674
1675type awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin struct {
1676}
1677
1678func (*awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) ID() string {
1679	return "OperationDeserializer"
1680}
1681
1682func (m *awsAwsjson11_deserializeOpCreateContainerServiceRegistryLogin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1683	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1684) {
1685	out, metadata, err = next.HandleDeserialize(ctx, in)
1686	if err != nil {
1687		return out, metadata, err
1688	}
1689
1690	response, ok := out.RawResponse.(*smithyhttp.Response)
1691	if !ok {
1692		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1693	}
1694
1695	if response.StatusCode < 200 || response.StatusCode >= 300 {
1696		return out, metadata, awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response, &metadata)
1697	}
1698	output := &CreateContainerServiceRegistryLoginOutput{}
1699	out.Result = output
1700
1701	var buff [1024]byte
1702	ringBuffer := smithyio.NewRingBuffer(buff[:])
1703
1704	body := io.TeeReader(response.Body, ringBuffer)
1705	decoder := json.NewDecoder(body)
1706	decoder.UseNumber()
1707	var shape interface{}
1708	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1709		var snapshot bytes.Buffer
1710		io.Copy(&snapshot, ringBuffer)
1711		err = &smithy.DeserializationError{
1712			Err:      fmt.Errorf("failed to decode response body, %w", err),
1713			Snapshot: snapshot.Bytes(),
1714		}
1715		return out, metadata, err
1716	}
1717
1718	err = awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(&output, shape)
1719	if err != nil {
1720		var snapshot bytes.Buffer
1721		io.Copy(&snapshot, ringBuffer)
1722		err = &smithy.DeserializationError{
1723			Err:      fmt.Errorf("failed to decode response body, %w", err),
1724			Snapshot: snapshot.Bytes(),
1725		}
1726		return out, metadata, err
1727	}
1728
1729	return out, metadata, err
1730}
1731
1732func awsAwsjson11_deserializeOpErrorCreateContainerServiceRegistryLogin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1733	var errorBuffer bytes.Buffer
1734	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1735		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1736	}
1737	errorBody := bytes.NewReader(errorBuffer.Bytes())
1738
1739	errorCode := "UnknownError"
1740	errorMessage := errorCode
1741
1742	code := response.Header.Get("X-Amzn-ErrorType")
1743	if len(code) != 0 {
1744		errorCode = restjson.SanitizeErrorCode(code)
1745	}
1746
1747	var buff [1024]byte
1748	ringBuffer := smithyio.NewRingBuffer(buff[:])
1749
1750	body := io.TeeReader(errorBody, ringBuffer)
1751	decoder := json.NewDecoder(body)
1752	decoder.UseNumber()
1753	code, message, err := restjson.GetErrorInfo(decoder)
1754	if err != nil {
1755		var snapshot bytes.Buffer
1756		io.Copy(&snapshot, ringBuffer)
1757		err = &smithy.DeserializationError{
1758			Err:      fmt.Errorf("failed to decode response body, %w", err),
1759			Snapshot: snapshot.Bytes(),
1760		}
1761		return err
1762	}
1763
1764	errorBody.Seek(0, io.SeekStart)
1765	if len(code) != 0 {
1766		errorCode = restjson.SanitizeErrorCode(code)
1767	}
1768	if len(message) != 0 {
1769		errorMessage = message
1770	}
1771
1772	switch {
1773	case strings.EqualFold("AccessDeniedException", errorCode):
1774		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1775
1776	case strings.EqualFold("InvalidInputException", errorCode):
1777		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1778
1779	case strings.EqualFold("NotFoundException", errorCode):
1780		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1781
1782	case strings.EqualFold("ServiceException", errorCode):
1783		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1784
1785	case strings.EqualFold("UnauthenticatedException", errorCode):
1786		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1787
1788	default:
1789		genericError := &smithy.GenericAPIError{
1790			Code:    errorCode,
1791			Message: errorMessage,
1792		}
1793		return genericError
1794
1795	}
1796}
1797
1798type awsAwsjson11_deserializeOpCreateDisk struct {
1799}
1800
1801func (*awsAwsjson11_deserializeOpCreateDisk) ID() string {
1802	return "OperationDeserializer"
1803}
1804
1805func (m *awsAwsjson11_deserializeOpCreateDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1806	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1807) {
1808	out, metadata, err = next.HandleDeserialize(ctx, in)
1809	if err != nil {
1810		return out, metadata, err
1811	}
1812
1813	response, ok := out.RawResponse.(*smithyhttp.Response)
1814	if !ok {
1815		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1816	}
1817
1818	if response.StatusCode < 200 || response.StatusCode >= 300 {
1819		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDisk(response, &metadata)
1820	}
1821	output := &CreateDiskOutput{}
1822	out.Result = output
1823
1824	var buff [1024]byte
1825	ringBuffer := smithyio.NewRingBuffer(buff[:])
1826
1827	body := io.TeeReader(response.Body, ringBuffer)
1828	decoder := json.NewDecoder(body)
1829	decoder.UseNumber()
1830	var shape interface{}
1831	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1832		var snapshot bytes.Buffer
1833		io.Copy(&snapshot, ringBuffer)
1834		err = &smithy.DeserializationError{
1835			Err:      fmt.Errorf("failed to decode response body, %w", err),
1836			Snapshot: snapshot.Bytes(),
1837		}
1838		return out, metadata, err
1839	}
1840
1841	err = awsAwsjson11_deserializeOpDocumentCreateDiskOutput(&output, shape)
1842	if err != nil {
1843		var snapshot bytes.Buffer
1844		io.Copy(&snapshot, ringBuffer)
1845		err = &smithy.DeserializationError{
1846			Err:      fmt.Errorf("failed to decode response body, %w", err),
1847			Snapshot: snapshot.Bytes(),
1848		}
1849		return out, metadata, err
1850	}
1851
1852	return out, metadata, err
1853}
1854
1855func awsAwsjson11_deserializeOpErrorCreateDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1856	var errorBuffer bytes.Buffer
1857	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1858		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1859	}
1860	errorBody := bytes.NewReader(errorBuffer.Bytes())
1861
1862	errorCode := "UnknownError"
1863	errorMessage := errorCode
1864
1865	code := response.Header.Get("X-Amzn-ErrorType")
1866	if len(code) != 0 {
1867		errorCode = restjson.SanitizeErrorCode(code)
1868	}
1869
1870	var buff [1024]byte
1871	ringBuffer := smithyio.NewRingBuffer(buff[:])
1872
1873	body := io.TeeReader(errorBody, ringBuffer)
1874	decoder := json.NewDecoder(body)
1875	decoder.UseNumber()
1876	code, message, err := restjson.GetErrorInfo(decoder)
1877	if err != nil {
1878		var snapshot bytes.Buffer
1879		io.Copy(&snapshot, ringBuffer)
1880		err = &smithy.DeserializationError{
1881			Err:      fmt.Errorf("failed to decode response body, %w", err),
1882			Snapshot: snapshot.Bytes(),
1883		}
1884		return err
1885	}
1886
1887	errorBody.Seek(0, io.SeekStart)
1888	if len(code) != 0 {
1889		errorCode = restjson.SanitizeErrorCode(code)
1890	}
1891	if len(message) != 0 {
1892		errorMessage = message
1893	}
1894
1895	switch {
1896	case strings.EqualFold("AccessDeniedException", errorCode):
1897		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1898
1899	case strings.EqualFold("AccountSetupInProgressException", errorCode):
1900		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
1901
1902	case strings.EqualFold("InvalidInputException", errorCode):
1903		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1904
1905	case strings.EqualFold("NotFoundException", errorCode):
1906		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
1907
1908	case strings.EqualFold("OperationFailureException", errorCode):
1909		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
1910
1911	case strings.EqualFold("ServiceException", errorCode):
1912		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1913
1914	case strings.EqualFold("UnauthenticatedException", errorCode):
1915		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
1916
1917	default:
1918		genericError := &smithy.GenericAPIError{
1919			Code:    errorCode,
1920			Message: errorMessage,
1921		}
1922		return genericError
1923
1924	}
1925}
1926
1927type awsAwsjson11_deserializeOpCreateDiskFromSnapshot struct {
1928}
1929
1930func (*awsAwsjson11_deserializeOpCreateDiskFromSnapshot) ID() string {
1931	return "OperationDeserializer"
1932}
1933
1934func (m *awsAwsjson11_deserializeOpCreateDiskFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1935	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1936) {
1937	out, metadata, err = next.HandleDeserialize(ctx, in)
1938	if err != nil {
1939		return out, metadata, err
1940	}
1941
1942	response, ok := out.RawResponse.(*smithyhttp.Response)
1943	if !ok {
1944		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1945	}
1946
1947	if response.StatusCode < 200 || response.StatusCode >= 300 {
1948		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response, &metadata)
1949	}
1950	output := &CreateDiskFromSnapshotOutput{}
1951	out.Result = output
1952
1953	var buff [1024]byte
1954	ringBuffer := smithyio.NewRingBuffer(buff[:])
1955
1956	body := io.TeeReader(response.Body, ringBuffer)
1957	decoder := json.NewDecoder(body)
1958	decoder.UseNumber()
1959	var shape interface{}
1960	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1961		var snapshot bytes.Buffer
1962		io.Copy(&snapshot, ringBuffer)
1963		err = &smithy.DeserializationError{
1964			Err:      fmt.Errorf("failed to decode response body, %w", err),
1965			Snapshot: snapshot.Bytes(),
1966		}
1967		return out, metadata, err
1968	}
1969
1970	err = awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(&output, shape)
1971	if err != nil {
1972		var snapshot bytes.Buffer
1973		io.Copy(&snapshot, ringBuffer)
1974		err = &smithy.DeserializationError{
1975			Err:      fmt.Errorf("failed to decode response body, %w", err),
1976			Snapshot: snapshot.Bytes(),
1977		}
1978		return out, metadata, err
1979	}
1980
1981	return out, metadata, err
1982}
1983
1984func awsAwsjson11_deserializeOpErrorCreateDiskFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1985	var errorBuffer bytes.Buffer
1986	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1987		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1988	}
1989	errorBody := bytes.NewReader(errorBuffer.Bytes())
1990
1991	errorCode := "UnknownError"
1992	errorMessage := errorCode
1993
1994	code := response.Header.Get("X-Amzn-ErrorType")
1995	if len(code) != 0 {
1996		errorCode = restjson.SanitizeErrorCode(code)
1997	}
1998
1999	var buff [1024]byte
2000	ringBuffer := smithyio.NewRingBuffer(buff[:])
2001
2002	body := io.TeeReader(errorBody, ringBuffer)
2003	decoder := json.NewDecoder(body)
2004	decoder.UseNumber()
2005	code, message, err := restjson.GetErrorInfo(decoder)
2006	if err != nil {
2007		var snapshot bytes.Buffer
2008		io.Copy(&snapshot, ringBuffer)
2009		err = &smithy.DeserializationError{
2010			Err:      fmt.Errorf("failed to decode response body, %w", err),
2011			Snapshot: snapshot.Bytes(),
2012		}
2013		return err
2014	}
2015
2016	errorBody.Seek(0, io.SeekStart)
2017	if len(code) != 0 {
2018		errorCode = restjson.SanitizeErrorCode(code)
2019	}
2020	if len(message) != 0 {
2021		errorMessage = message
2022	}
2023
2024	switch {
2025	case strings.EqualFold("AccessDeniedException", errorCode):
2026		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2027
2028	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2029		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2030
2031	case strings.EqualFold("InvalidInputException", errorCode):
2032		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2033
2034	case strings.EqualFold("NotFoundException", errorCode):
2035		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2036
2037	case strings.EqualFold("OperationFailureException", errorCode):
2038		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2039
2040	case strings.EqualFold("ServiceException", errorCode):
2041		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2042
2043	case strings.EqualFold("UnauthenticatedException", errorCode):
2044		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2045
2046	default:
2047		genericError := &smithy.GenericAPIError{
2048			Code:    errorCode,
2049			Message: errorMessage,
2050		}
2051		return genericError
2052
2053	}
2054}
2055
2056type awsAwsjson11_deserializeOpCreateDiskSnapshot struct {
2057}
2058
2059func (*awsAwsjson11_deserializeOpCreateDiskSnapshot) ID() string {
2060	return "OperationDeserializer"
2061}
2062
2063func (m *awsAwsjson11_deserializeOpCreateDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2064	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2065) {
2066	out, metadata, err = next.HandleDeserialize(ctx, in)
2067	if err != nil {
2068		return out, metadata, err
2069	}
2070
2071	response, ok := out.RawResponse.(*smithyhttp.Response)
2072	if !ok {
2073		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2074	}
2075
2076	if response.StatusCode < 200 || response.StatusCode >= 300 {
2077		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response, &metadata)
2078	}
2079	output := &CreateDiskSnapshotOutput{}
2080	out.Result = output
2081
2082	var buff [1024]byte
2083	ringBuffer := smithyio.NewRingBuffer(buff[:])
2084
2085	body := io.TeeReader(response.Body, ringBuffer)
2086	decoder := json.NewDecoder(body)
2087	decoder.UseNumber()
2088	var shape interface{}
2089	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2090		var snapshot bytes.Buffer
2091		io.Copy(&snapshot, ringBuffer)
2092		err = &smithy.DeserializationError{
2093			Err:      fmt.Errorf("failed to decode response body, %w", err),
2094			Snapshot: snapshot.Bytes(),
2095		}
2096		return out, metadata, err
2097	}
2098
2099	err = awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(&output, shape)
2100	if err != nil {
2101		var snapshot bytes.Buffer
2102		io.Copy(&snapshot, ringBuffer)
2103		err = &smithy.DeserializationError{
2104			Err:      fmt.Errorf("failed to decode response body, %w", err),
2105			Snapshot: snapshot.Bytes(),
2106		}
2107		return out, metadata, err
2108	}
2109
2110	return out, metadata, err
2111}
2112
2113func awsAwsjson11_deserializeOpErrorCreateDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2114	var errorBuffer bytes.Buffer
2115	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2116		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2117	}
2118	errorBody := bytes.NewReader(errorBuffer.Bytes())
2119
2120	errorCode := "UnknownError"
2121	errorMessage := errorCode
2122
2123	code := response.Header.Get("X-Amzn-ErrorType")
2124	if len(code) != 0 {
2125		errorCode = restjson.SanitizeErrorCode(code)
2126	}
2127
2128	var buff [1024]byte
2129	ringBuffer := smithyio.NewRingBuffer(buff[:])
2130
2131	body := io.TeeReader(errorBody, ringBuffer)
2132	decoder := json.NewDecoder(body)
2133	decoder.UseNumber()
2134	code, message, err := restjson.GetErrorInfo(decoder)
2135	if err != nil {
2136		var snapshot bytes.Buffer
2137		io.Copy(&snapshot, ringBuffer)
2138		err = &smithy.DeserializationError{
2139			Err:      fmt.Errorf("failed to decode response body, %w", err),
2140			Snapshot: snapshot.Bytes(),
2141		}
2142		return err
2143	}
2144
2145	errorBody.Seek(0, io.SeekStart)
2146	if len(code) != 0 {
2147		errorCode = restjson.SanitizeErrorCode(code)
2148	}
2149	if len(message) != 0 {
2150		errorMessage = message
2151	}
2152
2153	switch {
2154	case strings.EqualFold("AccessDeniedException", errorCode):
2155		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2156
2157	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2158		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2159
2160	case strings.EqualFold("InvalidInputException", errorCode):
2161		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2162
2163	case strings.EqualFold("NotFoundException", errorCode):
2164		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2165
2166	case strings.EqualFold("OperationFailureException", errorCode):
2167		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2168
2169	case strings.EqualFold("ServiceException", errorCode):
2170		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2171
2172	case strings.EqualFold("UnauthenticatedException", errorCode):
2173		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2174
2175	default:
2176		genericError := &smithy.GenericAPIError{
2177			Code:    errorCode,
2178			Message: errorMessage,
2179		}
2180		return genericError
2181
2182	}
2183}
2184
2185type awsAwsjson11_deserializeOpCreateDistribution struct {
2186}
2187
2188func (*awsAwsjson11_deserializeOpCreateDistribution) ID() string {
2189	return "OperationDeserializer"
2190}
2191
2192func (m *awsAwsjson11_deserializeOpCreateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2193	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2194) {
2195	out, metadata, err = next.HandleDeserialize(ctx, in)
2196	if err != nil {
2197		return out, metadata, err
2198	}
2199
2200	response, ok := out.RawResponse.(*smithyhttp.Response)
2201	if !ok {
2202		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2203	}
2204
2205	if response.StatusCode < 200 || response.StatusCode >= 300 {
2206		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDistribution(response, &metadata)
2207	}
2208	output := &CreateDistributionOutput{}
2209	out.Result = output
2210
2211	var buff [1024]byte
2212	ringBuffer := smithyio.NewRingBuffer(buff[:])
2213
2214	body := io.TeeReader(response.Body, ringBuffer)
2215	decoder := json.NewDecoder(body)
2216	decoder.UseNumber()
2217	var shape interface{}
2218	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2219		var snapshot bytes.Buffer
2220		io.Copy(&snapshot, ringBuffer)
2221		err = &smithy.DeserializationError{
2222			Err:      fmt.Errorf("failed to decode response body, %w", err),
2223			Snapshot: snapshot.Bytes(),
2224		}
2225		return out, metadata, err
2226	}
2227
2228	err = awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(&output, shape)
2229	if err != nil {
2230		var snapshot bytes.Buffer
2231		io.Copy(&snapshot, ringBuffer)
2232		err = &smithy.DeserializationError{
2233			Err:      fmt.Errorf("failed to decode response body, %w", err),
2234			Snapshot: snapshot.Bytes(),
2235		}
2236		return out, metadata, err
2237	}
2238
2239	return out, metadata, err
2240}
2241
2242func awsAwsjson11_deserializeOpErrorCreateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2243	var errorBuffer bytes.Buffer
2244	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2245		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2246	}
2247	errorBody := bytes.NewReader(errorBuffer.Bytes())
2248
2249	errorCode := "UnknownError"
2250	errorMessage := errorCode
2251
2252	code := response.Header.Get("X-Amzn-ErrorType")
2253	if len(code) != 0 {
2254		errorCode = restjson.SanitizeErrorCode(code)
2255	}
2256
2257	var buff [1024]byte
2258	ringBuffer := smithyio.NewRingBuffer(buff[:])
2259
2260	body := io.TeeReader(errorBody, ringBuffer)
2261	decoder := json.NewDecoder(body)
2262	decoder.UseNumber()
2263	code, message, err := restjson.GetErrorInfo(decoder)
2264	if err != nil {
2265		var snapshot bytes.Buffer
2266		io.Copy(&snapshot, ringBuffer)
2267		err = &smithy.DeserializationError{
2268			Err:      fmt.Errorf("failed to decode response body, %w", err),
2269			Snapshot: snapshot.Bytes(),
2270		}
2271		return err
2272	}
2273
2274	errorBody.Seek(0, io.SeekStart)
2275	if len(code) != 0 {
2276		errorCode = restjson.SanitizeErrorCode(code)
2277	}
2278	if len(message) != 0 {
2279		errorMessage = message
2280	}
2281
2282	switch {
2283	case strings.EqualFold("AccessDeniedException", errorCode):
2284		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2285
2286	case strings.EqualFold("InvalidInputException", errorCode):
2287		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2288
2289	case strings.EqualFold("NotFoundException", errorCode):
2290		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2291
2292	case strings.EqualFold("OperationFailureException", errorCode):
2293		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2294
2295	case strings.EqualFold("ServiceException", errorCode):
2296		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2297
2298	case strings.EqualFold("UnauthenticatedException", errorCode):
2299		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2300
2301	default:
2302		genericError := &smithy.GenericAPIError{
2303			Code:    errorCode,
2304			Message: errorMessage,
2305		}
2306		return genericError
2307
2308	}
2309}
2310
2311type awsAwsjson11_deserializeOpCreateDomain struct {
2312}
2313
2314func (*awsAwsjson11_deserializeOpCreateDomain) ID() string {
2315	return "OperationDeserializer"
2316}
2317
2318func (m *awsAwsjson11_deserializeOpCreateDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2319	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2320) {
2321	out, metadata, err = next.HandleDeserialize(ctx, in)
2322	if err != nil {
2323		return out, metadata, err
2324	}
2325
2326	response, ok := out.RawResponse.(*smithyhttp.Response)
2327	if !ok {
2328		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2329	}
2330
2331	if response.StatusCode < 200 || response.StatusCode >= 300 {
2332		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomain(response, &metadata)
2333	}
2334	output := &CreateDomainOutput{}
2335	out.Result = output
2336
2337	var buff [1024]byte
2338	ringBuffer := smithyio.NewRingBuffer(buff[:])
2339
2340	body := io.TeeReader(response.Body, ringBuffer)
2341	decoder := json.NewDecoder(body)
2342	decoder.UseNumber()
2343	var shape interface{}
2344	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentCreateDomainOutput(&output, shape)
2355	if err != nil {
2356		var snapshot bytes.Buffer
2357		io.Copy(&snapshot, ringBuffer)
2358		err = &smithy.DeserializationError{
2359			Err:      fmt.Errorf("failed to decode response body, %w", err),
2360			Snapshot: snapshot.Bytes(),
2361		}
2362		return out, metadata, err
2363	}
2364
2365	return out, metadata, err
2366}
2367
2368func awsAwsjson11_deserializeOpErrorCreateDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2369	var errorBuffer bytes.Buffer
2370	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2371		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2372	}
2373	errorBody := bytes.NewReader(errorBuffer.Bytes())
2374
2375	errorCode := "UnknownError"
2376	errorMessage := errorCode
2377
2378	code := response.Header.Get("X-Amzn-ErrorType")
2379	if len(code) != 0 {
2380		errorCode = restjson.SanitizeErrorCode(code)
2381	}
2382
2383	var buff [1024]byte
2384	ringBuffer := smithyio.NewRingBuffer(buff[:])
2385
2386	body := io.TeeReader(errorBody, ringBuffer)
2387	decoder := json.NewDecoder(body)
2388	decoder.UseNumber()
2389	code, message, err := restjson.GetErrorInfo(decoder)
2390	if err != nil {
2391		var snapshot bytes.Buffer
2392		io.Copy(&snapshot, ringBuffer)
2393		err = &smithy.DeserializationError{
2394			Err:      fmt.Errorf("failed to decode response body, %w", err),
2395			Snapshot: snapshot.Bytes(),
2396		}
2397		return err
2398	}
2399
2400	errorBody.Seek(0, io.SeekStart)
2401	if len(code) != 0 {
2402		errorCode = restjson.SanitizeErrorCode(code)
2403	}
2404	if len(message) != 0 {
2405		errorMessage = message
2406	}
2407
2408	switch {
2409	case strings.EqualFold("AccessDeniedException", errorCode):
2410		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2411
2412	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2413		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2414
2415	case strings.EqualFold("InvalidInputException", errorCode):
2416		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2417
2418	case strings.EqualFold("NotFoundException", errorCode):
2419		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2420
2421	case strings.EqualFold("OperationFailureException", errorCode):
2422		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2423
2424	case strings.EqualFold("ServiceException", errorCode):
2425		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2426
2427	case strings.EqualFold("UnauthenticatedException", errorCode):
2428		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2429
2430	default:
2431		genericError := &smithy.GenericAPIError{
2432			Code:    errorCode,
2433			Message: errorMessage,
2434		}
2435		return genericError
2436
2437	}
2438}
2439
2440type awsAwsjson11_deserializeOpCreateDomainEntry struct {
2441}
2442
2443func (*awsAwsjson11_deserializeOpCreateDomainEntry) ID() string {
2444	return "OperationDeserializer"
2445}
2446
2447func (m *awsAwsjson11_deserializeOpCreateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2448	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2449) {
2450	out, metadata, err = next.HandleDeserialize(ctx, in)
2451	if err != nil {
2452		return out, metadata, err
2453	}
2454
2455	response, ok := out.RawResponse.(*smithyhttp.Response)
2456	if !ok {
2457		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2458	}
2459
2460	if response.StatusCode < 200 || response.StatusCode >= 300 {
2461		return out, metadata, awsAwsjson11_deserializeOpErrorCreateDomainEntry(response, &metadata)
2462	}
2463	output := &CreateDomainEntryOutput{}
2464	out.Result = output
2465
2466	var buff [1024]byte
2467	ringBuffer := smithyio.NewRingBuffer(buff[:])
2468
2469	body := io.TeeReader(response.Body, ringBuffer)
2470	decoder := json.NewDecoder(body)
2471	decoder.UseNumber()
2472	var shape interface{}
2473	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(&output, shape)
2484	if err != nil {
2485		var snapshot bytes.Buffer
2486		io.Copy(&snapshot, ringBuffer)
2487		err = &smithy.DeserializationError{
2488			Err:      fmt.Errorf("failed to decode response body, %w", err),
2489			Snapshot: snapshot.Bytes(),
2490		}
2491		return out, metadata, err
2492	}
2493
2494	return out, metadata, err
2495}
2496
2497func awsAwsjson11_deserializeOpErrorCreateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2498	var errorBuffer bytes.Buffer
2499	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2500		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2501	}
2502	errorBody := bytes.NewReader(errorBuffer.Bytes())
2503
2504	errorCode := "UnknownError"
2505	errorMessage := errorCode
2506
2507	code := response.Header.Get("X-Amzn-ErrorType")
2508	if len(code) != 0 {
2509		errorCode = restjson.SanitizeErrorCode(code)
2510	}
2511
2512	var buff [1024]byte
2513	ringBuffer := smithyio.NewRingBuffer(buff[:])
2514
2515	body := io.TeeReader(errorBody, ringBuffer)
2516	decoder := json.NewDecoder(body)
2517	decoder.UseNumber()
2518	code, message, err := restjson.GetErrorInfo(decoder)
2519	if err != nil {
2520		var snapshot bytes.Buffer
2521		io.Copy(&snapshot, ringBuffer)
2522		err = &smithy.DeserializationError{
2523			Err:      fmt.Errorf("failed to decode response body, %w", err),
2524			Snapshot: snapshot.Bytes(),
2525		}
2526		return err
2527	}
2528
2529	errorBody.Seek(0, io.SeekStart)
2530	if len(code) != 0 {
2531		errorCode = restjson.SanitizeErrorCode(code)
2532	}
2533	if len(message) != 0 {
2534		errorMessage = message
2535	}
2536
2537	switch {
2538	case strings.EqualFold("AccessDeniedException", errorCode):
2539		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2540
2541	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2542		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2543
2544	case strings.EqualFold("InvalidInputException", errorCode):
2545		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2546
2547	case strings.EqualFold("NotFoundException", errorCode):
2548		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2549
2550	case strings.EqualFold("OperationFailureException", errorCode):
2551		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2552
2553	case strings.EqualFold("ServiceException", errorCode):
2554		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2555
2556	case strings.EqualFold("UnauthenticatedException", errorCode):
2557		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2558
2559	default:
2560		genericError := &smithy.GenericAPIError{
2561			Code:    errorCode,
2562			Message: errorMessage,
2563		}
2564		return genericError
2565
2566	}
2567}
2568
2569type awsAwsjson11_deserializeOpCreateInstances struct {
2570}
2571
2572func (*awsAwsjson11_deserializeOpCreateInstances) ID() string {
2573	return "OperationDeserializer"
2574}
2575
2576func (m *awsAwsjson11_deserializeOpCreateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2577	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2578) {
2579	out, metadata, err = next.HandleDeserialize(ctx, in)
2580	if err != nil {
2581		return out, metadata, err
2582	}
2583
2584	response, ok := out.RawResponse.(*smithyhttp.Response)
2585	if !ok {
2586		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2587	}
2588
2589	if response.StatusCode < 200 || response.StatusCode >= 300 {
2590		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstances(response, &metadata)
2591	}
2592	output := &CreateInstancesOutput{}
2593	out.Result = output
2594
2595	var buff [1024]byte
2596	ringBuffer := smithyio.NewRingBuffer(buff[:])
2597
2598	body := io.TeeReader(response.Body, ringBuffer)
2599	decoder := json.NewDecoder(body)
2600	decoder.UseNumber()
2601	var shape interface{}
2602	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2603		var snapshot bytes.Buffer
2604		io.Copy(&snapshot, ringBuffer)
2605		err = &smithy.DeserializationError{
2606			Err:      fmt.Errorf("failed to decode response body, %w", err),
2607			Snapshot: snapshot.Bytes(),
2608		}
2609		return out, metadata, err
2610	}
2611
2612	err = awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(&output, shape)
2613	if err != nil {
2614		var snapshot bytes.Buffer
2615		io.Copy(&snapshot, ringBuffer)
2616		err = &smithy.DeserializationError{
2617			Err:      fmt.Errorf("failed to decode response body, %w", err),
2618			Snapshot: snapshot.Bytes(),
2619		}
2620		return out, metadata, err
2621	}
2622
2623	return out, metadata, err
2624}
2625
2626func awsAwsjson11_deserializeOpErrorCreateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2627	var errorBuffer bytes.Buffer
2628	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2629		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2630	}
2631	errorBody := bytes.NewReader(errorBuffer.Bytes())
2632
2633	errorCode := "UnknownError"
2634	errorMessage := errorCode
2635
2636	code := response.Header.Get("X-Amzn-ErrorType")
2637	if len(code) != 0 {
2638		errorCode = restjson.SanitizeErrorCode(code)
2639	}
2640
2641	var buff [1024]byte
2642	ringBuffer := smithyio.NewRingBuffer(buff[:])
2643
2644	body := io.TeeReader(errorBody, ringBuffer)
2645	decoder := json.NewDecoder(body)
2646	decoder.UseNumber()
2647	code, message, err := restjson.GetErrorInfo(decoder)
2648	if err != nil {
2649		var snapshot bytes.Buffer
2650		io.Copy(&snapshot, ringBuffer)
2651		err = &smithy.DeserializationError{
2652			Err:      fmt.Errorf("failed to decode response body, %w", err),
2653			Snapshot: snapshot.Bytes(),
2654		}
2655		return err
2656	}
2657
2658	errorBody.Seek(0, io.SeekStart)
2659	if len(code) != 0 {
2660		errorCode = restjson.SanitizeErrorCode(code)
2661	}
2662	if len(message) != 0 {
2663		errorMessage = message
2664	}
2665
2666	switch {
2667	case strings.EqualFold("AccessDeniedException", errorCode):
2668		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2669
2670	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2671		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2672
2673	case strings.EqualFold("InvalidInputException", errorCode):
2674		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2675
2676	case strings.EqualFold("NotFoundException", errorCode):
2677		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2678
2679	case strings.EqualFold("OperationFailureException", errorCode):
2680		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2681
2682	case strings.EqualFold("ServiceException", errorCode):
2683		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2684
2685	case strings.EqualFold("UnauthenticatedException", errorCode):
2686		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2687
2688	default:
2689		genericError := &smithy.GenericAPIError{
2690			Code:    errorCode,
2691			Message: errorMessage,
2692		}
2693		return genericError
2694
2695	}
2696}
2697
2698type awsAwsjson11_deserializeOpCreateInstancesFromSnapshot struct {
2699}
2700
2701func (*awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) ID() string {
2702	return "OperationDeserializer"
2703}
2704
2705func (m *awsAwsjson11_deserializeOpCreateInstancesFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2706	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2707) {
2708	out, metadata, err = next.HandleDeserialize(ctx, in)
2709	if err != nil {
2710		return out, metadata, err
2711	}
2712
2713	response, ok := out.RawResponse.(*smithyhttp.Response)
2714	if !ok {
2715		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2716	}
2717
2718	if response.StatusCode < 200 || response.StatusCode >= 300 {
2719		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response, &metadata)
2720	}
2721	output := &CreateInstancesFromSnapshotOutput{}
2722	out.Result = output
2723
2724	var buff [1024]byte
2725	ringBuffer := smithyio.NewRingBuffer(buff[:])
2726
2727	body := io.TeeReader(response.Body, ringBuffer)
2728	decoder := json.NewDecoder(body)
2729	decoder.UseNumber()
2730	var shape interface{}
2731	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2732		var snapshot bytes.Buffer
2733		io.Copy(&snapshot, ringBuffer)
2734		err = &smithy.DeserializationError{
2735			Err:      fmt.Errorf("failed to decode response body, %w", err),
2736			Snapshot: snapshot.Bytes(),
2737		}
2738		return out, metadata, err
2739	}
2740
2741	err = awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(&output, shape)
2742	if err != nil {
2743		var snapshot bytes.Buffer
2744		io.Copy(&snapshot, ringBuffer)
2745		err = &smithy.DeserializationError{
2746			Err:      fmt.Errorf("failed to decode response body, %w", err),
2747			Snapshot: snapshot.Bytes(),
2748		}
2749		return out, metadata, err
2750	}
2751
2752	return out, metadata, err
2753}
2754
2755func awsAwsjson11_deserializeOpErrorCreateInstancesFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2756	var errorBuffer bytes.Buffer
2757	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2758		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2759	}
2760	errorBody := bytes.NewReader(errorBuffer.Bytes())
2761
2762	errorCode := "UnknownError"
2763	errorMessage := errorCode
2764
2765	code := response.Header.Get("X-Amzn-ErrorType")
2766	if len(code) != 0 {
2767		errorCode = restjson.SanitizeErrorCode(code)
2768	}
2769
2770	var buff [1024]byte
2771	ringBuffer := smithyio.NewRingBuffer(buff[:])
2772
2773	body := io.TeeReader(errorBody, ringBuffer)
2774	decoder := json.NewDecoder(body)
2775	decoder.UseNumber()
2776	code, message, err := restjson.GetErrorInfo(decoder)
2777	if err != nil {
2778		var snapshot bytes.Buffer
2779		io.Copy(&snapshot, ringBuffer)
2780		err = &smithy.DeserializationError{
2781			Err:      fmt.Errorf("failed to decode response body, %w", err),
2782			Snapshot: snapshot.Bytes(),
2783		}
2784		return err
2785	}
2786
2787	errorBody.Seek(0, io.SeekStart)
2788	if len(code) != 0 {
2789		errorCode = restjson.SanitizeErrorCode(code)
2790	}
2791	if len(message) != 0 {
2792		errorMessage = message
2793	}
2794
2795	switch {
2796	case strings.EqualFold("AccessDeniedException", errorCode):
2797		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2798
2799	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2800		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2801
2802	case strings.EqualFold("InvalidInputException", errorCode):
2803		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2804
2805	case strings.EqualFold("NotFoundException", errorCode):
2806		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2807
2808	case strings.EqualFold("OperationFailureException", errorCode):
2809		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2810
2811	case strings.EqualFold("ServiceException", errorCode):
2812		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2813
2814	case strings.EqualFold("UnauthenticatedException", errorCode):
2815		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2816
2817	default:
2818		genericError := &smithy.GenericAPIError{
2819			Code:    errorCode,
2820			Message: errorMessage,
2821		}
2822		return genericError
2823
2824	}
2825}
2826
2827type awsAwsjson11_deserializeOpCreateInstanceSnapshot struct {
2828}
2829
2830func (*awsAwsjson11_deserializeOpCreateInstanceSnapshot) ID() string {
2831	return "OperationDeserializer"
2832}
2833
2834func (m *awsAwsjson11_deserializeOpCreateInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2835	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2836) {
2837	out, metadata, err = next.HandleDeserialize(ctx, in)
2838	if err != nil {
2839		return out, metadata, err
2840	}
2841
2842	response, ok := out.RawResponse.(*smithyhttp.Response)
2843	if !ok {
2844		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2845	}
2846
2847	if response.StatusCode < 200 || response.StatusCode >= 300 {
2848		return out, metadata, awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response, &metadata)
2849	}
2850	output := &CreateInstanceSnapshotOutput{}
2851	out.Result = output
2852
2853	var buff [1024]byte
2854	ringBuffer := smithyio.NewRingBuffer(buff[:])
2855
2856	body := io.TeeReader(response.Body, ringBuffer)
2857	decoder := json.NewDecoder(body)
2858	decoder.UseNumber()
2859	var shape interface{}
2860	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2861		var snapshot bytes.Buffer
2862		io.Copy(&snapshot, ringBuffer)
2863		err = &smithy.DeserializationError{
2864			Err:      fmt.Errorf("failed to decode response body, %w", err),
2865			Snapshot: snapshot.Bytes(),
2866		}
2867		return out, metadata, err
2868	}
2869
2870	err = awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(&output, shape)
2871	if err != nil {
2872		var snapshot bytes.Buffer
2873		io.Copy(&snapshot, ringBuffer)
2874		err = &smithy.DeserializationError{
2875			Err:      fmt.Errorf("failed to decode response body, %w", err),
2876			Snapshot: snapshot.Bytes(),
2877		}
2878		return out, metadata, err
2879	}
2880
2881	return out, metadata, err
2882}
2883
2884func awsAwsjson11_deserializeOpErrorCreateInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2885	var errorBuffer bytes.Buffer
2886	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2887		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2888	}
2889	errorBody := bytes.NewReader(errorBuffer.Bytes())
2890
2891	errorCode := "UnknownError"
2892	errorMessage := errorCode
2893
2894	code := response.Header.Get("X-Amzn-ErrorType")
2895	if len(code) != 0 {
2896		errorCode = restjson.SanitizeErrorCode(code)
2897	}
2898
2899	var buff [1024]byte
2900	ringBuffer := smithyio.NewRingBuffer(buff[:])
2901
2902	body := io.TeeReader(errorBody, ringBuffer)
2903	decoder := json.NewDecoder(body)
2904	decoder.UseNumber()
2905	code, message, err := restjson.GetErrorInfo(decoder)
2906	if err != nil {
2907		var snapshot bytes.Buffer
2908		io.Copy(&snapshot, ringBuffer)
2909		err = &smithy.DeserializationError{
2910			Err:      fmt.Errorf("failed to decode response body, %w", err),
2911			Snapshot: snapshot.Bytes(),
2912		}
2913		return err
2914	}
2915
2916	errorBody.Seek(0, io.SeekStart)
2917	if len(code) != 0 {
2918		errorCode = restjson.SanitizeErrorCode(code)
2919	}
2920	if len(message) != 0 {
2921		errorMessage = message
2922	}
2923
2924	switch {
2925	case strings.EqualFold("AccessDeniedException", errorCode):
2926		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2927
2928	case strings.EqualFold("AccountSetupInProgressException", errorCode):
2929		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
2930
2931	case strings.EqualFold("InvalidInputException", errorCode):
2932		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2933
2934	case strings.EqualFold("NotFoundException", errorCode):
2935		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
2936
2937	case strings.EqualFold("OperationFailureException", errorCode):
2938		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
2939
2940	case strings.EqualFold("ServiceException", errorCode):
2941		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2942
2943	case strings.EqualFold("UnauthenticatedException", errorCode):
2944		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
2945
2946	default:
2947		genericError := &smithy.GenericAPIError{
2948			Code:    errorCode,
2949			Message: errorMessage,
2950		}
2951		return genericError
2952
2953	}
2954}
2955
2956type awsAwsjson11_deserializeOpCreateKeyPair struct {
2957}
2958
2959func (*awsAwsjson11_deserializeOpCreateKeyPair) ID() string {
2960	return "OperationDeserializer"
2961}
2962
2963func (m *awsAwsjson11_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2964	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2965) {
2966	out, metadata, err = next.HandleDeserialize(ctx, in)
2967	if err != nil {
2968		return out, metadata, err
2969	}
2970
2971	response, ok := out.RawResponse.(*smithyhttp.Response)
2972	if !ok {
2973		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2974	}
2975
2976	if response.StatusCode < 200 || response.StatusCode >= 300 {
2977		return out, metadata, awsAwsjson11_deserializeOpErrorCreateKeyPair(response, &metadata)
2978	}
2979	output := &CreateKeyPairOutput{}
2980	out.Result = output
2981
2982	var buff [1024]byte
2983	ringBuffer := smithyio.NewRingBuffer(buff[:])
2984
2985	body := io.TeeReader(response.Body, ringBuffer)
2986	decoder := json.NewDecoder(body)
2987	decoder.UseNumber()
2988	var shape interface{}
2989	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2990		var snapshot bytes.Buffer
2991		io.Copy(&snapshot, ringBuffer)
2992		err = &smithy.DeserializationError{
2993			Err:      fmt.Errorf("failed to decode response body, %w", err),
2994			Snapshot: snapshot.Bytes(),
2995		}
2996		return out, metadata, err
2997	}
2998
2999	err = awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(&output, shape)
3000	if err != nil {
3001		var snapshot bytes.Buffer
3002		io.Copy(&snapshot, ringBuffer)
3003		err = &smithy.DeserializationError{
3004			Err:      fmt.Errorf("failed to decode response body, %w", err),
3005			Snapshot: snapshot.Bytes(),
3006		}
3007		return out, metadata, err
3008	}
3009
3010	return out, metadata, err
3011}
3012
3013func awsAwsjson11_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3014	var errorBuffer bytes.Buffer
3015	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3016		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3017	}
3018	errorBody := bytes.NewReader(errorBuffer.Bytes())
3019
3020	errorCode := "UnknownError"
3021	errorMessage := errorCode
3022
3023	code := response.Header.Get("X-Amzn-ErrorType")
3024	if len(code) != 0 {
3025		errorCode = restjson.SanitizeErrorCode(code)
3026	}
3027
3028	var buff [1024]byte
3029	ringBuffer := smithyio.NewRingBuffer(buff[:])
3030
3031	body := io.TeeReader(errorBody, ringBuffer)
3032	decoder := json.NewDecoder(body)
3033	decoder.UseNumber()
3034	code, message, err := restjson.GetErrorInfo(decoder)
3035	if err != nil {
3036		var snapshot bytes.Buffer
3037		io.Copy(&snapshot, ringBuffer)
3038		err = &smithy.DeserializationError{
3039			Err:      fmt.Errorf("failed to decode response body, %w", err),
3040			Snapshot: snapshot.Bytes(),
3041		}
3042		return err
3043	}
3044
3045	errorBody.Seek(0, io.SeekStart)
3046	if len(code) != 0 {
3047		errorCode = restjson.SanitizeErrorCode(code)
3048	}
3049	if len(message) != 0 {
3050		errorMessage = message
3051	}
3052
3053	switch {
3054	case strings.EqualFold("AccessDeniedException", errorCode):
3055		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3056
3057	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3058		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3059
3060	case strings.EqualFold("InvalidInputException", errorCode):
3061		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3062
3063	case strings.EqualFold("NotFoundException", errorCode):
3064		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3065
3066	case strings.EqualFold("OperationFailureException", errorCode):
3067		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3068
3069	case strings.EqualFold("ServiceException", errorCode):
3070		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3071
3072	case strings.EqualFold("UnauthenticatedException", errorCode):
3073		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3074
3075	default:
3076		genericError := &smithy.GenericAPIError{
3077			Code:    errorCode,
3078			Message: errorMessage,
3079		}
3080		return genericError
3081
3082	}
3083}
3084
3085type awsAwsjson11_deserializeOpCreateLoadBalancer struct {
3086}
3087
3088func (*awsAwsjson11_deserializeOpCreateLoadBalancer) ID() string {
3089	return "OperationDeserializer"
3090}
3091
3092func (m *awsAwsjson11_deserializeOpCreateLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3093	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3094) {
3095	out, metadata, err = next.HandleDeserialize(ctx, in)
3096	if err != nil {
3097		return out, metadata, err
3098	}
3099
3100	response, ok := out.RawResponse.(*smithyhttp.Response)
3101	if !ok {
3102		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3103	}
3104
3105	if response.StatusCode < 200 || response.StatusCode >= 300 {
3106		return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response, &metadata)
3107	}
3108	output := &CreateLoadBalancerOutput{}
3109	out.Result = output
3110
3111	var buff [1024]byte
3112	ringBuffer := smithyio.NewRingBuffer(buff[:])
3113
3114	body := io.TeeReader(response.Body, ringBuffer)
3115	decoder := json.NewDecoder(body)
3116	decoder.UseNumber()
3117	var shape interface{}
3118	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3119		var snapshot bytes.Buffer
3120		io.Copy(&snapshot, ringBuffer)
3121		err = &smithy.DeserializationError{
3122			Err:      fmt.Errorf("failed to decode response body, %w", err),
3123			Snapshot: snapshot.Bytes(),
3124		}
3125		return out, metadata, err
3126	}
3127
3128	err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(&output, shape)
3129	if err != nil {
3130		var snapshot bytes.Buffer
3131		io.Copy(&snapshot, ringBuffer)
3132		err = &smithy.DeserializationError{
3133			Err:      fmt.Errorf("failed to decode response body, %w", err),
3134			Snapshot: snapshot.Bytes(),
3135		}
3136		return out, metadata, err
3137	}
3138
3139	return out, metadata, err
3140}
3141
3142func awsAwsjson11_deserializeOpErrorCreateLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3143	var errorBuffer bytes.Buffer
3144	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3145		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3146	}
3147	errorBody := bytes.NewReader(errorBuffer.Bytes())
3148
3149	errorCode := "UnknownError"
3150	errorMessage := errorCode
3151
3152	code := response.Header.Get("X-Amzn-ErrorType")
3153	if len(code) != 0 {
3154		errorCode = restjson.SanitizeErrorCode(code)
3155	}
3156
3157	var buff [1024]byte
3158	ringBuffer := smithyio.NewRingBuffer(buff[:])
3159
3160	body := io.TeeReader(errorBody, ringBuffer)
3161	decoder := json.NewDecoder(body)
3162	decoder.UseNumber()
3163	code, message, err := restjson.GetErrorInfo(decoder)
3164	if err != nil {
3165		var snapshot bytes.Buffer
3166		io.Copy(&snapshot, ringBuffer)
3167		err = &smithy.DeserializationError{
3168			Err:      fmt.Errorf("failed to decode response body, %w", err),
3169			Snapshot: snapshot.Bytes(),
3170		}
3171		return err
3172	}
3173
3174	errorBody.Seek(0, io.SeekStart)
3175	if len(code) != 0 {
3176		errorCode = restjson.SanitizeErrorCode(code)
3177	}
3178	if len(message) != 0 {
3179		errorMessage = message
3180	}
3181
3182	switch {
3183	case strings.EqualFold("AccessDeniedException", errorCode):
3184		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3185
3186	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3187		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3188
3189	case strings.EqualFold("InvalidInputException", errorCode):
3190		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3191
3192	case strings.EqualFold("NotFoundException", errorCode):
3193		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3194
3195	case strings.EqualFold("OperationFailureException", errorCode):
3196		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3197
3198	case strings.EqualFold("ServiceException", errorCode):
3199		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3200
3201	case strings.EqualFold("UnauthenticatedException", errorCode):
3202		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3203
3204	default:
3205		genericError := &smithy.GenericAPIError{
3206			Code:    errorCode,
3207			Message: errorMessage,
3208		}
3209		return genericError
3210
3211	}
3212}
3213
3214type awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate struct {
3215}
3216
3217func (*awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) ID() string {
3218	return "OperationDeserializer"
3219}
3220
3221func (m *awsAwsjson11_deserializeOpCreateLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3222	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3223) {
3224	out, metadata, err = next.HandleDeserialize(ctx, in)
3225	if err != nil {
3226		return out, metadata, err
3227	}
3228
3229	response, ok := out.RawResponse.(*smithyhttp.Response)
3230	if !ok {
3231		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3232	}
3233
3234	if response.StatusCode < 200 || response.StatusCode >= 300 {
3235		return out, metadata, awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response, &metadata)
3236	}
3237	output := &CreateLoadBalancerTlsCertificateOutput{}
3238	out.Result = output
3239
3240	var buff [1024]byte
3241	ringBuffer := smithyio.NewRingBuffer(buff[:])
3242
3243	body := io.TeeReader(response.Body, ringBuffer)
3244	decoder := json.NewDecoder(body)
3245	decoder.UseNumber()
3246	var shape interface{}
3247	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3248		var snapshot bytes.Buffer
3249		io.Copy(&snapshot, ringBuffer)
3250		err = &smithy.DeserializationError{
3251			Err:      fmt.Errorf("failed to decode response body, %w", err),
3252			Snapshot: snapshot.Bytes(),
3253		}
3254		return out, metadata, err
3255	}
3256
3257	err = awsAwsjson11_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(&output, shape)
3258	if err != nil {
3259		var snapshot bytes.Buffer
3260		io.Copy(&snapshot, ringBuffer)
3261		err = &smithy.DeserializationError{
3262			Err:      fmt.Errorf("failed to decode response body, %w", err),
3263			Snapshot: snapshot.Bytes(),
3264		}
3265		return out, metadata, err
3266	}
3267
3268	return out, metadata, err
3269}
3270
3271func awsAwsjson11_deserializeOpErrorCreateLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3272	var errorBuffer bytes.Buffer
3273	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3274		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3275	}
3276	errorBody := bytes.NewReader(errorBuffer.Bytes())
3277
3278	errorCode := "UnknownError"
3279	errorMessage := errorCode
3280
3281	code := response.Header.Get("X-Amzn-ErrorType")
3282	if len(code) != 0 {
3283		errorCode = restjson.SanitizeErrorCode(code)
3284	}
3285
3286	var buff [1024]byte
3287	ringBuffer := smithyio.NewRingBuffer(buff[:])
3288
3289	body := io.TeeReader(errorBody, ringBuffer)
3290	decoder := json.NewDecoder(body)
3291	decoder.UseNumber()
3292	code, message, err := restjson.GetErrorInfo(decoder)
3293	if err != nil {
3294		var snapshot bytes.Buffer
3295		io.Copy(&snapshot, ringBuffer)
3296		err = &smithy.DeserializationError{
3297			Err:      fmt.Errorf("failed to decode response body, %w", err),
3298			Snapshot: snapshot.Bytes(),
3299		}
3300		return err
3301	}
3302
3303	errorBody.Seek(0, io.SeekStart)
3304	if len(code) != 0 {
3305		errorCode = restjson.SanitizeErrorCode(code)
3306	}
3307	if len(message) != 0 {
3308		errorMessage = message
3309	}
3310
3311	switch {
3312	case strings.EqualFold("AccessDeniedException", errorCode):
3313		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3314
3315	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3316		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3317
3318	case strings.EqualFold("InvalidInputException", errorCode):
3319		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3320
3321	case strings.EqualFold("NotFoundException", errorCode):
3322		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3323
3324	case strings.EqualFold("OperationFailureException", errorCode):
3325		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3326
3327	case strings.EqualFold("ServiceException", errorCode):
3328		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3329
3330	case strings.EqualFold("UnauthenticatedException", errorCode):
3331		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3332
3333	default:
3334		genericError := &smithy.GenericAPIError{
3335			Code:    errorCode,
3336			Message: errorMessage,
3337		}
3338		return genericError
3339
3340	}
3341}
3342
3343type awsAwsjson11_deserializeOpCreateRelationalDatabase struct {
3344}
3345
3346func (*awsAwsjson11_deserializeOpCreateRelationalDatabase) ID() string {
3347	return "OperationDeserializer"
3348}
3349
3350func (m *awsAwsjson11_deserializeOpCreateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3351	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3352) {
3353	out, metadata, err = next.HandleDeserialize(ctx, in)
3354	if err != nil {
3355		return out, metadata, err
3356	}
3357
3358	response, ok := out.RawResponse.(*smithyhttp.Response)
3359	if !ok {
3360		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3361	}
3362
3363	if response.StatusCode < 200 || response.StatusCode >= 300 {
3364		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response, &metadata)
3365	}
3366	output := &CreateRelationalDatabaseOutput{}
3367	out.Result = output
3368
3369	var buff [1024]byte
3370	ringBuffer := smithyio.NewRingBuffer(buff[:])
3371
3372	body := io.TeeReader(response.Body, ringBuffer)
3373	decoder := json.NewDecoder(body)
3374	decoder.UseNumber()
3375	var shape interface{}
3376	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3377		var snapshot bytes.Buffer
3378		io.Copy(&snapshot, ringBuffer)
3379		err = &smithy.DeserializationError{
3380			Err:      fmt.Errorf("failed to decode response body, %w", err),
3381			Snapshot: snapshot.Bytes(),
3382		}
3383		return out, metadata, err
3384	}
3385
3386	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(&output, shape)
3387	if err != nil {
3388		var snapshot bytes.Buffer
3389		io.Copy(&snapshot, ringBuffer)
3390		err = &smithy.DeserializationError{
3391			Err:      fmt.Errorf("failed to decode response body, %w", err),
3392			Snapshot: snapshot.Bytes(),
3393		}
3394		return out, metadata, err
3395	}
3396
3397	return out, metadata, err
3398}
3399
3400func awsAwsjson11_deserializeOpErrorCreateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3401	var errorBuffer bytes.Buffer
3402	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3403		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3404	}
3405	errorBody := bytes.NewReader(errorBuffer.Bytes())
3406
3407	errorCode := "UnknownError"
3408	errorMessage := errorCode
3409
3410	code := response.Header.Get("X-Amzn-ErrorType")
3411	if len(code) != 0 {
3412		errorCode = restjson.SanitizeErrorCode(code)
3413	}
3414
3415	var buff [1024]byte
3416	ringBuffer := smithyio.NewRingBuffer(buff[:])
3417
3418	body := io.TeeReader(errorBody, ringBuffer)
3419	decoder := json.NewDecoder(body)
3420	decoder.UseNumber()
3421	code, message, err := restjson.GetErrorInfo(decoder)
3422	if err != nil {
3423		var snapshot bytes.Buffer
3424		io.Copy(&snapshot, ringBuffer)
3425		err = &smithy.DeserializationError{
3426			Err:      fmt.Errorf("failed to decode response body, %w", err),
3427			Snapshot: snapshot.Bytes(),
3428		}
3429		return err
3430	}
3431
3432	errorBody.Seek(0, io.SeekStart)
3433	if len(code) != 0 {
3434		errorCode = restjson.SanitizeErrorCode(code)
3435	}
3436	if len(message) != 0 {
3437		errorMessage = message
3438	}
3439
3440	switch {
3441	case strings.EqualFold("AccessDeniedException", errorCode):
3442		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3443
3444	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3445		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3446
3447	case strings.EqualFold("InvalidInputException", errorCode):
3448		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3449
3450	case strings.EqualFold("NotFoundException", errorCode):
3451		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3452
3453	case strings.EqualFold("OperationFailureException", errorCode):
3454		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3455
3456	case strings.EqualFold("ServiceException", errorCode):
3457		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3458
3459	case strings.EqualFold("UnauthenticatedException", errorCode):
3460		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3461
3462	default:
3463		genericError := &smithy.GenericAPIError{
3464			Code:    errorCode,
3465			Message: errorMessage,
3466		}
3467		return genericError
3468
3469	}
3470}
3471
3472type awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot struct {
3473}
3474
3475func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) ID() string {
3476	return "OperationDeserializer"
3477}
3478
3479func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseFromSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3480	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3481) {
3482	out, metadata, err = next.HandleDeserialize(ctx, in)
3483	if err != nil {
3484		return out, metadata, err
3485	}
3486
3487	response, ok := out.RawResponse.(*smithyhttp.Response)
3488	if !ok {
3489		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3490	}
3491
3492	if response.StatusCode < 200 || response.StatusCode >= 300 {
3493		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response, &metadata)
3494	}
3495	output := &CreateRelationalDatabaseFromSnapshotOutput{}
3496	out.Result = output
3497
3498	var buff [1024]byte
3499	ringBuffer := smithyio.NewRingBuffer(buff[:])
3500
3501	body := io.TeeReader(response.Body, ringBuffer)
3502	decoder := json.NewDecoder(body)
3503	decoder.UseNumber()
3504	var shape interface{}
3505	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3506		var snapshot bytes.Buffer
3507		io.Copy(&snapshot, ringBuffer)
3508		err = &smithy.DeserializationError{
3509			Err:      fmt.Errorf("failed to decode response body, %w", err),
3510			Snapshot: snapshot.Bytes(),
3511		}
3512		return out, metadata, err
3513	}
3514
3515	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(&output, shape)
3516	if err != nil {
3517		var snapshot bytes.Buffer
3518		io.Copy(&snapshot, ringBuffer)
3519		err = &smithy.DeserializationError{
3520			Err:      fmt.Errorf("failed to decode response body, %w", err),
3521			Snapshot: snapshot.Bytes(),
3522		}
3523		return out, metadata, err
3524	}
3525
3526	return out, metadata, err
3527}
3528
3529func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseFromSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3530	var errorBuffer bytes.Buffer
3531	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3532		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3533	}
3534	errorBody := bytes.NewReader(errorBuffer.Bytes())
3535
3536	errorCode := "UnknownError"
3537	errorMessage := errorCode
3538
3539	code := response.Header.Get("X-Amzn-ErrorType")
3540	if len(code) != 0 {
3541		errorCode = restjson.SanitizeErrorCode(code)
3542	}
3543
3544	var buff [1024]byte
3545	ringBuffer := smithyio.NewRingBuffer(buff[:])
3546
3547	body := io.TeeReader(errorBody, ringBuffer)
3548	decoder := json.NewDecoder(body)
3549	decoder.UseNumber()
3550	code, message, err := restjson.GetErrorInfo(decoder)
3551	if err != nil {
3552		var snapshot bytes.Buffer
3553		io.Copy(&snapshot, ringBuffer)
3554		err = &smithy.DeserializationError{
3555			Err:      fmt.Errorf("failed to decode response body, %w", err),
3556			Snapshot: snapshot.Bytes(),
3557		}
3558		return err
3559	}
3560
3561	errorBody.Seek(0, io.SeekStart)
3562	if len(code) != 0 {
3563		errorCode = restjson.SanitizeErrorCode(code)
3564	}
3565	if len(message) != 0 {
3566		errorMessage = message
3567	}
3568
3569	switch {
3570	case strings.EqualFold("AccessDeniedException", errorCode):
3571		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3572
3573	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3574		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3575
3576	case strings.EqualFold("InvalidInputException", errorCode):
3577		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3578
3579	case strings.EqualFold("NotFoundException", errorCode):
3580		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3581
3582	case strings.EqualFold("OperationFailureException", errorCode):
3583		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3584
3585	case strings.EqualFold("ServiceException", errorCode):
3586		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3587
3588	case strings.EqualFold("UnauthenticatedException", errorCode):
3589		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3590
3591	default:
3592		genericError := &smithy.GenericAPIError{
3593			Code:    errorCode,
3594			Message: errorMessage,
3595		}
3596		return genericError
3597
3598	}
3599}
3600
3601type awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot struct {
3602}
3603
3604func (*awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) ID() string {
3605	return "OperationDeserializer"
3606}
3607
3608func (m *awsAwsjson11_deserializeOpCreateRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3609	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3610) {
3611	out, metadata, err = next.HandleDeserialize(ctx, in)
3612	if err != nil {
3613		return out, metadata, err
3614	}
3615
3616	response, ok := out.RawResponse.(*smithyhttp.Response)
3617	if !ok {
3618		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3619	}
3620
3621	if response.StatusCode < 200 || response.StatusCode >= 300 {
3622		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response, &metadata)
3623	}
3624	output := &CreateRelationalDatabaseSnapshotOutput{}
3625	out.Result = output
3626
3627	var buff [1024]byte
3628	ringBuffer := smithyio.NewRingBuffer(buff[:])
3629
3630	body := io.TeeReader(response.Body, ringBuffer)
3631	decoder := json.NewDecoder(body)
3632	decoder.UseNumber()
3633	var shape interface{}
3634	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3635		var snapshot bytes.Buffer
3636		io.Copy(&snapshot, ringBuffer)
3637		err = &smithy.DeserializationError{
3638			Err:      fmt.Errorf("failed to decode response body, %w", err),
3639			Snapshot: snapshot.Bytes(),
3640		}
3641		return out, metadata, err
3642	}
3643
3644	err = awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(&output, shape)
3645	if err != nil {
3646		var snapshot bytes.Buffer
3647		io.Copy(&snapshot, ringBuffer)
3648		err = &smithy.DeserializationError{
3649			Err:      fmt.Errorf("failed to decode response body, %w", err),
3650			Snapshot: snapshot.Bytes(),
3651		}
3652		return out, metadata, err
3653	}
3654
3655	return out, metadata, err
3656}
3657
3658func awsAwsjson11_deserializeOpErrorCreateRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3659	var errorBuffer bytes.Buffer
3660	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3661		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3662	}
3663	errorBody := bytes.NewReader(errorBuffer.Bytes())
3664
3665	errorCode := "UnknownError"
3666	errorMessage := errorCode
3667
3668	code := response.Header.Get("X-Amzn-ErrorType")
3669	if len(code) != 0 {
3670		errorCode = restjson.SanitizeErrorCode(code)
3671	}
3672
3673	var buff [1024]byte
3674	ringBuffer := smithyio.NewRingBuffer(buff[:])
3675
3676	body := io.TeeReader(errorBody, ringBuffer)
3677	decoder := json.NewDecoder(body)
3678	decoder.UseNumber()
3679	code, message, err := restjson.GetErrorInfo(decoder)
3680	if err != nil {
3681		var snapshot bytes.Buffer
3682		io.Copy(&snapshot, ringBuffer)
3683		err = &smithy.DeserializationError{
3684			Err:      fmt.Errorf("failed to decode response body, %w", err),
3685			Snapshot: snapshot.Bytes(),
3686		}
3687		return err
3688	}
3689
3690	errorBody.Seek(0, io.SeekStart)
3691	if len(code) != 0 {
3692		errorCode = restjson.SanitizeErrorCode(code)
3693	}
3694	if len(message) != 0 {
3695		errorMessage = message
3696	}
3697
3698	switch {
3699	case strings.EqualFold("AccessDeniedException", errorCode):
3700		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3701
3702	case strings.EqualFold("AccountSetupInProgressException", errorCode):
3703		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
3704
3705	case strings.EqualFold("InvalidInputException", errorCode):
3706		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3707
3708	case strings.EqualFold("NotFoundException", errorCode):
3709		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3710
3711	case strings.EqualFold("OperationFailureException", errorCode):
3712		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3713
3714	case strings.EqualFold("ServiceException", errorCode):
3715		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3716
3717	case strings.EqualFold("UnauthenticatedException", errorCode):
3718		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3719
3720	default:
3721		genericError := &smithy.GenericAPIError{
3722			Code:    errorCode,
3723			Message: errorMessage,
3724		}
3725		return genericError
3726
3727	}
3728}
3729
3730type awsAwsjson11_deserializeOpDeleteAlarm struct {
3731}
3732
3733func (*awsAwsjson11_deserializeOpDeleteAlarm) ID() string {
3734	return "OperationDeserializer"
3735}
3736
3737func (m *awsAwsjson11_deserializeOpDeleteAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3738	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3739) {
3740	out, metadata, err = next.HandleDeserialize(ctx, in)
3741	if err != nil {
3742		return out, metadata, err
3743	}
3744
3745	response, ok := out.RawResponse.(*smithyhttp.Response)
3746	if !ok {
3747		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3748	}
3749
3750	if response.StatusCode < 200 || response.StatusCode >= 300 {
3751		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAlarm(response, &metadata)
3752	}
3753	output := &DeleteAlarmOutput{}
3754	out.Result = output
3755
3756	var buff [1024]byte
3757	ringBuffer := smithyio.NewRingBuffer(buff[:])
3758
3759	body := io.TeeReader(response.Body, ringBuffer)
3760	decoder := json.NewDecoder(body)
3761	decoder.UseNumber()
3762	var shape interface{}
3763	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3764		var snapshot bytes.Buffer
3765		io.Copy(&snapshot, ringBuffer)
3766		err = &smithy.DeserializationError{
3767			Err:      fmt.Errorf("failed to decode response body, %w", err),
3768			Snapshot: snapshot.Bytes(),
3769		}
3770		return out, metadata, err
3771	}
3772
3773	err = awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(&output, shape)
3774	if err != nil {
3775		var snapshot bytes.Buffer
3776		io.Copy(&snapshot, ringBuffer)
3777		err = &smithy.DeserializationError{
3778			Err:      fmt.Errorf("failed to decode response body, %w", err),
3779			Snapshot: snapshot.Bytes(),
3780		}
3781		return out, metadata, err
3782	}
3783
3784	return out, metadata, err
3785}
3786
3787func awsAwsjson11_deserializeOpErrorDeleteAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3788	var errorBuffer bytes.Buffer
3789	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3790		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3791	}
3792	errorBody := bytes.NewReader(errorBuffer.Bytes())
3793
3794	errorCode := "UnknownError"
3795	errorMessage := errorCode
3796
3797	code := response.Header.Get("X-Amzn-ErrorType")
3798	if len(code) != 0 {
3799		errorCode = restjson.SanitizeErrorCode(code)
3800	}
3801
3802	var buff [1024]byte
3803	ringBuffer := smithyio.NewRingBuffer(buff[:])
3804
3805	body := io.TeeReader(errorBody, ringBuffer)
3806	decoder := json.NewDecoder(body)
3807	decoder.UseNumber()
3808	code, message, err := restjson.GetErrorInfo(decoder)
3809	if err != nil {
3810		var snapshot bytes.Buffer
3811		io.Copy(&snapshot, ringBuffer)
3812		err = &smithy.DeserializationError{
3813			Err:      fmt.Errorf("failed to decode response body, %w", err),
3814			Snapshot: snapshot.Bytes(),
3815		}
3816		return err
3817	}
3818
3819	errorBody.Seek(0, io.SeekStart)
3820	if len(code) != 0 {
3821		errorCode = restjson.SanitizeErrorCode(code)
3822	}
3823	if len(message) != 0 {
3824		errorMessage = message
3825	}
3826
3827	switch {
3828	case strings.EqualFold("AccessDeniedException", errorCode):
3829		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3830
3831	case strings.EqualFold("InvalidInputException", errorCode):
3832		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3833
3834	case strings.EqualFold("NotFoundException", errorCode):
3835		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3836
3837	case strings.EqualFold("OperationFailureException", errorCode):
3838		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3839
3840	case strings.EqualFold("ServiceException", errorCode):
3841		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3842
3843	case strings.EqualFold("UnauthenticatedException", errorCode):
3844		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3845
3846	default:
3847		genericError := &smithy.GenericAPIError{
3848			Code:    errorCode,
3849			Message: errorMessage,
3850		}
3851		return genericError
3852
3853	}
3854}
3855
3856type awsAwsjson11_deserializeOpDeleteAutoSnapshot struct {
3857}
3858
3859func (*awsAwsjson11_deserializeOpDeleteAutoSnapshot) ID() string {
3860	return "OperationDeserializer"
3861}
3862
3863func (m *awsAwsjson11_deserializeOpDeleteAutoSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3864	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3865) {
3866	out, metadata, err = next.HandleDeserialize(ctx, in)
3867	if err != nil {
3868		return out, metadata, err
3869	}
3870
3871	response, ok := out.RawResponse.(*smithyhttp.Response)
3872	if !ok {
3873		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3874	}
3875
3876	if response.StatusCode < 200 || response.StatusCode >= 300 {
3877		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response, &metadata)
3878	}
3879	output := &DeleteAutoSnapshotOutput{}
3880	out.Result = output
3881
3882	var buff [1024]byte
3883	ringBuffer := smithyio.NewRingBuffer(buff[:])
3884
3885	body := io.TeeReader(response.Body, ringBuffer)
3886	decoder := json.NewDecoder(body)
3887	decoder.UseNumber()
3888	var shape interface{}
3889	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3890		var snapshot bytes.Buffer
3891		io.Copy(&snapshot, ringBuffer)
3892		err = &smithy.DeserializationError{
3893			Err:      fmt.Errorf("failed to decode response body, %w", err),
3894			Snapshot: snapshot.Bytes(),
3895		}
3896		return out, metadata, err
3897	}
3898
3899	err = awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(&output, shape)
3900	if err != nil {
3901		var snapshot bytes.Buffer
3902		io.Copy(&snapshot, ringBuffer)
3903		err = &smithy.DeserializationError{
3904			Err:      fmt.Errorf("failed to decode response body, %w", err),
3905			Snapshot: snapshot.Bytes(),
3906		}
3907		return out, metadata, err
3908	}
3909
3910	return out, metadata, err
3911}
3912
3913func awsAwsjson11_deserializeOpErrorDeleteAutoSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3914	var errorBuffer bytes.Buffer
3915	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3916		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3917	}
3918	errorBody := bytes.NewReader(errorBuffer.Bytes())
3919
3920	errorCode := "UnknownError"
3921	errorMessage := errorCode
3922
3923	code := response.Header.Get("X-Amzn-ErrorType")
3924	if len(code) != 0 {
3925		errorCode = restjson.SanitizeErrorCode(code)
3926	}
3927
3928	var buff [1024]byte
3929	ringBuffer := smithyio.NewRingBuffer(buff[:])
3930
3931	body := io.TeeReader(errorBody, ringBuffer)
3932	decoder := json.NewDecoder(body)
3933	decoder.UseNumber()
3934	code, message, err := restjson.GetErrorInfo(decoder)
3935	if err != nil {
3936		var snapshot bytes.Buffer
3937		io.Copy(&snapshot, ringBuffer)
3938		err = &smithy.DeserializationError{
3939			Err:      fmt.Errorf("failed to decode response body, %w", err),
3940			Snapshot: snapshot.Bytes(),
3941		}
3942		return err
3943	}
3944
3945	errorBody.Seek(0, io.SeekStart)
3946	if len(code) != 0 {
3947		errorCode = restjson.SanitizeErrorCode(code)
3948	}
3949	if len(message) != 0 {
3950		errorMessage = message
3951	}
3952
3953	switch {
3954	case strings.EqualFold("AccessDeniedException", errorCode):
3955		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3956
3957	case strings.EqualFold("InvalidInputException", errorCode):
3958		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3959
3960	case strings.EqualFold("NotFoundException", errorCode):
3961		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
3962
3963	case strings.EqualFold("OperationFailureException", errorCode):
3964		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
3965
3966	case strings.EqualFold("ServiceException", errorCode):
3967		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3968
3969	case strings.EqualFold("UnauthenticatedException", errorCode):
3970		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
3971
3972	default:
3973		genericError := &smithy.GenericAPIError{
3974			Code:    errorCode,
3975			Message: errorMessage,
3976		}
3977		return genericError
3978
3979	}
3980}
3981
3982type awsAwsjson11_deserializeOpDeleteCertificate struct {
3983}
3984
3985func (*awsAwsjson11_deserializeOpDeleteCertificate) ID() string {
3986	return "OperationDeserializer"
3987}
3988
3989func (m *awsAwsjson11_deserializeOpDeleteCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3990	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3991) {
3992	out, metadata, err = next.HandleDeserialize(ctx, in)
3993	if err != nil {
3994		return out, metadata, err
3995	}
3996
3997	response, ok := out.RawResponse.(*smithyhttp.Response)
3998	if !ok {
3999		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4000	}
4001
4002	if response.StatusCode < 200 || response.StatusCode >= 300 {
4003		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCertificate(response, &metadata)
4004	}
4005	output := &DeleteCertificateOutput{}
4006	out.Result = output
4007
4008	var buff [1024]byte
4009	ringBuffer := smithyio.NewRingBuffer(buff[:])
4010
4011	body := io.TeeReader(response.Body, ringBuffer)
4012	decoder := json.NewDecoder(body)
4013	decoder.UseNumber()
4014	var shape interface{}
4015	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4016		var snapshot bytes.Buffer
4017		io.Copy(&snapshot, ringBuffer)
4018		err = &smithy.DeserializationError{
4019			Err:      fmt.Errorf("failed to decode response body, %w", err),
4020			Snapshot: snapshot.Bytes(),
4021		}
4022		return out, metadata, err
4023	}
4024
4025	err = awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(&output, shape)
4026	if err != nil {
4027		var snapshot bytes.Buffer
4028		io.Copy(&snapshot, ringBuffer)
4029		err = &smithy.DeserializationError{
4030			Err:      fmt.Errorf("failed to decode response body, %w", err),
4031			Snapshot: snapshot.Bytes(),
4032		}
4033		return out, metadata, err
4034	}
4035
4036	return out, metadata, err
4037}
4038
4039func awsAwsjson11_deserializeOpErrorDeleteCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4040	var errorBuffer bytes.Buffer
4041	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4042		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4043	}
4044	errorBody := bytes.NewReader(errorBuffer.Bytes())
4045
4046	errorCode := "UnknownError"
4047	errorMessage := errorCode
4048
4049	code := response.Header.Get("X-Amzn-ErrorType")
4050	if len(code) != 0 {
4051		errorCode = restjson.SanitizeErrorCode(code)
4052	}
4053
4054	var buff [1024]byte
4055	ringBuffer := smithyio.NewRingBuffer(buff[:])
4056
4057	body := io.TeeReader(errorBody, ringBuffer)
4058	decoder := json.NewDecoder(body)
4059	decoder.UseNumber()
4060	code, message, err := restjson.GetErrorInfo(decoder)
4061	if err != nil {
4062		var snapshot bytes.Buffer
4063		io.Copy(&snapshot, ringBuffer)
4064		err = &smithy.DeserializationError{
4065			Err:      fmt.Errorf("failed to decode response body, %w", err),
4066			Snapshot: snapshot.Bytes(),
4067		}
4068		return err
4069	}
4070
4071	errorBody.Seek(0, io.SeekStart)
4072	if len(code) != 0 {
4073		errorCode = restjson.SanitizeErrorCode(code)
4074	}
4075	if len(message) != 0 {
4076		errorMessage = message
4077	}
4078
4079	switch {
4080	case strings.EqualFold("AccessDeniedException", errorCode):
4081		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4082
4083	case strings.EqualFold("InvalidInputException", errorCode):
4084		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4085
4086	case strings.EqualFold("NotFoundException", errorCode):
4087		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4088
4089	case strings.EqualFold("ServiceException", errorCode):
4090		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4091
4092	case strings.EqualFold("UnauthenticatedException", errorCode):
4093		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4094
4095	default:
4096		genericError := &smithy.GenericAPIError{
4097			Code:    errorCode,
4098			Message: errorMessage,
4099		}
4100		return genericError
4101
4102	}
4103}
4104
4105type awsAwsjson11_deserializeOpDeleteContactMethod struct {
4106}
4107
4108func (*awsAwsjson11_deserializeOpDeleteContactMethod) ID() string {
4109	return "OperationDeserializer"
4110}
4111
4112func (m *awsAwsjson11_deserializeOpDeleteContactMethod) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4113	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4114) {
4115	out, metadata, err = next.HandleDeserialize(ctx, in)
4116	if err != nil {
4117		return out, metadata, err
4118	}
4119
4120	response, ok := out.RawResponse.(*smithyhttp.Response)
4121	if !ok {
4122		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4123	}
4124
4125	if response.StatusCode < 200 || response.StatusCode >= 300 {
4126		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContactMethod(response, &metadata)
4127	}
4128	output := &DeleteContactMethodOutput{}
4129	out.Result = output
4130
4131	var buff [1024]byte
4132	ringBuffer := smithyio.NewRingBuffer(buff[:])
4133
4134	body := io.TeeReader(response.Body, ringBuffer)
4135	decoder := json.NewDecoder(body)
4136	decoder.UseNumber()
4137	var shape interface{}
4138	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4139		var snapshot bytes.Buffer
4140		io.Copy(&snapshot, ringBuffer)
4141		err = &smithy.DeserializationError{
4142			Err:      fmt.Errorf("failed to decode response body, %w", err),
4143			Snapshot: snapshot.Bytes(),
4144		}
4145		return out, metadata, err
4146	}
4147
4148	err = awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(&output, shape)
4149	if err != nil {
4150		var snapshot bytes.Buffer
4151		io.Copy(&snapshot, ringBuffer)
4152		err = &smithy.DeserializationError{
4153			Err:      fmt.Errorf("failed to decode response body, %w", err),
4154			Snapshot: snapshot.Bytes(),
4155		}
4156		return out, metadata, err
4157	}
4158
4159	return out, metadata, err
4160}
4161
4162func awsAwsjson11_deserializeOpErrorDeleteContactMethod(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4163	var errorBuffer bytes.Buffer
4164	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4165		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4166	}
4167	errorBody := bytes.NewReader(errorBuffer.Bytes())
4168
4169	errorCode := "UnknownError"
4170	errorMessage := errorCode
4171
4172	code := response.Header.Get("X-Amzn-ErrorType")
4173	if len(code) != 0 {
4174		errorCode = restjson.SanitizeErrorCode(code)
4175	}
4176
4177	var buff [1024]byte
4178	ringBuffer := smithyio.NewRingBuffer(buff[:])
4179
4180	body := io.TeeReader(errorBody, ringBuffer)
4181	decoder := json.NewDecoder(body)
4182	decoder.UseNumber()
4183	code, message, err := restjson.GetErrorInfo(decoder)
4184	if err != nil {
4185		var snapshot bytes.Buffer
4186		io.Copy(&snapshot, ringBuffer)
4187		err = &smithy.DeserializationError{
4188			Err:      fmt.Errorf("failed to decode response body, %w", err),
4189			Snapshot: snapshot.Bytes(),
4190		}
4191		return err
4192	}
4193
4194	errorBody.Seek(0, io.SeekStart)
4195	if len(code) != 0 {
4196		errorCode = restjson.SanitizeErrorCode(code)
4197	}
4198	if len(message) != 0 {
4199		errorMessage = message
4200	}
4201
4202	switch {
4203	case strings.EqualFold("AccessDeniedException", errorCode):
4204		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4205
4206	case strings.EqualFold("InvalidInputException", errorCode):
4207		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4208
4209	case strings.EqualFold("NotFoundException", errorCode):
4210		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4211
4212	case strings.EqualFold("OperationFailureException", errorCode):
4213		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4214
4215	case strings.EqualFold("ServiceException", errorCode):
4216		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4217
4218	case strings.EqualFold("UnauthenticatedException", errorCode):
4219		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4220
4221	default:
4222		genericError := &smithy.GenericAPIError{
4223			Code:    errorCode,
4224			Message: errorMessage,
4225		}
4226		return genericError
4227
4228	}
4229}
4230
4231type awsAwsjson11_deserializeOpDeleteContainerImage struct {
4232}
4233
4234func (*awsAwsjson11_deserializeOpDeleteContainerImage) ID() string {
4235	return "OperationDeserializer"
4236}
4237
4238func (m *awsAwsjson11_deserializeOpDeleteContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4239	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4240) {
4241	out, metadata, err = next.HandleDeserialize(ctx, in)
4242	if err != nil {
4243		return out, metadata, err
4244	}
4245
4246	response, ok := out.RawResponse.(*smithyhttp.Response)
4247	if !ok {
4248		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4249	}
4250
4251	if response.StatusCode < 200 || response.StatusCode >= 300 {
4252		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerImage(response, &metadata)
4253	}
4254	output := &DeleteContainerImageOutput{}
4255	out.Result = output
4256
4257	var buff [1024]byte
4258	ringBuffer := smithyio.NewRingBuffer(buff[:])
4259
4260	body := io.TeeReader(response.Body, ringBuffer)
4261	decoder := json.NewDecoder(body)
4262	decoder.UseNumber()
4263	var shape interface{}
4264	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4265		var snapshot bytes.Buffer
4266		io.Copy(&snapshot, ringBuffer)
4267		err = &smithy.DeserializationError{
4268			Err:      fmt.Errorf("failed to decode response body, %w", err),
4269			Snapshot: snapshot.Bytes(),
4270		}
4271		return out, metadata, err
4272	}
4273
4274	err = awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(&output, shape)
4275	if err != nil {
4276		var snapshot bytes.Buffer
4277		io.Copy(&snapshot, ringBuffer)
4278		err = &smithy.DeserializationError{
4279			Err:      fmt.Errorf("failed to decode response body, %w", err),
4280			Snapshot: snapshot.Bytes(),
4281		}
4282		return out, metadata, err
4283	}
4284
4285	return out, metadata, err
4286}
4287
4288func awsAwsjson11_deserializeOpErrorDeleteContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4289	var errorBuffer bytes.Buffer
4290	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4291		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4292	}
4293	errorBody := bytes.NewReader(errorBuffer.Bytes())
4294
4295	errorCode := "UnknownError"
4296	errorMessage := errorCode
4297
4298	code := response.Header.Get("X-Amzn-ErrorType")
4299	if len(code) != 0 {
4300		errorCode = restjson.SanitizeErrorCode(code)
4301	}
4302
4303	var buff [1024]byte
4304	ringBuffer := smithyio.NewRingBuffer(buff[:])
4305
4306	body := io.TeeReader(errorBody, ringBuffer)
4307	decoder := json.NewDecoder(body)
4308	decoder.UseNumber()
4309	code, message, err := restjson.GetErrorInfo(decoder)
4310	if err != nil {
4311		var snapshot bytes.Buffer
4312		io.Copy(&snapshot, ringBuffer)
4313		err = &smithy.DeserializationError{
4314			Err:      fmt.Errorf("failed to decode response body, %w", err),
4315			Snapshot: snapshot.Bytes(),
4316		}
4317		return err
4318	}
4319
4320	errorBody.Seek(0, io.SeekStart)
4321	if len(code) != 0 {
4322		errorCode = restjson.SanitizeErrorCode(code)
4323	}
4324	if len(message) != 0 {
4325		errorMessage = message
4326	}
4327
4328	switch {
4329	case strings.EqualFold("AccessDeniedException", errorCode):
4330		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4331
4332	case strings.EqualFold("InvalidInputException", errorCode):
4333		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4334
4335	case strings.EqualFold("NotFoundException", errorCode):
4336		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4337
4338	case strings.EqualFold("ServiceException", errorCode):
4339		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4340
4341	case strings.EqualFold("UnauthenticatedException", errorCode):
4342		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4343
4344	default:
4345		genericError := &smithy.GenericAPIError{
4346			Code:    errorCode,
4347			Message: errorMessage,
4348		}
4349		return genericError
4350
4351	}
4352}
4353
4354type awsAwsjson11_deserializeOpDeleteContainerService struct {
4355}
4356
4357func (*awsAwsjson11_deserializeOpDeleteContainerService) ID() string {
4358	return "OperationDeserializer"
4359}
4360
4361func (m *awsAwsjson11_deserializeOpDeleteContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4362	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4363) {
4364	out, metadata, err = next.HandleDeserialize(ctx, in)
4365	if err != nil {
4366		return out, metadata, err
4367	}
4368
4369	response, ok := out.RawResponse.(*smithyhttp.Response)
4370	if !ok {
4371		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4372	}
4373
4374	if response.StatusCode < 200 || response.StatusCode >= 300 {
4375		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteContainerService(response, &metadata)
4376	}
4377	output := &DeleteContainerServiceOutput{}
4378	out.Result = output
4379
4380	var buff [1024]byte
4381	ringBuffer := smithyio.NewRingBuffer(buff[:])
4382
4383	body := io.TeeReader(response.Body, ringBuffer)
4384	decoder := json.NewDecoder(body)
4385	decoder.UseNumber()
4386	var shape interface{}
4387	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4388		var snapshot bytes.Buffer
4389		io.Copy(&snapshot, ringBuffer)
4390		err = &smithy.DeserializationError{
4391			Err:      fmt.Errorf("failed to decode response body, %w", err),
4392			Snapshot: snapshot.Bytes(),
4393		}
4394		return out, metadata, err
4395	}
4396
4397	err = awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(&output, shape)
4398	if err != nil {
4399		var snapshot bytes.Buffer
4400		io.Copy(&snapshot, ringBuffer)
4401		err = &smithy.DeserializationError{
4402			Err:      fmt.Errorf("failed to decode response body, %w", err),
4403			Snapshot: snapshot.Bytes(),
4404		}
4405		return out, metadata, err
4406	}
4407
4408	return out, metadata, err
4409}
4410
4411func awsAwsjson11_deserializeOpErrorDeleteContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4412	var errorBuffer bytes.Buffer
4413	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4414		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4415	}
4416	errorBody := bytes.NewReader(errorBuffer.Bytes())
4417
4418	errorCode := "UnknownError"
4419	errorMessage := errorCode
4420
4421	code := response.Header.Get("X-Amzn-ErrorType")
4422	if len(code) != 0 {
4423		errorCode = restjson.SanitizeErrorCode(code)
4424	}
4425
4426	var buff [1024]byte
4427	ringBuffer := smithyio.NewRingBuffer(buff[:])
4428
4429	body := io.TeeReader(errorBody, ringBuffer)
4430	decoder := json.NewDecoder(body)
4431	decoder.UseNumber()
4432	code, message, err := restjson.GetErrorInfo(decoder)
4433	if err != nil {
4434		var snapshot bytes.Buffer
4435		io.Copy(&snapshot, ringBuffer)
4436		err = &smithy.DeserializationError{
4437			Err:      fmt.Errorf("failed to decode response body, %w", err),
4438			Snapshot: snapshot.Bytes(),
4439		}
4440		return err
4441	}
4442
4443	errorBody.Seek(0, io.SeekStart)
4444	if len(code) != 0 {
4445		errorCode = restjson.SanitizeErrorCode(code)
4446	}
4447	if len(message) != 0 {
4448		errorMessage = message
4449	}
4450
4451	switch {
4452	case strings.EqualFold("AccessDeniedException", errorCode):
4453		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4454
4455	case strings.EqualFold("InvalidInputException", errorCode):
4456		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4457
4458	case strings.EqualFold("NotFoundException", errorCode):
4459		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4460
4461	case strings.EqualFold("ServiceException", errorCode):
4462		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4463
4464	case strings.EqualFold("UnauthenticatedException", errorCode):
4465		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4466
4467	default:
4468		genericError := &smithy.GenericAPIError{
4469			Code:    errorCode,
4470			Message: errorMessage,
4471		}
4472		return genericError
4473
4474	}
4475}
4476
4477type awsAwsjson11_deserializeOpDeleteDisk struct {
4478}
4479
4480func (*awsAwsjson11_deserializeOpDeleteDisk) ID() string {
4481	return "OperationDeserializer"
4482}
4483
4484func (m *awsAwsjson11_deserializeOpDeleteDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4485	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4486) {
4487	out, metadata, err = next.HandleDeserialize(ctx, in)
4488	if err != nil {
4489		return out, metadata, err
4490	}
4491
4492	response, ok := out.RawResponse.(*smithyhttp.Response)
4493	if !ok {
4494		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4495	}
4496
4497	if response.StatusCode < 200 || response.StatusCode >= 300 {
4498		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDisk(response, &metadata)
4499	}
4500	output := &DeleteDiskOutput{}
4501	out.Result = output
4502
4503	var buff [1024]byte
4504	ringBuffer := smithyio.NewRingBuffer(buff[:])
4505
4506	body := io.TeeReader(response.Body, ringBuffer)
4507	decoder := json.NewDecoder(body)
4508	decoder.UseNumber()
4509	var shape interface{}
4510	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4511		var snapshot bytes.Buffer
4512		io.Copy(&snapshot, ringBuffer)
4513		err = &smithy.DeserializationError{
4514			Err:      fmt.Errorf("failed to decode response body, %w", err),
4515			Snapshot: snapshot.Bytes(),
4516		}
4517		return out, metadata, err
4518	}
4519
4520	err = awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(&output, shape)
4521	if err != nil {
4522		var snapshot bytes.Buffer
4523		io.Copy(&snapshot, ringBuffer)
4524		err = &smithy.DeserializationError{
4525			Err:      fmt.Errorf("failed to decode response body, %w", err),
4526			Snapshot: snapshot.Bytes(),
4527		}
4528		return out, metadata, err
4529	}
4530
4531	return out, metadata, err
4532}
4533
4534func awsAwsjson11_deserializeOpErrorDeleteDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4535	var errorBuffer bytes.Buffer
4536	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4537		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4538	}
4539	errorBody := bytes.NewReader(errorBuffer.Bytes())
4540
4541	errorCode := "UnknownError"
4542	errorMessage := errorCode
4543
4544	code := response.Header.Get("X-Amzn-ErrorType")
4545	if len(code) != 0 {
4546		errorCode = restjson.SanitizeErrorCode(code)
4547	}
4548
4549	var buff [1024]byte
4550	ringBuffer := smithyio.NewRingBuffer(buff[:])
4551
4552	body := io.TeeReader(errorBody, ringBuffer)
4553	decoder := json.NewDecoder(body)
4554	decoder.UseNumber()
4555	code, message, err := restjson.GetErrorInfo(decoder)
4556	if err != nil {
4557		var snapshot bytes.Buffer
4558		io.Copy(&snapshot, ringBuffer)
4559		err = &smithy.DeserializationError{
4560			Err:      fmt.Errorf("failed to decode response body, %w", err),
4561			Snapshot: snapshot.Bytes(),
4562		}
4563		return err
4564	}
4565
4566	errorBody.Seek(0, io.SeekStart)
4567	if len(code) != 0 {
4568		errorCode = restjson.SanitizeErrorCode(code)
4569	}
4570	if len(message) != 0 {
4571		errorMessage = message
4572	}
4573
4574	switch {
4575	case strings.EqualFold("AccessDeniedException", errorCode):
4576		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4577
4578	case strings.EqualFold("AccountSetupInProgressException", errorCode):
4579		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
4580
4581	case strings.EqualFold("InvalidInputException", errorCode):
4582		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4583
4584	case strings.EqualFold("NotFoundException", errorCode):
4585		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4586
4587	case strings.EqualFold("OperationFailureException", errorCode):
4588		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4589
4590	case strings.EqualFold("ServiceException", errorCode):
4591		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4592
4593	case strings.EqualFold("UnauthenticatedException", errorCode):
4594		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4595
4596	default:
4597		genericError := &smithy.GenericAPIError{
4598			Code:    errorCode,
4599			Message: errorMessage,
4600		}
4601		return genericError
4602
4603	}
4604}
4605
4606type awsAwsjson11_deserializeOpDeleteDiskSnapshot struct {
4607}
4608
4609func (*awsAwsjson11_deserializeOpDeleteDiskSnapshot) ID() string {
4610	return "OperationDeserializer"
4611}
4612
4613func (m *awsAwsjson11_deserializeOpDeleteDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4614	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4615) {
4616	out, metadata, err = next.HandleDeserialize(ctx, in)
4617	if err != nil {
4618		return out, metadata, err
4619	}
4620
4621	response, ok := out.RawResponse.(*smithyhttp.Response)
4622	if !ok {
4623		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4624	}
4625
4626	if response.StatusCode < 200 || response.StatusCode >= 300 {
4627		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response, &metadata)
4628	}
4629	output := &DeleteDiskSnapshotOutput{}
4630	out.Result = output
4631
4632	var buff [1024]byte
4633	ringBuffer := smithyio.NewRingBuffer(buff[:])
4634
4635	body := io.TeeReader(response.Body, ringBuffer)
4636	decoder := json.NewDecoder(body)
4637	decoder.UseNumber()
4638	var shape interface{}
4639	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(&output, shape)
4650	if err != nil {
4651		var snapshot bytes.Buffer
4652		io.Copy(&snapshot, ringBuffer)
4653		err = &smithy.DeserializationError{
4654			Err:      fmt.Errorf("failed to decode response body, %w", err),
4655			Snapshot: snapshot.Bytes(),
4656		}
4657		return out, metadata, err
4658	}
4659
4660	return out, metadata, err
4661}
4662
4663func awsAwsjson11_deserializeOpErrorDeleteDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4664	var errorBuffer bytes.Buffer
4665	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4666		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4667	}
4668	errorBody := bytes.NewReader(errorBuffer.Bytes())
4669
4670	errorCode := "UnknownError"
4671	errorMessage := errorCode
4672
4673	code := response.Header.Get("X-Amzn-ErrorType")
4674	if len(code) != 0 {
4675		errorCode = restjson.SanitizeErrorCode(code)
4676	}
4677
4678	var buff [1024]byte
4679	ringBuffer := smithyio.NewRingBuffer(buff[:])
4680
4681	body := io.TeeReader(errorBody, ringBuffer)
4682	decoder := json.NewDecoder(body)
4683	decoder.UseNumber()
4684	code, message, err := restjson.GetErrorInfo(decoder)
4685	if err != nil {
4686		var snapshot bytes.Buffer
4687		io.Copy(&snapshot, ringBuffer)
4688		err = &smithy.DeserializationError{
4689			Err:      fmt.Errorf("failed to decode response body, %w", err),
4690			Snapshot: snapshot.Bytes(),
4691		}
4692		return err
4693	}
4694
4695	errorBody.Seek(0, io.SeekStart)
4696	if len(code) != 0 {
4697		errorCode = restjson.SanitizeErrorCode(code)
4698	}
4699	if len(message) != 0 {
4700		errorMessage = message
4701	}
4702
4703	switch {
4704	case strings.EqualFold("AccessDeniedException", errorCode):
4705		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4706
4707	case strings.EqualFold("AccountSetupInProgressException", errorCode):
4708		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
4709
4710	case strings.EqualFold("InvalidInputException", errorCode):
4711		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4712
4713	case strings.EqualFold("NotFoundException", errorCode):
4714		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4715
4716	case strings.EqualFold("OperationFailureException", errorCode):
4717		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4718
4719	case strings.EqualFold("ServiceException", errorCode):
4720		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4721
4722	case strings.EqualFold("UnauthenticatedException", errorCode):
4723		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4724
4725	default:
4726		genericError := &smithy.GenericAPIError{
4727			Code:    errorCode,
4728			Message: errorMessage,
4729		}
4730		return genericError
4731
4732	}
4733}
4734
4735type awsAwsjson11_deserializeOpDeleteDistribution struct {
4736}
4737
4738func (*awsAwsjson11_deserializeOpDeleteDistribution) ID() string {
4739	return "OperationDeserializer"
4740}
4741
4742func (m *awsAwsjson11_deserializeOpDeleteDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4743	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4744) {
4745	out, metadata, err = next.HandleDeserialize(ctx, in)
4746	if err != nil {
4747		return out, metadata, err
4748	}
4749
4750	response, ok := out.RawResponse.(*smithyhttp.Response)
4751	if !ok {
4752		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4753	}
4754
4755	if response.StatusCode < 200 || response.StatusCode >= 300 {
4756		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDistribution(response, &metadata)
4757	}
4758	output := &DeleteDistributionOutput{}
4759	out.Result = output
4760
4761	var buff [1024]byte
4762	ringBuffer := smithyio.NewRingBuffer(buff[:])
4763
4764	body := io.TeeReader(response.Body, ringBuffer)
4765	decoder := json.NewDecoder(body)
4766	decoder.UseNumber()
4767	var shape interface{}
4768	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4769		var snapshot bytes.Buffer
4770		io.Copy(&snapshot, ringBuffer)
4771		err = &smithy.DeserializationError{
4772			Err:      fmt.Errorf("failed to decode response body, %w", err),
4773			Snapshot: snapshot.Bytes(),
4774		}
4775		return out, metadata, err
4776	}
4777
4778	err = awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(&output, shape)
4779	if err != nil {
4780		var snapshot bytes.Buffer
4781		io.Copy(&snapshot, ringBuffer)
4782		err = &smithy.DeserializationError{
4783			Err:      fmt.Errorf("failed to decode response body, %w", err),
4784			Snapshot: snapshot.Bytes(),
4785		}
4786		return out, metadata, err
4787	}
4788
4789	return out, metadata, err
4790}
4791
4792func awsAwsjson11_deserializeOpErrorDeleteDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4793	var errorBuffer bytes.Buffer
4794	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4795		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4796	}
4797	errorBody := bytes.NewReader(errorBuffer.Bytes())
4798
4799	errorCode := "UnknownError"
4800	errorMessage := errorCode
4801
4802	code := response.Header.Get("X-Amzn-ErrorType")
4803	if len(code) != 0 {
4804		errorCode = restjson.SanitizeErrorCode(code)
4805	}
4806
4807	var buff [1024]byte
4808	ringBuffer := smithyio.NewRingBuffer(buff[:])
4809
4810	body := io.TeeReader(errorBody, ringBuffer)
4811	decoder := json.NewDecoder(body)
4812	decoder.UseNumber()
4813	code, message, err := restjson.GetErrorInfo(decoder)
4814	if err != nil {
4815		var snapshot bytes.Buffer
4816		io.Copy(&snapshot, ringBuffer)
4817		err = &smithy.DeserializationError{
4818			Err:      fmt.Errorf("failed to decode response body, %w", err),
4819			Snapshot: snapshot.Bytes(),
4820		}
4821		return err
4822	}
4823
4824	errorBody.Seek(0, io.SeekStart)
4825	if len(code) != 0 {
4826		errorCode = restjson.SanitizeErrorCode(code)
4827	}
4828	if len(message) != 0 {
4829		errorMessage = message
4830	}
4831
4832	switch {
4833	case strings.EqualFold("AccessDeniedException", errorCode):
4834		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4835
4836	case strings.EqualFold("InvalidInputException", errorCode):
4837		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4838
4839	case strings.EqualFold("NotFoundException", errorCode):
4840		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4841
4842	case strings.EqualFold("OperationFailureException", errorCode):
4843		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4844
4845	case strings.EqualFold("ServiceException", errorCode):
4846		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4847
4848	case strings.EqualFold("UnauthenticatedException", errorCode):
4849		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4850
4851	default:
4852		genericError := &smithy.GenericAPIError{
4853			Code:    errorCode,
4854			Message: errorMessage,
4855		}
4856		return genericError
4857
4858	}
4859}
4860
4861type awsAwsjson11_deserializeOpDeleteDomain struct {
4862}
4863
4864func (*awsAwsjson11_deserializeOpDeleteDomain) ID() string {
4865	return "OperationDeserializer"
4866}
4867
4868func (m *awsAwsjson11_deserializeOpDeleteDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4869	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4870) {
4871	out, metadata, err = next.HandleDeserialize(ctx, in)
4872	if err != nil {
4873		return out, metadata, err
4874	}
4875
4876	response, ok := out.RawResponse.(*smithyhttp.Response)
4877	if !ok {
4878		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4879	}
4880
4881	if response.StatusCode < 200 || response.StatusCode >= 300 {
4882		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomain(response, &metadata)
4883	}
4884	output := &DeleteDomainOutput{}
4885	out.Result = output
4886
4887	var buff [1024]byte
4888	ringBuffer := smithyio.NewRingBuffer(buff[:])
4889
4890	body := io.TeeReader(response.Body, ringBuffer)
4891	decoder := json.NewDecoder(body)
4892	decoder.UseNumber()
4893	var shape interface{}
4894	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4895		var snapshot bytes.Buffer
4896		io.Copy(&snapshot, ringBuffer)
4897		err = &smithy.DeserializationError{
4898			Err:      fmt.Errorf("failed to decode response body, %w", err),
4899			Snapshot: snapshot.Bytes(),
4900		}
4901		return out, metadata, err
4902	}
4903
4904	err = awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(&output, shape)
4905	if err != nil {
4906		var snapshot bytes.Buffer
4907		io.Copy(&snapshot, ringBuffer)
4908		err = &smithy.DeserializationError{
4909			Err:      fmt.Errorf("failed to decode response body, %w", err),
4910			Snapshot: snapshot.Bytes(),
4911		}
4912		return out, metadata, err
4913	}
4914
4915	return out, metadata, err
4916}
4917
4918func awsAwsjson11_deserializeOpErrorDeleteDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4919	var errorBuffer bytes.Buffer
4920	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4921		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4922	}
4923	errorBody := bytes.NewReader(errorBuffer.Bytes())
4924
4925	errorCode := "UnknownError"
4926	errorMessage := errorCode
4927
4928	code := response.Header.Get("X-Amzn-ErrorType")
4929	if len(code) != 0 {
4930		errorCode = restjson.SanitizeErrorCode(code)
4931	}
4932
4933	var buff [1024]byte
4934	ringBuffer := smithyio.NewRingBuffer(buff[:])
4935
4936	body := io.TeeReader(errorBody, ringBuffer)
4937	decoder := json.NewDecoder(body)
4938	decoder.UseNumber()
4939	code, message, err := restjson.GetErrorInfo(decoder)
4940	if err != nil {
4941		var snapshot bytes.Buffer
4942		io.Copy(&snapshot, ringBuffer)
4943		err = &smithy.DeserializationError{
4944			Err:      fmt.Errorf("failed to decode response body, %w", err),
4945			Snapshot: snapshot.Bytes(),
4946		}
4947		return err
4948	}
4949
4950	errorBody.Seek(0, io.SeekStart)
4951	if len(code) != 0 {
4952		errorCode = restjson.SanitizeErrorCode(code)
4953	}
4954	if len(message) != 0 {
4955		errorMessage = message
4956	}
4957
4958	switch {
4959	case strings.EqualFold("AccessDeniedException", errorCode):
4960		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4961
4962	case strings.EqualFold("AccountSetupInProgressException", errorCode):
4963		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
4964
4965	case strings.EqualFold("InvalidInputException", errorCode):
4966		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4967
4968	case strings.EqualFold("NotFoundException", errorCode):
4969		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
4970
4971	case strings.EqualFold("OperationFailureException", errorCode):
4972		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
4973
4974	case strings.EqualFold("ServiceException", errorCode):
4975		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4976
4977	case strings.EqualFold("UnauthenticatedException", errorCode):
4978		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
4979
4980	default:
4981		genericError := &smithy.GenericAPIError{
4982			Code:    errorCode,
4983			Message: errorMessage,
4984		}
4985		return genericError
4986
4987	}
4988}
4989
4990type awsAwsjson11_deserializeOpDeleteDomainEntry struct {
4991}
4992
4993func (*awsAwsjson11_deserializeOpDeleteDomainEntry) ID() string {
4994	return "OperationDeserializer"
4995}
4996
4997func (m *awsAwsjson11_deserializeOpDeleteDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4998	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4999) {
5000	out, metadata, err = next.HandleDeserialize(ctx, in)
5001	if err != nil {
5002		return out, metadata, err
5003	}
5004
5005	response, ok := out.RawResponse.(*smithyhttp.Response)
5006	if !ok {
5007		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5008	}
5009
5010	if response.StatusCode < 200 || response.StatusCode >= 300 {
5011		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response, &metadata)
5012	}
5013	output := &DeleteDomainEntryOutput{}
5014	out.Result = output
5015
5016	var buff [1024]byte
5017	ringBuffer := smithyio.NewRingBuffer(buff[:])
5018
5019	body := io.TeeReader(response.Body, ringBuffer)
5020	decoder := json.NewDecoder(body)
5021	decoder.UseNumber()
5022	var shape interface{}
5023	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5024		var snapshot bytes.Buffer
5025		io.Copy(&snapshot, ringBuffer)
5026		err = &smithy.DeserializationError{
5027			Err:      fmt.Errorf("failed to decode response body, %w", err),
5028			Snapshot: snapshot.Bytes(),
5029		}
5030		return out, metadata, err
5031	}
5032
5033	err = awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(&output, shape)
5034	if err != nil {
5035		var snapshot bytes.Buffer
5036		io.Copy(&snapshot, ringBuffer)
5037		err = &smithy.DeserializationError{
5038			Err:      fmt.Errorf("failed to decode response body, %w", err),
5039			Snapshot: snapshot.Bytes(),
5040		}
5041		return out, metadata, err
5042	}
5043
5044	return out, metadata, err
5045}
5046
5047func awsAwsjson11_deserializeOpErrorDeleteDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5048	var errorBuffer bytes.Buffer
5049	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5050		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5051	}
5052	errorBody := bytes.NewReader(errorBuffer.Bytes())
5053
5054	errorCode := "UnknownError"
5055	errorMessage := errorCode
5056
5057	code := response.Header.Get("X-Amzn-ErrorType")
5058	if len(code) != 0 {
5059		errorCode = restjson.SanitizeErrorCode(code)
5060	}
5061
5062	var buff [1024]byte
5063	ringBuffer := smithyio.NewRingBuffer(buff[:])
5064
5065	body := io.TeeReader(errorBody, ringBuffer)
5066	decoder := json.NewDecoder(body)
5067	decoder.UseNumber()
5068	code, message, err := restjson.GetErrorInfo(decoder)
5069	if err != nil {
5070		var snapshot bytes.Buffer
5071		io.Copy(&snapshot, ringBuffer)
5072		err = &smithy.DeserializationError{
5073			Err:      fmt.Errorf("failed to decode response body, %w", err),
5074			Snapshot: snapshot.Bytes(),
5075		}
5076		return err
5077	}
5078
5079	errorBody.Seek(0, io.SeekStart)
5080	if len(code) != 0 {
5081		errorCode = restjson.SanitizeErrorCode(code)
5082	}
5083	if len(message) != 0 {
5084		errorMessage = message
5085	}
5086
5087	switch {
5088	case strings.EqualFold("AccessDeniedException", errorCode):
5089		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5090
5091	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5092		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5093
5094	case strings.EqualFold("InvalidInputException", errorCode):
5095		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5096
5097	case strings.EqualFold("NotFoundException", errorCode):
5098		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5099
5100	case strings.EqualFold("OperationFailureException", errorCode):
5101		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5102
5103	case strings.EqualFold("ServiceException", errorCode):
5104		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5105
5106	case strings.EqualFold("UnauthenticatedException", errorCode):
5107		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5108
5109	default:
5110		genericError := &smithy.GenericAPIError{
5111			Code:    errorCode,
5112			Message: errorMessage,
5113		}
5114		return genericError
5115
5116	}
5117}
5118
5119type awsAwsjson11_deserializeOpDeleteInstance struct {
5120}
5121
5122func (*awsAwsjson11_deserializeOpDeleteInstance) ID() string {
5123	return "OperationDeserializer"
5124}
5125
5126func (m *awsAwsjson11_deserializeOpDeleteInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5127	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5128) {
5129	out, metadata, err = next.HandleDeserialize(ctx, in)
5130	if err != nil {
5131		return out, metadata, err
5132	}
5133
5134	response, ok := out.RawResponse.(*smithyhttp.Response)
5135	if !ok {
5136		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5137	}
5138
5139	if response.StatusCode < 200 || response.StatusCode >= 300 {
5140		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstance(response, &metadata)
5141	}
5142	output := &DeleteInstanceOutput{}
5143	out.Result = output
5144
5145	var buff [1024]byte
5146	ringBuffer := smithyio.NewRingBuffer(buff[:])
5147
5148	body := io.TeeReader(response.Body, ringBuffer)
5149	decoder := json.NewDecoder(body)
5150	decoder.UseNumber()
5151	var shape interface{}
5152	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5153		var snapshot bytes.Buffer
5154		io.Copy(&snapshot, ringBuffer)
5155		err = &smithy.DeserializationError{
5156			Err:      fmt.Errorf("failed to decode response body, %w", err),
5157			Snapshot: snapshot.Bytes(),
5158		}
5159		return out, metadata, err
5160	}
5161
5162	err = awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(&output, shape)
5163	if err != nil {
5164		var snapshot bytes.Buffer
5165		io.Copy(&snapshot, ringBuffer)
5166		err = &smithy.DeserializationError{
5167			Err:      fmt.Errorf("failed to decode response body, %w", err),
5168			Snapshot: snapshot.Bytes(),
5169		}
5170		return out, metadata, err
5171	}
5172
5173	return out, metadata, err
5174}
5175
5176func awsAwsjson11_deserializeOpErrorDeleteInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5177	var errorBuffer bytes.Buffer
5178	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5179		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5180	}
5181	errorBody := bytes.NewReader(errorBuffer.Bytes())
5182
5183	errorCode := "UnknownError"
5184	errorMessage := errorCode
5185
5186	code := response.Header.Get("X-Amzn-ErrorType")
5187	if len(code) != 0 {
5188		errorCode = restjson.SanitizeErrorCode(code)
5189	}
5190
5191	var buff [1024]byte
5192	ringBuffer := smithyio.NewRingBuffer(buff[:])
5193
5194	body := io.TeeReader(errorBody, ringBuffer)
5195	decoder := json.NewDecoder(body)
5196	decoder.UseNumber()
5197	code, message, err := restjson.GetErrorInfo(decoder)
5198	if err != nil {
5199		var snapshot bytes.Buffer
5200		io.Copy(&snapshot, ringBuffer)
5201		err = &smithy.DeserializationError{
5202			Err:      fmt.Errorf("failed to decode response body, %w", err),
5203			Snapshot: snapshot.Bytes(),
5204		}
5205		return err
5206	}
5207
5208	errorBody.Seek(0, io.SeekStart)
5209	if len(code) != 0 {
5210		errorCode = restjson.SanitizeErrorCode(code)
5211	}
5212	if len(message) != 0 {
5213		errorMessage = message
5214	}
5215
5216	switch {
5217	case strings.EqualFold("AccessDeniedException", errorCode):
5218		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5219
5220	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5221		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5222
5223	case strings.EqualFold("InvalidInputException", errorCode):
5224		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5225
5226	case strings.EqualFold("NotFoundException", errorCode):
5227		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5228
5229	case strings.EqualFold("OperationFailureException", errorCode):
5230		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5231
5232	case strings.EqualFold("ServiceException", errorCode):
5233		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5234
5235	case strings.EqualFold("UnauthenticatedException", errorCode):
5236		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5237
5238	default:
5239		genericError := &smithy.GenericAPIError{
5240			Code:    errorCode,
5241			Message: errorMessage,
5242		}
5243		return genericError
5244
5245	}
5246}
5247
5248type awsAwsjson11_deserializeOpDeleteInstanceSnapshot struct {
5249}
5250
5251func (*awsAwsjson11_deserializeOpDeleteInstanceSnapshot) ID() string {
5252	return "OperationDeserializer"
5253}
5254
5255func (m *awsAwsjson11_deserializeOpDeleteInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5256	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5257) {
5258	out, metadata, err = next.HandleDeserialize(ctx, in)
5259	if err != nil {
5260		return out, metadata, err
5261	}
5262
5263	response, ok := out.RawResponse.(*smithyhttp.Response)
5264	if !ok {
5265		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5266	}
5267
5268	if response.StatusCode < 200 || response.StatusCode >= 300 {
5269		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response, &metadata)
5270	}
5271	output := &DeleteInstanceSnapshotOutput{}
5272	out.Result = output
5273
5274	var buff [1024]byte
5275	ringBuffer := smithyio.NewRingBuffer(buff[:])
5276
5277	body := io.TeeReader(response.Body, ringBuffer)
5278	decoder := json.NewDecoder(body)
5279	decoder.UseNumber()
5280	var shape interface{}
5281	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5282		var snapshot bytes.Buffer
5283		io.Copy(&snapshot, ringBuffer)
5284		err = &smithy.DeserializationError{
5285			Err:      fmt.Errorf("failed to decode response body, %w", err),
5286			Snapshot: snapshot.Bytes(),
5287		}
5288		return out, metadata, err
5289	}
5290
5291	err = awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(&output, shape)
5292	if err != nil {
5293		var snapshot bytes.Buffer
5294		io.Copy(&snapshot, ringBuffer)
5295		err = &smithy.DeserializationError{
5296			Err:      fmt.Errorf("failed to decode response body, %w", err),
5297			Snapshot: snapshot.Bytes(),
5298		}
5299		return out, metadata, err
5300	}
5301
5302	return out, metadata, err
5303}
5304
5305func awsAwsjson11_deserializeOpErrorDeleteInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5306	var errorBuffer bytes.Buffer
5307	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5308		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5309	}
5310	errorBody := bytes.NewReader(errorBuffer.Bytes())
5311
5312	errorCode := "UnknownError"
5313	errorMessage := errorCode
5314
5315	code := response.Header.Get("X-Amzn-ErrorType")
5316	if len(code) != 0 {
5317		errorCode = restjson.SanitizeErrorCode(code)
5318	}
5319
5320	var buff [1024]byte
5321	ringBuffer := smithyio.NewRingBuffer(buff[:])
5322
5323	body := io.TeeReader(errorBody, ringBuffer)
5324	decoder := json.NewDecoder(body)
5325	decoder.UseNumber()
5326	code, message, err := restjson.GetErrorInfo(decoder)
5327	if err != nil {
5328		var snapshot bytes.Buffer
5329		io.Copy(&snapshot, ringBuffer)
5330		err = &smithy.DeserializationError{
5331			Err:      fmt.Errorf("failed to decode response body, %w", err),
5332			Snapshot: snapshot.Bytes(),
5333		}
5334		return err
5335	}
5336
5337	errorBody.Seek(0, io.SeekStart)
5338	if len(code) != 0 {
5339		errorCode = restjson.SanitizeErrorCode(code)
5340	}
5341	if len(message) != 0 {
5342		errorMessage = message
5343	}
5344
5345	switch {
5346	case strings.EqualFold("AccessDeniedException", errorCode):
5347		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5348
5349	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5350		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5351
5352	case strings.EqualFold("InvalidInputException", errorCode):
5353		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5354
5355	case strings.EqualFold("NotFoundException", errorCode):
5356		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5357
5358	case strings.EqualFold("OperationFailureException", errorCode):
5359		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5360
5361	case strings.EqualFold("ServiceException", errorCode):
5362		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5363
5364	case strings.EqualFold("UnauthenticatedException", errorCode):
5365		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5366
5367	default:
5368		genericError := &smithy.GenericAPIError{
5369			Code:    errorCode,
5370			Message: errorMessage,
5371		}
5372		return genericError
5373
5374	}
5375}
5376
5377type awsAwsjson11_deserializeOpDeleteKeyPair struct {
5378}
5379
5380func (*awsAwsjson11_deserializeOpDeleteKeyPair) ID() string {
5381	return "OperationDeserializer"
5382}
5383
5384func (m *awsAwsjson11_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5385	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5386) {
5387	out, metadata, err = next.HandleDeserialize(ctx, in)
5388	if err != nil {
5389		return out, metadata, err
5390	}
5391
5392	response, ok := out.RawResponse.(*smithyhttp.Response)
5393	if !ok {
5394		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5395	}
5396
5397	if response.StatusCode < 200 || response.StatusCode >= 300 {
5398		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKeyPair(response, &metadata)
5399	}
5400	output := &DeleteKeyPairOutput{}
5401	out.Result = output
5402
5403	var buff [1024]byte
5404	ringBuffer := smithyio.NewRingBuffer(buff[:])
5405
5406	body := io.TeeReader(response.Body, ringBuffer)
5407	decoder := json.NewDecoder(body)
5408	decoder.UseNumber()
5409	var shape interface{}
5410	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5411		var snapshot bytes.Buffer
5412		io.Copy(&snapshot, ringBuffer)
5413		err = &smithy.DeserializationError{
5414			Err:      fmt.Errorf("failed to decode response body, %w", err),
5415			Snapshot: snapshot.Bytes(),
5416		}
5417		return out, metadata, err
5418	}
5419
5420	err = awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(&output, shape)
5421	if err != nil {
5422		var snapshot bytes.Buffer
5423		io.Copy(&snapshot, ringBuffer)
5424		err = &smithy.DeserializationError{
5425			Err:      fmt.Errorf("failed to decode response body, %w", err),
5426			Snapshot: snapshot.Bytes(),
5427		}
5428		return out, metadata, err
5429	}
5430
5431	return out, metadata, err
5432}
5433
5434func awsAwsjson11_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5435	var errorBuffer bytes.Buffer
5436	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5437		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5438	}
5439	errorBody := bytes.NewReader(errorBuffer.Bytes())
5440
5441	errorCode := "UnknownError"
5442	errorMessage := errorCode
5443
5444	code := response.Header.Get("X-Amzn-ErrorType")
5445	if len(code) != 0 {
5446		errorCode = restjson.SanitizeErrorCode(code)
5447	}
5448
5449	var buff [1024]byte
5450	ringBuffer := smithyio.NewRingBuffer(buff[:])
5451
5452	body := io.TeeReader(errorBody, ringBuffer)
5453	decoder := json.NewDecoder(body)
5454	decoder.UseNumber()
5455	code, message, err := restjson.GetErrorInfo(decoder)
5456	if err != nil {
5457		var snapshot bytes.Buffer
5458		io.Copy(&snapshot, ringBuffer)
5459		err = &smithy.DeserializationError{
5460			Err:      fmt.Errorf("failed to decode response body, %w", err),
5461			Snapshot: snapshot.Bytes(),
5462		}
5463		return err
5464	}
5465
5466	errorBody.Seek(0, io.SeekStart)
5467	if len(code) != 0 {
5468		errorCode = restjson.SanitizeErrorCode(code)
5469	}
5470	if len(message) != 0 {
5471		errorMessage = message
5472	}
5473
5474	switch {
5475	case strings.EqualFold("AccessDeniedException", errorCode):
5476		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5477
5478	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5479		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5480
5481	case strings.EqualFold("InvalidInputException", errorCode):
5482		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5483
5484	case strings.EqualFold("NotFoundException", errorCode):
5485		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5486
5487	case strings.EqualFold("OperationFailureException", errorCode):
5488		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5489
5490	case strings.EqualFold("ServiceException", errorCode):
5491		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5492
5493	case strings.EqualFold("UnauthenticatedException", errorCode):
5494		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5495
5496	default:
5497		genericError := &smithy.GenericAPIError{
5498			Code:    errorCode,
5499			Message: errorMessage,
5500		}
5501		return genericError
5502
5503	}
5504}
5505
5506type awsAwsjson11_deserializeOpDeleteKnownHostKeys struct {
5507}
5508
5509func (*awsAwsjson11_deserializeOpDeleteKnownHostKeys) ID() string {
5510	return "OperationDeserializer"
5511}
5512
5513func (m *awsAwsjson11_deserializeOpDeleteKnownHostKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5514	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5515) {
5516	out, metadata, err = next.HandleDeserialize(ctx, in)
5517	if err != nil {
5518		return out, metadata, err
5519	}
5520
5521	response, ok := out.RawResponse.(*smithyhttp.Response)
5522	if !ok {
5523		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5524	}
5525
5526	if response.StatusCode < 200 || response.StatusCode >= 300 {
5527		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response, &metadata)
5528	}
5529	output := &DeleteKnownHostKeysOutput{}
5530	out.Result = output
5531
5532	var buff [1024]byte
5533	ringBuffer := smithyio.NewRingBuffer(buff[:])
5534
5535	body := io.TeeReader(response.Body, ringBuffer)
5536	decoder := json.NewDecoder(body)
5537	decoder.UseNumber()
5538	var shape interface{}
5539	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5540		var snapshot bytes.Buffer
5541		io.Copy(&snapshot, ringBuffer)
5542		err = &smithy.DeserializationError{
5543			Err:      fmt.Errorf("failed to decode response body, %w", err),
5544			Snapshot: snapshot.Bytes(),
5545		}
5546		return out, metadata, err
5547	}
5548
5549	err = awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(&output, shape)
5550	if err != nil {
5551		var snapshot bytes.Buffer
5552		io.Copy(&snapshot, ringBuffer)
5553		err = &smithy.DeserializationError{
5554			Err:      fmt.Errorf("failed to decode response body, %w", err),
5555			Snapshot: snapshot.Bytes(),
5556		}
5557		return out, metadata, err
5558	}
5559
5560	return out, metadata, err
5561}
5562
5563func awsAwsjson11_deserializeOpErrorDeleteKnownHostKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5564	var errorBuffer bytes.Buffer
5565	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5566		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5567	}
5568	errorBody := bytes.NewReader(errorBuffer.Bytes())
5569
5570	errorCode := "UnknownError"
5571	errorMessage := errorCode
5572
5573	code := response.Header.Get("X-Amzn-ErrorType")
5574	if len(code) != 0 {
5575		errorCode = restjson.SanitizeErrorCode(code)
5576	}
5577
5578	var buff [1024]byte
5579	ringBuffer := smithyio.NewRingBuffer(buff[:])
5580
5581	body := io.TeeReader(errorBody, ringBuffer)
5582	decoder := json.NewDecoder(body)
5583	decoder.UseNumber()
5584	code, message, err := restjson.GetErrorInfo(decoder)
5585	if err != nil {
5586		var snapshot bytes.Buffer
5587		io.Copy(&snapshot, ringBuffer)
5588		err = &smithy.DeserializationError{
5589			Err:      fmt.Errorf("failed to decode response body, %w", err),
5590			Snapshot: snapshot.Bytes(),
5591		}
5592		return err
5593	}
5594
5595	errorBody.Seek(0, io.SeekStart)
5596	if len(code) != 0 {
5597		errorCode = restjson.SanitizeErrorCode(code)
5598	}
5599	if len(message) != 0 {
5600		errorMessage = message
5601	}
5602
5603	switch {
5604	case strings.EqualFold("AccessDeniedException", errorCode):
5605		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5606
5607	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5608		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5609
5610	case strings.EqualFold("InvalidInputException", errorCode):
5611		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5612
5613	case strings.EqualFold("NotFoundException", errorCode):
5614		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5615
5616	case strings.EqualFold("OperationFailureException", errorCode):
5617		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5618
5619	case strings.EqualFold("ServiceException", errorCode):
5620		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5621
5622	case strings.EqualFold("UnauthenticatedException", errorCode):
5623		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5624
5625	default:
5626		genericError := &smithy.GenericAPIError{
5627			Code:    errorCode,
5628			Message: errorMessage,
5629		}
5630		return genericError
5631
5632	}
5633}
5634
5635type awsAwsjson11_deserializeOpDeleteLoadBalancer struct {
5636}
5637
5638func (*awsAwsjson11_deserializeOpDeleteLoadBalancer) ID() string {
5639	return "OperationDeserializer"
5640}
5641
5642func (m *awsAwsjson11_deserializeOpDeleteLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5643	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5644) {
5645	out, metadata, err = next.HandleDeserialize(ctx, in)
5646	if err != nil {
5647		return out, metadata, err
5648	}
5649
5650	response, ok := out.RawResponse.(*smithyhttp.Response)
5651	if !ok {
5652		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5653	}
5654
5655	if response.StatusCode < 200 || response.StatusCode >= 300 {
5656		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response, &metadata)
5657	}
5658	output := &DeleteLoadBalancerOutput{}
5659	out.Result = output
5660
5661	var buff [1024]byte
5662	ringBuffer := smithyio.NewRingBuffer(buff[:])
5663
5664	body := io.TeeReader(response.Body, ringBuffer)
5665	decoder := json.NewDecoder(body)
5666	decoder.UseNumber()
5667	var shape interface{}
5668	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5669		var snapshot bytes.Buffer
5670		io.Copy(&snapshot, ringBuffer)
5671		err = &smithy.DeserializationError{
5672			Err:      fmt.Errorf("failed to decode response body, %w", err),
5673			Snapshot: snapshot.Bytes(),
5674		}
5675		return out, metadata, err
5676	}
5677
5678	err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(&output, shape)
5679	if err != nil {
5680		var snapshot bytes.Buffer
5681		io.Copy(&snapshot, ringBuffer)
5682		err = &smithy.DeserializationError{
5683			Err:      fmt.Errorf("failed to decode response body, %w", err),
5684			Snapshot: snapshot.Bytes(),
5685		}
5686		return out, metadata, err
5687	}
5688
5689	return out, metadata, err
5690}
5691
5692func awsAwsjson11_deserializeOpErrorDeleteLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5693	var errorBuffer bytes.Buffer
5694	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5695		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5696	}
5697	errorBody := bytes.NewReader(errorBuffer.Bytes())
5698
5699	errorCode := "UnknownError"
5700	errorMessage := errorCode
5701
5702	code := response.Header.Get("X-Amzn-ErrorType")
5703	if len(code) != 0 {
5704		errorCode = restjson.SanitizeErrorCode(code)
5705	}
5706
5707	var buff [1024]byte
5708	ringBuffer := smithyio.NewRingBuffer(buff[:])
5709
5710	body := io.TeeReader(errorBody, ringBuffer)
5711	decoder := json.NewDecoder(body)
5712	decoder.UseNumber()
5713	code, message, err := restjson.GetErrorInfo(decoder)
5714	if err != nil {
5715		var snapshot bytes.Buffer
5716		io.Copy(&snapshot, ringBuffer)
5717		err = &smithy.DeserializationError{
5718			Err:      fmt.Errorf("failed to decode response body, %w", err),
5719			Snapshot: snapshot.Bytes(),
5720		}
5721		return err
5722	}
5723
5724	errorBody.Seek(0, io.SeekStart)
5725	if len(code) != 0 {
5726		errorCode = restjson.SanitizeErrorCode(code)
5727	}
5728	if len(message) != 0 {
5729		errorMessage = message
5730	}
5731
5732	switch {
5733	case strings.EqualFold("AccessDeniedException", errorCode):
5734		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5735
5736	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5737		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5738
5739	case strings.EqualFold("InvalidInputException", errorCode):
5740		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5741
5742	case strings.EqualFold("NotFoundException", errorCode):
5743		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5744
5745	case strings.EqualFold("OperationFailureException", errorCode):
5746		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5747
5748	case strings.EqualFold("ServiceException", errorCode):
5749		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5750
5751	case strings.EqualFold("UnauthenticatedException", errorCode):
5752		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5753
5754	default:
5755		genericError := &smithy.GenericAPIError{
5756			Code:    errorCode,
5757			Message: errorMessage,
5758		}
5759		return genericError
5760
5761	}
5762}
5763
5764type awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate struct {
5765}
5766
5767func (*awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) ID() string {
5768	return "OperationDeserializer"
5769}
5770
5771func (m *awsAwsjson11_deserializeOpDeleteLoadBalancerTlsCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5772	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5773) {
5774	out, metadata, err = next.HandleDeserialize(ctx, in)
5775	if err != nil {
5776		return out, metadata, err
5777	}
5778
5779	response, ok := out.RawResponse.(*smithyhttp.Response)
5780	if !ok {
5781		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5782	}
5783
5784	if response.StatusCode < 200 || response.StatusCode >= 300 {
5785		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response, &metadata)
5786	}
5787	output := &DeleteLoadBalancerTlsCertificateOutput{}
5788	out.Result = output
5789
5790	var buff [1024]byte
5791	ringBuffer := smithyio.NewRingBuffer(buff[:])
5792
5793	body := io.TeeReader(response.Body, ringBuffer)
5794	decoder := json.NewDecoder(body)
5795	decoder.UseNumber()
5796	var shape interface{}
5797	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5798		var snapshot bytes.Buffer
5799		io.Copy(&snapshot, ringBuffer)
5800		err = &smithy.DeserializationError{
5801			Err:      fmt.Errorf("failed to decode response body, %w", err),
5802			Snapshot: snapshot.Bytes(),
5803		}
5804		return out, metadata, err
5805	}
5806
5807	err = awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(&output, shape)
5808	if err != nil {
5809		var snapshot bytes.Buffer
5810		io.Copy(&snapshot, ringBuffer)
5811		err = &smithy.DeserializationError{
5812			Err:      fmt.Errorf("failed to decode response body, %w", err),
5813			Snapshot: snapshot.Bytes(),
5814		}
5815		return out, metadata, err
5816	}
5817
5818	return out, metadata, err
5819}
5820
5821func awsAwsjson11_deserializeOpErrorDeleteLoadBalancerTlsCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5822	var errorBuffer bytes.Buffer
5823	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5824		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5825	}
5826	errorBody := bytes.NewReader(errorBuffer.Bytes())
5827
5828	errorCode := "UnknownError"
5829	errorMessage := errorCode
5830
5831	code := response.Header.Get("X-Amzn-ErrorType")
5832	if len(code) != 0 {
5833		errorCode = restjson.SanitizeErrorCode(code)
5834	}
5835
5836	var buff [1024]byte
5837	ringBuffer := smithyio.NewRingBuffer(buff[:])
5838
5839	body := io.TeeReader(errorBody, ringBuffer)
5840	decoder := json.NewDecoder(body)
5841	decoder.UseNumber()
5842	code, message, err := restjson.GetErrorInfo(decoder)
5843	if err != nil {
5844		var snapshot bytes.Buffer
5845		io.Copy(&snapshot, ringBuffer)
5846		err = &smithy.DeserializationError{
5847			Err:      fmt.Errorf("failed to decode response body, %w", err),
5848			Snapshot: snapshot.Bytes(),
5849		}
5850		return err
5851	}
5852
5853	errorBody.Seek(0, io.SeekStart)
5854	if len(code) != 0 {
5855		errorCode = restjson.SanitizeErrorCode(code)
5856	}
5857	if len(message) != 0 {
5858		errorMessage = message
5859	}
5860
5861	switch {
5862	case strings.EqualFold("AccessDeniedException", errorCode):
5863		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5864
5865	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5866		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5867
5868	case strings.EqualFold("InvalidInputException", errorCode):
5869		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5870
5871	case strings.EqualFold("NotFoundException", errorCode):
5872		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
5873
5874	case strings.EqualFold("OperationFailureException", errorCode):
5875		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
5876
5877	case strings.EqualFold("ServiceException", errorCode):
5878		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5879
5880	case strings.EqualFold("UnauthenticatedException", errorCode):
5881		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
5882
5883	default:
5884		genericError := &smithy.GenericAPIError{
5885			Code:    errorCode,
5886			Message: errorMessage,
5887		}
5888		return genericError
5889
5890	}
5891}
5892
5893type awsAwsjson11_deserializeOpDeleteRelationalDatabase struct {
5894}
5895
5896func (*awsAwsjson11_deserializeOpDeleteRelationalDatabase) ID() string {
5897	return "OperationDeserializer"
5898}
5899
5900func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5901	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5902) {
5903	out, metadata, err = next.HandleDeserialize(ctx, in)
5904	if err != nil {
5905		return out, metadata, err
5906	}
5907
5908	response, ok := out.RawResponse.(*smithyhttp.Response)
5909	if !ok {
5910		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5911	}
5912
5913	if response.StatusCode < 200 || response.StatusCode >= 300 {
5914		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response, &metadata)
5915	}
5916	output := &DeleteRelationalDatabaseOutput{}
5917	out.Result = output
5918
5919	var buff [1024]byte
5920	ringBuffer := smithyio.NewRingBuffer(buff[:])
5921
5922	body := io.TeeReader(response.Body, ringBuffer)
5923	decoder := json.NewDecoder(body)
5924	decoder.UseNumber()
5925	var shape interface{}
5926	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5927		var snapshot bytes.Buffer
5928		io.Copy(&snapshot, ringBuffer)
5929		err = &smithy.DeserializationError{
5930			Err:      fmt.Errorf("failed to decode response body, %w", err),
5931			Snapshot: snapshot.Bytes(),
5932		}
5933		return out, metadata, err
5934	}
5935
5936	err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(&output, shape)
5937	if err != nil {
5938		var snapshot bytes.Buffer
5939		io.Copy(&snapshot, ringBuffer)
5940		err = &smithy.DeserializationError{
5941			Err:      fmt.Errorf("failed to decode response body, %w", err),
5942			Snapshot: snapshot.Bytes(),
5943		}
5944		return out, metadata, err
5945	}
5946
5947	return out, metadata, err
5948}
5949
5950func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5951	var errorBuffer bytes.Buffer
5952	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5953		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5954	}
5955	errorBody := bytes.NewReader(errorBuffer.Bytes())
5956
5957	errorCode := "UnknownError"
5958	errorMessage := errorCode
5959
5960	code := response.Header.Get("X-Amzn-ErrorType")
5961	if len(code) != 0 {
5962		errorCode = restjson.SanitizeErrorCode(code)
5963	}
5964
5965	var buff [1024]byte
5966	ringBuffer := smithyio.NewRingBuffer(buff[:])
5967
5968	body := io.TeeReader(errorBody, ringBuffer)
5969	decoder := json.NewDecoder(body)
5970	decoder.UseNumber()
5971	code, message, err := restjson.GetErrorInfo(decoder)
5972	if err != nil {
5973		var snapshot bytes.Buffer
5974		io.Copy(&snapshot, ringBuffer)
5975		err = &smithy.DeserializationError{
5976			Err:      fmt.Errorf("failed to decode response body, %w", err),
5977			Snapshot: snapshot.Bytes(),
5978		}
5979		return err
5980	}
5981
5982	errorBody.Seek(0, io.SeekStart)
5983	if len(code) != 0 {
5984		errorCode = restjson.SanitizeErrorCode(code)
5985	}
5986	if len(message) != 0 {
5987		errorMessage = message
5988	}
5989
5990	switch {
5991	case strings.EqualFold("AccessDeniedException", errorCode):
5992		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5993
5994	case strings.EqualFold("AccountSetupInProgressException", errorCode):
5995		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
5996
5997	case strings.EqualFold("InvalidInputException", errorCode):
5998		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5999
6000	case strings.EqualFold("NotFoundException", errorCode):
6001		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6002
6003	case strings.EqualFold("OperationFailureException", errorCode):
6004		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6005
6006	case strings.EqualFold("ServiceException", errorCode):
6007		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6008
6009	case strings.EqualFold("UnauthenticatedException", errorCode):
6010		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6011
6012	default:
6013		genericError := &smithy.GenericAPIError{
6014			Code:    errorCode,
6015			Message: errorMessage,
6016		}
6017		return genericError
6018
6019	}
6020}
6021
6022type awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot struct {
6023}
6024
6025func (*awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) ID() string {
6026	return "OperationDeserializer"
6027}
6028
6029func (m *awsAwsjson11_deserializeOpDeleteRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6030	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6031) {
6032	out, metadata, err = next.HandleDeserialize(ctx, in)
6033	if err != nil {
6034		return out, metadata, err
6035	}
6036
6037	response, ok := out.RawResponse.(*smithyhttp.Response)
6038	if !ok {
6039		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6040	}
6041
6042	if response.StatusCode < 200 || response.StatusCode >= 300 {
6043		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response, &metadata)
6044	}
6045	output := &DeleteRelationalDatabaseSnapshotOutput{}
6046	out.Result = output
6047
6048	var buff [1024]byte
6049	ringBuffer := smithyio.NewRingBuffer(buff[:])
6050
6051	body := io.TeeReader(response.Body, ringBuffer)
6052	decoder := json.NewDecoder(body)
6053	decoder.UseNumber()
6054	var shape interface{}
6055	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6056		var snapshot bytes.Buffer
6057		io.Copy(&snapshot, ringBuffer)
6058		err = &smithy.DeserializationError{
6059			Err:      fmt.Errorf("failed to decode response body, %w", err),
6060			Snapshot: snapshot.Bytes(),
6061		}
6062		return out, metadata, err
6063	}
6064
6065	err = awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(&output, shape)
6066	if err != nil {
6067		var snapshot bytes.Buffer
6068		io.Copy(&snapshot, ringBuffer)
6069		err = &smithy.DeserializationError{
6070			Err:      fmt.Errorf("failed to decode response body, %w", err),
6071			Snapshot: snapshot.Bytes(),
6072		}
6073		return out, metadata, err
6074	}
6075
6076	return out, metadata, err
6077}
6078
6079func awsAwsjson11_deserializeOpErrorDeleteRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6080	var errorBuffer bytes.Buffer
6081	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6082		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6083	}
6084	errorBody := bytes.NewReader(errorBuffer.Bytes())
6085
6086	errorCode := "UnknownError"
6087	errorMessage := errorCode
6088
6089	code := response.Header.Get("X-Amzn-ErrorType")
6090	if len(code) != 0 {
6091		errorCode = restjson.SanitizeErrorCode(code)
6092	}
6093
6094	var buff [1024]byte
6095	ringBuffer := smithyio.NewRingBuffer(buff[:])
6096
6097	body := io.TeeReader(errorBody, ringBuffer)
6098	decoder := json.NewDecoder(body)
6099	decoder.UseNumber()
6100	code, message, err := restjson.GetErrorInfo(decoder)
6101	if err != nil {
6102		var snapshot bytes.Buffer
6103		io.Copy(&snapshot, ringBuffer)
6104		err = &smithy.DeserializationError{
6105			Err:      fmt.Errorf("failed to decode response body, %w", err),
6106			Snapshot: snapshot.Bytes(),
6107		}
6108		return err
6109	}
6110
6111	errorBody.Seek(0, io.SeekStart)
6112	if len(code) != 0 {
6113		errorCode = restjson.SanitizeErrorCode(code)
6114	}
6115	if len(message) != 0 {
6116		errorMessage = message
6117	}
6118
6119	switch {
6120	case strings.EqualFold("AccessDeniedException", errorCode):
6121		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6122
6123	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6124		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6125
6126	case strings.EqualFold("InvalidInputException", errorCode):
6127		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6128
6129	case strings.EqualFold("NotFoundException", errorCode):
6130		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6131
6132	case strings.EqualFold("OperationFailureException", errorCode):
6133		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6134
6135	case strings.EqualFold("ServiceException", errorCode):
6136		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6137
6138	case strings.EqualFold("UnauthenticatedException", errorCode):
6139		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6140
6141	default:
6142		genericError := &smithy.GenericAPIError{
6143			Code:    errorCode,
6144			Message: errorMessage,
6145		}
6146		return genericError
6147
6148	}
6149}
6150
6151type awsAwsjson11_deserializeOpDetachCertificateFromDistribution struct {
6152}
6153
6154func (*awsAwsjson11_deserializeOpDetachCertificateFromDistribution) ID() string {
6155	return "OperationDeserializer"
6156}
6157
6158func (m *awsAwsjson11_deserializeOpDetachCertificateFromDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6159	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6160) {
6161	out, metadata, err = next.HandleDeserialize(ctx, in)
6162	if err != nil {
6163		return out, metadata, err
6164	}
6165
6166	response, ok := out.RawResponse.(*smithyhttp.Response)
6167	if !ok {
6168		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6169	}
6170
6171	if response.StatusCode < 200 || response.StatusCode >= 300 {
6172		return out, metadata, awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response, &metadata)
6173	}
6174	output := &DetachCertificateFromDistributionOutput{}
6175	out.Result = output
6176
6177	var buff [1024]byte
6178	ringBuffer := smithyio.NewRingBuffer(buff[:])
6179
6180	body := io.TeeReader(response.Body, ringBuffer)
6181	decoder := json.NewDecoder(body)
6182	decoder.UseNumber()
6183	var shape interface{}
6184	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6185		var snapshot bytes.Buffer
6186		io.Copy(&snapshot, ringBuffer)
6187		err = &smithy.DeserializationError{
6188			Err:      fmt.Errorf("failed to decode response body, %w", err),
6189			Snapshot: snapshot.Bytes(),
6190		}
6191		return out, metadata, err
6192	}
6193
6194	err = awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(&output, shape)
6195	if err != nil {
6196		var snapshot bytes.Buffer
6197		io.Copy(&snapshot, ringBuffer)
6198		err = &smithy.DeserializationError{
6199			Err:      fmt.Errorf("failed to decode response body, %w", err),
6200			Snapshot: snapshot.Bytes(),
6201		}
6202		return out, metadata, err
6203	}
6204
6205	return out, metadata, err
6206}
6207
6208func awsAwsjson11_deserializeOpErrorDetachCertificateFromDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6209	var errorBuffer bytes.Buffer
6210	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6211		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6212	}
6213	errorBody := bytes.NewReader(errorBuffer.Bytes())
6214
6215	errorCode := "UnknownError"
6216	errorMessage := errorCode
6217
6218	code := response.Header.Get("X-Amzn-ErrorType")
6219	if len(code) != 0 {
6220		errorCode = restjson.SanitizeErrorCode(code)
6221	}
6222
6223	var buff [1024]byte
6224	ringBuffer := smithyio.NewRingBuffer(buff[:])
6225
6226	body := io.TeeReader(errorBody, ringBuffer)
6227	decoder := json.NewDecoder(body)
6228	decoder.UseNumber()
6229	code, message, err := restjson.GetErrorInfo(decoder)
6230	if err != nil {
6231		var snapshot bytes.Buffer
6232		io.Copy(&snapshot, ringBuffer)
6233		err = &smithy.DeserializationError{
6234			Err:      fmt.Errorf("failed to decode response body, %w", err),
6235			Snapshot: snapshot.Bytes(),
6236		}
6237		return err
6238	}
6239
6240	errorBody.Seek(0, io.SeekStart)
6241	if len(code) != 0 {
6242		errorCode = restjson.SanitizeErrorCode(code)
6243	}
6244	if len(message) != 0 {
6245		errorMessage = message
6246	}
6247
6248	switch {
6249	case strings.EqualFold("AccessDeniedException", errorCode):
6250		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6251
6252	case strings.EqualFold("InvalidInputException", errorCode):
6253		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6254
6255	case strings.EqualFold("NotFoundException", errorCode):
6256		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6257
6258	case strings.EqualFold("OperationFailureException", errorCode):
6259		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6260
6261	case strings.EqualFold("ServiceException", errorCode):
6262		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6263
6264	case strings.EqualFold("UnauthenticatedException", errorCode):
6265		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6266
6267	default:
6268		genericError := &smithy.GenericAPIError{
6269			Code:    errorCode,
6270			Message: errorMessage,
6271		}
6272		return genericError
6273
6274	}
6275}
6276
6277type awsAwsjson11_deserializeOpDetachDisk struct {
6278}
6279
6280func (*awsAwsjson11_deserializeOpDetachDisk) ID() string {
6281	return "OperationDeserializer"
6282}
6283
6284func (m *awsAwsjson11_deserializeOpDetachDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6285	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6286) {
6287	out, metadata, err = next.HandleDeserialize(ctx, in)
6288	if err != nil {
6289		return out, metadata, err
6290	}
6291
6292	response, ok := out.RawResponse.(*smithyhttp.Response)
6293	if !ok {
6294		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6295	}
6296
6297	if response.StatusCode < 200 || response.StatusCode >= 300 {
6298		return out, metadata, awsAwsjson11_deserializeOpErrorDetachDisk(response, &metadata)
6299	}
6300	output := &DetachDiskOutput{}
6301	out.Result = output
6302
6303	var buff [1024]byte
6304	ringBuffer := smithyio.NewRingBuffer(buff[:])
6305
6306	body := io.TeeReader(response.Body, ringBuffer)
6307	decoder := json.NewDecoder(body)
6308	decoder.UseNumber()
6309	var shape interface{}
6310	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6311		var snapshot bytes.Buffer
6312		io.Copy(&snapshot, ringBuffer)
6313		err = &smithy.DeserializationError{
6314			Err:      fmt.Errorf("failed to decode response body, %w", err),
6315			Snapshot: snapshot.Bytes(),
6316		}
6317		return out, metadata, err
6318	}
6319
6320	err = awsAwsjson11_deserializeOpDocumentDetachDiskOutput(&output, shape)
6321	if err != nil {
6322		var snapshot bytes.Buffer
6323		io.Copy(&snapshot, ringBuffer)
6324		err = &smithy.DeserializationError{
6325			Err:      fmt.Errorf("failed to decode response body, %w", err),
6326			Snapshot: snapshot.Bytes(),
6327		}
6328		return out, metadata, err
6329	}
6330
6331	return out, metadata, err
6332}
6333
6334func awsAwsjson11_deserializeOpErrorDetachDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6335	var errorBuffer bytes.Buffer
6336	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6337		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6338	}
6339	errorBody := bytes.NewReader(errorBuffer.Bytes())
6340
6341	errorCode := "UnknownError"
6342	errorMessage := errorCode
6343
6344	code := response.Header.Get("X-Amzn-ErrorType")
6345	if len(code) != 0 {
6346		errorCode = restjson.SanitizeErrorCode(code)
6347	}
6348
6349	var buff [1024]byte
6350	ringBuffer := smithyio.NewRingBuffer(buff[:])
6351
6352	body := io.TeeReader(errorBody, ringBuffer)
6353	decoder := json.NewDecoder(body)
6354	decoder.UseNumber()
6355	code, message, err := restjson.GetErrorInfo(decoder)
6356	if err != nil {
6357		var snapshot bytes.Buffer
6358		io.Copy(&snapshot, ringBuffer)
6359		err = &smithy.DeserializationError{
6360			Err:      fmt.Errorf("failed to decode response body, %w", err),
6361			Snapshot: snapshot.Bytes(),
6362		}
6363		return err
6364	}
6365
6366	errorBody.Seek(0, io.SeekStart)
6367	if len(code) != 0 {
6368		errorCode = restjson.SanitizeErrorCode(code)
6369	}
6370	if len(message) != 0 {
6371		errorMessage = message
6372	}
6373
6374	switch {
6375	case strings.EqualFold("AccessDeniedException", errorCode):
6376		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6377
6378	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6379		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6380
6381	case strings.EqualFold("InvalidInputException", errorCode):
6382		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6383
6384	case strings.EqualFold("NotFoundException", errorCode):
6385		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6386
6387	case strings.EqualFold("OperationFailureException", errorCode):
6388		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6389
6390	case strings.EqualFold("ServiceException", errorCode):
6391		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6392
6393	case strings.EqualFold("UnauthenticatedException", errorCode):
6394		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6395
6396	default:
6397		genericError := &smithy.GenericAPIError{
6398			Code:    errorCode,
6399			Message: errorMessage,
6400		}
6401		return genericError
6402
6403	}
6404}
6405
6406type awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer struct {
6407}
6408
6409func (*awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) ID() string {
6410	return "OperationDeserializer"
6411}
6412
6413func (m *awsAwsjson11_deserializeOpDetachInstancesFromLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6414	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6415) {
6416	out, metadata, err = next.HandleDeserialize(ctx, in)
6417	if err != nil {
6418		return out, metadata, err
6419	}
6420
6421	response, ok := out.RawResponse.(*smithyhttp.Response)
6422	if !ok {
6423		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6424	}
6425
6426	if response.StatusCode < 200 || response.StatusCode >= 300 {
6427		return out, metadata, awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response, &metadata)
6428	}
6429	output := &DetachInstancesFromLoadBalancerOutput{}
6430	out.Result = output
6431
6432	var buff [1024]byte
6433	ringBuffer := smithyio.NewRingBuffer(buff[:])
6434
6435	body := io.TeeReader(response.Body, ringBuffer)
6436	decoder := json.NewDecoder(body)
6437	decoder.UseNumber()
6438	var shape interface{}
6439	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6440		var snapshot bytes.Buffer
6441		io.Copy(&snapshot, ringBuffer)
6442		err = &smithy.DeserializationError{
6443			Err:      fmt.Errorf("failed to decode response body, %w", err),
6444			Snapshot: snapshot.Bytes(),
6445		}
6446		return out, metadata, err
6447	}
6448
6449	err = awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(&output, shape)
6450	if err != nil {
6451		var snapshot bytes.Buffer
6452		io.Copy(&snapshot, ringBuffer)
6453		err = &smithy.DeserializationError{
6454			Err:      fmt.Errorf("failed to decode response body, %w", err),
6455			Snapshot: snapshot.Bytes(),
6456		}
6457		return out, metadata, err
6458	}
6459
6460	return out, metadata, err
6461}
6462
6463func awsAwsjson11_deserializeOpErrorDetachInstancesFromLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6464	var errorBuffer bytes.Buffer
6465	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6466		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6467	}
6468	errorBody := bytes.NewReader(errorBuffer.Bytes())
6469
6470	errorCode := "UnknownError"
6471	errorMessage := errorCode
6472
6473	code := response.Header.Get("X-Amzn-ErrorType")
6474	if len(code) != 0 {
6475		errorCode = restjson.SanitizeErrorCode(code)
6476	}
6477
6478	var buff [1024]byte
6479	ringBuffer := smithyio.NewRingBuffer(buff[:])
6480
6481	body := io.TeeReader(errorBody, ringBuffer)
6482	decoder := json.NewDecoder(body)
6483	decoder.UseNumber()
6484	code, message, err := restjson.GetErrorInfo(decoder)
6485	if err != nil {
6486		var snapshot bytes.Buffer
6487		io.Copy(&snapshot, ringBuffer)
6488		err = &smithy.DeserializationError{
6489			Err:      fmt.Errorf("failed to decode response body, %w", err),
6490			Snapshot: snapshot.Bytes(),
6491		}
6492		return err
6493	}
6494
6495	errorBody.Seek(0, io.SeekStart)
6496	if len(code) != 0 {
6497		errorCode = restjson.SanitizeErrorCode(code)
6498	}
6499	if len(message) != 0 {
6500		errorMessage = message
6501	}
6502
6503	switch {
6504	case strings.EqualFold("AccessDeniedException", errorCode):
6505		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6506
6507	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6508		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6509
6510	case strings.EqualFold("InvalidInputException", errorCode):
6511		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6512
6513	case strings.EqualFold("NotFoundException", errorCode):
6514		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6515
6516	case strings.EqualFold("OperationFailureException", errorCode):
6517		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6518
6519	case strings.EqualFold("ServiceException", errorCode):
6520		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6521
6522	case strings.EqualFold("UnauthenticatedException", errorCode):
6523		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6524
6525	default:
6526		genericError := &smithy.GenericAPIError{
6527			Code:    errorCode,
6528			Message: errorMessage,
6529		}
6530		return genericError
6531
6532	}
6533}
6534
6535type awsAwsjson11_deserializeOpDetachStaticIp struct {
6536}
6537
6538func (*awsAwsjson11_deserializeOpDetachStaticIp) ID() string {
6539	return "OperationDeserializer"
6540}
6541
6542func (m *awsAwsjson11_deserializeOpDetachStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6543	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6544) {
6545	out, metadata, err = next.HandleDeserialize(ctx, in)
6546	if err != nil {
6547		return out, metadata, err
6548	}
6549
6550	response, ok := out.RawResponse.(*smithyhttp.Response)
6551	if !ok {
6552		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6553	}
6554
6555	if response.StatusCode < 200 || response.StatusCode >= 300 {
6556		return out, metadata, awsAwsjson11_deserializeOpErrorDetachStaticIp(response, &metadata)
6557	}
6558	output := &DetachStaticIpOutput{}
6559	out.Result = output
6560
6561	var buff [1024]byte
6562	ringBuffer := smithyio.NewRingBuffer(buff[:])
6563
6564	body := io.TeeReader(response.Body, ringBuffer)
6565	decoder := json.NewDecoder(body)
6566	decoder.UseNumber()
6567	var shape interface{}
6568	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6569		var snapshot bytes.Buffer
6570		io.Copy(&snapshot, ringBuffer)
6571		err = &smithy.DeserializationError{
6572			Err:      fmt.Errorf("failed to decode response body, %w", err),
6573			Snapshot: snapshot.Bytes(),
6574		}
6575		return out, metadata, err
6576	}
6577
6578	err = awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(&output, shape)
6579	if err != nil {
6580		var snapshot bytes.Buffer
6581		io.Copy(&snapshot, ringBuffer)
6582		err = &smithy.DeserializationError{
6583			Err:      fmt.Errorf("failed to decode response body, %w", err),
6584			Snapshot: snapshot.Bytes(),
6585		}
6586		return out, metadata, err
6587	}
6588
6589	return out, metadata, err
6590}
6591
6592func awsAwsjson11_deserializeOpErrorDetachStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6593	var errorBuffer bytes.Buffer
6594	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6595		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6596	}
6597	errorBody := bytes.NewReader(errorBuffer.Bytes())
6598
6599	errorCode := "UnknownError"
6600	errorMessage := errorCode
6601
6602	code := response.Header.Get("X-Amzn-ErrorType")
6603	if len(code) != 0 {
6604		errorCode = restjson.SanitizeErrorCode(code)
6605	}
6606
6607	var buff [1024]byte
6608	ringBuffer := smithyio.NewRingBuffer(buff[:])
6609
6610	body := io.TeeReader(errorBody, ringBuffer)
6611	decoder := json.NewDecoder(body)
6612	decoder.UseNumber()
6613	code, message, err := restjson.GetErrorInfo(decoder)
6614	if err != nil {
6615		var snapshot bytes.Buffer
6616		io.Copy(&snapshot, ringBuffer)
6617		err = &smithy.DeserializationError{
6618			Err:      fmt.Errorf("failed to decode response body, %w", err),
6619			Snapshot: snapshot.Bytes(),
6620		}
6621		return err
6622	}
6623
6624	errorBody.Seek(0, io.SeekStart)
6625	if len(code) != 0 {
6626		errorCode = restjson.SanitizeErrorCode(code)
6627	}
6628	if len(message) != 0 {
6629		errorMessage = message
6630	}
6631
6632	switch {
6633	case strings.EqualFold("AccessDeniedException", errorCode):
6634		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6635
6636	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6637		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6638
6639	case strings.EqualFold("InvalidInputException", errorCode):
6640		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6641
6642	case strings.EqualFold("NotFoundException", errorCode):
6643		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6644
6645	case strings.EqualFold("OperationFailureException", errorCode):
6646		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6647
6648	case strings.EqualFold("ServiceException", errorCode):
6649		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6650
6651	case strings.EqualFold("UnauthenticatedException", errorCode):
6652		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6653
6654	default:
6655		genericError := &smithy.GenericAPIError{
6656			Code:    errorCode,
6657			Message: errorMessage,
6658		}
6659		return genericError
6660
6661	}
6662}
6663
6664type awsAwsjson11_deserializeOpDisableAddOn struct {
6665}
6666
6667func (*awsAwsjson11_deserializeOpDisableAddOn) ID() string {
6668	return "OperationDeserializer"
6669}
6670
6671func (m *awsAwsjson11_deserializeOpDisableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6672	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6673) {
6674	out, metadata, err = next.HandleDeserialize(ctx, in)
6675	if err != nil {
6676		return out, metadata, err
6677	}
6678
6679	response, ok := out.RawResponse.(*smithyhttp.Response)
6680	if !ok {
6681		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6682	}
6683
6684	if response.StatusCode < 200 || response.StatusCode >= 300 {
6685		return out, metadata, awsAwsjson11_deserializeOpErrorDisableAddOn(response, &metadata)
6686	}
6687	output := &DisableAddOnOutput{}
6688	out.Result = output
6689
6690	var buff [1024]byte
6691	ringBuffer := smithyio.NewRingBuffer(buff[:])
6692
6693	body := io.TeeReader(response.Body, ringBuffer)
6694	decoder := json.NewDecoder(body)
6695	decoder.UseNumber()
6696	var shape interface{}
6697	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6698		var snapshot bytes.Buffer
6699		io.Copy(&snapshot, ringBuffer)
6700		err = &smithy.DeserializationError{
6701			Err:      fmt.Errorf("failed to decode response body, %w", err),
6702			Snapshot: snapshot.Bytes(),
6703		}
6704		return out, metadata, err
6705	}
6706
6707	err = awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(&output, shape)
6708	if err != nil {
6709		var snapshot bytes.Buffer
6710		io.Copy(&snapshot, ringBuffer)
6711		err = &smithy.DeserializationError{
6712			Err:      fmt.Errorf("failed to decode response body, %w", err),
6713			Snapshot: snapshot.Bytes(),
6714		}
6715		return out, metadata, err
6716	}
6717
6718	return out, metadata, err
6719}
6720
6721func awsAwsjson11_deserializeOpErrorDisableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6722	var errorBuffer bytes.Buffer
6723	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6724		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6725	}
6726	errorBody := bytes.NewReader(errorBuffer.Bytes())
6727
6728	errorCode := "UnknownError"
6729	errorMessage := errorCode
6730
6731	code := response.Header.Get("X-Amzn-ErrorType")
6732	if len(code) != 0 {
6733		errorCode = restjson.SanitizeErrorCode(code)
6734	}
6735
6736	var buff [1024]byte
6737	ringBuffer := smithyio.NewRingBuffer(buff[:])
6738
6739	body := io.TeeReader(errorBody, ringBuffer)
6740	decoder := json.NewDecoder(body)
6741	decoder.UseNumber()
6742	code, message, err := restjson.GetErrorInfo(decoder)
6743	if err != nil {
6744		var snapshot bytes.Buffer
6745		io.Copy(&snapshot, ringBuffer)
6746		err = &smithy.DeserializationError{
6747			Err:      fmt.Errorf("failed to decode response body, %w", err),
6748			Snapshot: snapshot.Bytes(),
6749		}
6750		return err
6751	}
6752
6753	errorBody.Seek(0, io.SeekStart)
6754	if len(code) != 0 {
6755		errorCode = restjson.SanitizeErrorCode(code)
6756	}
6757	if len(message) != 0 {
6758		errorMessage = message
6759	}
6760
6761	switch {
6762	case strings.EqualFold("AccessDeniedException", errorCode):
6763		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6764
6765	case strings.EqualFold("InvalidInputException", errorCode):
6766		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6767
6768	case strings.EqualFold("NotFoundException", errorCode):
6769		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6770
6771	case strings.EqualFold("OperationFailureException", errorCode):
6772		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6773
6774	case strings.EqualFold("ServiceException", errorCode):
6775		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6776
6777	case strings.EqualFold("UnauthenticatedException", errorCode):
6778		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6779
6780	default:
6781		genericError := &smithy.GenericAPIError{
6782			Code:    errorCode,
6783			Message: errorMessage,
6784		}
6785		return genericError
6786
6787	}
6788}
6789
6790type awsAwsjson11_deserializeOpDownloadDefaultKeyPair struct {
6791}
6792
6793func (*awsAwsjson11_deserializeOpDownloadDefaultKeyPair) ID() string {
6794	return "OperationDeserializer"
6795}
6796
6797func (m *awsAwsjson11_deserializeOpDownloadDefaultKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6798	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6799) {
6800	out, metadata, err = next.HandleDeserialize(ctx, in)
6801	if err != nil {
6802		return out, metadata, err
6803	}
6804
6805	response, ok := out.RawResponse.(*smithyhttp.Response)
6806	if !ok {
6807		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6808	}
6809
6810	if response.StatusCode < 200 || response.StatusCode >= 300 {
6811		return out, metadata, awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response, &metadata)
6812	}
6813	output := &DownloadDefaultKeyPairOutput{}
6814	out.Result = output
6815
6816	var buff [1024]byte
6817	ringBuffer := smithyio.NewRingBuffer(buff[:])
6818
6819	body := io.TeeReader(response.Body, ringBuffer)
6820	decoder := json.NewDecoder(body)
6821	decoder.UseNumber()
6822	var shape interface{}
6823	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6824		var snapshot bytes.Buffer
6825		io.Copy(&snapshot, ringBuffer)
6826		err = &smithy.DeserializationError{
6827			Err:      fmt.Errorf("failed to decode response body, %w", err),
6828			Snapshot: snapshot.Bytes(),
6829		}
6830		return out, metadata, err
6831	}
6832
6833	err = awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(&output, shape)
6834	if err != nil {
6835		var snapshot bytes.Buffer
6836		io.Copy(&snapshot, ringBuffer)
6837		err = &smithy.DeserializationError{
6838			Err:      fmt.Errorf("failed to decode response body, %w", err),
6839			Snapshot: snapshot.Bytes(),
6840		}
6841		return out, metadata, err
6842	}
6843
6844	return out, metadata, err
6845}
6846
6847func awsAwsjson11_deserializeOpErrorDownloadDefaultKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6848	var errorBuffer bytes.Buffer
6849	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6850		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6851	}
6852	errorBody := bytes.NewReader(errorBuffer.Bytes())
6853
6854	errorCode := "UnknownError"
6855	errorMessage := errorCode
6856
6857	code := response.Header.Get("X-Amzn-ErrorType")
6858	if len(code) != 0 {
6859		errorCode = restjson.SanitizeErrorCode(code)
6860	}
6861
6862	var buff [1024]byte
6863	ringBuffer := smithyio.NewRingBuffer(buff[:])
6864
6865	body := io.TeeReader(errorBody, ringBuffer)
6866	decoder := json.NewDecoder(body)
6867	decoder.UseNumber()
6868	code, message, err := restjson.GetErrorInfo(decoder)
6869	if err != nil {
6870		var snapshot bytes.Buffer
6871		io.Copy(&snapshot, ringBuffer)
6872		err = &smithy.DeserializationError{
6873			Err:      fmt.Errorf("failed to decode response body, %w", err),
6874			Snapshot: snapshot.Bytes(),
6875		}
6876		return err
6877	}
6878
6879	errorBody.Seek(0, io.SeekStart)
6880	if len(code) != 0 {
6881		errorCode = restjson.SanitizeErrorCode(code)
6882	}
6883	if len(message) != 0 {
6884		errorMessage = message
6885	}
6886
6887	switch {
6888	case strings.EqualFold("AccessDeniedException", errorCode):
6889		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6890
6891	case strings.EqualFold("AccountSetupInProgressException", errorCode):
6892		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
6893
6894	case strings.EqualFold("InvalidInputException", errorCode):
6895		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6896
6897	case strings.EqualFold("NotFoundException", errorCode):
6898		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
6899
6900	case strings.EqualFold("OperationFailureException", errorCode):
6901		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
6902
6903	case strings.EqualFold("ServiceException", errorCode):
6904		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6905
6906	case strings.EqualFold("UnauthenticatedException", errorCode):
6907		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
6908
6909	default:
6910		genericError := &smithy.GenericAPIError{
6911			Code:    errorCode,
6912			Message: errorMessage,
6913		}
6914		return genericError
6915
6916	}
6917}
6918
6919type awsAwsjson11_deserializeOpEnableAddOn struct {
6920}
6921
6922func (*awsAwsjson11_deserializeOpEnableAddOn) ID() string {
6923	return "OperationDeserializer"
6924}
6925
6926func (m *awsAwsjson11_deserializeOpEnableAddOn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6927	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6928) {
6929	out, metadata, err = next.HandleDeserialize(ctx, in)
6930	if err != nil {
6931		return out, metadata, err
6932	}
6933
6934	response, ok := out.RawResponse.(*smithyhttp.Response)
6935	if !ok {
6936		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6937	}
6938
6939	if response.StatusCode < 200 || response.StatusCode >= 300 {
6940		return out, metadata, awsAwsjson11_deserializeOpErrorEnableAddOn(response, &metadata)
6941	}
6942	output := &EnableAddOnOutput{}
6943	out.Result = output
6944
6945	var buff [1024]byte
6946	ringBuffer := smithyio.NewRingBuffer(buff[:])
6947
6948	body := io.TeeReader(response.Body, ringBuffer)
6949	decoder := json.NewDecoder(body)
6950	decoder.UseNumber()
6951	var shape interface{}
6952	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6953		var snapshot bytes.Buffer
6954		io.Copy(&snapshot, ringBuffer)
6955		err = &smithy.DeserializationError{
6956			Err:      fmt.Errorf("failed to decode response body, %w", err),
6957			Snapshot: snapshot.Bytes(),
6958		}
6959		return out, metadata, err
6960	}
6961
6962	err = awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(&output, shape)
6963	if err != nil {
6964		var snapshot bytes.Buffer
6965		io.Copy(&snapshot, ringBuffer)
6966		err = &smithy.DeserializationError{
6967			Err:      fmt.Errorf("failed to decode response body, %w", err),
6968			Snapshot: snapshot.Bytes(),
6969		}
6970		return out, metadata, err
6971	}
6972
6973	return out, metadata, err
6974}
6975
6976func awsAwsjson11_deserializeOpErrorEnableAddOn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6977	var errorBuffer bytes.Buffer
6978	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6979		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6980	}
6981	errorBody := bytes.NewReader(errorBuffer.Bytes())
6982
6983	errorCode := "UnknownError"
6984	errorMessage := errorCode
6985
6986	code := response.Header.Get("X-Amzn-ErrorType")
6987	if len(code) != 0 {
6988		errorCode = restjson.SanitizeErrorCode(code)
6989	}
6990
6991	var buff [1024]byte
6992	ringBuffer := smithyio.NewRingBuffer(buff[:])
6993
6994	body := io.TeeReader(errorBody, ringBuffer)
6995	decoder := json.NewDecoder(body)
6996	decoder.UseNumber()
6997	code, message, err := restjson.GetErrorInfo(decoder)
6998	if err != nil {
6999		var snapshot bytes.Buffer
7000		io.Copy(&snapshot, ringBuffer)
7001		err = &smithy.DeserializationError{
7002			Err:      fmt.Errorf("failed to decode response body, %w", err),
7003			Snapshot: snapshot.Bytes(),
7004		}
7005		return err
7006	}
7007
7008	errorBody.Seek(0, io.SeekStart)
7009	if len(code) != 0 {
7010		errorCode = restjson.SanitizeErrorCode(code)
7011	}
7012	if len(message) != 0 {
7013		errorMessage = message
7014	}
7015
7016	switch {
7017	case strings.EqualFold("AccessDeniedException", errorCode):
7018		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7019
7020	case strings.EqualFold("InvalidInputException", errorCode):
7021		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7022
7023	case strings.EqualFold("NotFoundException", errorCode):
7024		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7025
7026	case strings.EqualFold("OperationFailureException", errorCode):
7027		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7028
7029	case strings.EqualFold("ServiceException", errorCode):
7030		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7031
7032	case strings.EqualFold("UnauthenticatedException", errorCode):
7033		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7034
7035	default:
7036		genericError := &smithy.GenericAPIError{
7037			Code:    errorCode,
7038			Message: errorMessage,
7039		}
7040		return genericError
7041
7042	}
7043}
7044
7045type awsAwsjson11_deserializeOpExportSnapshot struct {
7046}
7047
7048func (*awsAwsjson11_deserializeOpExportSnapshot) ID() string {
7049	return "OperationDeserializer"
7050}
7051
7052func (m *awsAwsjson11_deserializeOpExportSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7053	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7054) {
7055	out, metadata, err = next.HandleDeserialize(ctx, in)
7056	if err != nil {
7057		return out, metadata, err
7058	}
7059
7060	response, ok := out.RawResponse.(*smithyhttp.Response)
7061	if !ok {
7062		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7063	}
7064
7065	if response.StatusCode < 200 || response.StatusCode >= 300 {
7066		return out, metadata, awsAwsjson11_deserializeOpErrorExportSnapshot(response, &metadata)
7067	}
7068	output := &ExportSnapshotOutput{}
7069	out.Result = output
7070
7071	var buff [1024]byte
7072	ringBuffer := smithyio.NewRingBuffer(buff[:])
7073
7074	body := io.TeeReader(response.Body, ringBuffer)
7075	decoder := json.NewDecoder(body)
7076	decoder.UseNumber()
7077	var shape interface{}
7078	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7079		var snapshot bytes.Buffer
7080		io.Copy(&snapshot, ringBuffer)
7081		err = &smithy.DeserializationError{
7082			Err:      fmt.Errorf("failed to decode response body, %w", err),
7083			Snapshot: snapshot.Bytes(),
7084		}
7085		return out, metadata, err
7086	}
7087
7088	err = awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(&output, shape)
7089	if err != nil {
7090		var snapshot bytes.Buffer
7091		io.Copy(&snapshot, ringBuffer)
7092		err = &smithy.DeserializationError{
7093			Err:      fmt.Errorf("failed to decode response body, %w", err),
7094			Snapshot: snapshot.Bytes(),
7095		}
7096		return out, metadata, err
7097	}
7098
7099	return out, metadata, err
7100}
7101
7102func awsAwsjson11_deserializeOpErrorExportSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7103	var errorBuffer bytes.Buffer
7104	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7105		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7106	}
7107	errorBody := bytes.NewReader(errorBuffer.Bytes())
7108
7109	errorCode := "UnknownError"
7110	errorMessage := errorCode
7111
7112	code := response.Header.Get("X-Amzn-ErrorType")
7113	if len(code) != 0 {
7114		errorCode = restjson.SanitizeErrorCode(code)
7115	}
7116
7117	var buff [1024]byte
7118	ringBuffer := smithyio.NewRingBuffer(buff[:])
7119
7120	body := io.TeeReader(errorBody, ringBuffer)
7121	decoder := json.NewDecoder(body)
7122	decoder.UseNumber()
7123	code, message, err := restjson.GetErrorInfo(decoder)
7124	if err != nil {
7125		var snapshot bytes.Buffer
7126		io.Copy(&snapshot, ringBuffer)
7127		err = &smithy.DeserializationError{
7128			Err:      fmt.Errorf("failed to decode response body, %w", err),
7129			Snapshot: snapshot.Bytes(),
7130		}
7131		return err
7132	}
7133
7134	errorBody.Seek(0, io.SeekStart)
7135	if len(code) != 0 {
7136		errorCode = restjson.SanitizeErrorCode(code)
7137	}
7138	if len(message) != 0 {
7139		errorMessage = message
7140	}
7141
7142	switch {
7143	case strings.EqualFold("AccessDeniedException", errorCode):
7144		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7145
7146	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7147		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7148
7149	case strings.EqualFold("InvalidInputException", errorCode):
7150		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7151
7152	case strings.EqualFold("NotFoundException", errorCode):
7153		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7154
7155	case strings.EqualFold("OperationFailureException", errorCode):
7156		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7157
7158	case strings.EqualFold("ServiceException", errorCode):
7159		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7160
7161	case strings.EqualFold("UnauthenticatedException", errorCode):
7162		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7163
7164	default:
7165		genericError := &smithy.GenericAPIError{
7166			Code:    errorCode,
7167			Message: errorMessage,
7168		}
7169		return genericError
7170
7171	}
7172}
7173
7174type awsAwsjson11_deserializeOpGetActiveNames struct {
7175}
7176
7177func (*awsAwsjson11_deserializeOpGetActiveNames) ID() string {
7178	return "OperationDeserializer"
7179}
7180
7181func (m *awsAwsjson11_deserializeOpGetActiveNames) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7182	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7183) {
7184	out, metadata, err = next.HandleDeserialize(ctx, in)
7185	if err != nil {
7186		return out, metadata, err
7187	}
7188
7189	response, ok := out.RawResponse.(*smithyhttp.Response)
7190	if !ok {
7191		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7192	}
7193
7194	if response.StatusCode < 200 || response.StatusCode >= 300 {
7195		return out, metadata, awsAwsjson11_deserializeOpErrorGetActiveNames(response, &metadata)
7196	}
7197	output := &GetActiveNamesOutput{}
7198	out.Result = output
7199
7200	var buff [1024]byte
7201	ringBuffer := smithyio.NewRingBuffer(buff[:])
7202
7203	body := io.TeeReader(response.Body, ringBuffer)
7204	decoder := json.NewDecoder(body)
7205	decoder.UseNumber()
7206	var shape interface{}
7207	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7208		var snapshot bytes.Buffer
7209		io.Copy(&snapshot, ringBuffer)
7210		err = &smithy.DeserializationError{
7211			Err:      fmt.Errorf("failed to decode response body, %w", err),
7212			Snapshot: snapshot.Bytes(),
7213		}
7214		return out, metadata, err
7215	}
7216
7217	err = awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(&output, shape)
7218	if err != nil {
7219		var snapshot bytes.Buffer
7220		io.Copy(&snapshot, ringBuffer)
7221		err = &smithy.DeserializationError{
7222			Err:      fmt.Errorf("failed to decode response body, %w", err),
7223			Snapshot: snapshot.Bytes(),
7224		}
7225		return out, metadata, err
7226	}
7227
7228	return out, metadata, err
7229}
7230
7231func awsAwsjson11_deserializeOpErrorGetActiveNames(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7232	var errorBuffer bytes.Buffer
7233	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7234		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7235	}
7236	errorBody := bytes.NewReader(errorBuffer.Bytes())
7237
7238	errorCode := "UnknownError"
7239	errorMessage := errorCode
7240
7241	code := response.Header.Get("X-Amzn-ErrorType")
7242	if len(code) != 0 {
7243		errorCode = restjson.SanitizeErrorCode(code)
7244	}
7245
7246	var buff [1024]byte
7247	ringBuffer := smithyio.NewRingBuffer(buff[:])
7248
7249	body := io.TeeReader(errorBody, ringBuffer)
7250	decoder := json.NewDecoder(body)
7251	decoder.UseNumber()
7252	code, message, err := restjson.GetErrorInfo(decoder)
7253	if err != nil {
7254		var snapshot bytes.Buffer
7255		io.Copy(&snapshot, ringBuffer)
7256		err = &smithy.DeserializationError{
7257			Err:      fmt.Errorf("failed to decode response body, %w", err),
7258			Snapshot: snapshot.Bytes(),
7259		}
7260		return err
7261	}
7262
7263	errorBody.Seek(0, io.SeekStart)
7264	if len(code) != 0 {
7265		errorCode = restjson.SanitizeErrorCode(code)
7266	}
7267	if len(message) != 0 {
7268		errorMessage = message
7269	}
7270
7271	switch {
7272	case strings.EqualFold("AccessDeniedException", errorCode):
7273		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7274
7275	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7276		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7277
7278	case strings.EqualFold("InvalidInputException", errorCode):
7279		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7280
7281	case strings.EqualFold("NotFoundException", errorCode):
7282		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7283
7284	case strings.EqualFold("OperationFailureException", errorCode):
7285		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7286
7287	case strings.EqualFold("ServiceException", errorCode):
7288		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7289
7290	case strings.EqualFold("UnauthenticatedException", errorCode):
7291		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7292
7293	default:
7294		genericError := &smithy.GenericAPIError{
7295			Code:    errorCode,
7296			Message: errorMessage,
7297		}
7298		return genericError
7299
7300	}
7301}
7302
7303type awsAwsjson11_deserializeOpGetAlarms struct {
7304}
7305
7306func (*awsAwsjson11_deserializeOpGetAlarms) ID() string {
7307	return "OperationDeserializer"
7308}
7309
7310func (m *awsAwsjson11_deserializeOpGetAlarms) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7311	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7312) {
7313	out, metadata, err = next.HandleDeserialize(ctx, in)
7314	if err != nil {
7315		return out, metadata, err
7316	}
7317
7318	response, ok := out.RawResponse.(*smithyhttp.Response)
7319	if !ok {
7320		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7321	}
7322
7323	if response.StatusCode < 200 || response.StatusCode >= 300 {
7324		return out, metadata, awsAwsjson11_deserializeOpErrorGetAlarms(response, &metadata)
7325	}
7326	output := &GetAlarmsOutput{}
7327	out.Result = output
7328
7329	var buff [1024]byte
7330	ringBuffer := smithyio.NewRingBuffer(buff[:])
7331
7332	body := io.TeeReader(response.Body, ringBuffer)
7333	decoder := json.NewDecoder(body)
7334	decoder.UseNumber()
7335	var shape interface{}
7336	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7337		var snapshot bytes.Buffer
7338		io.Copy(&snapshot, ringBuffer)
7339		err = &smithy.DeserializationError{
7340			Err:      fmt.Errorf("failed to decode response body, %w", err),
7341			Snapshot: snapshot.Bytes(),
7342		}
7343		return out, metadata, err
7344	}
7345
7346	err = awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(&output, shape)
7347	if err != nil {
7348		var snapshot bytes.Buffer
7349		io.Copy(&snapshot, ringBuffer)
7350		err = &smithy.DeserializationError{
7351			Err:      fmt.Errorf("failed to decode response body, %w", err),
7352			Snapshot: snapshot.Bytes(),
7353		}
7354		return out, metadata, err
7355	}
7356
7357	return out, metadata, err
7358}
7359
7360func awsAwsjson11_deserializeOpErrorGetAlarms(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7361	var errorBuffer bytes.Buffer
7362	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7363		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7364	}
7365	errorBody := bytes.NewReader(errorBuffer.Bytes())
7366
7367	errorCode := "UnknownError"
7368	errorMessage := errorCode
7369
7370	code := response.Header.Get("X-Amzn-ErrorType")
7371	if len(code) != 0 {
7372		errorCode = restjson.SanitizeErrorCode(code)
7373	}
7374
7375	var buff [1024]byte
7376	ringBuffer := smithyio.NewRingBuffer(buff[:])
7377
7378	body := io.TeeReader(errorBody, ringBuffer)
7379	decoder := json.NewDecoder(body)
7380	decoder.UseNumber()
7381	code, message, err := restjson.GetErrorInfo(decoder)
7382	if err != nil {
7383		var snapshot bytes.Buffer
7384		io.Copy(&snapshot, ringBuffer)
7385		err = &smithy.DeserializationError{
7386			Err:      fmt.Errorf("failed to decode response body, %w", err),
7387			Snapshot: snapshot.Bytes(),
7388		}
7389		return err
7390	}
7391
7392	errorBody.Seek(0, io.SeekStart)
7393	if len(code) != 0 {
7394		errorCode = restjson.SanitizeErrorCode(code)
7395	}
7396	if len(message) != 0 {
7397		errorMessage = message
7398	}
7399
7400	switch {
7401	case strings.EqualFold("AccessDeniedException", errorCode):
7402		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7403
7404	case strings.EqualFold("InvalidInputException", errorCode):
7405		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7406
7407	case strings.EqualFold("NotFoundException", errorCode):
7408		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7409
7410	case strings.EqualFold("OperationFailureException", errorCode):
7411		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7412
7413	case strings.EqualFold("ServiceException", errorCode):
7414		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7415
7416	case strings.EqualFold("UnauthenticatedException", errorCode):
7417		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7418
7419	default:
7420		genericError := &smithy.GenericAPIError{
7421			Code:    errorCode,
7422			Message: errorMessage,
7423		}
7424		return genericError
7425
7426	}
7427}
7428
7429type awsAwsjson11_deserializeOpGetAutoSnapshots struct {
7430}
7431
7432func (*awsAwsjson11_deserializeOpGetAutoSnapshots) ID() string {
7433	return "OperationDeserializer"
7434}
7435
7436func (m *awsAwsjson11_deserializeOpGetAutoSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7437	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7438) {
7439	out, metadata, err = next.HandleDeserialize(ctx, in)
7440	if err != nil {
7441		return out, metadata, err
7442	}
7443
7444	response, ok := out.RawResponse.(*smithyhttp.Response)
7445	if !ok {
7446		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7447	}
7448
7449	if response.StatusCode < 200 || response.StatusCode >= 300 {
7450		return out, metadata, awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response, &metadata)
7451	}
7452	output := &GetAutoSnapshotsOutput{}
7453	out.Result = output
7454
7455	var buff [1024]byte
7456	ringBuffer := smithyio.NewRingBuffer(buff[:])
7457
7458	body := io.TeeReader(response.Body, ringBuffer)
7459	decoder := json.NewDecoder(body)
7460	decoder.UseNumber()
7461	var shape interface{}
7462	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7463		var snapshot bytes.Buffer
7464		io.Copy(&snapshot, ringBuffer)
7465		err = &smithy.DeserializationError{
7466			Err:      fmt.Errorf("failed to decode response body, %w", err),
7467			Snapshot: snapshot.Bytes(),
7468		}
7469		return out, metadata, err
7470	}
7471
7472	err = awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(&output, shape)
7473	if err != nil {
7474		var snapshot bytes.Buffer
7475		io.Copy(&snapshot, ringBuffer)
7476		err = &smithy.DeserializationError{
7477			Err:      fmt.Errorf("failed to decode response body, %w", err),
7478			Snapshot: snapshot.Bytes(),
7479		}
7480		return out, metadata, err
7481	}
7482
7483	return out, metadata, err
7484}
7485
7486func awsAwsjson11_deserializeOpErrorGetAutoSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7487	var errorBuffer bytes.Buffer
7488	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7489		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7490	}
7491	errorBody := bytes.NewReader(errorBuffer.Bytes())
7492
7493	errorCode := "UnknownError"
7494	errorMessage := errorCode
7495
7496	code := response.Header.Get("X-Amzn-ErrorType")
7497	if len(code) != 0 {
7498		errorCode = restjson.SanitizeErrorCode(code)
7499	}
7500
7501	var buff [1024]byte
7502	ringBuffer := smithyio.NewRingBuffer(buff[:])
7503
7504	body := io.TeeReader(errorBody, ringBuffer)
7505	decoder := json.NewDecoder(body)
7506	decoder.UseNumber()
7507	code, message, err := restjson.GetErrorInfo(decoder)
7508	if err != nil {
7509		var snapshot bytes.Buffer
7510		io.Copy(&snapshot, ringBuffer)
7511		err = &smithy.DeserializationError{
7512			Err:      fmt.Errorf("failed to decode response body, %w", err),
7513			Snapshot: snapshot.Bytes(),
7514		}
7515		return err
7516	}
7517
7518	errorBody.Seek(0, io.SeekStart)
7519	if len(code) != 0 {
7520		errorCode = restjson.SanitizeErrorCode(code)
7521	}
7522	if len(message) != 0 {
7523		errorMessage = message
7524	}
7525
7526	switch {
7527	case strings.EqualFold("AccessDeniedException", errorCode):
7528		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7529
7530	case strings.EqualFold("InvalidInputException", errorCode):
7531		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7532
7533	case strings.EqualFold("NotFoundException", errorCode):
7534		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7535
7536	case strings.EqualFold("OperationFailureException", errorCode):
7537		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7538
7539	case strings.EqualFold("ServiceException", errorCode):
7540		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7541
7542	case strings.EqualFold("UnauthenticatedException", errorCode):
7543		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7544
7545	default:
7546		genericError := &smithy.GenericAPIError{
7547			Code:    errorCode,
7548			Message: errorMessage,
7549		}
7550		return genericError
7551
7552	}
7553}
7554
7555type awsAwsjson11_deserializeOpGetBlueprints struct {
7556}
7557
7558func (*awsAwsjson11_deserializeOpGetBlueprints) ID() string {
7559	return "OperationDeserializer"
7560}
7561
7562func (m *awsAwsjson11_deserializeOpGetBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7563	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7564) {
7565	out, metadata, err = next.HandleDeserialize(ctx, in)
7566	if err != nil {
7567		return out, metadata, err
7568	}
7569
7570	response, ok := out.RawResponse.(*smithyhttp.Response)
7571	if !ok {
7572		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7573	}
7574
7575	if response.StatusCode < 200 || response.StatusCode >= 300 {
7576		return out, metadata, awsAwsjson11_deserializeOpErrorGetBlueprints(response, &metadata)
7577	}
7578	output := &GetBlueprintsOutput{}
7579	out.Result = output
7580
7581	var buff [1024]byte
7582	ringBuffer := smithyio.NewRingBuffer(buff[:])
7583
7584	body := io.TeeReader(response.Body, ringBuffer)
7585	decoder := json.NewDecoder(body)
7586	decoder.UseNumber()
7587	var shape interface{}
7588	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7589		var snapshot bytes.Buffer
7590		io.Copy(&snapshot, ringBuffer)
7591		err = &smithy.DeserializationError{
7592			Err:      fmt.Errorf("failed to decode response body, %w", err),
7593			Snapshot: snapshot.Bytes(),
7594		}
7595		return out, metadata, err
7596	}
7597
7598	err = awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(&output, shape)
7599	if err != nil {
7600		var snapshot bytes.Buffer
7601		io.Copy(&snapshot, ringBuffer)
7602		err = &smithy.DeserializationError{
7603			Err:      fmt.Errorf("failed to decode response body, %w", err),
7604			Snapshot: snapshot.Bytes(),
7605		}
7606		return out, metadata, err
7607	}
7608
7609	return out, metadata, err
7610}
7611
7612func awsAwsjson11_deserializeOpErrorGetBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7613	var errorBuffer bytes.Buffer
7614	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7615		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7616	}
7617	errorBody := bytes.NewReader(errorBuffer.Bytes())
7618
7619	errorCode := "UnknownError"
7620	errorMessage := errorCode
7621
7622	code := response.Header.Get("X-Amzn-ErrorType")
7623	if len(code) != 0 {
7624		errorCode = restjson.SanitizeErrorCode(code)
7625	}
7626
7627	var buff [1024]byte
7628	ringBuffer := smithyio.NewRingBuffer(buff[:])
7629
7630	body := io.TeeReader(errorBody, ringBuffer)
7631	decoder := json.NewDecoder(body)
7632	decoder.UseNumber()
7633	code, message, err := restjson.GetErrorInfo(decoder)
7634	if err != nil {
7635		var snapshot bytes.Buffer
7636		io.Copy(&snapshot, ringBuffer)
7637		err = &smithy.DeserializationError{
7638			Err:      fmt.Errorf("failed to decode response body, %w", err),
7639			Snapshot: snapshot.Bytes(),
7640		}
7641		return err
7642	}
7643
7644	errorBody.Seek(0, io.SeekStart)
7645	if len(code) != 0 {
7646		errorCode = restjson.SanitizeErrorCode(code)
7647	}
7648	if len(message) != 0 {
7649		errorMessage = message
7650	}
7651
7652	switch {
7653	case strings.EqualFold("AccessDeniedException", errorCode):
7654		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7655
7656	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7657		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7658
7659	case strings.EqualFold("InvalidInputException", errorCode):
7660		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7661
7662	case strings.EqualFold("NotFoundException", errorCode):
7663		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7664
7665	case strings.EqualFold("OperationFailureException", errorCode):
7666		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7667
7668	case strings.EqualFold("ServiceException", errorCode):
7669		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7670
7671	case strings.EqualFold("UnauthenticatedException", errorCode):
7672		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7673
7674	default:
7675		genericError := &smithy.GenericAPIError{
7676			Code:    errorCode,
7677			Message: errorMessage,
7678		}
7679		return genericError
7680
7681	}
7682}
7683
7684type awsAwsjson11_deserializeOpGetBundles struct {
7685}
7686
7687func (*awsAwsjson11_deserializeOpGetBundles) ID() string {
7688	return "OperationDeserializer"
7689}
7690
7691func (m *awsAwsjson11_deserializeOpGetBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7692	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7693) {
7694	out, metadata, err = next.HandleDeserialize(ctx, in)
7695	if err != nil {
7696		return out, metadata, err
7697	}
7698
7699	response, ok := out.RawResponse.(*smithyhttp.Response)
7700	if !ok {
7701		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7702	}
7703
7704	if response.StatusCode < 200 || response.StatusCode >= 300 {
7705		return out, metadata, awsAwsjson11_deserializeOpErrorGetBundles(response, &metadata)
7706	}
7707	output := &GetBundlesOutput{}
7708	out.Result = output
7709
7710	var buff [1024]byte
7711	ringBuffer := smithyio.NewRingBuffer(buff[:])
7712
7713	body := io.TeeReader(response.Body, ringBuffer)
7714	decoder := json.NewDecoder(body)
7715	decoder.UseNumber()
7716	var shape interface{}
7717	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7718		var snapshot bytes.Buffer
7719		io.Copy(&snapshot, ringBuffer)
7720		err = &smithy.DeserializationError{
7721			Err:      fmt.Errorf("failed to decode response body, %w", err),
7722			Snapshot: snapshot.Bytes(),
7723		}
7724		return out, metadata, err
7725	}
7726
7727	err = awsAwsjson11_deserializeOpDocumentGetBundlesOutput(&output, shape)
7728	if err != nil {
7729		var snapshot bytes.Buffer
7730		io.Copy(&snapshot, ringBuffer)
7731		err = &smithy.DeserializationError{
7732			Err:      fmt.Errorf("failed to decode response body, %w", err),
7733			Snapshot: snapshot.Bytes(),
7734		}
7735		return out, metadata, err
7736	}
7737
7738	return out, metadata, err
7739}
7740
7741func awsAwsjson11_deserializeOpErrorGetBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7742	var errorBuffer bytes.Buffer
7743	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7744		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7745	}
7746	errorBody := bytes.NewReader(errorBuffer.Bytes())
7747
7748	errorCode := "UnknownError"
7749	errorMessage := errorCode
7750
7751	code := response.Header.Get("X-Amzn-ErrorType")
7752	if len(code) != 0 {
7753		errorCode = restjson.SanitizeErrorCode(code)
7754	}
7755
7756	var buff [1024]byte
7757	ringBuffer := smithyio.NewRingBuffer(buff[:])
7758
7759	body := io.TeeReader(errorBody, ringBuffer)
7760	decoder := json.NewDecoder(body)
7761	decoder.UseNumber()
7762	code, message, err := restjson.GetErrorInfo(decoder)
7763	if err != nil {
7764		var snapshot bytes.Buffer
7765		io.Copy(&snapshot, ringBuffer)
7766		err = &smithy.DeserializationError{
7767			Err:      fmt.Errorf("failed to decode response body, %w", err),
7768			Snapshot: snapshot.Bytes(),
7769		}
7770		return err
7771	}
7772
7773	errorBody.Seek(0, io.SeekStart)
7774	if len(code) != 0 {
7775		errorCode = restjson.SanitizeErrorCode(code)
7776	}
7777	if len(message) != 0 {
7778		errorMessage = message
7779	}
7780
7781	switch {
7782	case strings.EqualFold("AccessDeniedException", errorCode):
7783		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7784
7785	case strings.EqualFold("AccountSetupInProgressException", errorCode):
7786		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
7787
7788	case strings.EqualFold("InvalidInputException", errorCode):
7789		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7790
7791	case strings.EqualFold("NotFoundException", errorCode):
7792		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7793
7794	case strings.EqualFold("OperationFailureException", errorCode):
7795		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
7796
7797	case strings.EqualFold("ServiceException", errorCode):
7798		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7799
7800	case strings.EqualFold("UnauthenticatedException", errorCode):
7801		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7802
7803	default:
7804		genericError := &smithy.GenericAPIError{
7805			Code:    errorCode,
7806			Message: errorMessage,
7807		}
7808		return genericError
7809
7810	}
7811}
7812
7813type awsAwsjson11_deserializeOpGetCertificates struct {
7814}
7815
7816func (*awsAwsjson11_deserializeOpGetCertificates) ID() string {
7817	return "OperationDeserializer"
7818}
7819
7820func (m *awsAwsjson11_deserializeOpGetCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7821	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7822) {
7823	out, metadata, err = next.HandleDeserialize(ctx, in)
7824	if err != nil {
7825		return out, metadata, err
7826	}
7827
7828	response, ok := out.RawResponse.(*smithyhttp.Response)
7829	if !ok {
7830		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7831	}
7832
7833	if response.StatusCode < 200 || response.StatusCode >= 300 {
7834		return out, metadata, awsAwsjson11_deserializeOpErrorGetCertificates(response, &metadata)
7835	}
7836	output := &GetCertificatesOutput{}
7837	out.Result = output
7838
7839	var buff [1024]byte
7840	ringBuffer := smithyio.NewRingBuffer(buff[:])
7841
7842	body := io.TeeReader(response.Body, ringBuffer)
7843	decoder := json.NewDecoder(body)
7844	decoder.UseNumber()
7845	var shape interface{}
7846	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7847		var snapshot bytes.Buffer
7848		io.Copy(&snapshot, ringBuffer)
7849		err = &smithy.DeserializationError{
7850			Err:      fmt.Errorf("failed to decode response body, %w", err),
7851			Snapshot: snapshot.Bytes(),
7852		}
7853		return out, metadata, err
7854	}
7855
7856	err = awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(&output, shape)
7857	if err != nil {
7858		var snapshot bytes.Buffer
7859		io.Copy(&snapshot, ringBuffer)
7860		err = &smithy.DeserializationError{
7861			Err:      fmt.Errorf("failed to decode response body, %w", err),
7862			Snapshot: snapshot.Bytes(),
7863		}
7864		return out, metadata, err
7865	}
7866
7867	return out, metadata, err
7868}
7869
7870func awsAwsjson11_deserializeOpErrorGetCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7871	var errorBuffer bytes.Buffer
7872	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7873		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7874	}
7875	errorBody := bytes.NewReader(errorBuffer.Bytes())
7876
7877	errorCode := "UnknownError"
7878	errorMessage := errorCode
7879
7880	code := response.Header.Get("X-Amzn-ErrorType")
7881	if len(code) != 0 {
7882		errorCode = restjson.SanitizeErrorCode(code)
7883	}
7884
7885	var buff [1024]byte
7886	ringBuffer := smithyio.NewRingBuffer(buff[:])
7887
7888	body := io.TeeReader(errorBody, ringBuffer)
7889	decoder := json.NewDecoder(body)
7890	decoder.UseNumber()
7891	code, message, err := restjson.GetErrorInfo(decoder)
7892	if err != nil {
7893		var snapshot bytes.Buffer
7894		io.Copy(&snapshot, ringBuffer)
7895		err = &smithy.DeserializationError{
7896			Err:      fmt.Errorf("failed to decode response body, %w", err),
7897			Snapshot: snapshot.Bytes(),
7898		}
7899		return err
7900	}
7901
7902	errorBody.Seek(0, io.SeekStart)
7903	if len(code) != 0 {
7904		errorCode = restjson.SanitizeErrorCode(code)
7905	}
7906	if len(message) != 0 {
7907		errorMessage = message
7908	}
7909
7910	switch {
7911	case strings.EqualFold("AccessDeniedException", errorCode):
7912		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7913
7914	case strings.EqualFold("InvalidInputException", errorCode):
7915		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
7916
7917	case strings.EqualFold("NotFoundException", errorCode):
7918		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
7919
7920	case strings.EqualFold("ServiceException", errorCode):
7921		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
7922
7923	case strings.EqualFold("UnauthenticatedException", errorCode):
7924		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
7925
7926	default:
7927		genericError := &smithy.GenericAPIError{
7928			Code:    errorCode,
7929			Message: errorMessage,
7930		}
7931		return genericError
7932
7933	}
7934}
7935
7936type awsAwsjson11_deserializeOpGetCloudFormationStackRecords struct {
7937}
7938
7939func (*awsAwsjson11_deserializeOpGetCloudFormationStackRecords) ID() string {
7940	return "OperationDeserializer"
7941}
7942
7943func (m *awsAwsjson11_deserializeOpGetCloudFormationStackRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7944	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7945) {
7946	out, metadata, err = next.HandleDeserialize(ctx, in)
7947	if err != nil {
7948		return out, metadata, err
7949	}
7950
7951	response, ok := out.RawResponse.(*smithyhttp.Response)
7952	if !ok {
7953		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7954	}
7955
7956	if response.StatusCode < 200 || response.StatusCode >= 300 {
7957		return out, metadata, awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response, &metadata)
7958	}
7959	output := &GetCloudFormationStackRecordsOutput{}
7960	out.Result = output
7961
7962	var buff [1024]byte
7963	ringBuffer := smithyio.NewRingBuffer(buff[:])
7964
7965	body := io.TeeReader(response.Body, ringBuffer)
7966	decoder := json.NewDecoder(body)
7967	decoder.UseNumber()
7968	var shape interface{}
7969	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7970		var snapshot bytes.Buffer
7971		io.Copy(&snapshot, ringBuffer)
7972		err = &smithy.DeserializationError{
7973			Err:      fmt.Errorf("failed to decode response body, %w", err),
7974			Snapshot: snapshot.Bytes(),
7975		}
7976		return out, metadata, err
7977	}
7978
7979	err = awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(&output, shape)
7980	if err != nil {
7981		var snapshot bytes.Buffer
7982		io.Copy(&snapshot, ringBuffer)
7983		err = &smithy.DeserializationError{
7984			Err:      fmt.Errorf("failed to decode response body, %w", err),
7985			Snapshot: snapshot.Bytes(),
7986		}
7987		return out, metadata, err
7988	}
7989
7990	return out, metadata, err
7991}
7992
7993func awsAwsjson11_deserializeOpErrorGetCloudFormationStackRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7994	var errorBuffer bytes.Buffer
7995	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7996		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7997	}
7998	errorBody := bytes.NewReader(errorBuffer.Bytes())
7999
8000	errorCode := "UnknownError"
8001	errorMessage := errorCode
8002
8003	code := response.Header.Get("X-Amzn-ErrorType")
8004	if len(code) != 0 {
8005		errorCode = restjson.SanitizeErrorCode(code)
8006	}
8007
8008	var buff [1024]byte
8009	ringBuffer := smithyio.NewRingBuffer(buff[:])
8010
8011	body := io.TeeReader(errorBody, ringBuffer)
8012	decoder := json.NewDecoder(body)
8013	decoder.UseNumber()
8014	code, message, err := restjson.GetErrorInfo(decoder)
8015	if err != nil {
8016		var snapshot bytes.Buffer
8017		io.Copy(&snapshot, ringBuffer)
8018		err = &smithy.DeserializationError{
8019			Err:      fmt.Errorf("failed to decode response body, %w", err),
8020			Snapshot: snapshot.Bytes(),
8021		}
8022		return err
8023	}
8024
8025	errorBody.Seek(0, io.SeekStart)
8026	if len(code) != 0 {
8027		errorCode = restjson.SanitizeErrorCode(code)
8028	}
8029	if len(message) != 0 {
8030		errorMessage = message
8031	}
8032
8033	switch {
8034	case strings.EqualFold("AccessDeniedException", errorCode):
8035		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8036
8037	case strings.EqualFold("AccountSetupInProgressException", errorCode):
8038		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
8039
8040	case strings.EqualFold("InvalidInputException", errorCode):
8041		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8042
8043	case strings.EqualFold("NotFoundException", errorCode):
8044		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8045
8046	case strings.EqualFold("OperationFailureException", errorCode):
8047		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8048
8049	case strings.EqualFold("ServiceException", errorCode):
8050		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8051
8052	case strings.EqualFold("UnauthenticatedException", errorCode):
8053		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8054
8055	default:
8056		genericError := &smithy.GenericAPIError{
8057			Code:    errorCode,
8058			Message: errorMessage,
8059		}
8060		return genericError
8061
8062	}
8063}
8064
8065type awsAwsjson11_deserializeOpGetContactMethods struct {
8066}
8067
8068func (*awsAwsjson11_deserializeOpGetContactMethods) ID() string {
8069	return "OperationDeserializer"
8070}
8071
8072func (m *awsAwsjson11_deserializeOpGetContactMethods) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8073	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8074) {
8075	out, metadata, err = next.HandleDeserialize(ctx, in)
8076	if err != nil {
8077		return out, metadata, err
8078	}
8079
8080	response, ok := out.RawResponse.(*smithyhttp.Response)
8081	if !ok {
8082		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8083	}
8084
8085	if response.StatusCode < 200 || response.StatusCode >= 300 {
8086		return out, metadata, awsAwsjson11_deserializeOpErrorGetContactMethods(response, &metadata)
8087	}
8088	output := &GetContactMethodsOutput{}
8089	out.Result = output
8090
8091	var buff [1024]byte
8092	ringBuffer := smithyio.NewRingBuffer(buff[:])
8093
8094	body := io.TeeReader(response.Body, ringBuffer)
8095	decoder := json.NewDecoder(body)
8096	decoder.UseNumber()
8097	var shape interface{}
8098	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8099		var snapshot bytes.Buffer
8100		io.Copy(&snapshot, ringBuffer)
8101		err = &smithy.DeserializationError{
8102			Err:      fmt.Errorf("failed to decode response body, %w", err),
8103			Snapshot: snapshot.Bytes(),
8104		}
8105		return out, metadata, err
8106	}
8107
8108	err = awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(&output, shape)
8109	if err != nil {
8110		var snapshot bytes.Buffer
8111		io.Copy(&snapshot, ringBuffer)
8112		err = &smithy.DeserializationError{
8113			Err:      fmt.Errorf("failed to decode response body, %w", err),
8114			Snapshot: snapshot.Bytes(),
8115		}
8116		return out, metadata, err
8117	}
8118
8119	return out, metadata, err
8120}
8121
8122func awsAwsjson11_deserializeOpErrorGetContactMethods(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8123	var errorBuffer bytes.Buffer
8124	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8125		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8126	}
8127	errorBody := bytes.NewReader(errorBuffer.Bytes())
8128
8129	errorCode := "UnknownError"
8130	errorMessage := errorCode
8131
8132	code := response.Header.Get("X-Amzn-ErrorType")
8133	if len(code) != 0 {
8134		errorCode = restjson.SanitizeErrorCode(code)
8135	}
8136
8137	var buff [1024]byte
8138	ringBuffer := smithyio.NewRingBuffer(buff[:])
8139
8140	body := io.TeeReader(errorBody, ringBuffer)
8141	decoder := json.NewDecoder(body)
8142	decoder.UseNumber()
8143	code, message, err := restjson.GetErrorInfo(decoder)
8144	if err != nil {
8145		var snapshot bytes.Buffer
8146		io.Copy(&snapshot, ringBuffer)
8147		err = &smithy.DeserializationError{
8148			Err:      fmt.Errorf("failed to decode response body, %w", err),
8149			Snapshot: snapshot.Bytes(),
8150		}
8151		return err
8152	}
8153
8154	errorBody.Seek(0, io.SeekStart)
8155	if len(code) != 0 {
8156		errorCode = restjson.SanitizeErrorCode(code)
8157	}
8158	if len(message) != 0 {
8159		errorMessage = message
8160	}
8161
8162	switch {
8163	case strings.EqualFold("AccessDeniedException", errorCode):
8164		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8165
8166	case strings.EqualFold("InvalidInputException", errorCode):
8167		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8168
8169	case strings.EqualFold("NotFoundException", errorCode):
8170		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8171
8172	case strings.EqualFold("OperationFailureException", errorCode):
8173		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
8174
8175	case strings.EqualFold("ServiceException", errorCode):
8176		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8177
8178	case strings.EqualFold("UnauthenticatedException", errorCode):
8179		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8180
8181	default:
8182		genericError := &smithy.GenericAPIError{
8183			Code:    errorCode,
8184			Message: errorMessage,
8185		}
8186		return genericError
8187
8188	}
8189}
8190
8191type awsAwsjson11_deserializeOpGetContainerAPIMetadata struct {
8192}
8193
8194func (*awsAwsjson11_deserializeOpGetContainerAPIMetadata) ID() string {
8195	return "OperationDeserializer"
8196}
8197
8198func (m *awsAwsjson11_deserializeOpGetContainerAPIMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8199	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8200) {
8201	out, metadata, err = next.HandleDeserialize(ctx, in)
8202	if err != nil {
8203		return out, metadata, err
8204	}
8205
8206	response, ok := out.RawResponse.(*smithyhttp.Response)
8207	if !ok {
8208		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8209	}
8210
8211	if response.StatusCode < 200 || response.StatusCode >= 300 {
8212		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response, &metadata)
8213	}
8214	output := &GetContainerAPIMetadataOutput{}
8215	out.Result = output
8216
8217	var buff [1024]byte
8218	ringBuffer := smithyio.NewRingBuffer(buff[:])
8219
8220	body := io.TeeReader(response.Body, ringBuffer)
8221	decoder := json.NewDecoder(body)
8222	decoder.UseNumber()
8223	var shape interface{}
8224	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8225		var snapshot bytes.Buffer
8226		io.Copy(&snapshot, ringBuffer)
8227		err = &smithy.DeserializationError{
8228			Err:      fmt.Errorf("failed to decode response body, %w", err),
8229			Snapshot: snapshot.Bytes(),
8230		}
8231		return out, metadata, err
8232	}
8233
8234	err = awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(&output, shape)
8235	if err != nil {
8236		var snapshot bytes.Buffer
8237		io.Copy(&snapshot, ringBuffer)
8238		err = &smithy.DeserializationError{
8239			Err:      fmt.Errorf("failed to decode response body, %w", err),
8240			Snapshot: snapshot.Bytes(),
8241		}
8242		return out, metadata, err
8243	}
8244
8245	return out, metadata, err
8246}
8247
8248func awsAwsjson11_deserializeOpErrorGetContainerAPIMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8249	var errorBuffer bytes.Buffer
8250	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8251		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8252	}
8253	errorBody := bytes.NewReader(errorBuffer.Bytes())
8254
8255	errorCode := "UnknownError"
8256	errorMessage := errorCode
8257
8258	code := response.Header.Get("X-Amzn-ErrorType")
8259	if len(code) != 0 {
8260		errorCode = restjson.SanitizeErrorCode(code)
8261	}
8262
8263	var buff [1024]byte
8264	ringBuffer := smithyio.NewRingBuffer(buff[:])
8265
8266	body := io.TeeReader(errorBody, ringBuffer)
8267	decoder := json.NewDecoder(body)
8268	decoder.UseNumber()
8269	code, message, err := restjson.GetErrorInfo(decoder)
8270	if err != nil {
8271		var snapshot bytes.Buffer
8272		io.Copy(&snapshot, ringBuffer)
8273		err = &smithy.DeserializationError{
8274			Err:      fmt.Errorf("failed to decode response body, %w", err),
8275			Snapshot: snapshot.Bytes(),
8276		}
8277		return err
8278	}
8279
8280	errorBody.Seek(0, io.SeekStart)
8281	if len(code) != 0 {
8282		errorCode = restjson.SanitizeErrorCode(code)
8283	}
8284	if len(message) != 0 {
8285		errorMessage = message
8286	}
8287
8288	switch {
8289	case strings.EqualFold("AccessDeniedException", errorCode):
8290		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8291
8292	case strings.EqualFold("ServiceException", errorCode):
8293		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8294
8295	case strings.EqualFold("UnauthenticatedException", errorCode):
8296		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8297
8298	default:
8299		genericError := &smithy.GenericAPIError{
8300			Code:    errorCode,
8301			Message: errorMessage,
8302		}
8303		return genericError
8304
8305	}
8306}
8307
8308type awsAwsjson11_deserializeOpGetContainerImages struct {
8309}
8310
8311func (*awsAwsjson11_deserializeOpGetContainerImages) ID() string {
8312	return "OperationDeserializer"
8313}
8314
8315func (m *awsAwsjson11_deserializeOpGetContainerImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8316	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8317) {
8318	out, metadata, err = next.HandleDeserialize(ctx, in)
8319	if err != nil {
8320		return out, metadata, err
8321	}
8322
8323	response, ok := out.RawResponse.(*smithyhttp.Response)
8324	if !ok {
8325		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8326	}
8327
8328	if response.StatusCode < 200 || response.StatusCode >= 300 {
8329		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerImages(response, &metadata)
8330	}
8331	output := &GetContainerImagesOutput{}
8332	out.Result = output
8333
8334	var buff [1024]byte
8335	ringBuffer := smithyio.NewRingBuffer(buff[:])
8336
8337	body := io.TeeReader(response.Body, ringBuffer)
8338	decoder := json.NewDecoder(body)
8339	decoder.UseNumber()
8340	var shape interface{}
8341	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(&output, shape)
8352	if err != nil {
8353		var snapshot bytes.Buffer
8354		io.Copy(&snapshot, ringBuffer)
8355		err = &smithy.DeserializationError{
8356			Err:      fmt.Errorf("failed to decode response body, %w", err),
8357			Snapshot: snapshot.Bytes(),
8358		}
8359		return out, metadata, err
8360	}
8361
8362	return out, metadata, err
8363}
8364
8365func awsAwsjson11_deserializeOpErrorGetContainerImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8366	var errorBuffer bytes.Buffer
8367	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8368		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8369	}
8370	errorBody := bytes.NewReader(errorBuffer.Bytes())
8371
8372	errorCode := "UnknownError"
8373	errorMessage := errorCode
8374
8375	code := response.Header.Get("X-Amzn-ErrorType")
8376	if len(code) != 0 {
8377		errorCode = restjson.SanitizeErrorCode(code)
8378	}
8379
8380	var buff [1024]byte
8381	ringBuffer := smithyio.NewRingBuffer(buff[:])
8382
8383	body := io.TeeReader(errorBody, ringBuffer)
8384	decoder := json.NewDecoder(body)
8385	decoder.UseNumber()
8386	code, message, err := restjson.GetErrorInfo(decoder)
8387	if err != nil {
8388		var snapshot bytes.Buffer
8389		io.Copy(&snapshot, ringBuffer)
8390		err = &smithy.DeserializationError{
8391			Err:      fmt.Errorf("failed to decode response body, %w", err),
8392			Snapshot: snapshot.Bytes(),
8393		}
8394		return err
8395	}
8396
8397	errorBody.Seek(0, io.SeekStart)
8398	if len(code) != 0 {
8399		errorCode = restjson.SanitizeErrorCode(code)
8400	}
8401	if len(message) != 0 {
8402		errorMessage = message
8403	}
8404
8405	switch {
8406	case strings.EqualFold("AccessDeniedException", errorCode):
8407		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8408
8409	case strings.EqualFold("InvalidInputException", errorCode):
8410		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8411
8412	case strings.EqualFold("NotFoundException", errorCode):
8413		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8414
8415	case strings.EqualFold("ServiceException", errorCode):
8416		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8417
8418	case strings.EqualFold("UnauthenticatedException", errorCode):
8419		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8420
8421	default:
8422		genericError := &smithy.GenericAPIError{
8423			Code:    errorCode,
8424			Message: errorMessage,
8425		}
8426		return genericError
8427
8428	}
8429}
8430
8431type awsAwsjson11_deserializeOpGetContainerLog struct {
8432}
8433
8434func (*awsAwsjson11_deserializeOpGetContainerLog) ID() string {
8435	return "OperationDeserializer"
8436}
8437
8438func (m *awsAwsjson11_deserializeOpGetContainerLog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8439	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8440) {
8441	out, metadata, err = next.HandleDeserialize(ctx, in)
8442	if err != nil {
8443		return out, metadata, err
8444	}
8445
8446	response, ok := out.RawResponse.(*smithyhttp.Response)
8447	if !ok {
8448		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8449	}
8450
8451	if response.StatusCode < 200 || response.StatusCode >= 300 {
8452		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerLog(response, &metadata)
8453	}
8454	output := &GetContainerLogOutput{}
8455	out.Result = output
8456
8457	var buff [1024]byte
8458	ringBuffer := smithyio.NewRingBuffer(buff[:])
8459
8460	body := io.TeeReader(response.Body, ringBuffer)
8461	decoder := json.NewDecoder(body)
8462	decoder.UseNumber()
8463	var shape interface{}
8464	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8465		var snapshot bytes.Buffer
8466		io.Copy(&snapshot, ringBuffer)
8467		err = &smithy.DeserializationError{
8468			Err:      fmt.Errorf("failed to decode response body, %w", err),
8469			Snapshot: snapshot.Bytes(),
8470		}
8471		return out, metadata, err
8472	}
8473
8474	err = awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(&output, shape)
8475	if err != nil {
8476		var snapshot bytes.Buffer
8477		io.Copy(&snapshot, ringBuffer)
8478		err = &smithy.DeserializationError{
8479			Err:      fmt.Errorf("failed to decode response body, %w", err),
8480			Snapshot: snapshot.Bytes(),
8481		}
8482		return out, metadata, err
8483	}
8484
8485	return out, metadata, err
8486}
8487
8488func awsAwsjson11_deserializeOpErrorGetContainerLog(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8489	var errorBuffer bytes.Buffer
8490	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8491		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8492	}
8493	errorBody := bytes.NewReader(errorBuffer.Bytes())
8494
8495	errorCode := "UnknownError"
8496	errorMessage := errorCode
8497
8498	code := response.Header.Get("X-Amzn-ErrorType")
8499	if len(code) != 0 {
8500		errorCode = restjson.SanitizeErrorCode(code)
8501	}
8502
8503	var buff [1024]byte
8504	ringBuffer := smithyio.NewRingBuffer(buff[:])
8505
8506	body := io.TeeReader(errorBody, ringBuffer)
8507	decoder := json.NewDecoder(body)
8508	decoder.UseNumber()
8509	code, message, err := restjson.GetErrorInfo(decoder)
8510	if err != nil {
8511		var snapshot bytes.Buffer
8512		io.Copy(&snapshot, ringBuffer)
8513		err = &smithy.DeserializationError{
8514			Err:      fmt.Errorf("failed to decode response body, %w", err),
8515			Snapshot: snapshot.Bytes(),
8516		}
8517		return err
8518	}
8519
8520	errorBody.Seek(0, io.SeekStart)
8521	if len(code) != 0 {
8522		errorCode = restjson.SanitizeErrorCode(code)
8523	}
8524	if len(message) != 0 {
8525		errorMessage = message
8526	}
8527
8528	switch {
8529	case strings.EqualFold("AccessDeniedException", errorCode):
8530		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8531
8532	case strings.EqualFold("InvalidInputException", errorCode):
8533		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8534
8535	case strings.EqualFold("NotFoundException", errorCode):
8536		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8537
8538	case strings.EqualFold("ServiceException", errorCode):
8539		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8540
8541	case strings.EqualFold("UnauthenticatedException", errorCode):
8542		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8543
8544	default:
8545		genericError := &smithy.GenericAPIError{
8546			Code:    errorCode,
8547			Message: errorMessage,
8548		}
8549		return genericError
8550
8551	}
8552}
8553
8554type awsAwsjson11_deserializeOpGetContainerServiceDeployments struct {
8555}
8556
8557func (*awsAwsjson11_deserializeOpGetContainerServiceDeployments) ID() string {
8558	return "OperationDeserializer"
8559}
8560
8561func (m *awsAwsjson11_deserializeOpGetContainerServiceDeployments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8562	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8563) {
8564	out, metadata, err = next.HandleDeserialize(ctx, in)
8565	if err != nil {
8566		return out, metadata, err
8567	}
8568
8569	response, ok := out.RawResponse.(*smithyhttp.Response)
8570	if !ok {
8571		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8572	}
8573
8574	if response.StatusCode < 200 || response.StatusCode >= 300 {
8575		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response, &metadata)
8576	}
8577	output := &GetContainerServiceDeploymentsOutput{}
8578	out.Result = output
8579
8580	var buff [1024]byte
8581	ringBuffer := smithyio.NewRingBuffer(buff[:])
8582
8583	body := io.TeeReader(response.Body, ringBuffer)
8584	decoder := json.NewDecoder(body)
8585	decoder.UseNumber()
8586	var shape interface{}
8587	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8588		var snapshot bytes.Buffer
8589		io.Copy(&snapshot, ringBuffer)
8590		err = &smithy.DeserializationError{
8591			Err:      fmt.Errorf("failed to decode response body, %w", err),
8592			Snapshot: snapshot.Bytes(),
8593		}
8594		return out, metadata, err
8595	}
8596
8597	err = awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(&output, shape)
8598	if err != nil {
8599		var snapshot bytes.Buffer
8600		io.Copy(&snapshot, ringBuffer)
8601		err = &smithy.DeserializationError{
8602			Err:      fmt.Errorf("failed to decode response body, %w", err),
8603			Snapshot: snapshot.Bytes(),
8604		}
8605		return out, metadata, err
8606	}
8607
8608	return out, metadata, err
8609}
8610
8611func awsAwsjson11_deserializeOpErrorGetContainerServiceDeployments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8612	var errorBuffer bytes.Buffer
8613	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8614		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8615	}
8616	errorBody := bytes.NewReader(errorBuffer.Bytes())
8617
8618	errorCode := "UnknownError"
8619	errorMessage := errorCode
8620
8621	code := response.Header.Get("X-Amzn-ErrorType")
8622	if len(code) != 0 {
8623		errorCode = restjson.SanitizeErrorCode(code)
8624	}
8625
8626	var buff [1024]byte
8627	ringBuffer := smithyio.NewRingBuffer(buff[:])
8628
8629	body := io.TeeReader(errorBody, ringBuffer)
8630	decoder := json.NewDecoder(body)
8631	decoder.UseNumber()
8632	code, message, err := restjson.GetErrorInfo(decoder)
8633	if err != nil {
8634		var snapshot bytes.Buffer
8635		io.Copy(&snapshot, ringBuffer)
8636		err = &smithy.DeserializationError{
8637			Err:      fmt.Errorf("failed to decode response body, %w", err),
8638			Snapshot: snapshot.Bytes(),
8639		}
8640		return err
8641	}
8642
8643	errorBody.Seek(0, io.SeekStart)
8644	if len(code) != 0 {
8645		errorCode = restjson.SanitizeErrorCode(code)
8646	}
8647	if len(message) != 0 {
8648		errorMessage = message
8649	}
8650
8651	switch {
8652	case strings.EqualFold("AccessDeniedException", errorCode):
8653		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8654
8655	case strings.EqualFold("InvalidInputException", errorCode):
8656		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8657
8658	case strings.EqualFold("NotFoundException", errorCode):
8659		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8660
8661	case strings.EqualFold("ServiceException", errorCode):
8662		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8663
8664	case strings.EqualFold("UnauthenticatedException", errorCode):
8665		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8666
8667	default:
8668		genericError := &smithy.GenericAPIError{
8669			Code:    errorCode,
8670			Message: errorMessage,
8671		}
8672		return genericError
8673
8674	}
8675}
8676
8677type awsAwsjson11_deserializeOpGetContainerServiceMetricData struct {
8678}
8679
8680func (*awsAwsjson11_deserializeOpGetContainerServiceMetricData) ID() string {
8681	return "OperationDeserializer"
8682}
8683
8684func (m *awsAwsjson11_deserializeOpGetContainerServiceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8685	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8686) {
8687	out, metadata, err = next.HandleDeserialize(ctx, in)
8688	if err != nil {
8689		return out, metadata, err
8690	}
8691
8692	response, ok := out.RawResponse.(*smithyhttp.Response)
8693	if !ok {
8694		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8695	}
8696
8697	if response.StatusCode < 200 || response.StatusCode >= 300 {
8698		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response, &metadata)
8699	}
8700	output := &GetContainerServiceMetricDataOutput{}
8701	out.Result = output
8702
8703	var buff [1024]byte
8704	ringBuffer := smithyio.NewRingBuffer(buff[:])
8705
8706	body := io.TeeReader(response.Body, ringBuffer)
8707	decoder := json.NewDecoder(body)
8708	decoder.UseNumber()
8709	var shape interface{}
8710	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8711		var snapshot bytes.Buffer
8712		io.Copy(&snapshot, ringBuffer)
8713		err = &smithy.DeserializationError{
8714			Err:      fmt.Errorf("failed to decode response body, %w", err),
8715			Snapshot: snapshot.Bytes(),
8716		}
8717		return out, metadata, err
8718	}
8719
8720	err = awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(&output, shape)
8721	if err != nil {
8722		var snapshot bytes.Buffer
8723		io.Copy(&snapshot, ringBuffer)
8724		err = &smithy.DeserializationError{
8725			Err:      fmt.Errorf("failed to decode response body, %w", err),
8726			Snapshot: snapshot.Bytes(),
8727		}
8728		return out, metadata, err
8729	}
8730
8731	return out, metadata, err
8732}
8733
8734func awsAwsjson11_deserializeOpErrorGetContainerServiceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8735	var errorBuffer bytes.Buffer
8736	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8737		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8738	}
8739	errorBody := bytes.NewReader(errorBuffer.Bytes())
8740
8741	errorCode := "UnknownError"
8742	errorMessage := errorCode
8743
8744	code := response.Header.Get("X-Amzn-ErrorType")
8745	if len(code) != 0 {
8746		errorCode = restjson.SanitizeErrorCode(code)
8747	}
8748
8749	var buff [1024]byte
8750	ringBuffer := smithyio.NewRingBuffer(buff[:])
8751
8752	body := io.TeeReader(errorBody, ringBuffer)
8753	decoder := json.NewDecoder(body)
8754	decoder.UseNumber()
8755	code, message, err := restjson.GetErrorInfo(decoder)
8756	if err != nil {
8757		var snapshot bytes.Buffer
8758		io.Copy(&snapshot, ringBuffer)
8759		err = &smithy.DeserializationError{
8760			Err:      fmt.Errorf("failed to decode response body, %w", err),
8761			Snapshot: snapshot.Bytes(),
8762		}
8763		return err
8764	}
8765
8766	errorBody.Seek(0, io.SeekStart)
8767	if len(code) != 0 {
8768		errorCode = restjson.SanitizeErrorCode(code)
8769	}
8770	if len(message) != 0 {
8771		errorMessage = message
8772	}
8773
8774	switch {
8775	case strings.EqualFold("AccessDeniedException", errorCode):
8776		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8777
8778	case strings.EqualFold("InvalidInputException", errorCode):
8779		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8780
8781	case strings.EqualFold("NotFoundException", errorCode):
8782		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8783
8784	case strings.EqualFold("ServiceException", errorCode):
8785		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8786
8787	case strings.EqualFold("UnauthenticatedException", errorCode):
8788		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8789
8790	default:
8791		genericError := &smithy.GenericAPIError{
8792			Code:    errorCode,
8793			Message: errorMessage,
8794		}
8795		return genericError
8796
8797	}
8798}
8799
8800type awsAwsjson11_deserializeOpGetContainerServicePowers struct {
8801}
8802
8803func (*awsAwsjson11_deserializeOpGetContainerServicePowers) ID() string {
8804	return "OperationDeserializer"
8805}
8806
8807func (m *awsAwsjson11_deserializeOpGetContainerServicePowers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8808	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8809) {
8810	out, metadata, err = next.HandleDeserialize(ctx, in)
8811	if err != nil {
8812		return out, metadata, err
8813	}
8814
8815	response, ok := out.RawResponse.(*smithyhttp.Response)
8816	if !ok {
8817		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8818	}
8819
8820	if response.StatusCode < 200 || response.StatusCode >= 300 {
8821		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response, &metadata)
8822	}
8823	output := &GetContainerServicePowersOutput{}
8824	out.Result = output
8825
8826	var buff [1024]byte
8827	ringBuffer := smithyio.NewRingBuffer(buff[:])
8828
8829	body := io.TeeReader(response.Body, ringBuffer)
8830	decoder := json.NewDecoder(body)
8831	decoder.UseNumber()
8832	var shape interface{}
8833	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8834		var snapshot bytes.Buffer
8835		io.Copy(&snapshot, ringBuffer)
8836		err = &smithy.DeserializationError{
8837			Err:      fmt.Errorf("failed to decode response body, %w", err),
8838			Snapshot: snapshot.Bytes(),
8839		}
8840		return out, metadata, err
8841	}
8842
8843	err = awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(&output, shape)
8844	if err != nil {
8845		var snapshot bytes.Buffer
8846		io.Copy(&snapshot, ringBuffer)
8847		err = &smithy.DeserializationError{
8848			Err:      fmt.Errorf("failed to decode response body, %w", err),
8849			Snapshot: snapshot.Bytes(),
8850		}
8851		return out, metadata, err
8852	}
8853
8854	return out, metadata, err
8855}
8856
8857func awsAwsjson11_deserializeOpErrorGetContainerServicePowers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8858	var errorBuffer bytes.Buffer
8859	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8860		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8861	}
8862	errorBody := bytes.NewReader(errorBuffer.Bytes())
8863
8864	errorCode := "UnknownError"
8865	errorMessage := errorCode
8866
8867	code := response.Header.Get("X-Amzn-ErrorType")
8868	if len(code) != 0 {
8869		errorCode = restjson.SanitizeErrorCode(code)
8870	}
8871
8872	var buff [1024]byte
8873	ringBuffer := smithyio.NewRingBuffer(buff[:])
8874
8875	body := io.TeeReader(errorBody, ringBuffer)
8876	decoder := json.NewDecoder(body)
8877	decoder.UseNumber()
8878	code, message, err := restjson.GetErrorInfo(decoder)
8879	if err != nil {
8880		var snapshot bytes.Buffer
8881		io.Copy(&snapshot, ringBuffer)
8882		err = &smithy.DeserializationError{
8883			Err:      fmt.Errorf("failed to decode response body, %w", err),
8884			Snapshot: snapshot.Bytes(),
8885		}
8886		return err
8887	}
8888
8889	errorBody.Seek(0, io.SeekStart)
8890	if len(code) != 0 {
8891		errorCode = restjson.SanitizeErrorCode(code)
8892	}
8893	if len(message) != 0 {
8894		errorMessage = message
8895	}
8896
8897	switch {
8898	case strings.EqualFold("AccessDeniedException", errorCode):
8899		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
8900
8901	case strings.EqualFold("InvalidInputException", errorCode):
8902		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
8903
8904	case strings.EqualFold("NotFoundException", errorCode):
8905		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
8906
8907	case strings.EqualFold("ServiceException", errorCode):
8908		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
8909
8910	case strings.EqualFold("UnauthenticatedException", errorCode):
8911		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
8912
8913	default:
8914		genericError := &smithy.GenericAPIError{
8915			Code:    errorCode,
8916			Message: errorMessage,
8917		}
8918		return genericError
8919
8920	}
8921}
8922
8923type awsAwsjson11_deserializeOpGetContainerServices struct {
8924}
8925
8926func (*awsAwsjson11_deserializeOpGetContainerServices) ID() string {
8927	return "OperationDeserializer"
8928}
8929
8930func (m *awsAwsjson11_deserializeOpGetContainerServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8931	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8932) {
8933	out, metadata, err = next.HandleDeserialize(ctx, in)
8934	if err != nil {
8935		return out, metadata, err
8936	}
8937
8938	response, ok := out.RawResponse.(*smithyhttp.Response)
8939	if !ok {
8940		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8941	}
8942
8943	if response.StatusCode < 200 || response.StatusCode >= 300 {
8944		return out, metadata, awsAwsjson11_deserializeOpErrorGetContainerServices(response, &metadata)
8945	}
8946	output := &GetContainerServicesOutput{}
8947	out.Result = output
8948
8949	var buff [1024]byte
8950	ringBuffer := smithyio.NewRingBuffer(buff[:])
8951
8952	body := io.TeeReader(response.Body, ringBuffer)
8953	decoder := json.NewDecoder(body)
8954	decoder.UseNumber()
8955	var shape interface{}
8956	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8957		var snapshot bytes.Buffer
8958		io.Copy(&snapshot, ringBuffer)
8959		err = &smithy.DeserializationError{
8960			Err:      fmt.Errorf("failed to decode response body, %w", err),
8961			Snapshot: snapshot.Bytes(),
8962		}
8963		return out, metadata, err
8964	}
8965
8966	err = awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(&output, shape)
8967	if err != nil {
8968		var snapshot bytes.Buffer
8969		io.Copy(&snapshot, ringBuffer)
8970		err = &smithy.DeserializationError{
8971			Err:      fmt.Errorf("failed to decode response body, %w", err),
8972			Snapshot: snapshot.Bytes(),
8973		}
8974		return out, metadata, err
8975	}
8976
8977	return out, metadata, err
8978}
8979
8980func awsAwsjson11_deserializeOpErrorGetContainerServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8981	var errorBuffer bytes.Buffer
8982	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8983		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8984	}
8985	errorBody := bytes.NewReader(errorBuffer.Bytes())
8986
8987	errorCode := "UnknownError"
8988	errorMessage := errorCode
8989
8990	code := response.Header.Get("X-Amzn-ErrorType")
8991	if len(code) != 0 {
8992		errorCode = restjson.SanitizeErrorCode(code)
8993	}
8994
8995	var buff [1024]byte
8996	ringBuffer := smithyio.NewRingBuffer(buff[:])
8997
8998	body := io.TeeReader(errorBody, ringBuffer)
8999	decoder := json.NewDecoder(body)
9000	decoder.UseNumber()
9001	code, message, err := restjson.GetErrorInfo(decoder)
9002	if err != nil {
9003		var snapshot bytes.Buffer
9004		io.Copy(&snapshot, ringBuffer)
9005		err = &smithy.DeserializationError{
9006			Err:      fmt.Errorf("failed to decode response body, %w", err),
9007			Snapshot: snapshot.Bytes(),
9008		}
9009		return err
9010	}
9011
9012	errorBody.Seek(0, io.SeekStart)
9013	if len(code) != 0 {
9014		errorCode = restjson.SanitizeErrorCode(code)
9015	}
9016	if len(message) != 0 {
9017		errorMessage = message
9018	}
9019
9020	switch {
9021	case strings.EqualFold("AccessDeniedException", errorCode):
9022		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9023
9024	case strings.EqualFold("InvalidInputException", errorCode):
9025		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9026
9027	case strings.EqualFold("NotFoundException", errorCode):
9028		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9029
9030	case strings.EqualFold("ServiceException", errorCode):
9031		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9032
9033	case strings.EqualFold("UnauthenticatedException", errorCode):
9034		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9035
9036	default:
9037		genericError := &smithy.GenericAPIError{
9038			Code:    errorCode,
9039			Message: errorMessage,
9040		}
9041		return genericError
9042
9043	}
9044}
9045
9046type awsAwsjson11_deserializeOpGetDisk struct {
9047}
9048
9049func (*awsAwsjson11_deserializeOpGetDisk) ID() string {
9050	return "OperationDeserializer"
9051}
9052
9053func (m *awsAwsjson11_deserializeOpGetDisk) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9054	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9055) {
9056	out, metadata, err = next.HandleDeserialize(ctx, in)
9057	if err != nil {
9058		return out, metadata, err
9059	}
9060
9061	response, ok := out.RawResponse.(*smithyhttp.Response)
9062	if !ok {
9063		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9064	}
9065
9066	if response.StatusCode < 200 || response.StatusCode >= 300 {
9067		return out, metadata, awsAwsjson11_deserializeOpErrorGetDisk(response, &metadata)
9068	}
9069	output := &GetDiskOutput{}
9070	out.Result = output
9071
9072	var buff [1024]byte
9073	ringBuffer := smithyio.NewRingBuffer(buff[:])
9074
9075	body := io.TeeReader(response.Body, ringBuffer)
9076	decoder := json.NewDecoder(body)
9077	decoder.UseNumber()
9078	var shape interface{}
9079	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9080		var snapshot bytes.Buffer
9081		io.Copy(&snapshot, ringBuffer)
9082		err = &smithy.DeserializationError{
9083			Err:      fmt.Errorf("failed to decode response body, %w", err),
9084			Snapshot: snapshot.Bytes(),
9085		}
9086		return out, metadata, err
9087	}
9088
9089	err = awsAwsjson11_deserializeOpDocumentGetDiskOutput(&output, shape)
9090	if err != nil {
9091		var snapshot bytes.Buffer
9092		io.Copy(&snapshot, ringBuffer)
9093		err = &smithy.DeserializationError{
9094			Err:      fmt.Errorf("failed to decode response body, %w", err),
9095			Snapshot: snapshot.Bytes(),
9096		}
9097		return out, metadata, err
9098	}
9099
9100	return out, metadata, err
9101}
9102
9103func awsAwsjson11_deserializeOpErrorGetDisk(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9104	var errorBuffer bytes.Buffer
9105	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9106		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9107	}
9108	errorBody := bytes.NewReader(errorBuffer.Bytes())
9109
9110	errorCode := "UnknownError"
9111	errorMessage := errorCode
9112
9113	code := response.Header.Get("X-Amzn-ErrorType")
9114	if len(code) != 0 {
9115		errorCode = restjson.SanitizeErrorCode(code)
9116	}
9117
9118	var buff [1024]byte
9119	ringBuffer := smithyio.NewRingBuffer(buff[:])
9120
9121	body := io.TeeReader(errorBody, ringBuffer)
9122	decoder := json.NewDecoder(body)
9123	decoder.UseNumber()
9124	code, message, err := restjson.GetErrorInfo(decoder)
9125	if err != nil {
9126		var snapshot bytes.Buffer
9127		io.Copy(&snapshot, ringBuffer)
9128		err = &smithy.DeserializationError{
9129			Err:      fmt.Errorf("failed to decode response body, %w", err),
9130			Snapshot: snapshot.Bytes(),
9131		}
9132		return err
9133	}
9134
9135	errorBody.Seek(0, io.SeekStart)
9136	if len(code) != 0 {
9137		errorCode = restjson.SanitizeErrorCode(code)
9138	}
9139	if len(message) != 0 {
9140		errorMessage = message
9141	}
9142
9143	switch {
9144	case strings.EqualFold("AccessDeniedException", errorCode):
9145		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9146
9147	case strings.EqualFold("AccountSetupInProgressException", errorCode):
9148		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9149
9150	case strings.EqualFold("InvalidInputException", errorCode):
9151		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9152
9153	case strings.EqualFold("NotFoundException", errorCode):
9154		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9155
9156	case strings.EqualFold("OperationFailureException", errorCode):
9157		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9158
9159	case strings.EqualFold("ServiceException", errorCode):
9160		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9161
9162	case strings.EqualFold("UnauthenticatedException", errorCode):
9163		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9164
9165	default:
9166		genericError := &smithy.GenericAPIError{
9167			Code:    errorCode,
9168			Message: errorMessage,
9169		}
9170		return genericError
9171
9172	}
9173}
9174
9175type awsAwsjson11_deserializeOpGetDisks struct {
9176}
9177
9178func (*awsAwsjson11_deserializeOpGetDisks) ID() string {
9179	return "OperationDeserializer"
9180}
9181
9182func (m *awsAwsjson11_deserializeOpGetDisks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9183	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9184) {
9185	out, metadata, err = next.HandleDeserialize(ctx, in)
9186	if err != nil {
9187		return out, metadata, err
9188	}
9189
9190	response, ok := out.RawResponse.(*smithyhttp.Response)
9191	if !ok {
9192		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9193	}
9194
9195	if response.StatusCode < 200 || response.StatusCode >= 300 {
9196		return out, metadata, awsAwsjson11_deserializeOpErrorGetDisks(response, &metadata)
9197	}
9198	output := &GetDisksOutput{}
9199	out.Result = output
9200
9201	var buff [1024]byte
9202	ringBuffer := smithyio.NewRingBuffer(buff[:])
9203
9204	body := io.TeeReader(response.Body, ringBuffer)
9205	decoder := json.NewDecoder(body)
9206	decoder.UseNumber()
9207	var shape interface{}
9208	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9209		var snapshot bytes.Buffer
9210		io.Copy(&snapshot, ringBuffer)
9211		err = &smithy.DeserializationError{
9212			Err:      fmt.Errorf("failed to decode response body, %w", err),
9213			Snapshot: snapshot.Bytes(),
9214		}
9215		return out, metadata, err
9216	}
9217
9218	err = awsAwsjson11_deserializeOpDocumentGetDisksOutput(&output, shape)
9219	if err != nil {
9220		var snapshot bytes.Buffer
9221		io.Copy(&snapshot, ringBuffer)
9222		err = &smithy.DeserializationError{
9223			Err:      fmt.Errorf("failed to decode response body, %w", err),
9224			Snapshot: snapshot.Bytes(),
9225		}
9226		return out, metadata, err
9227	}
9228
9229	return out, metadata, err
9230}
9231
9232func awsAwsjson11_deserializeOpErrorGetDisks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9233	var errorBuffer bytes.Buffer
9234	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9235		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9236	}
9237	errorBody := bytes.NewReader(errorBuffer.Bytes())
9238
9239	errorCode := "UnknownError"
9240	errorMessage := errorCode
9241
9242	code := response.Header.Get("X-Amzn-ErrorType")
9243	if len(code) != 0 {
9244		errorCode = restjson.SanitizeErrorCode(code)
9245	}
9246
9247	var buff [1024]byte
9248	ringBuffer := smithyio.NewRingBuffer(buff[:])
9249
9250	body := io.TeeReader(errorBody, ringBuffer)
9251	decoder := json.NewDecoder(body)
9252	decoder.UseNumber()
9253	code, message, err := restjson.GetErrorInfo(decoder)
9254	if err != nil {
9255		var snapshot bytes.Buffer
9256		io.Copy(&snapshot, ringBuffer)
9257		err = &smithy.DeserializationError{
9258			Err:      fmt.Errorf("failed to decode response body, %w", err),
9259			Snapshot: snapshot.Bytes(),
9260		}
9261		return err
9262	}
9263
9264	errorBody.Seek(0, io.SeekStart)
9265	if len(code) != 0 {
9266		errorCode = restjson.SanitizeErrorCode(code)
9267	}
9268	if len(message) != 0 {
9269		errorMessage = message
9270	}
9271
9272	switch {
9273	case strings.EqualFold("AccessDeniedException", errorCode):
9274		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9275
9276	case strings.EqualFold("AccountSetupInProgressException", errorCode):
9277		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9278
9279	case strings.EqualFold("InvalidInputException", errorCode):
9280		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9281
9282	case strings.EqualFold("NotFoundException", errorCode):
9283		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9284
9285	case strings.EqualFold("OperationFailureException", errorCode):
9286		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9287
9288	case strings.EqualFold("ServiceException", errorCode):
9289		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9290
9291	case strings.EqualFold("UnauthenticatedException", errorCode):
9292		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9293
9294	default:
9295		genericError := &smithy.GenericAPIError{
9296			Code:    errorCode,
9297			Message: errorMessage,
9298		}
9299		return genericError
9300
9301	}
9302}
9303
9304type awsAwsjson11_deserializeOpGetDiskSnapshot struct {
9305}
9306
9307func (*awsAwsjson11_deserializeOpGetDiskSnapshot) ID() string {
9308	return "OperationDeserializer"
9309}
9310
9311func (m *awsAwsjson11_deserializeOpGetDiskSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9312	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9313) {
9314	out, metadata, err = next.HandleDeserialize(ctx, in)
9315	if err != nil {
9316		return out, metadata, err
9317	}
9318
9319	response, ok := out.RawResponse.(*smithyhttp.Response)
9320	if !ok {
9321		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9322	}
9323
9324	if response.StatusCode < 200 || response.StatusCode >= 300 {
9325		return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response, &metadata)
9326	}
9327	output := &GetDiskSnapshotOutput{}
9328	out.Result = output
9329
9330	var buff [1024]byte
9331	ringBuffer := smithyio.NewRingBuffer(buff[:])
9332
9333	body := io.TeeReader(response.Body, ringBuffer)
9334	decoder := json.NewDecoder(body)
9335	decoder.UseNumber()
9336	var shape interface{}
9337	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9338		var snapshot bytes.Buffer
9339		io.Copy(&snapshot, ringBuffer)
9340		err = &smithy.DeserializationError{
9341			Err:      fmt.Errorf("failed to decode response body, %w", err),
9342			Snapshot: snapshot.Bytes(),
9343		}
9344		return out, metadata, err
9345	}
9346
9347	err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(&output, shape)
9348	if err != nil {
9349		var snapshot bytes.Buffer
9350		io.Copy(&snapshot, ringBuffer)
9351		err = &smithy.DeserializationError{
9352			Err:      fmt.Errorf("failed to decode response body, %w", err),
9353			Snapshot: snapshot.Bytes(),
9354		}
9355		return out, metadata, err
9356	}
9357
9358	return out, metadata, err
9359}
9360
9361func awsAwsjson11_deserializeOpErrorGetDiskSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9362	var errorBuffer bytes.Buffer
9363	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9364		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9365	}
9366	errorBody := bytes.NewReader(errorBuffer.Bytes())
9367
9368	errorCode := "UnknownError"
9369	errorMessage := errorCode
9370
9371	code := response.Header.Get("X-Amzn-ErrorType")
9372	if len(code) != 0 {
9373		errorCode = restjson.SanitizeErrorCode(code)
9374	}
9375
9376	var buff [1024]byte
9377	ringBuffer := smithyio.NewRingBuffer(buff[:])
9378
9379	body := io.TeeReader(errorBody, ringBuffer)
9380	decoder := json.NewDecoder(body)
9381	decoder.UseNumber()
9382	code, message, err := restjson.GetErrorInfo(decoder)
9383	if err != nil {
9384		var snapshot bytes.Buffer
9385		io.Copy(&snapshot, ringBuffer)
9386		err = &smithy.DeserializationError{
9387			Err:      fmt.Errorf("failed to decode response body, %w", err),
9388			Snapshot: snapshot.Bytes(),
9389		}
9390		return err
9391	}
9392
9393	errorBody.Seek(0, io.SeekStart)
9394	if len(code) != 0 {
9395		errorCode = restjson.SanitizeErrorCode(code)
9396	}
9397	if len(message) != 0 {
9398		errorMessage = message
9399	}
9400
9401	switch {
9402	case strings.EqualFold("AccessDeniedException", errorCode):
9403		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9404
9405	case strings.EqualFold("AccountSetupInProgressException", errorCode):
9406		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9407
9408	case strings.EqualFold("InvalidInputException", errorCode):
9409		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9410
9411	case strings.EqualFold("NotFoundException", errorCode):
9412		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9413
9414	case strings.EqualFold("OperationFailureException", errorCode):
9415		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9416
9417	case strings.EqualFold("ServiceException", errorCode):
9418		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9419
9420	case strings.EqualFold("UnauthenticatedException", errorCode):
9421		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9422
9423	default:
9424		genericError := &smithy.GenericAPIError{
9425			Code:    errorCode,
9426			Message: errorMessage,
9427		}
9428		return genericError
9429
9430	}
9431}
9432
9433type awsAwsjson11_deserializeOpGetDiskSnapshots struct {
9434}
9435
9436func (*awsAwsjson11_deserializeOpGetDiskSnapshots) ID() string {
9437	return "OperationDeserializer"
9438}
9439
9440func (m *awsAwsjson11_deserializeOpGetDiskSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9441	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9442) {
9443	out, metadata, err = next.HandleDeserialize(ctx, in)
9444	if err != nil {
9445		return out, metadata, err
9446	}
9447
9448	response, ok := out.RawResponse.(*smithyhttp.Response)
9449	if !ok {
9450		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9451	}
9452
9453	if response.StatusCode < 200 || response.StatusCode >= 300 {
9454		return out, metadata, awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response, &metadata)
9455	}
9456	output := &GetDiskSnapshotsOutput{}
9457	out.Result = output
9458
9459	var buff [1024]byte
9460	ringBuffer := smithyio.NewRingBuffer(buff[:])
9461
9462	body := io.TeeReader(response.Body, ringBuffer)
9463	decoder := json.NewDecoder(body)
9464	decoder.UseNumber()
9465	var shape interface{}
9466	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9467		var snapshot bytes.Buffer
9468		io.Copy(&snapshot, ringBuffer)
9469		err = &smithy.DeserializationError{
9470			Err:      fmt.Errorf("failed to decode response body, %w", err),
9471			Snapshot: snapshot.Bytes(),
9472		}
9473		return out, metadata, err
9474	}
9475
9476	err = awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(&output, shape)
9477	if err != nil {
9478		var snapshot bytes.Buffer
9479		io.Copy(&snapshot, ringBuffer)
9480		err = &smithy.DeserializationError{
9481			Err:      fmt.Errorf("failed to decode response body, %w", err),
9482			Snapshot: snapshot.Bytes(),
9483		}
9484		return out, metadata, err
9485	}
9486
9487	return out, metadata, err
9488}
9489
9490func awsAwsjson11_deserializeOpErrorGetDiskSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9491	var errorBuffer bytes.Buffer
9492	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9493		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9494	}
9495	errorBody := bytes.NewReader(errorBuffer.Bytes())
9496
9497	errorCode := "UnknownError"
9498	errorMessage := errorCode
9499
9500	code := response.Header.Get("X-Amzn-ErrorType")
9501	if len(code) != 0 {
9502		errorCode = restjson.SanitizeErrorCode(code)
9503	}
9504
9505	var buff [1024]byte
9506	ringBuffer := smithyio.NewRingBuffer(buff[:])
9507
9508	body := io.TeeReader(errorBody, ringBuffer)
9509	decoder := json.NewDecoder(body)
9510	decoder.UseNumber()
9511	code, message, err := restjson.GetErrorInfo(decoder)
9512	if err != nil {
9513		var snapshot bytes.Buffer
9514		io.Copy(&snapshot, ringBuffer)
9515		err = &smithy.DeserializationError{
9516			Err:      fmt.Errorf("failed to decode response body, %w", err),
9517			Snapshot: snapshot.Bytes(),
9518		}
9519		return err
9520	}
9521
9522	errorBody.Seek(0, io.SeekStart)
9523	if len(code) != 0 {
9524		errorCode = restjson.SanitizeErrorCode(code)
9525	}
9526	if len(message) != 0 {
9527		errorMessage = message
9528	}
9529
9530	switch {
9531	case strings.EqualFold("AccessDeniedException", errorCode):
9532		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9533
9534	case strings.EqualFold("AccountSetupInProgressException", errorCode):
9535		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
9536
9537	case strings.EqualFold("InvalidInputException", errorCode):
9538		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9539
9540	case strings.EqualFold("NotFoundException", errorCode):
9541		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9542
9543	case strings.EqualFold("OperationFailureException", errorCode):
9544		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9545
9546	case strings.EqualFold("ServiceException", errorCode):
9547		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9548
9549	case strings.EqualFold("UnauthenticatedException", errorCode):
9550		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9551
9552	default:
9553		genericError := &smithy.GenericAPIError{
9554			Code:    errorCode,
9555			Message: errorMessage,
9556		}
9557		return genericError
9558
9559	}
9560}
9561
9562type awsAwsjson11_deserializeOpGetDistributionBundles struct {
9563}
9564
9565func (*awsAwsjson11_deserializeOpGetDistributionBundles) ID() string {
9566	return "OperationDeserializer"
9567}
9568
9569func (m *awsAwsjson11_deserializeOpGetDistributionBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9570	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9571) {
9572	out, metadata, err = next.HandleDeserialize(ctx, in)
9573	if err != nil {
9574		return out, metadata, err
9575	}
9576
9577	response, ok := out.RawResponse.(*smithyhttp.Response)
9578	if !ok {
9579		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9580	}
9581
9582	if response.StatusCode < 200 || response.StatusCode >= 300 {
9583		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionBundles(response, &metadata)
9584	}
9585	output := &GetDistributionBundlesOutput{}
9586	out.Result = output
9587
9588	var buff [1024]byte
9589	ringBuffer := smithyio.NewRingBuffer(buff[:])
9590
9591	body := io.TeeReader(response.Body, ringBuffer)
9592	decoder := json.NewDecoder(body)
9593	decoder.UseNumber()
9594	var shape interface{}
9595	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9596		var snapshot bytes.Buffer
9597		io.Copy(&snapshot, ringBuffer)
9598		err = &smithy.DeserializationError{
9599			Err:      fmt.Errorf("failed to decode response body, %w", err),
9600			Snapshot: snapshot.Bytes(),
9601		}
9602		return out, metadata, err
9603	}
9604
9605	err = awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(&output, shape)
9606	if err != nil {
9607		var snapshot bytes.Buffer
9608		io.Copy(&snapshot, ringBuffer)
9609		err = &smithy.DeserializationError{
9610			Err:      fmt.Errorf("failed to decode response body, %w", err),
9611			Snapshot: snapshot.Bytes(),
9612		}
9613		return out, metadata, err
9614	}
9615
9616	return out, metadata, err
9617}
9618
9619func awsAwsjson11_deserializeOpErrorGetDistributionBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9620	var errorBuffer bytes.Buffer
9621	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9622		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9623	}
9624	errorBody := bytes.NewReader(errorBuffer.Bytes())
9625
9626	errorCode := "UnknownError"
9627	errorMessage := errorCode
9628
9629	code := response.Header.Get("X-Amzn-ErrorType")
9630	if len(code) != 0 {
9631		errorCode = restjson.SanitizeErrorCode(code)
9632	}
9633
9634	var buff [1024]byte
9635	ringBuffer := smithyio.NewRingBuffer(buff[:])
9636
9637	body := io.TeeReader(errorBody, ringBuffer)
9638	decoder := json.NewDecoder(body)
9639	decoder.UseNumber()
9640	code, message, err := restjson.GetErrorInfo(decoder)
9641	if err != nil {
9642		var snapshot bytes.Buffer
9643		io.Copy(&snapshot, ringBuffer)
9644		err = &smithy.DeserializationError{
9645			Err:      fmt.Errorf("failed to decode response body, %w", err),
9646			Snapshot: snapshot.Bytes(),
9647		}
9648		return err
9649	}
9650
9651	errorBody.Seek(0, io.SeekStart)
9652	if len(code) != 0 {
9653		errorCode = restjson.SanitizeErrorCode(code)
9654	}
9655	if len(message) != 0 {
9656		errorMessage = message
9657	}
9658
9659	switch {
9660	case strings.EqualFold("AccessDeniedException", errorCode):
9661		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9662
9663	case strings.EqualFold("InvalidInputException", errorCode):
9664		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9665
9666	case strings.EqualFold("NotFoundException", errorCode):
9667		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9668
9669	case strings.EqualFold("OperationFailureException", errorCode):
9670		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9671
9672	case strings.EqualFold("ServiceException", errorCode):
9673		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9674
9675	case strings.EqualFold("UnauthenticatedException", errorCode):
9676		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9677
9678	default:
9679		genericError := &smithy.GenericAPIError{
9680			Code:    errorCode,
9681			Message: errorMessage,
9682		}
9683		return genericError
9684
9685	}
9686}
9687
9688type awsAwsjson11_deserializeOpGetDistributionLatestCacheReset struct {
9689}
9690
9691func (*awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) ID() string {
9692	return "OperationDeserializer"
9693}
9694
9695func (m *awsAwsjson11_deserializeOpGetDistributionLatestCacheReset) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9696	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9697) {
9698	out, metadata, err = next.HandleDeserialize(ctx, in)
9699	if err != nil {
9700		return out, metadata, err
9701	}
9702
9703	response, ok := out.RawResponse.(*smithyhttp.Response)
9704	if !ok {
9705		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9706	}
9707
9708	if response.StatusCode < 200 || response.StatusCode >= 300 {
9709		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response, &metadata)
9710	}
9711	output := &GetDistributionLatestCacheResetOutput{}
9712	out.Result = output
9713
9714	var buff [1024]byte
9715	ringBuffer := smithyio.NewRingBuffer(buff[:])
9716
9717	body := io.TeeReader(response.Body, ringBuffer)
9718	decoder := json.NewDecoder(body)
9719	decoder.UseNumber()
9720	var shape interface{}
9721	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9722		var snapshot bytes.Buffer
9723		io.Copy(&snapshot, ringBuffer)
9724		err = &smithy.DeserializationError{
9725			Err:      fmt.Errorf("failed to decode response body, %w", err),
9726			Snapshot: snapshot.Bytes(),
9727		}
9728		return out, metadata, err
9729	}
9730
9731	err = awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(&output, shape)
9732	if err != nil {
9733		var snapshot bytes.Buffer
9734		io.Copy(&snapshot, ringBuffer)
9735		err = &smithy.DeserializationError{
9736			Err:      fmt.Errorf("failed to decode response body, %w", err),
9737			Snapshot: snapshot.Bytes(),
9738		}
9739		return out, metadata, err
9740	}
9741
9742	return out, metadata, err
9743}
9744
9745func awsAwsjson11_deserializeOpErrorGetDistributionLatestCacheReset(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9746	var errorBuffer bytes.Buffer
9747	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9748		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9749	}
9750	errorBody := bytes.NewReader(errorBuffer.Bytes())
9751
9752	errorCode := "UnknownError"
9753	errorMessage := errorCode
9754
9755	code := response.Header.Get("X-Amzn-ErrorType")
9756	if len(code) != 0 {
9757		errorCode = restjson.SanitizeErrorCode(code)
9758	}
9759
9760	var buff [1024]byte
9761	ringBuffer := smithyio.NewRingBuffer(buff[:])
9762
9763	body := io.TeeReader(errorBody, ringBuffer)
9764	decoder := json.NewDecoder(body)
9765	decoder.UseNumber()
9766	code, message, err := restjson.GetErrorInfo(decoder)
9767	if err != nil {
9768		var snapshot bytes.Buffer
9769		io.Copy(&snapshot, ringBuffer)
9770		err = &smithy.DeserializationError{
9771			Err:      fmt.Errorf("failed to decode response body, %w", err),
9772			Snapshot: snapshot.Bytes(),
9773		}
9774		return err
9775	}
9776
9777	errorBody.Seek(0, io.SeekStart)
9778	if len(code) != 0 {
9779		errorCode = restjson.SanitizeErrorCode(code)
9780	}
9781	if len(message) != 0 {
9782		errorMessage = message
9783	}
9784
9785	switch {
9786	case strings.EqualFold("AccessDeniedException", errorCode):
9787		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9788
9789	case strings.EqualFold("InvalidInputException", errorCode):
9790		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9791
9792	case strings.EqualFold("NotFoundException", errorCode):
9793		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9794
9795	case strings.EqualFold("OperationFailureException", errorCode):
9796		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9797
9798	case strings.EqualFold("ServiceException", errorCode):
9799		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9800
9801	case strings.EqualFold("UnauthenticatedException", errorCode):
9802		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9803
9804	default:
9805		genericError := &smithy.GenericAPIError{
9806			Code:    errorCode,
9807			Message: errorMessage,
9808		}
9809		return genericError
9810
9811	}
9812}
9813
9814type awsAwsjson11_deserializeOpGetDistributionMetricData struct {
9815}
9816
9817func (*awsAwsjson11_deserializeOpGetDistributionMetricData) ID() string {
9818	return "OperationDeserializer"
9819}
9820
9821func (m *awsAwsjson11_deserializeOpGetDistributionMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9822	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9823) {
9824	out, metadata, err = next.HandleDeserialize(ctx, in)
9825	if err != nil {
9826		return out, metadata, err
9827	}
9828
9829	response, ok := out.RawResponse.(*smithyhttp.Response)
9830	if !ok {
9831		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9832	}
9833
9834	if response.StatusCode < 200 || response.StatusCode >= 300 {
9835		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response, &metadata)
9836	}
9837	output := &GetDistributionMetricDataOutput{}
9838	out.Result = output
9839
9840	var buff [1024]byte
9841	ringBuffer := smithyio.NewRingBuffer(buff[:])
9842
9843	body := io.TeeReader(response.Body, ringBuffer)
9844	decoder := json.NewDecoder(body)
9845	decoder.UseNumber()
9846	var shape interface{}
9847	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9848		var snapshot bytes.Buffer
9849		io.Copy(&snapshot, ringBuffer)
9850		err = &smithy.DeserializationError{
9851			Err:      fmt.Errorf("failed to decode response body, %w", err),
9852			Snapshot: snapshot.Bytes(),
9853		}
9854		return out, metadata, err
9855	}
9856
9857	err = awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(&output, shape)
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 out, metadata, err
9866	}
9867
9868	return out, metadata, err
9869}
9870
9871func awsAwsjson11_deserializeOpErrorGetDistributionMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9872	var errorBuffer bytes.Buffer
9873	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9874		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9875	}
9876	errorBody := bytes.NewReader(errorBuffer.Bytes())
9877
9878	errorCode := "UnknownError"
9879	errorMessage := errorCode
9880
9881	code := response.Header.Get("X-Amzn-ErrorType")
9882	if len(code) != 0 {
9883		errorCode = restjson.SanitizeErrorCode(code)
9884	}
9885
9886	var buff [1024]byte
9887	ringBuffer := smithyio.NewRingBuffer(buff[:])
9888
9889	body := io.TeeReader(errorBody, ringBuffer)
9890	decoder := json.NewDecoder(body)
9891	decoder.UseNumber()
9892	code, message, err := restjson.GetErrorInfo(decoder)
9893	if err != nil {
9894		var snapshot bytes.Buffer
9895		io.Copy(&snapshot, ringBuffer)
9896		err = &smithy.DeserializationError{
9897			Err:      fmt.Errorf("failed to decode response body, %w", err),
9898			Snapshot: snapshot.Bytes(),
9899		}
9900		return err
9901	}
9902
9903	errorBody.Seek(0, io.SeekStart)
9904	if len(code) != 0 {
9905		errorCode = restjson.SanitizeErrorCode(code)
9906	}
9907	if len(message) != 0 {
9908		errorMessage = message
9909	}
9910
9911	switch {
9912	case strings.EqualFold("AccessDeniedException", errorCode):
9913		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
9914
9915	case strings.EqualFold("InvalidInputException", errorCode):
9916		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
9917
9918	case strings.EqualFold("NotFoundException", errorCode):
9919		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
9920
9921	case strings.EqualFold("OperationFailureException", errorCode):
9922		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
9923
9924	case strings.EqualFold("ServiceException", errorCode):
9925		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
9926
9927	case strings.EqualFold("UnauthenticatedException", errorCode):
9928		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
9929
9930	default:
9931		genericError := &smithy.GenericAPIError{
9932			Code:    errorCode,
9933			Message: errorMessage,
9934		}
9935		return genericError
9936
9937	}
9938}
9939
9940type awsAwsjson11_deserializeOpGetDistributions struct {
9941}
9942
9943func (*awsAwsjson11_deserializeOpGetDistributions) ID() string {
9944	return "OperationDeserializer"
9945}
9946
9947func (m *awsAwsjson11_deserializeOpGetDistributions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9948	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9949) {
9950	out, metadata, err = next.HandleDeserialize(ctx, in)
9951	if err != nil {
9952		return out, metadata, err
9953	}
9954
9955	response, ok := out.RawResponse.(*smithyhttp.Response)
9956	if !ok {
9957		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9958	}
9959
9960	if response.StatusCode < 200 || response.StatusCode >= 300 {
9961		return out, metadata, awsAwsjson11_deserializeOpErrorGetDistributions(response, &metadata)
9962	}
9963	output := &GetDistributionsOutput{}
9964	out.Result = output
9965
9966	var buff [1024]byte
9967	ringBuffer := smithyio.NewRingBuffer(buff[:])
9968
9969	body := io.TeeReader(response.Body, ringBuffer)
9970	decoder := json.NewDecoder(body)
9971	decoder.UseNumber()
9972	var shape interface{}
9973	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9974		var snapshot bytes.Buffer
9975		io.Copy(&snapshot, ringBuffer)
9976		err = &smithy.DeserializationError{
9977			Err:      fmt.Errorf("failed to decode response body, %w", err),
9978			Snapshot: snapshot.Bytes(),
9979		}
9980		return out, metadata, err
9981	}
9982
9983	err = awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(&output, shape)
9984	if err != nil {
9985		var snapshot bytes.Buffer
9986		io.Copy(&snapshot, ringBuffer)
9987		err = &smithy.DeserializationError{
9988			Err:      fmt.Errorf("failed to decode response body, %w", err),
9989			Snapshot: snapshot.Bytes(),
9990		}
9991		return out, metadata, err
9992	}
9993
9994	return out, metadata, err
9995}
9996
9997func awsAwsjson11_deserializeOpErrorGetDistributions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9998	var errorBuffer bytes.Buffer
9999	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10000		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10001	}
10002	errorBody := bytes.NewReader(errorBuffer.Bytes())
10003
10004	errorCode := "UnknownError"
10005	errorMessage := errorCode
10006
10007	code := response.Header.Get("X-Amzn-ErrorType")
10008	if len(code) != 0 {
10009		errorCode = restjson.SanitizeErrorCode(code)
10010	}
10011
10012	var buff [1024]byte
10013	ringBuffer := smithyio.NewRingBuffer(buff[:])
10014
10015	body := io.TeeReader(errorBody, ringBuffer)
10016	decoder := json.NewDecoder(body)
10017	decoder.UseNumber()
10018	code, message, err := restjson.GetErrorInfo(decoder)
10019	if err != nil {
10020		var snapshot bytes.Buffer
10021		io.Copy(&snapshot, ringBuffer)
10022		err = &smithy.DeserializationError{
10023			Err:      fmt.Errorf("failed to decode response body, %w", err),
10024			Snapshot: snapshot.Bytes(),
10025		}
10026		return err
10027	}
10028
10029	errorBody.Seek(0, io.SeekStart)
10030	if len(code) != 0 {
10031		errorCode = restjson.SanitizeErrorCode(code)
10032	}
10033	if len(message) != 0 {
10034		errorMessage = message
10035	}
10036
10037	switch {
10038	case strings.EqualFold("AccessDeniedException", errorCode):
10039		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10040
10041	case strings.EqualFold("InvalidInputException", errorCode):
10042		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10043
10044	case strings.EqualFold("NotFoundException", errorCode):
10045		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10046
10047	case strings.EqualFold("OperationFailureException", errorCode):
10048		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10049
10050	case strings.EqualFold("ServiceException", errorCode):
10051		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10052
10053	case strings.EqualFold("UnauthenticatedException", errorCode):
10054		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10055
10056	default:
10057		genericError := &smithy.GenericAPIError{
10058			Code:    errorCode,
10059			Message: errorMessage,
10060		}
10061		return genericError
10062
10063	}
10064}
10065
10066type awsAwsjson11_deserializeOpGetDomain struct {
10067}
10068
10069func (*awsAwsjson11_deserializeOpGetDomain) ID() string {
10070	return "OperationDeserializer"
10071}
10072
10073func (m *awsAwsjson11_deserializeOpGetDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10074	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10075) {
10076	out, metadata, err = next.HandleDeserialize(ctx, in)
10077	if err != nil {
10078		return out, metadata, err
10079	}
10080
10081	response, ok := out.RawResponse.(*smithyhttp.Response)
10082	if !ok {
10083		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10084	}
10085
10086	if response.StatusCode < 200 || response.StatusCode >= 300 {
10087		return out, metadata, awsAwsjson11_deserializeOpErrorGetDomain(response, &metadata)
10088	}
10089	output := &GetDomainOutput{}
10090	out.Result = output
10091
10092	var buff [1024]byte
10093	ringBuffer := smithyio.NewRingBuffer(buff[:])
10094
10095	body := io.TeeReader(response.Body, ringBuffer)
10096	decoder := json.NewDecoder(body)
10097	decoder.UseNumber()
10098	var shape interface{}
10099	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10100		var snapshot bytes.Buffer
10101		io.Copy(&snapshot, ringBuffer)
10102		err = &smithy.DeserializationError{
10103			Err:      fmt.Errorf("failed to decode response body, %w", err),
10104			Snapshot: snapshot.Bytes(),
10105		}
10106		return out, metadata, err
10107	}
10108
10109	err = awsAwsjson11_deserializeOpDocumentGetDomainOutput(&output, shape)
10110	if err != nil {
10111		var snapshot bytes.Buffer
10112		io.Copy(&snapshot, ringBuffer)
10113		err = &smithy.DeserializationError{
10114			Err:      fmt.Errorf("failed to decode response body, %w", err),
10115			Snapshot: snapshot.Bytes(),
10116		}
10117		return out, metadata, err
10118	}
10119
10120	return out, metadata, err
10121}
10122
10123func awsAwsjson11_deserializeOpErrorGetDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10124	var errorBuffer bytes.Buffer
10125	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10126		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10127	}
10128	errorBody := bytes.NewReader(errorBuffer.Bytes())
10129
10130	errorCode := "UnknownError"
10131	errorMessage := errorCode
10132
10133	code := response.Header.Get("X-Amzn-ErrorType")
10134	if len(code) != 0 {
10135		errorCode = restjson.SanitizeErrorCode(code)
10136	}
10137
10138	var buff [1024]byte
10139	ringBuffer := smithyio.NewRingBuffer(buff[:])
10140
10141	body := io.TeeReader(errorBody, ringBuffer)
10142	decoder := json.NewDecoder(body)
10143	decoder.UseNumber()
10144	code, message, err := restjson.GetErrorInfo(decoder)
10145	if err != nil {
10146		var snapshot bytes.Buffer
10147		io.Copy(&snapshot, ringBuffer)
10148		err = &smithy.DeserializationError{
10149			Err:      fmt.Errorf("failed to decode response body, %w", err),
10150			Snapshot: snapshot.Bytes(),
10151		}
10152		return err
10153	}
10154
10155	errorBody.Seek(0, io.SeekStart)
10156	if len(code) != 0 {
10157		errorCode = restjson.SanitizeErrorCode(code)
10158	}
10159	if len(message) != 0 {
10160		errorMessage = message
10161	}
10162
10163	switch {
10164	case strings.EqualFold("AccessDeniedException", errorCode):
10165		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10166
10167	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10168		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10169
10170	case strings.EqualFold("InvalidInputException", errorCode):
10171		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10172
10173	case strings.EqualFold("NotFoundException", errorCode):
10174		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10175
10176	case strings.EqualFold("OperationFailureException", errorCode):
10177		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10178
10179	case strings.EqualFold("ServiceException", errorCode):
10180		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10181
10182	case strings.EqualFold("UnauthenticatedException", errorCode):
10183		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10184
10185	default:
10186		genericError := &smithy.GenericAPIError{
10187			Code:    errorCode,
10188			Message: errorMessage,
10189		}
10190		return genericError
10191
10192	}
10193}
10194
10195type awsAwsjson11_deserializeOpGetDomains struct {
10196}
10197
10198func (*awsAwsjson11_deserializeOpGetDomains) ID() string {
10199	return "OperationDeserializer"
10200}
10201
10202func (m *awsAwsjson11_deserializeOpGetDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10203	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10204) {
10205	out, metadata, err = next.HandleDeserialize(ctx, in)
10206	if err != nil {
10207		return out, metadata, err
10208	}
10209
10210	response, ok := out.RawResponse.(*smithyhttp.Response)
10211	if !ok {
10212		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10213	}
10214
10215	if response.StatusCode < 200 || response.StatusCode >= 300 {
10216		return out, metadata, awsAwsjson11_deserializeOpErrorGetDomains(response, &metadata)
10217	}
10218	output := &GetDomainsOutput{}
10219	out.Result = output
10220
10221	var buff [1024]byte
10222	ringBuffer := smithyio.NewRingBuffer(buff[:])
10223
10224	body := io.TeeReader(response.Body, ringBuffer)
10225	decoder := json.NewDecoder(body)
10226	decoder.UseNumber()
10227	var shape interface{}
10228	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10229		var snapshot bytes.Buffer
10230		io.Copy(&snapshot, ringBuffer)
10231		err = &smithy.DeserializationError{
10232			Err:      fmt.Errorf("failed to decode response body, %w", err),
10233			Snapshot: snapshot.Bytes(),
10234		}
10235		return out, metadata, err
10236	}
10237
10238	err = awsAwsjson11_deserializeOpDocumentGetDomainsOutput(&output, shape)
10239	if err != nil {
10240		var snapshot bytes.Buffer
10241		io.Copy(&snapshot, ringBuffer)
10242		err = &smithy.DeserializationError{
10243			Err:      fmt.Errorf("failed to decode response body, %w", err),
10244			Snapshot: snapshot.Bytes(),
10245		}
10246		return out, metadata, err
10247	}
10248
10249	return out, metadata, err
10250}
10251
10252func awsAwsjson11_deserializeOpErrorGetDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10253	var errorBuffer bytes.Buffer
10254	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10255		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10256	}
10257	errorBody := bytes.NewReader(errorBuffer.Bytes())
10258
10259	errorCode := "UnknownError"
10260	errorMessage := errorCode
10261
10262	code := response.Header.Get("X-Amzn-ErrorType")
10263	if len(code) != 0 {
10264		errorCode = restjson.SanitizeErrorCode(code)
10265	}
10266
10267	var buff [1024]byte
10268	ringBuffer := smithyio.NewRingBuffer(buff[:])
10269
10270	body := io.TeeReader(errorBody, ringBuffer)
10271	decoder := json.NewDecoder(body)
10272	decoder.UseNumber()
10273	code, message, err := restjson.GetErrorInfo(decoder)
10274	if err != nil {
10275		var snapshot bytes.Buffer
10276		io.Copy(&snapshot, ringBuffer)
10277		err = &smithy.DeserializationError{
10278			Err:      fmt.Errorf("failed to decode response body, %w", err),
10279			Snapshot: snapshot.Bytes(),
10280		}
10281		return err
10282	}
10283
10284	errorBody.Seek(0, io.SeekStart)
10285	if len(code) != 0 {
10286		errorCode = restjson.SanitizeErrorCode(code)
10287	}
10288	if len(message) != 0 {
10289		errorMessage = message
10290	}
10291
10292	switch {
10293	case strings.EqualFold("AccessDeniedException", errorCode):
10294		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10295
10296	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10297		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10298
10299	case strings.EqualFold("InvalidInputException", errorCode):
10300		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10301
10302	case strings.EqualFold("NotFoundException", errorCode):
10303		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10304
10305	case strings.EqualFold("OperationFailureException", errorCode):
10306		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10307
10308	case strings.EqualFold("ServiceException", errorCode):
10309		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10310
10311	case strings.EqualFold("UnauthenticatedException", errorCode):
10312		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10313
10314	default:
10315		genericError := &smithy.GenericAPIError{
10316			Code:    errorCode,
10317			Message: errorMessage,
10318		}
10319		return genericError
10320
10321	}
10322}
10323
10324type awsAwsjson11_deserializeOpGetExportSnapshotRecords struct {
10325}
10326
10327func (*awsAwsjson11_deserializeOpGetExportSnapshotRecords) ID() string {
10328	return "OperationDeserializer"
10329}
10330
10331func (m *awsAwsjson11_deserializeOpGetExportSnapshotRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10332	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10333) {
10334	out, metadata, err = next.HandleDeserialize(ctx, in)
10335	if err != nil {
10336		return out, metadata, err
10337	}
10338
10339	response, ok := out.RawResponse.(*smithyhttp.Response)
10340	if !ok {
10341		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10342	}
10343
10344	if response.StatusCode < 200 || response.StatusCode >= 300 {
10345		return out, metadata, awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response, &metadata)
10346	}
10347	output := &GetExportSnapshotRecordsOutput{}
10348	out.Result = output
10349
10350	var buff [1024]byte
10351	ringBuffer := smithyio.NewRingBuffer(buff[:])
10352
10353	body := io.TeeReader(response.Body, ringBuffer)
10354	decoder := json.NewDecoder(body)
10355	decoder.UseNumber()
10356	var shape interface{}
10357	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10358		var snapshot bytes.Buffer
10359		io.Copy(&snapshot, ringBuffer)
10360		err = &smithy.DeserializationError{
10361			Err:      fmt.Errorf("failed to decode response body, %w", err),
10362			Snapshot: snapshot.Bytes(),
10363		}
10364		return out, metadata, err
10365	}
10366
10367	err = awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(&output, shape)
10368	if err != nil {
10369		var snapshot bytes.Buffer
10370		io.Copy(&snapshot, ringBuffer)
10371		err = &smithy.DeserializationError{
10372			Err:      fmt.Errorf("failed to decode response body, %w", err),
10373			Snapshot: snapshot.Bytes(),
10374		}
10375		return out, metadata, err
10376	}
10377
10378	return out, metadata, err
10379}
10380
10381func awsAwsjson11_deserializeOpErrorGetExportSnapshotRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10382	var errorBuffer bytes.Buffer
10383	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10384		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10385	}
10386	errorBody := bytes.NewReader(errorBuffer.Bytes())
10387
10388	errorCode := "UnknownError"
10389	errorMessage := errorCode
10390
10391	code := response.Header.Get("X-Amzn-ErrorType")
10392	if len(code) != 0 {
10393		errorCode = restjson.SanitizeErrorCode(code)
10394	}
10395
10396	var buff [1024]byte
10397	ringBuffer := smithyio.NewRingBuffer(buff[:])
10398
10399	body := io.TeeReader(errorBody, ringBuffer)
10400	decoder := json.NewDecoder(body)
10401	decoder.UseNumber()
10402	code, message, err := restjson.GetErrorInfo(decoder)
10403	if err != nil {
10404		var snapshot bytes.Buffer
10405		io.Copy(&snapshot, ringBuffer)
10406		err = &smithy.DeserializationError{
10407			Err:      fmt.Errorf("failed to decode response body, %w", err),
10408			Snapshot: snapshot.Bytes(),
10409		}
10410		return err
10411	}
10412
10413	errorBody.Seek(0, io.SeekStart)
10414	if len(code) != 0 {
10415		errorCode = restjson.SanitizeErrorCode(code)
10416	}
10417	if len(message) != 0 {
10418		errorMessage = message
10419	}
10420
10421	switch {
10422	case strings.EqualFold("AccessDeniedException", errorCode):
10423		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10424
10425	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10426		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10427
10428	case strings.EqualFold("InvalidInputException", errorCode):
10429		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10430
10431	case strings.EqualFold("NotFoundException", errorCode):
10432		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10433
10434	case strings.EqualFold("OperationFailureException", errorCode):
10435		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10436
10437	case strings.EqualFold("ServiceException", errorCode):
10438		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10439
10440	case strings.EqualFold("UnauthenticatedException", errorCode):
10441		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10442
10443	default:
10444		genericError := &smithy.GenericAPIError{
10445			Code:    errorCode,
10446			Message: errorMessage,
10447		}
10448		return genericError
10449
10450	}
10451}
10452
10453type awsAwsjson11_deserializeOpGetInstance struct {
10454}
10455
10456func (*awsAwsjson11_deserializeOpGetInstance) ID() string {
10457	return "OperationDeserializer"
10458}
10459
10460func (m *awsAwsjson11_deserializeOpGetInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10461	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10462) {
10463	out, metadata, err = next.HandleDeserialize(ctx, in)
10464	if err != nil {
10465		return out, metadata, err
10466	}
10467
10468	response, ok := out.RawResponse.(*smithyhttp.Response)
10469	if !ok {
10470		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10471	}
10472
10473	if response.StatusCode < 200 || response.StatusCode >= 300 {
10474		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstance(response, &metadata)
10475	}
10476	output := &GetInstanceOutput{}
10477	out.Result = output
10478
10479	var buff [1024]byte
10480	ringBuffer := smithyio.NewRingBuffer(buff[:])
10481
10482	body := io.TeeReader(response.Body, ringBuffer)
10483	decoder := json.NewDecoder(body)
10484	decoder.UseNumber()
10485	var shape interface{}
10486	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10487		var snapshot bytes.Buffer
10488		io.Copy(&snapshot, ringBuffer)
10489		err = &smithy.DeserializationError{
10490			Err:      fmt.Errorf("failed to decode response body, %w", err),
10491			Snapshot: snapshot.Bytes(),
10492		}
10493		return out, metadata, err
10494	}
10495
10496	err = awsAwsjson11_deserializeOpDocumentGetInstanceOutput(&output, shape)
10497	if err != nil {
10498		var snapshot bytes.Buffer
10499		io.Copy(&snapshot, ringBuffer)
10500		err = &smithy.DeserializationError{
10501			Err:      fmt.Errorf("failed to decode response body, %w", err),
10502			Snapshot: snapshot.Bytes(),
10503		}
10504		return out, metadata, err
10505	}
10506
10507	return out, metadata, err
10508}
10509
10510func awsAwsjson11_deserializeOpErrorGetInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10511	var errorBuffer bytes.Buffer
10512	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10513		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10514	}
10515	errorBody := bytes.NewReader(errorBuffer.Bytes())
10516
10517	errorCode := "UnknownError"
10518	errorMessage := errorCode
10519
10520	code := response.Header.Get("X-Amzn-ErrorType")
10521	if len(code) != 0 {
10522		errorCode = restjson.SanitizeErrorCode(code)
10523	}
10524
10525	var buff [1024]byte
10526	ringBuffer := smithyio.NewRingBuffer(buff[:])
10527
10528	body := io.TeeReader(errorBody, ringBuffer)
10529	decoder := json.NewDecoder(body)
10530	decoder.UseNumber()
10531	code, message, err := restjson.GetErrorInfo(decoder)
10532	if err != nil {
10533		var snapshot bytes.Buffer
10534		io.Copy(&snapshot, ringBuffer)
10535		err = &smithy.DeserializationError{
10536			Err:      fmt.Errorf("failed to decode response body, %w", err),
10537			Snapshot: snapshot.Bytes(),
10538		}
10539		return err
10540	}
10541
10542	errorBody.Seek(0, io.SeekStart)
10543	if len(code) != 0 {
10544		errorCode = restjson.SanitizeErrorCode(code)
10545	}
10546	if len(message) != 0 {
10547		errorMessage = message
10548	}
10549
10550	switch {
10551	case strings.EqualFold("AccessDeniedException", errorCode):
10552		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10553
10554	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10555		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10556
10557	case strings.EqualFold("InvalidInputException", errorCode):
10558		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10559
10560	case strings.EqualFold("NotFoundException", errorCode):
10561		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10562
10563	case strings.EqualFold("OperationFailureException", errorCode):
10564		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10565
10566	case strings.EqualFold("ServiceException", errorCode):
10567		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10568
10569	case strings.EqualFold("UnauthenticatedException", errorCode):
10570		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10571
10572	default:
10573		genericError := &smithy.GenericAPIError{
10574			Code:    errorCode,
10575			Message: errorMessage,
10576		}
10577		return genericError
10578
10579	}
10580}
10581
10582type awsAwsjson11_deserializeOpGetInstanceAccessDetails struct {
10583}
10584
10585func (*awsAwsjson11_deserializeOpGetInstanceAccessDetails) ID() string {
10586	return "OperationDeserializer"
10587}
10588
10589func (m *awsAwsjson11_deserializeOpGetInstanceAccessDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10590	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10591) {
10592	out, metadata, err = next.HandleDeserialize(ctx, in)
10593	if err != nil {
10594		return out, metadata, err
10595	}
10596
10597	response, ok := out.RawResponse.(*smithyhttp.Response)
10598	if !ok {
10599		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10600	}
10601
10602	if response.StatusCode < 200 || response.StatusCode >= 300 {
10603		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response, &metadata)
10604	}
10605	output := &GetInstanceAccessDetailsOutput{}
10606	out.Result = output
10607
10608	var buff [1024]byte
10609	ringBuffer := smithyio.NewRingBuffer(buff[:])
10610
10611	body := io.TeeReader(response.Body, ringBuffer)
10612	decoder := json.NewDecoder(body)
10613	decoder.UseNumber()
10614	var shape interface{}
10615	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10616		var snapshot bytes.Buffer
10617		io.Copy(&snapshot, ringBuffer)
10618		err = &smithy.DeserializationError{
10619			Err:      fmt.Errorf("failed to decode response body, %w", err),
10620			Snapshot: snapshot.Bytes(),
10621		}
10622		return out, metadata, err
10623	}
10624
10625	err = awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(&output, shape)
10626	if err != nil {
10627		var snapshot bytes.Buffer
10628		io.Copy(&snapshot, ringBuffer)
10629		err = &smithy.DeserializationError{
10630			Err:      fmt.Errorf("failed to decode response body, %w", err),
10631			Snapshot: snapshot.Bytes(),
10632		}
10633		return out, metadata, err
10634	}
10635
10636	return out, metadata, err
10637}
10638
10639func awsAwsjson11_deserializeOpErrorGetInstanceAccessDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10640	var errorBuffer bytes.Buffer
10641	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10642		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10643	}
10644	errorBody := bytes.NewReader(errorBuffer.Bytes())
10645
10646	errorCode := "UnknownError"
10647	errorMessage := errorCode
10648
10649	code := response.Header.Get("X-Amzn-ErrorType")
10650	if len(code) != 0 {
10651		errorCode = restjson.SanitizeErrorCode(code)
10652	}
10653
10654	var buff [1024]byte
10655	ringBuffer := smithyio.NewRingBuffer(buff[:])
10656
10657	body := io.TeeReader(errorBody, ringBuffer)
10658	decoder := json.NewDecoder(body)
10659	decoder.UseNumber()
10660	code, message, err := restjson.GetErrorInfo(decoder)
10661	if err != nil {
10662		var snapshot bytes.Buffer
10663		io.Copy(&snapshot, ringBuffer)
10664		err = &smithy.DeserializationError{
10665			Err:      fmt.Errorf("failed to decode response body, %w", err),
10666			Snapshot: snapshot.Bytes(),
10667		}
10668		return err
10669	}
10670
10671	errorBody.Seek(0, io.SeekStart)
10672	if len(code) != 0 {
10673		errorCode = restjson.SanitizeErrorCode(code)
10674	}
10675	if len(message) != 0 {
10676		errorMessage = message
10677	}
10678
10679	switch {
10680	case strings.EqualFold("AccessDeniedException", errorCode):
10681		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10682
10683	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10684		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10685
10686	case strings.EqualFold("InvalidInputException", errorCode):
10687		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10688
10689	case strings.EqualFold("NotFoundException", errorCode):
10690		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10691
10692	case strings.EqualFold("OperationFailureException", errorCode):
10693		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10694
10695	case strings.EqualFold("ServiceException", errorCode):
10696		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10697
10698	case strings.EqualFold("UnauthenticatedException", errorCode):
10699		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10700
10701	default:
10702		genericError := &smithy.GenericAPIError{
10703			Code:    errorCode,
10704			Message: errorMessage,
10705		}
10706		return genericError
10707
10708	}
10709}
10710
10711type awsAwsjson11_deserializeOpGetInstanceMetricData struct {
10712}
10713
10714func (*awsAwsjson11_deserializeOpGetInstanceMetricData) ID() string {
10715	return "OperationDeserializer"
10716}
10717
10718func (m *awsAwsjson11_deserializeOpGetInstanceMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10719	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10720) {
10721	out, metadata, err = next.HandleDeserialize(ctx, in)
10722	if err != nil {
10723		return out, metadata, err
10724	}
10725
10726	response, ok := out.RawResponse.(*smithyhttp.Response)
10727	if !ok {
10728		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10729	}
10730
10731	if response.StatusCode < 200 || response.StatusCode >= 300 {
10732		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response, &metadata)
10733	}
10734	output := &GetInstanceMetricDataOutput{}
10735	out.Result = output
10736
10737	var buff [1024]byte
10738	ringBuffer := smithyio.NewRingBuffer(buff[:])
10739
10740	body := io.TeeReader(response.Body, ringBuffer)
10741	decoder := json.NewDecoder(body)
10742	decoder.UseNumber()
10743	var shape interface{}
10744	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10745		var snapshot bytes.Buffer
10746		io.Copy(&snapshot, ringBuffer)
10747		err = &smithy.DeserializationError{
10748			Err:      fmt.Errorf("failed to decode response body, %w", err),
10749			Snapshot: snapshot.Bytes(),
10750		}
10751		return out, metadata, err
10752	}
10753
10754	err = awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(&output, shape)
10755	if err != nil {
10756		var snapshot bytes.Buffer
10757		io.Copy(&snapshot, ringBuffer)
10758		err = &smithy.DeserializationError{
10759			Err:      fmt.Errorf("failed to decode response body, %w", err),
10760			Snapshot: snapshot.Bytes(),
10761		}
10762		return out, metadata, err
10763	}
10764
10765	return out, metadata, err
10766}
10767
10768func awsAwsjson11_deserializeOpErrorGetInstanceMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10769	var errorBuffer bytes.Buffer
10770	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10771		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10772	}
10773	errorBody := bytes.NewReader(errorBuffer.Bytes())
10774
10775	errorCode := "UnknownError"
10776	errorMessage := errorCode
10777
10778	code := response.Header.Get("X-Amzn-ErrorType")
10779	if len(code) != 0 {
10780		errorCode = restjson.SanitizeErrorCode(code)
10781	}
10782
10783	var buff [1024]byte
10784	ringBuffer := smithyio.NewRingBuffer(buff[:])
10785
10786	body := io.TeeReader(errorBody, ringBuffer)
10787	decoder := json.NewDecoder(body)
10788	decoder.UseNumber()
10789	code, message, err := restjson.GetErrorInfo(decoder)
10790	if err != nil {
10791		var snapshot bytes.Buffer
10792		io.Copy(&snapshot, ringBuffer)
10793		err = &smithy.DeserializationError{
10794			Err:      fmt.Errorf("failed to decode response body, %w", err),
10795			Snapshot: snapshot.Bytes(),
10796		}
10797		return err
10798	}
10799
10800	errorBody.Seek(0, io.SeekStart)
10801	if len(code) != 0 {
10802		errorCode = restjson.SanitizeErrorCode(code)
10803	}
10804	if len(message) != 0 {
10805		errorMessage = message
10806	}
10807
10808	switch {
10809	case strings.EqualFold("AccessDeniedException", errorCode):
10810		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10811
10812	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10813		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10814
10815	case strings.EqualFold("InvalidInputException", errorCode):
10816		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10817
10818	case strings.EqualFold("NotFoundException", errorCode):
10819		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10820
10821	case strings.EqualFold("OperationFailureException", errorCode):
10822		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10823
10824	case strings.EqualFold("ServiceException", errorCode):
10825		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10826
10827	case strings.EqualFold("UnauthenticatedException", errorCode):
10828		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10829
10830	default:
10831		genericError := &smithy.GenericAPIError{
10832			Code:    errorCode,
10833			Message: errorMessage,
10834		}
10835		return genericError
10836
10837	}
10838}
10839
10840type awsAwsjson11_deserializeOpGetInstancePortStates struct {
10841}
10842
10843func (*awsAwsjson11_deserializeOpGetInstancePortStates) ID() string {
10844	return "OperationDeserializer"
10845}
10846
10847func (m *awsAwsjson11_deserializeOpGetInstancePortStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10848	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10849) {
10850	out, metadata, err = next.HandleDeserialize(ctx, in)
10851	if err != nil {
10852		return out, metadata, err
10853	}
10854
10855	response, ok := out.RawResponse.(*smithyhttp.Response)
10856	if !ok {
10857		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10858	}
10859
10860	if response.StatusCode < 200 || response.StatusCode >= 300 {
10861		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstancePortStates(response, &metadata)
10862	}
10863	output := &GetInstancePortStatesOutput{}
10864	out.Result = output
10865
10866	var buff [1024]byte
10867	ringBuffer := smithyio.NewRingBuffer(buff[:])
10868
10869	body := io.TeeReader(response.Body, ringBuffer)
10870	decoder := json.NewDecoder(body)
10871	decoder.UseNumber()
10872	var shape interface{}
10873	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10874		var snapshot bytes.Buffer
10875		io.Copy(&snapshot, ringBuffer)
10876		err = &smithy.DeserializationError{
10877			Err:      fmt.Errorf("failed to decode response body, %w", err),
10878			Snapshot: snapshot.Bytes(),
10879		}
10880		return out, metadata, err
10881	}
10882
10883	err = awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(&output, shape)
10884	if err != nil {
10885		var snapshot bytes.Buffer
10886		io.Copy(&snapshot, ringBuffer)
10887		err = &smithy.DeserializationError{
10888			Err:      fmt.Errorf("failed to decode response body, %w", err),
10889			Snapshot: snapshot.Bytes(),
10890		}
10891		return out, metadata, err
10892	}
10893
10894	return out, metadata, err
10895}
10896
10897func awsAwsjson11_deserializeOpErrorGetInstancePortStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
10898	var errorBuffer bytes.Buffer
10899	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
10900		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
10901	}
10902	errorBody := bytes.NewReader(errorBuffer.Bytes())
10903
10904	errorCode := "UnknownError"
10905	errorMessage := errorCode
10906
10907	code := response.Header.Get("X-Amzn-ErrorType")
10908	if len(code) != 0 {
10909		errorCode = restjson.SanitizeErrorCode(code)
10910	}
10911
10912	var buff [1024]byte
10913	ringBuffer := smithyio.NewRingBuffer(buff[:])
10914
10915	body := io.TeeReader(errorBody, ringBuffer)
10916	decoder := json.NewDecoder(body)
10917	decoder.UseNumber()
10918	code, message, err := restjson.GetErrorInfo(decoder)
10919	if err != nil {
10920		var snapshot bytes.Buffer
10921		io.Copy(&snapshot, ringBuffer)
10922		err = &smithy.DeserializationError{
10923			Err:      fmt.Errorf("failed to decode response body, %w", err),
10924			Snapshot: snapshot.Bytes(),
10925		}
10926		return err
10927	}
10928
10929	errorBody.Seek(0, io.SeekStart)
10930	if len(code) != 0 {
10931		errorCode = restjson.SanitizeErrorCode(code)
10932	}
10933	if len(message) != 0 {
10934		errorMessage = message
10935	}
10936
10937	switch {
10938	case strings.EqualFold("AccessDeniedException", errorCode):
10939		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
10940
10941	case strings.EqualFold("AccountSetupInProgressException", errorCode):
10942		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
10943
10944	case strings.EqualFold("InvalidInputException", errorCode):
10945		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
10946
10947	case strings.EqualFold("NotFoundException", errorCode):
10948		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
10949
10950	case strings.EqualFold("OperationFailureException", errorCode):
10951		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
10952
10953	case strings.EqualFold("ServiceException", errorCode):
10954		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
10955
10956	case strings.EqualFold("UnauthenticatedException", errorCode):
10957		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
10958
10959	default:
10960		genericError := &smithy.GenericAPIError{
10961			Code:    errorCode,
10962			Message: errorMessage,
10963		}
10964		return genericError
10965
10966	}
10967}
10968
10969type awsAwsjson11_deserializeOpGetInstances struct {
10970}
10971
10972func (*awsAwsjson11_deserializeOpGetInstances) ID() string {
10973	return "OperationDeserializer"
10974}
10975
10976func (m *awsAwsjson11_deserializeOpGetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
10977	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
10978) {
10979	out, metadata, err = next.HandleDeserialize(ctx, in)
10980	if err != nil {
10981		return out, metadata, err
10982	}
10983
10984	response, ok := out.RawResponse.(*smithyhttp.Response)
10985	if !ok {
10986		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
10987	}
10988
10989	if response.StatusCode < 200 || response.StatusCode >= 300 {
10990		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstances(response, &metadata)
10991	}
10992	output := &GetInstancesOutput{}
10993	out.Result = output
10994
10995	var buff [1024]byte
10996	ringBuffer := smithyio.NewRingBuffer(buff[:])
10997
10998	body := io.TeeReader(response.Body, ringBuffer)
10999	decoder := json.NewDecoder(body)
11000	decoder.UseNumber()
11001	var shape interface{}
11002	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11003		var snapshot bytes.Buffer
11004		io.Copy(&snapshot, ringBuffer)
11005		err = &smithy.DeserializationError{
11006			Err:      fmt.Errorf("failed to decode response body, %w", err),
11007			Snapshot: snapshot.Bytes(),
11008		}
11009		return out, metadata, err
11010	}
11011
11012	err = awsAwsjson11_deserializeOpDocumentGetInstancesOutput(&output, shape)
11013	if err != nil {
11014		var snapshot bytes.Buffer
11015		io.Copy(&snapshot, ringBuffer)
11016		err = &smithy.DeserializationError{
11017			Err:      fmt.Errorf("failed to decode response body, %w", err),
11018			Snapshot: snapshot.Bytes(),
11019		}
11020		return out, metadata, err
11021	}
11022
11023	return out, metadata, err
11024}
11025
11026func awsAwsjson11_deserializeOpErrorGetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11027	var errorBuffer bytes.Buffer
11028	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11029		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11030	}
11031	errorBody := bytes.NewReader(errorBuffer.Bytes())
11032
11033	errorCode := "UnknownError"
11034	errorMessage := errorCode
11035
11036	code := response.Header.Get("X-Amzn-ErrorType")
11037	if len(code) != 0 {
11038		errorCode = restjson.SanitizeErrorCode(code)
11039	}
11040
11041	var buff [1024]byte
11042	ringBuffer := smithyio.NewRingBuffer(buff[:])
11043
11044	body := io.TeeReader(errorBody, ringBuffer)
11045	decoder := json.NewDecoder(body)
11046	decoder.UseNumber()
11047	code, message, err := restjson.GetErrorInfo(decoder)
11048	if err != nil {
11049		var snapshot bytes.Buffer
11050		io.Copy(&snapshot, ringBuffer)
11051		err = &smithy.DeserializationError{
11052			Err:      fmt.Errorf("failed to decode response body, %w", err),
11053			Snapshot: snapshot.Bytes(),
11054		}
11055		return err
11056	}
11057
11058	errorBody.Seek(0, io.SeekStart)
11059	if len(code) != 0 {
11060		errorCode = restjson.SanitizeErrorCode(code)
11061	}
11062	if len(message) != 0 {
11063		errorMessage = message
11064	}
11065
11066	switch {
11067	case strings.EqualFold("AccessDeniedException", errorCode):
11068		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11069
11070	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11071		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11072
11073	case strings.EqualFold("InvalidInputException", errorCode):
11074		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11075
11076	case strings.EqualFold("NotFoundException", errorCode):
11077		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11078
11079	case strings.EqualFold("OperationFailureException", errorCode):
11080		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11081
11082	case strings.EqualFold("ServiceException", errorCode):
11083		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11084
11085	case strings.EqualFold("UnauthenticatedException", errorCode):
11086		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11087
11088	default:
11089		genericError := &smithy.GenericAPIError{
11090			Code:    errorCode,
11091			Message: errorMessage,
11092		}
11093		return genericError
11094
11095	}
11096}
11097
11098type awsAwsjson11_deserializeOpGetInstanceSnapshot struct {
11099}
11100
11101func (*awsAwsjson11_deserializeOpGetInstanceSnapshot) ID() string {
11102	return "OperationDeserializer"
11103}
11104
11105func (m *awsAwsjson11_deserializeOpGetInstanceSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11106	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11107) {
11108	out, metadata, err = next.HandleDeserialize(ctx, in)
11109	if err != nil {
11110		return out, metadata, err
11111	}
11112
11113	response, ok := out.RawResponse.(*smithyhttp.Response)
11114	if !ok {
11115		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11116	}
11117
11118	if response.StatusCode < 200 || response.StatusCode >= 300 {
11119		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response, &metadata)
11120	}
11121	output := &GetInstanceSnapshotOutput{}
11122	out.Result = output
11123
11124	var buff [1024]byte
11125	ringBuffer := smithyio.NewRingBuffer(buff[:])
11126
11127	body := io.TeeReader(response.Body, ringBuffer)
11128	decoder := json.NewDecoder(body)
11129	decoder.UseNumber()
11130	var shape interface{}
11131	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11132		var snapshot bytes.Buffer
11133		io.Copy(&snapshot, ringBuffer)
11134		err = &smithy.DeserializationError{
11135			Err:      fmt.Errorf("failed to decode response body, %w", err),
11136			Snapshot: snapshot.Bytes(),
11137		}
11138		return out, metadata, err
11139	}
11140
11141	err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(&output, shape)
11142	if err != nil {
11143		var snapshot bytes.Buffer
11144		io.Copy(&snapshot, ringBuffer)
11145		err = &smithy.DeserializationError{
11146			Err:      fmt.Errorf("failed to decode response body, %w", err),
11147			Snapshot: snapshot.Bytes(),
11148		}
11149		return out, metadata, err
11150	}
11151
11152	return out, metadata, err
11153}
11154
11155func awsAwsjson11_deserializeOpErrorGetInstanceSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11156	var errorBuffer bytes.Buffer
11157	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11158		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11159	}
11160	errorBody := bytes.NewReader(errorBuffer.Bytes())
11161
11162	errorCode := "UnknownError"
11163	errorMessage := errorCode
11164
11165	code := response.Header.Get("X-Amzn-ErrorType")
11166	if len(code) != 0 {
11167		errorCode = restjson.SanitizeErrorCode(code)
11168	}
11169
11170	var buff [1024]byte
11171	ringBuffer := smithyio.NewRingBuffer(buff[:])
11172
11173	body := io.TeeReader(errorBody, ringBuffer)
11174	decoder := json.NewDecoder(body)
11175	decoder.UseNumber()
11176	code, message, err := restjson.GetErrorInfo(decoder)
11177	if err != nil {
11178		var snapshot bytes.Buffer
11179		io.Copy(&snapshot, ringBuffer)
11180		err = &smithy.DeserializationError{
11181			Err:      fmt.Errorf("failed to decode response body, %w", err),
11182			Snapshot: snapshot.Bytes(),
11183		}
11184		return err
11185	}
11186
11187	errorBody.Seek(0, io.SeekStart)
11188	if len(code) != 0 {
11189		errorCode = restjson.SanitizeErrorCode(code)
11190	}
11191	if len(message) != 0 {
11192		errorMessage = message
11193	}
11194
11195	switch {
11196	case strings.EqualFold("AccessDeniedException", errorCode):
11197		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11198
11199	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11200		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11201
11202	case strings.EqualFold("InvalidInputException", errorCode):
11203		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11204
11205	case strings.EqualFold("NotFoundException", errorCode):
11206		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11207
11208	case strings.EqualFold("OperationFailureException", errorCode):
11209		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11210
11211	case strings.EqualFold("ServiceException", errorCode):
11212		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11213
11214	case strings.EqualFold("UnauthenticatedException", errorCode):
11215		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11216
11217	default:
11218		genericError := &smithy.GenericAPIError{
11219			Code:    errorCode,
11220			Message: errorMessage,
11221		}
11222		return genericError
11223
11224	}
11225}
11226
11227type awsAwsjson11_deserializeOpGetInstanceSnapshots struct {
11228}
11229
11230func (*awsAwsjson11_deserializeOpGetInstanceSnapshots) ID() string {
11231	return "OperationDeserializer"
11232}
11233
11234func (m *awsAwsjson11_deserializeOpGetInstanceSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11235	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11236) {
11237	out, metadata, err = next.HandleDeserialize(ctx, in)
11238	if err != nil {
11239		return out, metadata, err
11240	}
11241
11242	response, ok := out.RawResponse.(*smithyhttp.Response)
11243	if !ok {
11244		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11245	}
11246
11247	if response.StatusCode < 200 || response.StatusCode >= 300 {
11248		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response, &metadata)
11249	}
11250	output := &GetInstanceSnapshotsOutput{}
11251	out.Result = output
11252
11253	var buff [1024]byte
11254	ringBuffer := smithyio.NewRingBuffer(buff[:])
11255
11256	body := io.TeeReader(response.Body, ringBuffer)
11257	decoder := json.NewDecoder(body)
11258	decoder.UseNumber()
11259	var shape interface{}
11260	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11261		var snapshot bytes.Buffer
11262		io.Copy(&snapshot, ringBuffer)
11263		err = &smithy.DeserializationError{
11264			Err:      fmt.Errorf("failed to decode response body, %w", err),
11265			Snapshot: snapshot.Bytes(),
11266		}
11267		return out, metadata, err
11268	}
11269
11270	err = awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(&output, shape)
11271	if err != nil {
11272		var snapshot bytes.Buffer
11273		io.Copy(&snapshot, ringBuffer)
11274		err = &smithy.DeserializationError{
11275			Err:      fmt.Errorf("failed to decode response body, %w", err),
11276			Snapshot: snapshot.Bytes(),
11277		}
11278		return out, metadata, err
11279	}
11280
11281	return out, metadata, err
11282}
11283
11284func awsAwsjson11_deserializeOpErrorGetInstanceSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11285	var errorBuffer bytes.Buffer
11286	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11287		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11288	}
11289	errorBody := bytes.NewReader(errorBuffer.Bytes())
11290
11291	errorCode := "UnknownError"
11292	errorMessage := errorCode
11293
11294	code := response.Header.Get("X-Amzn-ErrorType")
11295	if len(code) != 0 {
11296		errorCode = restjson.SanitizeErrorCode(code)
11297	}
11298
11299	var buff [1024]byte
11300	ringBuffer := smithyio.NewRingBuffer(buff[:])
11301
11302	body := io.TeeReader(errorBody, ringBuffer)
11303	decoder := json.NewDecoder(body)
11304	decoder.UseNumber()
11305	code, message, err := restjson.GetErrorInfo(decoder)
11306	if err != nil {
11307		var snapshot bytes.Buffer
11308		io.Copy(&snapshot, ringBuffer)
11309		err = &smithy.DeserializationError{
11310			Err:      fmt.Errorf("failed to decode response body, %w", err),
11311			Snapshot: snapshot.Bytes(),
11312		}
11313		return err
11314	}
11315
11316	errorBody.Seek(0, io.SeekStart)
11317	if len(code) != 0 {
11318		errorCode = restjson.SanitizeErrorCode(code)
11319	}
11320	if len(message) != 0 {
11321		errorMessage = message
11322	}
11323
11324	switch {
11325	case strings.EqualFold("AccessDeniedException", errorCode):
11326		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11327
11328	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11329		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11330
11331	case strings.EqualFold("InvalidInputException", errorCode):
11332		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11333
11334	case strings.EqualFold("NotFoundException", errorCode):
11335		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11336
11337	case strings.EqualFold("OperationFailureException", errorCode):
11338		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11339
11340	case strings.EqualFold("ServiceException", errorCode):
11341		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11342
11343	case strings.EqualFold("UnauthenticatedException", errorCode):
11344		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11345
11346	default:
11347		genericError := &smithy.GenericAPIError{
11348			Code:    errorCode,
11349			Message: errorMessage,
11350		}
11351		return genericError
11352
11353	}
11354}
11355
11356type awsAwsjson11_deserializeOpGetInstanceState struct {
11357}
11358
11359func (*awsAwsjson11_deserializeOpGetInstanceState) ID() string {
11360	return "OperationDeserializer"
11361}
11362
11363func (m *awsAwsjson11_deserializeOpGetInstanceState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11364	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11365) {
11366	out, metadata, err = next.HandleDeserialize(ctx, in)
11367	if err != nil {
11368		return out, metadata, err
11369	}
11370
11371	response, ok := out.RawResponse.(*smithyhttp.Response)
11372	if !ok {
11373		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11374	}
11375
11376	if response.StatusCode < 200 || response.StatusCode >= 300 {
11377		return out, metadata, awsAwsjson11_deserializeOpErrorGetInstanceState(response, &metadata)
11378	}
11379	output := &GetInstanceStateOutput{}
11380	out.Result = output
11381
11382	var buff [1024]byte
11383	ringBuffer := smithyio.NewRingBuffer(buff[:])
11384
11385	body := io.TeeReader(response.Body, ringBuffer)
11386	decoder := json.NewDecoder(body)
11387	decoder.UseNumber()
11388	var shape interface{}
11389	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11390		var snapshot bytes.Buffer
11391		io.Copy(&snapshot, ringBuffer)
11392		err = &smithy.DeserializationError{
11393			Err:      fmt.Errorf("failed to decode response body, %w", err),
11394			Snapshot: snapshot.Bytes(),
11395		}
11396		return out, metadata, err
11397	}
11398
11399	err = awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(&output, shape)
11400	if err != nil {
11401		var snapshot bytes.Buffer
11402		io.Copy(&snapshot, ringBuffer)
11403		err = &smithy.DeserializationError{
11404			Err:      fmt.Errorf("failed to decode response body, %w", err),
11405			Snapshot: snapshot.Bytes(),
11406		}
11407		return out, metadata, err
11408	}
11409
11410	return out, metadata, err
11411}
11412
11413func awsAwsjson11_deserializeOpErrorGetInstanceState(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11414	var errorBuffer bytes.Buffer
11415	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11416		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11417	}
11418	errorBody := bytes.NewReader(errorBuffer.Bytes())
11419
11420	errorCode := "UnknownError"
11421	errorMessage := errorCode
11422
11423	code := response.Header.Get("X-Amzn-ErrorType")
11424	if len(code) != 0 {
11425		errorCode = restjson.SanitizeErrorCode(code)
11426	}
11427
11428	var buff [1024]byte
11429	ringBuffer := smithyio.NewRingBuffer(buff[:])
11430
11431	body := io.TeeReader(errorBody, ringBuffer)
11432	decoder := json.NewDecoder(body)
11433	decoder.UseNumber()
11434	code, message, err := restjson.GetErrorInfo(decoder)
11435	if err != nil {
11436		var snapshot bytes.Buffer
11437		io.Copy(&snapshot, ringBuffer)
11438		err = &smithy.DeserializationError{
11439			Err:      fmt.Errorf("failed to decode response body, %w", err),
11440			Snapshot: snapshot.Bytes(),
11441		}
11442		return err
11443	}
11444
11445	errorBody.Seek(0, io.SeekStart)
11446	if len(code) != 0 {
11447		errorCode = restjson.SanitizeErrorCode(code)
11448	}
11449	if len(message) != 0 {
11450		errorMessage = message
11451	}
11452
11453	switch {
11454	case strings.EqualFold("AccessDeniedException", errorCode):
11455		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11456
11457	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11458		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11459
11460	case strings.EqualFold("InvalidInputException", errorCode):
11461		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11462
11463	case strings.EqualFold("NotFoundException", errorCode):
11464		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11465
11466	case strings.EqualFold("OperationFailureException", errorCode):
11467		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11468
11469	case strings.EqualFold("ServiceException", errorCode):
11470		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11471
11472	case strings.EqualFold("UnauthenticatedException", errorCode):
11473		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11474
11475	default:
11476		genericError := &smithy.GenericAPIError{
11477			Code:    errorCode,
11478			Message: errorMessage,
11479		}
11480		return genericError
11481
11482	}
11483}
11484
11485type awsAwsjson11_deserializeOpGetKeyPair struct {
11486}
11487
11488func (*awsAwsjson11_deserializeOpGetKeyPair) ID() string {
11489	return "OperationDeserializer"
11490}
11491
11492func (m *awsAwsjson11_deserializeOpGetKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11493	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11494) {
11495	out, metadata, err = next.HandleDeserialize(ctx, in)
11496	if err != nil {
11497		return out, metadata, err
11498	}
11499
11500	response, ok := out.RawResponse.(*smithyhttp.Response)
11501	if !ok {
11502		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11503	}
11504
11505	if response.StatusCode < 200 || response.StatusCode >= 300 {
11506		return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPair(response, &metadata)
11507	}
11508	output := &GetKeyPairOutput{}
11509	out.Result = output
11510
11511	var buff [1024]byte
11512	ringBuffer := smithyio.NewRingBuffer(buff[:])
11513
11514	body := io.TeeReader(response.Body, ringBuffer)
11515	decoder := json.NewDecoder(body)
11516	decoder.UseNumber()
11517	var shape interface{}
11518	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11519		var snapshot bytes.Buffer
11520		io.Copy(&snapshot, ringBuffer)
11521		err = &smithy.DeserializationError{
11522			Err:      fmt.Errorf("failed to decode response body, %w", err),
11523			Snapshot: snapshot.Bytes(),
11524		}
11525		return out, metadata, err
11526	}
11527
11528	err = awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(&output, shape)
11529	if err != nil {
11530		var snapshot bytes.Buffer
11531		io.Copy(&snapshot, ringBuffer)
11532		err = &smithy.DeserializationError{
11533			Err:      fmt.Errorf("failed to decode response body, %w", err),
11534			Snapshot: snapshot.Bytes(),
11535		}
11536		return out, metadata, err
11537	}
11538
11539	return out, metadata, err
11540}
11541
11542func awsAwsjson11_deserializeOpErrorGetKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11543	var errorBuffer bytes.Buffer
11544	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11545		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11546	}
11547	errorBody := bytes.NewReader(errorBuffer.Bytes())
11548
11549	errorCode := "UnknownError"
11550	errorMessage := errorCode
11551
11552	code := response.Header.Get("X-Amzn-ErrorType")
11553	if len(code) != 0 {
11554		errorCode = restjson.SanitizeErrorCode(code)
11555	}
11556
11557	var buff [1024]byte
11558	ringBuffer := smithyio.NewRingBuffer(buff[:])
11559
11560	body := io.TeeReader(errorBody, ringBuffer)
11561	decoder := json.NewDecoder(body)
11562	decoder.UseNumber()
11563	code, message, err := restjson.GetErrorInfo(decoder)
11564	if err != nil {
11565		var snapshot bytes.Buffer
11566		io.Copy(&snapshot, ringBuffer)
11567		err = &smithy.DeserializationError{
11568			Err:      fmt.Errorf("failed to decode response body, %w", err),
11569			Snapshot: snapshot.Bytes(),
11570		}
11571		return err
11572	}
11573
11574	errorBody.Seek(0, io.SeekStart)
11575	if len(code) != 0 {
11576		errorCode = restjson.SanitizeErrorCode(code)
11577	}
11578	if len(message) != 0 {
11579		errorMessage = message
11580	}
11581
11582	switch {
11583	case strings.EqualFold("AccessDeniedException", errorCode):
11584		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11585
11586	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11587		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11588
11589	case strings.EqualFold("InvalidInputException", errorCode):
11590		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11591
11592	case strings.EqualFold("NotFoundException", errorCode):
11593		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11594
11595	case strings.EqualFold("OperationFailureException", errorCode):
11596		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11597
11598	case strings.EqualFold("ServiceException", errorCode):
11599		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11600
11601	case strings.EqualFold("UnauthenticatedException", errorCode):
11602		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11603
11604	default:
11605		genericError := &smithy.GenericAPIError{
11606			Code:    errorCode,
11607			Message: errorMessage,
11608		}
11609		return genericError
11610
11611	}
11612}
11613
11614type awsAwsjson11_deserializeOpGetKeyPairs struct {
11615}
11616
11617func (*awsAwsjson11_deserializeOpGetKeyPairs) ID() string {
11618	return "OperationDeserializer"
11619}
11620
11621func (m *awsAwsjson11_deserializeOpGetKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11622	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11623) {
11624	out, metadata, err = next.HandleDeserialize(ctx, in)
11625	if err != nil {
11626		return out, metadata, err
11627	}
11628
11629	response, ok := out.RawResponse.(*smithyhttp.Response)
11630	if !ok {
11631		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11632	}
11633
11634	if response.StatusCode < 200 || response.StatusCode >= 300 {
11635		return out, metadata, awsAwsjson11_deserializeOpErrorGetKeyPairs(response, &metadata)
11636	}
11637	output := &GetKeyPairsOutput{}
11638	out.Result = output
11639
11640	var buff [1024]byte
11641	ringBuffer := smithyio.NewRingBuffer(buff[:])
11642
11643	body := io.TeeReader(response.Body, ringBuffer)
11644	decoder := json.NewDecoder(body)
11645	decoder.UseNumber()
11646	var shape interface{}
11647	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11648		var snapshot bytes.Buffer
11649		io.Copy(&snapshot, ringBuffer)
11650		err = &smithy.DeserializationError{
11651			Err:      fmt.Errorf("failed to decode response body, %w", err),
11652			Snapshot: snapshot.Bytes(),
11653		}
11654		return out, metadata, err
11655	}
11656
11657	err = awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(&output, shape)
11658	if err != nil {
11659		var snapshot bytes.Buffer
11660		io.Copy(&snapshot, ringBuffer)
11661		err = &smithy.DeserializationError{
11662			Err:      fmt.Errorf("failed to decode response body, %w", err),
11663			Snapshot: snapshot.Bytes(),
11664		}
11665		return out, metadata, err
11666	}
11667
11668	return out, metadata, err
11669}
11670
11671func awsAwsjson11_deserializeOpErrorGetKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11672	var errorBuffer bytes.Buffer
11673	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11674		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11675	}
11676	errorBody := bytes.NewReader(errorBuffer.Bytes())
11677
11678	errorCode := "UnknownError"
11679	errorMessage := errorCode
11680
11681	code := response.Header.Get("X-Amzn-ErrorType")
11682	if len(code) != 0 {
11683		errorCode = restjson.SanitizeErrorCode(code)
11684	}
11685
11686	var buff [1024]byte
11687	ringBuffer := smithyio.NewRingBuffer(buff[:])
11688
11689	body := io.TeeReader(errorBody, ringBuffer)
11690	decoder := json.NewDecoder(body)
11691	decoder.UseNumber()
11692	code, message, err := restjson.GetErrorInfo(decoder)
11693	if err != nil {
11694		var snapshot bytes.Buffer
11695		io.Copy(&snapshot, ringBuffer)
11696		err = &smithy.DeserializationError{
11697			Err:      fmt.Errorf("failed to decode response body, %w", err),
11698			Snapshot: snapshot.Bytes(),
11699		}
11700		return err
11701	}
11702
11703	errorBody.Seek(0, io.SeekStart)
11704	if len(code) != 0 {
11705		errorCode = restjson.SanitizeErrorCode(code)
11706	}
11707	if len(message) != 0 {
11708		errorMessage = message
11709	}
11710
11711	switch {
11712	case strings.EqualFold("AccessDeniedException", errorCode):
11713		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11714
11715	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11716		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11717
11718	case strings.EqualFold("InvalidInputException", errorCode):
11719		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11720
11721	case strings.EqualFold("NotFoundException", errorCode):
11722		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11723
11724	case strings.EqualFold("OperationFailureException", errorCode):
11725		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11726
11727	case strings.EqualFold("ServiceException", errorCode):
11728		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11729
11730	case strings.EqualFold("UnauthenticatedException", errorCode):
11731		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11732
11733	default:
11734		genericError := &smithy.GenericAPIError{
11735			Code:    errorCode,
11736			Message: errorMessage,
11737		}
11738		return genericError
11739
11740	}
11741}
11742
11743type awsAwsjson11_deserializeOpGetLoadBalancer struct {
11744}
11745
11746func (*awsAwsjson11_deserializeOpGetLoadBalancer) ID() string {
11747	return "OperationDeserializer"
11748}
11749
11750func (m *awsAwsjson11_deserializeOpGetLoadBalancer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11751	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11752) {
11753	out, metadata, err = next.HandleDeserialize(ctx, in)
11754	if err != nil {
11755		return out, metadata, err
11756	}
11757
11758	response, ok := out.RawResponse.(*smithyhttp.Response)
11759	if !ok {
11760		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11761	}
11762
11763	if response.StatusCode < 200 || response.StatusCode >= 300 {
11764		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancer(response, &metadata)
11765	}
11766	output := &GetLoadBalancerOutput{}
11767	out.Result = output
11768
11769	var buff [1024]byte
11770	ringBuffer := smithyio.NewRingBuffer(buff[:])
11771
11772	body := io.TeeReader(response.Body, ringBuffer)
11773	decoder := json.NewDecoder(body)
11774	decoder.UseNumber()
11775	var shape interface{}
11776	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11777		var snapshot bytes.Buffer
11778		io.Copy(&snapshot, ringBuffer)
11779		err = &smithy.DeserializationError{
11780			Err:      fmt.Errorf("failed to decode response body, %w", err),
11781			Snapshot: snapshot.Bytes(),
11782		}
11783		return out, metadata, err
11784	}
11785
11786	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(&output, shape)
11787	if err != nil {
11788		var snapshot bytes.Buffer
11789		io.Copy(&snapshot, ringBuffer)
11790		err = &smithy.DeserializationError{
11791			Err:      fmt.Errorf("failed to decode response body, %w", err),
11792			Snapshot: snapshot.Bytes(),
11793		}
11794		return out, metadata, err
11795	}
11796
11797	return out, metadata, err
11798}
11799
11800func awsAwsjson11_deserializeOpErrorGetLoadBalancer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11801	var errorBuffer bytes.Buffer
11802	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11803		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11804	}
11805	errorBody := bytes.NewReader(errorBuffer.Bytes())
11806
11807	errorCode := "UnknownError"
11808	errorMessage := errorCode
11809
11810	code := response.Header.Get("X-Amzn-ErrorType")
11811	if len(code) != 0 {
11812		errorCode = restjson.SanitizeErrorCode(code)
11813	}
11814
11815	var buff [1024]byte
11816	ringBuffer := smithyio.NewRingBuffer(buff[:])
11817
11818	body := io.TeeReader(errorBody, ringBuffer)
11819	decoder := json.NewDecoder(body)
11820	decoder.UseNumber()
11821	code, message, err := restjson.GetErrorInfo(decoder)
11822	if err != nil {
11823		var snapshot bytes.Buffer
11824		io.Copy(&snapshot, ringBuffer)
11825		err = &smithy.DeserializationError{
11826			Err:      fmt.Errorf("failed to decode response body, %w", err),
11827			Snapshot: snapshot.Bytes(),
11828		}
11829		return err
11830	}
11831
11832	errorBody.Seek(0, io.SeekStart)
11833	if len(code) != 0 {
11834		errorCode = restjson.SanitizeErrorCode(code)
11835	}
11836	if len(message) != 0 {
11837		errorMessage = message
11838	}
11839
11840	switch {
11841	case strings.EqualFold("AccessDeniedException", errorCode):
11842		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11843
11844	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11845		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11846
11847	case strings.EqualFold("InvalidInputException", errorCode):
11848		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11849
11850	case strings.EqualFold("NotFoundException", errorCode):
11851		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11852
11853	case strings.EqualFold("OperationFailureException", errorCode):
11854		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11855
11856	case strings.EqualFold("ServiceException", errorCode):
11857		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11858
11859	case strings.EqualFold("UnauthenticatedException", errorCode):
11860		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11861
11862	default:
11863		genericError := &smithy.GenericAPIError{
11864			Code:    errorCode,
11865			Message: errorMessage,
11866		}
11867		return genericError
11868
11869	}
11870}
11871
11872type awsAwsjson11_deserializeOpGetLoadBalancerMetricData struct {
11873}
11874
11875func (*awsAwsjson11_deserializeOpGetLoadBalancerMetricData) ID() string {
11876	return "OperationDeserializer"
11877}
11878
11879func (m *awsAwsjson11_deserializeOpGetLoadBalancerMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
11880	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
11881) {
11882	out, metadata, err = next.HandleDeserialize(ctx, in)
11883	if err != nil {
11884		return out, metadata, err
11885	}
11886
11887	response, ok := out.RawResponse.(*smithyhttp.Response)
11888	if !ok {
11889		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
11890	}
11891
11892	if response.StatusCode < 200 || response.StatusCode >= 300 {
11893		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response, &metadata)
11894	}
11895	output := &GetLoadBalancerMetricDataOutput{}
11896	out.Result = output
11897
11898	var buff [1024]byte
11899	ringBuffer := smithyio.NewRingBuffer(buff[:])
11900
11901	body := io.TeeReader(response.Body, ringBuffer)
11902	decoder := json.NewDecoder(body)
11903	decoder.UseNumber()
11904	var shape interface{}
11905	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
11906		var snapshot bytes.Buffer
11907		io.Copy(&snapshot, ringBuffer)
11908		err = &smithy.DeserializationError{
11909			Err:      fmt.Errorf("failed to decode response body, %w", err),
11910			Snapshot: snapshot.Bytes(),
11911		}
11912		return out, metadata, err
11913	}
11914
11915	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(&output, shape)
11916	if err != nil {
11917		var snapshot bytes.Buffer
11918		io.Copy(&snapshot, ringBuffer)
11919		err = &smithy.DeserializationError{
11920			Err:      fmt.Errorf("failed to decode response body, %w", err),
11921			Snapshot: snapshot.Bytes(),
11922		}
11923		return out, metadata, err
11924	}
11925
11926	return out, metadata, err
11927}
11928
11929func awsAwsjson11_deserializeOpErrorGetLoadBalancerMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
11930	var errorBuffer bytes.Buffer
11931	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
11932		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
11933	}
11934	errorBody := bytes.NewReader(errorBuffer.Bytes())
11935
11936	errorCode := "UnknownError"
11937	errorMessage := errorCode
11938
11939	code := response.Header.Get("X-Amzn-ErrorType")
11940	if len(code) != 0 {
11941		errorCode = restjson.SanitizeErrorCode(code)
11942	}
11943
11944	var buff [1024]byte
11945	ringBuffer := smithyio.NewRingBuffer(buff[:])
11946
11947	body := io.TeeReader(errorBody, ringBuffer)
11948	decoder := json.NewDecoder(body)
11949	decoder.UseNumber()
11950	code, message, err := restjson.GetErrorInfo(decoder)
11951	if err != nil {
11952		var snapshot bytes.Buffer
11953		io.Copy(&snapshot, ringBuffer)
11954		err = &smithy.DeserializationError{
11955			Err:      fmt.Errorf("failed to decode response body, %w", err),
11956			Snapshot: snapshot.Bytes(),
11957		}
11958		return err
11959	}
11960
11961	errorBody.Seek(0, io.SeekStart)
11962	if len(code) != 0 {
11963		errorCode = restjson.SanitizeErrorCode(code)
11964	}
11965	if len(message) != 0 {
11966		errorMessage = message
11967	}
11968
11969	switch {
11970	case strings.EqualFold("AccessDeniedException", errorCode):
11971		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
11972
11973	case strings.EqualFold("AccountSetupInProgressException", errorCode):
11974		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
11975
11976	case strings.EqualFold("InvalidInputException", errorCode):
11977		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
11978
11979	case strings.EqualFold("NotFoundException", errorCode):
11980		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
11981
11982	case strings.EqualFold("OperationFailureException", errorCode):
11983		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
11984
11985	case strings.EqualFold("ServiceException", errorCode):
11986		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
11987
11988	case strings.EqualFold("UnauthenticatedException", errorCode):
11989		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
11990
11991	default:
11992		genericError := &smithy.GenericAPIError{
11993			Code:    errorCode,
11994			Message: errorMessage,
11995		}
11996		return genericError
11997
11998	}
11999}
12000
12001type awsAwsjson11_deserializeOpGetLoadBalancers struct {
12002}
12003
12004func (*awsAwsjson11_deserializeOpGetLoadBalancers) ID() string {
12005	return "OperationDeserializer"
12006}
12007
12008func (m *awsAwsjson11_deserializeOpGetLoadBalancers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12009	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12010) {
12011	out, metadata, err = next.HandleDeserialize(ctx, in)
12012	if err != nil {
12013		return out, metadata, err
12014	}
12015
12016	response, ok := out.RawResponse.(*smithyhttp.Response)
12017	if !ok {
12018		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12019	}
12020
12021	if response.StatusCode < 200 || response.StatusCode >= 300 {
12022		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancers(response, &metadata)
12023	}
12024	output := &GetLoadBalancersOutput{}
12025	out.Result = output
12026
12027	var buff [1024]byte
12028	ringBuffer := smithyio.NewRingBuffer(buff[:])
12029
12030	body := io.TeeReader(response.Body, ringBuffer)
12031	decoder := json.NewDecoder(body)
12032	decoder.UseNumber()
12033	var shape interface{}
12034	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12035		var snapshot bytes.Buffer
12036		io.Copy(&snapshot, ringBuffer)
12037		err = &smithy.DeserializationError{
12038			Err:      fmt.Errorf("failed to decode response body, %w", err),
12039			Snapshot: snapshot.Bytes(),
12040		}
12041		return out, metadata, err
12042	}
12043
12044	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(&output, shape)
12045	if err != nil {
12046		var snapshot bytes.Buffer
12047		io.Copy(&snapshot, ringBuffer)
12048		err = &smithy.DeserializationError{
12049			Err:      fmt.Errorf("failed to decode response body, %w", err),
12050			Snapshot: snapshot.Bytes(),
12051		}
12052		return out, metadata, err
12053	}
12054
12055	return out, metadata, err
12056}
12057
12058func awsAwsjson11_deserializeOpErrorGetLoadBalancers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12059	var errorBuffer bytes.Buffer
12060	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12061		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12062	}
12063	errorBody := bytes.NewReader(errorBuffer.Bytes())
12064
12065	errorCode := "UnknownError"
12066	errorMessage := errorCode
12067
12068	code := response.Header.Get("X-Amzn-ErrorType")
12069	if len(code) != 0 {
12070		errorCode = restjson.SanitizeErrorCode(code)
12071	}
12072
12073	var buff [1024]byte
12074	ringBuffer := smithyio.NewRingBuffer(buff[:])
12075
12076	body := io.TeeReader(errorBody, ringBuffer)
12077	decoder := json.NewDecoder(body)
12078	decoder.UseNumber()
12079	code, message, err := restjson.GetErrorInfo(decoder)
12080	if err != nil {
12081		var snapshot bytes.Buffer
12082		io.Copy(&snapshot, ringBuffer)
12083		err = &smithy.DeserializationError{
12084			Err:      fmt.Errorf("failed to decode response body, %w", err),
12085			Snapshot: snapshot.Bytes(),
12086		}
12087		return err
12088	}
12089
12090	errorBody.Seek(0, io.SeekStart)
12091	if len(code) != 0 {
12092		errorCode = restjson.SanitizeErrorCode(code)
12093	}
12094	if len(message) != 0 {
12095		errorMessage = message
12096	}
12097
12098	switch {
12099	case strings.EqualFold("AccessDeniedException", errorCode):
12100		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12101
12102	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12103		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12104
12105	case strings.EqualFold("InvalidInputException", errorCode):
12106		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12107
12108	case strings.EqualFold("NotFoundException", errorCode):
12109		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12110
12111	case strings.EqualFold("OperationFailureException", errorCode):
12112		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12113
12114	case strings.EqualFold("ServiceException", errorCode):
12115		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12116
12117	case strings.EqualFold("UnauthenticatedException", errorCode):
12118		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12119
12120	default:
12121		genericError := &smithy.GenericAPIError{
12122			Code:    errorCode,
12123			Message: errorMessage,
12124		}
12125		return genericError
12126
12127	}
12128}
12129
12130type awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates struct {
12131}
12132
12133func (*awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) ID() string {
12134	return "OperationDeserializer"
12135}
12136
12137func (m *awsAwsjson11_deserializeOpGetLoadBalancerTlsCertificates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12138	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12139) {
12140	out, metadata, err = next.HandleDeserialize(ctx, in)
12141	if err != nil {
12142		return out, metadata, err
12143	}
12144
12145	response, ok := out.RawResponse.(*smithyhttp.Response)
12146	if !ok {
12147		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12148	}
12149
12150	if response.StatusCode < 200 || response.StatusCode >= 300 {
12151		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response, &metadata)
12152	}
12153	output := &GetLoadBalancerTlsCertificatesOutput{}
12154	out.Result = output
12155
12156	var buff [1024]byte
12157	ringBuffer := smithyio.NewRingBuffer(buff[:])
12158
12159	body := io.TeeReader(response.Body, ringBuffer)
12160	decoder := json.NewDecoder(body)
12161	decoder.UseNumber()
12162	var shape interface{}
12163	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12164		var snapshot bytes.Buffer
12165		io.Copy(&snapshot, ringBuffer)
12166		err = &smithy.DeserializationError{
12167			Err:      fmt.Errorf("failed to decode response body, %w", err),
12168			Snapshot: snapshot.Bytes(),
12169		}
12170		return out, metadata, err
12171	}
12172
12173	err = awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(&output, shape)
12174	if err != nil {
12175		var snapshot bytes.Buffer
12176		io.Copy(&snapshot, ringBuffer)
12177		err = &smithy.DeserializationError{
12178			Err:      fmt.Errorf("failed to decode response body, %w", err),
12179			Snapshot: snapshot.Bytes(),
12180		}
12181		return out, metadata, err
12182	}
12183
12184	return out, metadata, err
12185}
12186
12187func awsAwsjson11_deserializeOpErrorGetLoadBalancerTlsCertificates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12188	var errorBuffer bytes.Buffer
12189	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12190		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12191	}
12192	errorBody := bytes.NewReader(errorBuffer.Bytes())
12193
12194	errorCode := "UnknownError"
12195	errorMessage := errorCode
12196
12197	code := response.Header.Get("X-Amzn-ErrorType")
12198	if len(code) != 0 {
12199		errorCode = restjson.SanitizeErrorCode(code)
12200	}
12201
12202	var buff [1024]byte
12203	ringBuffer := smithyio.NewRingBuffer(buff[:])
12204
12205	body := io.TeeReader(errorBody, ringBuffer)
12206	decoder := json.NewDecoder(body)
12207	decoder.UseNumber()
12208	code, message, err := restjson.GetErrorInfo(decoder)
12209	if err != nil {
12210		var snapshot bytes.Buffer
12211		io.Copy(&snapshot, ringBuffer)
12212		err = &smithy.DeserializationError{
12213			Err:      fmt.Errorf("failed to decode response body, %w", err),
12214			Snapshot: snapshot.Bytes(),
12215		}
12216		return err
12217	}
12218
12219	errorBody.Seek(0, io.SeekStart)
12220	if len(code) != 0 {
12221		errorCode = restjson.SanitizeErrorCode(code)
12222	}
12223	if len(message) != 0 {
12224		errorMessage = message
12225	}
12226
12227	switch {
12228	case strings.EqualFold("AccessDeniedException", errorCode):
12229		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12230
12231	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12232		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12233
12234	case strings.EqualFold("InvalidInputException", errorCode):
12235		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12236
12237	case strings.EqualFold("NotFoundException", errorCode):
12238		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12239
12240	case strings.EqualFold("OperationFailureException", errorCode):
12241		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12242
12243	case strings.EqualFold("ServiceException", errorCode):
12244		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12245
12246	case strings.EqualFold("UnauthenticatedException", errorCode):
12247		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12248
12249	default:
12250		genericError := &smithy.GenericAPIError{
12251			Code:    errorCode,
12252			Message: errorMessage,
12253		}
12254		return genericError
12255
12256	}
12257}
12258
12259type awsAwsjson11_deserializeOpGetOperation struct {
12260}
12261
12262func (*awsAwsjson11_deserializeOpGetOperation) ID() string {
12263	return "OperationDeserializer"
12264}
12265
12266func (m *awsAwsjson11_deserializeOpGetOperation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12267	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12268) {
12269	out, metadata, err = next.HandleDeserialize(ctx, in)
12270	if err != nil {
12271		return out, metadata, err
12272	}
12273
12274	response, ok := out.RawResponse.(*smithyhttp.Response)
12275	if !ok {
12276		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12277	}
12278
12279	if response.StatusCode < 200 || response.StatusCode >= 300 {
12280		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperation(response, &metadata)
12281	}
12282	output := &GetOperationOutput{}
12283	out.Result = output
12284
12285	var buff [1024]byte
12286	ringBuffer := smithyio.NewRingBuffer(buff[:])
12287
12288	body := io.TeeReader(response.Body, ringBuffer)
12289	decoder := json.NewDecoder(body)
12290	decoder.UseNumber()
12291	var shape interface{}
12292	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12293		var snapshot bytes.Buffer
12294		io.Copy(&snapshot, ringBuffer)
12295		err = &smithy.DeserializationError{
12296			Err:      fmt.Errorf("failed to decode response body, %w", err),
12297			Snapshot: snapshot.Bytes(),
12298		}
12299		return out, metadata, err
12300	}
12301
12302	err = awsAwsjson11_deserializeOpDocumentGetOperationOutput(&output, shape)
12303	if err != nil {
12304		var snapshot bytes.Buffer
12305		io.Copy(&snapshot, ringBuffer)
12306		err = &smithy.DeserializationError{
12307			Err:      fmt.Errorf("failed to decode response body, %w", err),
12308			Snapshot: snapshot.Bytes(),
12309		}
12310		return out, metadata, err
12311	}
12312
12313	return out, metadata, err
12314}
12315
12316func awsAwsjson11_deserializeOpErrorGetOperation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12317	var errorBuffer bytes.Buffer
12318	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12319		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12320	}
12321	errorBody := bytes.NewReader(errorBuffer.Bytes())
12322
12323	errorCode := "UnknownError"
12324	errorMessage := errorCode
12325
12326	code := response.Header.Get("X-Amzn-ErrorType")
12327	if len(code) != 0 {
12328		errorCode = restjson.SanitizeErrorCode(code)
12329	}
12330
12331	var buff [1024]byte
12332	ringBuffer := smithyio.NewRingBuffer(buff[:])
12333
12334	body := io.TeeReader(errorBody, ringBuffer)
12335	decoder := json.NewDecoder(body)
12336	decoder.UseNumber()
12337	code, message, err := restjson.GetErrorInfo(decoder)
12338	if err != nil {
12339		var snapshot bytes.Buffer
12340		io.Copy(&snapshot, ringBuffer)
12341		err = &smithy.DeserializationError{
12342			Err:      fmt.Errorf("failed to decode response body, %w", err),
12343			Snapshot: snapshot.Bytes(),
12344		}
12345		return err
12346	}
12347
12348	errorBody.Seek(0, io.SeekStart)
12349	if len(code) != 0 {
12350		errorCode = restjson.SanitizeErrorCode(code)
12351	}
12352	if len(message) != 0 {
12353		errorMessage = message
12354	}
12355
12356	switch {
12357	case strings.EqualFold("AccessDeniedException", errorCode):
12358		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12359
12360	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12361		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12362
12363	case strings.EqualFold("InvalidInputException", errorCode):
12364		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12365
12366	case strings.EqualFold("NotFoundException", errorCode):
12367		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12368
12369	case strings.EqualFold("OperationFailureException", errorCode):
12370		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12371
12372	case strings.EqualFold("ServiceException", errorCode):
12373		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12374
12375	case strings.EqualFold("UnauthenticatedException", errorCode):
12376		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12377
12378	default:
12379		genericError := &smithy.GenericAPIError{
12380			Code:    errorCode,
12381			Message: errorMessage,
12382		}
12383		return genericError
12384
12385	}
12386}
12387
12388type awsAwsjson11_deserializeOpGetOperations struct {
12389}
12390
12391func (*awsAwsjson11_deserializeOpGetOperations) ID() string {
12392	return "OperationDeserializer"
12393}
12394
12395func (m *awsAwsjson11_deserializeOpGetOperations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12396	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12397) {
12398	out, metadata, err = next.HandleDeserialize(ctx, in)
12399	if err != nil {
12400		return out, metadata, err
12401	}
12402
12403	response, ok := out.RawResponse.(*smithyhttp.Response)
12404	if !ok {
12405		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12406	}
12407
12408	if response.StatusCode < 200 || response.StatusCode >= 300 {
12409		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperations(response, &metadata)
12410	}
12411	output := &GetOperationsOutput{}
12412	out.Result = output
12413
12414	var buff [1024]byte
12415	ringBuffer := smithyio.NewRingBuffer(buff[:])
12416
12417	body := io.TeeReader(response.Body, ringBuffer)
12418	decoder := json.NewDecoder(body)
12419	decoder.UseNumber()
12420	var shape interface{}
12421	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12422		var snapshot bytes.Buffer
12423		io.Copy(&snapshot, ringBuffer)
12424		err = &smithy.DeserializationError{
12425			Err:      fmt.Errorf("failed to decode response body, %w", err),
12426			Snapshot: snapshot.Bytes(),
12427		}
12428		return out, metadata, err
12429	}
12430
12431	err = awsAwsjson11_deserializeOpDocumentGetOperationsOutput(&output, shape)
12432	if err != nil {
12433		var snapshot bytes.Buffer
12434		io.Copy(&snapshot, ringBuffer)
12435		err = &smithy.DeserializationError{
12436			Err:      fmt.Errorf("failed to decode response body, %w", err),
12437			Snapshot: snapshot.Bytes(),
12438		}
12439		return out, metadata, err
12440	}
12441
12442	return out, metadata, err
12443}
12444
12445func awsAwsjson11_deserializeOpErrorGetOperations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12446	var errorBuffer bytes.Buffer
12447	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12448		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12449	}
12450	errorBody := bytes.NewReader(errorBuffer.Bytes())
12451
12452	errorCode := "UnknownError"
12453	errorMessage := errorCode
12454
12455	code := response.Header.Get("X-Amzn-ErrorType")
12456	if len(code) != 0 {
12457		errorCode = restjson.SanitizeErrorCode(code)
12458	}
12459
12460	var buff [1024]byte
12461	ringBuffer := smithyio.NewRingBuffer(buff[:])
12462
12463	body := io.TeeReader(errorBody, ringBuffer)
12464	decoder := json.NewDecoder(body)
12465	decoder.UseNumber()
12466	code, message, err := restjson.GetErrorInfo(decoder)
12467	if err != nil {
12468		var snapshot bytes.Buffer
12469		io.Copy(&snapshot, ringBuffer)
12470		err = &smithy.DeserializationError{
12471			Err:      fmt.Errorf("failed to decode response body, %w", err),
12472			Snapshot: snapshot.Bytes(),
12473		}
12474		return err
12475	}
12476
12477	errorBody.Seek(0, io.SeekStart)
12478	if len(code) != 0 {
12479		errorCode = restjson.SanitizeErrorCode(code)
12480	}
12481	if len(message) != 0 {
12482		errorMessage = message
12483	}
12484
12485	switch {
12486	case strings.EqualFold("AccessDeniedException", errorCode):
12487		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12488
12489	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12490		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12491
12492	case strings.EqualFold("InvalidInputException", errorCode):
12493		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12494
12495	case strings.EqualFold("NotFoundException", errorCode):
12496		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12497
12498	case strings.EqualFold("OperationFailureException", errorCode):
12499		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12500
12501	case strings.EqualFold("ServiceException", errorCode):
12502		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12503
12504	case strings.EqualFold("UnauthenticatedException", errorCode):
12505		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12506
12507	default:
12508		genericError := &smithy.GenericAPIError{
12509			Code:    errorCode,
12510			Message: errorMessage,
12511		}
12512		return genericError
12513
12514	}
12515}
12516
12517type awsAwsjson11_deserializeOpGetOperationsForResource struct {
12518}
12519
12520func (*awsAwsjson11_deserializeOpGetOperationsForResource) ID() string {
12521	return "OperationDeserializer"
12522}
12523
12524func (m *awsAwsjson11_deserializeOpGetOperationsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12525	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12526) {
12527	out, metadata, err = next.HandleDeserialize(ctx, in)
12528	if err != nil {
12529		return out, metadata, err
12530	}
12531
12532	response, ok := out.RawResponse.(*smithyhttp.Response)
12533	if !ok {
12534		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12535	}
12536
12537	if response.StatusCode < 200 || response.StatusCode >= 300 {
12538		return out, metadata, awsAwsjson11_deserializeOpErrorGetOperationsForResource(response, &metadata)
12539	}
12540	output := &GetOperationsForResourceOutput{}
12541	out.Result = output
12542
12543	var buff [1024]byte
12544	ringBuffer := smithyio.NewRingBuffer(buff[:])
12545
12546	body := io.TeeReader(response.Body, ringBuffer)
12547	decoder := json.NewDecoder(body)
12548	decoder.UseNumber()
12549	var shape interface{}
12550	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12551		var snapshot bytes.Buffer
12552		io.Copy(&snapshot, ringBuffer)
12553		err = &smithy.DeserializationError{
12554			Err:      fmt.Errorf("failed to decode response body, %w", err),
12555			Snapshot: snapshot.Bytes(),
12556		}
12557		return out, metadata, err
12558	}
12559
12560	err = awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(&output, shape)
12561	if err != nil {
12562		var snapshot bytes.Buffer
12563		io.Copy(&snapshot, ringBuffer)
12564		err = &smithy.DeserializationError{
12565			Err:      fmt.Errorf("failed to decode response body, %w", err),
12566			Snapshot: snapshot.Bytes(),
12567		}
12568		return out, metadata, err
12569	}
12570
12571	return out, metadata, err
12572}
12573
12574func awsAwsjson11_deserializeOpErrorGetOperationsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12575	var errorBuffer bytes.Buffer
12576	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12577		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12578	}
12579	errorBody := bytes.NewReader(errorBuffer.Bytes())
12580
12581	errorCode := "UnknownError"
12582	errorMessage := errorCode
12583
12584	code := response.Header.Get("X-Amzn-ErrorType")
12585	if len(code) != 0 {
12586		errorCode = restjson.SanitizeErrorCode(code)
12587	}
12588
12589	var buff [1024]byte
12590	ringBuffer := smithyio.NewRingBuffer(buff[:])
12591
12592	body := io.TeeReader(errorBody, ringBuffer)
12593	decoder := json.NewDecoder(body)
12594	decoder.UseNumber()
12595	code, message, err := restjson.GetErrorInfo(decoder)
12596	if err != nil {
12597		var snapshot bytes.Buffer
12598		io.Copy(&snapshot, ringBuffer)
12599		err = &smithy.DeserializationError{
12600			Err:      fmt.Errorf("failed to decode response body, %w", err),
12601			Snapshot: snapshot.Bytes(),
12602		}
12603		return err
12604	}
12605
12606	errorBody.Seek(0, io.SeekStart)
12607	if len(code) != 0 {
12608		errorCode = restjson.SanitizeErrorCode(code)
12609	}
12610	if len(message) != 0 {
12611		errorMessage = message
12612	}
12613
12614	switch {
12615	case strings.EqualFold("AccessDeniedException", errorCode):
12616		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12617
12618	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12619		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12620
12621	case strings.EqualFold("InvalidInputException", errorCode):
12622		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12623
12624	case strings.EqualFold("NotFoundException", errorCode):
12625		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12626
12627	case strings.EqualFold("OperationFailureException", errorCode):
12628		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12629
12630	case strings.EqualFold("ServiceException", errorCode):
12631		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12632
12633	case strings.EqualFold("UnauthenticatedException", errorCode):
12634		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12635
12636	default:
12637		genericError := &smithy.GenericAPIError{
12638			Code:    errorCode,
12639			Message: errorMessage,
12640		}
12641		return genericError
12642
12643	}
12644}
12645
12646type awsAwsjson11_deserializeOpGetRegions struct {
12647}
12648
12649func (*awsAwsjson11_deserializeOpGetRegions) ID() string {
12650	return "OperationDeserializer"
12651}
12652
12653func (m *awsAwsjson11_deserializeOpGetRegions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12654	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12655) {
12656	out, metadata, err = next.HandleDeserialize(ctx, in)
12657	if err != nil {
12658		return out, metadata, err
12659	}
12660
12661	response, ok := out.RawResponse.(*smithyhttp.Response)
12662	if !ok {
12663		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12664	}
12665
12666	if response.StatusCode < 200 || response.StatusCode >= 300 {
12667		return out, metadata, awsAwsjson11_deserializeOpErrorGetRegions(response, &metadata)
12668	}
12669	output := &GetRegionsOutput{}
12670	out.Result = output
12671
12672	var buff [1024]byte
12673	ringBuffer := smithyio.NewRingBuffer(buff[:])
12674
12675	body := io.TeeReader(response.Body, ringBuffer)
12676	decoder := json.NewDecoder(body)
12677	decoder.UseNumber()
12678	var shape interface{}
12679	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12680		var snapshot bytes.Buffer
12681		io.Copy(&snapshot, ringBuffer)
12682		err = &smithy.DeserializationError{
12683			Err:      fmt.Errorf("failed to decode response body, %w", err),
12684			Snapshot: snapshot.Bytes(),
12685		}
12686		return out, metadata, err
12687	}
12688
12689	err = awsAwsjson11_deserializeOpDocumentGetRegionsOutput(&output, shape)
12690	if err != nil {
12691		var snapshot bytes.Buffer
12692		io.Copy(&snapshot, ringBuffer)
12693		err = &smithy.DeserializationError{
12694			Err:      fmt.Errorf("failed to decode response body, %w", err),
12695			Snapshot: snapshot.Bytes(),
12696		}
12697		return out, metadata, err
12698	}
12699
12700	return out, metadata, err
12701}
12702
12703func awsAwsjson11_deserializeOpErrorGetRegions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12704	var errorBuffer bytes.Buffer
12705	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12706		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12707	}
12708	errorBody := bytes.NewReader(errorBuffer.Bytes())
12709
12710	errorCode := "UnknownError"
12711	errorMessage := errorCode
12712
12713	code := response.Header.Get("X-Amzn-ErrorType")
12714	if len(code) != 0 {
12715		errorCode = restjson.SanitizeErrorCode(code)
12716	}
12717
12718	var buff [1024]byte
12719	ringBuffer := smithyio.NewRingBuffer(buff[:])
12720
12721	body := io.TeeReader(errorBody, ringBuffer)
12722	decoder := json.NewDecoder(body)
12723	decoder.UseNumber()
12724	code, message, err := restjson.GetErrorInfo(decoder)
12725	if err != nil {
12726		var snapshot bytes.Buffer
12727		io.Copy(&snapshot, ringBuffer)
12728		err = &smithy.DeserializationError{
12729			Err:      fmt.Errorf("failed to decode response body, %w", err),
12730			Snapshot: snapshot.Bytes(),
12731		}
12732		return err
12733	}
12734
12735	errorBody.Seek(0, io.SeekStart)
12736	if len(code) != 0 {
12737		errorCode = restjson.SanitizeErrorCode(code)
12738	}
12739	if len(message) != 0 {
12740		errorMessage = message
12741	}
12742
12743	switch {
12744	case strings.EqualFold("AccessDeniedException", errorCode):
12745		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12746
12747	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12748		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12749
12750	case strings.EqualFold("InvalidInputException", errorCode):
12751		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12752
12753	case strings.EqualFold("NotFoundException", errorCode):
12754		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12755
12756	case strings.EqualFold("OperationFailureException", errorCode):
12757		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12758
12759	case strings.EqualFold("ServiceException", errorCode):
12760		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12761
12762	case strings.EqualFold("UnauthenticatedException", errorCode):
12763		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12764
12765	default:
12766		genericError := &smithy.GenericAPIError{
12767			Code:    errorCode,
12768			Message: errorMessage,
12769		}
12770		return genericError
12771
12772	}
12773}
12774
12775type awsAwsjson11_deserializeOpGetRelationalDatabase struct {
12776}
12777
12778func (*awsAwsjson11_deserializeOpGetRelationalDatabase) ID() string {
12779	return "OperationDeserializer"
12780}
12781
12782func (m *awsAwsjson11_deserializeOpGetRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12783	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12784) {
12785	out, metadata, err = next.HandleDeserialize(ctx, in)
12786	if err != nil {
12787		return out, metadata, err
12788	}
12789
12790	response, ok := out.RawResponse.(*smithyhttp.Response)
12791	if !ok {
12792		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12793	}
12794
12795	if response.StatusCode < 200 || response.StatusCode >= 300 {
12796		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response, &metadata)
12797	}
12798	output := &GetRelationalDatabaseOutput{}
12799	out.Result = output
12800
12801	var buff [1024]byte
12802	ringBuffer := smithyio.NewRingBuffer(buff[:])
12803
12804	body := io.TeeReader(response.Body, ringBuffer)
12805	decoder := json.NewDecoder(body)
12806	decoder.UseNumber()
12807	var shape interface{}
12808	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12809		var snapshot bytes.Buffer
12810		io.Copy(&snapshot, ringBuffer)
12811		err = &smithy.DeserializationError{
12812			Err:      fmt.Errorf("failed to decode response body, %w", err),
12813			Snapshot: snapshot.Bytes(),
12814		}
12815		return out, metadata, err
12816	}
12817
12818	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(&output, shape)
12819	if err != nil {
12820		var snapshot bytes.Buffer
12821		io.Copy(&snapshot, ringBuffer)
12822		err = &smithy.DeserializationError{
12823			Err:      fmt.Errorf("failed to decode response body, %w", err),
12824			Snapshot: snapshot.Bytes(),
12825		}
12826		return out, metadata, err
12827	}
12828
12829	return out, metadata, err
12830}
12831
12832func awsAwsjson11_deserializeOpErrorGetRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12833	var errorBuffer bytes.Buffer
12834	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12835		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12836	}
12837	errorBody := bytes.NewReader(errorBuffer.Bytes())
12838
12839	errorCode := "UnknownError"
12840	errorMessage := errorCode
12841
12842	code := response.Header.Get("X-Amzn-ErrorType")
12843	if len(code) != 0 {
12844		errorCode = restjson.SanitizeErrorCode(code)
12845	}
12846
12847	var buff [1024]byte
12848	ringBuffer := smithyio.NewRingBuffer(buff[:])
12849
12850	body := io.TeeReader(errorBody, ringBuffer)
12851	decoder := json.NewDecoder(body)
12852	decoder.UseNumber()
12853	code, message, err := restjson.GetErrorInfo(decoder)
12854	if err != nil {
12855		var snapshot bytes.Buffer
12856		io.Copy(&snapshot, ringBuffer)
12857		err = &smithy.DeserializationError{
12858			Err:      fmt.Errorf("failed to decode response body, %w", err),
12859			Snapshot: snapshot.Bytes(),
12860		}
12861		return err
12862	}
12863
12864	errorBody.Seek(0, io.SeekStart)
12865	if len(code) != 0 {
12866		errorCode = restjson.SanitizeErrorCode(code)
12867	}
12868	if len(message) != 0 {
12869		errorMessage = message
12870	}
12871
12872	switch {
12873	case strings.EqualFold("AccessDeniedException", errorCode):
12874		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
12875
12876	case strings.EqualFold("AccountSetupInProgressException", errorCode):
12877		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
12878
12879	case strings.EqualFold("InvalidInputException", errorCode):
12880		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
12881
12882	case strings.EqualFold("NotFoundException", errorCode):
12883		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
12884
12885	case strings.EqualFold("OperationFailureException", errorCode):
12886		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
12887
12888	case strings.EqualFold("ServiceException", errorCode):
12889		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
12890
12891	case strings.EqualFold("UnauthenticatedException", errorCode):
12892		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
12893
12894	default:
12895		genericError := &smithy.GenericAPIError{
12896			Code:    errorCode,
12897			Message: errorMessage,
12898		}
12899		return genericError
12900
12901	}
12902}
12903
12904type awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints struct {
12905}
12906
12907func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) ID() string {
12908	return "OperationDeserializer"
12909}
12910
12911func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBlueprints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
12912	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
12913) {
12914	out, metadata, err = next.HandleDeserialize(ctx, in)
12915	if err != nil {
12916		return out, metadata, err
12917	}
12918
12919	response, ok := out.RawResponse.(*smithyhttp.Response)
12920	if !ok {
12921		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
12922	}
12923
12924	if response.StatusCode < 200 || response.StatusCode >= 300 {
12925		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response, &metadata)
12926	}
12927	output := &GetRelationalDatabaseBlueprintsOutput{}
12928	out.Result = output
12929
12930	var buff [1024]byte
12931	ringBuffer := smithyio.NewRingBuffer(buff[:])
12932
12933	body := io.TeeReader(response.Body, ringBuffer)
12934	decoder := json.NewDecoder(body)
12935	decoder.UseNumber()
12936	var shape interface{}
12937	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
12938		var snapshot bytes.Buffer
12939		io.Copy(&snapshot, ringBuffer)
12940		err = &smithy.DeserializationError{
12941			Err:      fmt.Errorf("failed to decode response body, %w", err),
12942			Snapshot: snapshot.Bytes(),
12943		}
12944		return out, metadata, err
12945	}
12946
12947	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(&output, shape)
12948	if err != nil {
12949		var snapshot bytes.Buffer
12950		io.Copy(&snapshot, ringBuffer)
12951		err = &smithy.DeserializationError{
12952			Err:      fmt.Errorf("failed to decode response body, %w", err),
12953			Snapshot: snapshot.Bytes(),
12954		}
12955		return out, metadata, err
12956	}
12957
12958	return out, metadata, err
12959}
12960
12961func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBlueprints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
12962	var errorBuffer bytes.Buffer
12963	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
12964		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
12965	}
12966	errorBody := bytes.NewReader(errorBuffer.Bytes())
12967
12968	errorCode := "UnknownError"
12969	errorMessage := errorCode
12970
12971	code := response.Header.Get("X-Amzn-ErrorType")
12972	if len(code) != 0 {
12973		errorCode = restjson.SanitizeErrorCode(code)
12974	}
12975
12976	var buff [1024]byte
12977	ringBuffer := smithyio.NewRingBuffer(buff[:])
12978
12979	body := io.TeeReader(errorBody, ringBuffer)
12980	decoder := json.NewDecoder(body)
12981	decoder.UseNumber()
12982	code, message, err := restjson.GetErrorInfo(decoder)
12983	if err != nil {
12984		var snapshot bytes.Buffer
12985		io.Copy(&snapshot, ringBuffer)
12986		err = &smithy.DeserializationError{
12987			Err:      fmt.Errorf("failed to decode response body, %w", err),
12988			Snapshot: snapshot.Bytes(),
12989		}
12990		return err
12991	}
12992
12993	errorBody.Seek(0, io.SeekStart)
12994	if len(code) != 0 {
12995		errorCode = restjson.SanitizeErrorCode(code)
12996	}
12997	if len(message) != 0 {
12998		errorMessage = message
12999	}
13000
13001	switch {
13002	case strings.EqualFold("AccessDeniedException", errorCode):
13003		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13004
13005	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13006		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13007
13008	case strings.EqualFold("InvalidInputException", errorCode):
13009		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13010
13011	case strings.EqualFold("NotFoundException", errorCode):
13012		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13013
13014	case strings.EqualFold("OperationFailureException", errorCode):
13015		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13016
13017	case strings.EqualFold("ServiceException", errorCode):
13018		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13019
13020	case strings.EqualFold("UnauthenticatedException", errorCode):
13021		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13022
13023	default:
13024		genericError := &smithy.GenericAPIError{
13025			Code:    errorCode,
13026			Message: errorMessage,
13027		}
13028		return genericError
13029
13030	}
13031}
13032
13033type awsAwsjson11_deserializeOpGetRelationalDatabaseBundles struct {
13034}
13035
13036func (*awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) ID() string {
13037	return "OperationDeserializer"
13038}
13039
13040func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseBundles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13041	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13042) {
13043	out, metadata, err = next.HandleDeserialize(ctx, in)
13044	if err != nil {
13045		return out, metadata, err
13046	}
13047
13048	response, ok := out.RawResponse.(*smithyhttp.Response)
13049	if !ok {
13050		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13051	}
13052
13053	if response.StatusCode < 200 || response.StatusCode >= 300 {
13054		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response, &metadata)
13055	}
13056	output := &GetRelationalDatabaseBundlesOutput{}
13057	out.Result = output
13058
13059	var buff [1024]byte
13060	ringBuffer := smithyio.NewRingBuffer(buff[:])
13061
13062	body := io.TeeReader(response.Body, ringBuffer)
13063	decoder := json.NewDecoder(body)
13064	decoder.UseNumber()
13065	var shape interface{}
13066	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13067		var snapshot bytes.Buffer
13068		io.Copy(&snapshot, ringBuffer)
13069		err = &smithy.DeserializationError{
13070			Err:      fmt.Errorf("failed to decode response body, %w", err),
13071			Snapshot: snapshot.Bytes(),
13072		}
13073		return out, metadata, err
13074	}
13075
13076	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(&output, shape)
13077	if err != nil {
13078		var snapshot bytes.Buffer
13079		io.Copy(&snapshot, ringBuffer)
13080		err = &smithy.DeserializationError{
13081			Err:      fmt.Errorf("failed to decode response body, %w", err),
13082			Snapshot: snapshot.Bytes(),
13083		}
13084		return out, metadata, err
13085	}
13086
13087	return out, metadata, err
13088}
13089
13090func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseBundles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13091	var errorBuffer bytes.Buffer
13092	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13093		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13094	}
13095	errorBody := bytes.NewReader(errorBuffer.Bytes())
13096
13097	errorCode := "UnknownError"
13098	errorMessage := errorCode
13099
13100	code := response.Header.Get("X-Amzn-ErrorType")
13101	if len(code) != 0 {
13102		errorCode = restjson.SanitizeErrorCode(code)
13103	}
13104
13105	var buff [1024]byte
13106	ringBuffer := smithyio.NewRingBuffer(buff[:])
13107
13108	body := io.TeeReader(errorBody, ringBuffer)
13109	decoder := json.NewDecoder(body)
13110	decoder.UseNumber()
13111	code, message, err := restjson.GetErrorInfo(decoder)
13112	if err != nil {
13113		var snapshot bytes.Buffer
13114		io.Copy(&snapshot, ringBuffer)
13115		err = &smithy.DeserializationError{
13116			Err:      fmt.Errorf("failed to decode response body, %w", err),
13117			Snapshot: snapshot.Bytes(),
13118		}
13119		return err
13120	}
13121
13122	errorBody.Seek(0, io.SeekStart)
13123	if len(code) != 0 {
13124		errorCode = restjson.SanitizeErrorCode(code)
13125	}
13126	if len(message) != 0 {
13127		errorMessage = message
13128	}
13129
13130	switch {
13131	case strings.EqualFold("AccessDeniedException", errorCode):
13132		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13133
13134	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13135		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13136
13137	case strings.EqualFold("InvalidInputException", errorCode):
13138		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13139
13140	case strings.EqualFold("NotFoundException", errorCode):
13141		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13142
13143	case strings.EqualFold("OperationFailureException", errorCode):
13144		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13145
13146	case strings.EqualFold("ServiceException", errorCode):
13147		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13148
13149	case strings.EqualFold("UnauthenticatedException", errorCode):
13150		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13151
13152	default:
13153		genericError := &smithy.GenericAPIError{
13154			Code:    errorCode,
13155			Message: errorMessage,
13156		}
13157		return genericError
13158
13159	}
13160}
13161
13162type awsAwsjson11_deserializeOpGetRelationalDatabaseEvents struct {
13163}
13164
13165func (*awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) ID() string {
13166	return "OperationDeserializer"
13167}
13168
13169func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13170	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13171) {
13172	out, metadata, err = next.HandleDeserialize(ctx, in)
13173	if err != nil {
13174		return out, metadata, err
13175	}
13176
13177	response, ok := out.RawResponse.(*smithyhttp.Response)
13178	if !ok {
13179		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13180	}
13181
13182	if response.StatusCode < 200 || response.StatusCode >= 300 {
13183		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response, &metadata)
13184	}
13185	output := &GetRelationalDatabaseEventsOutput{}
13186	out.Result = output
13187
13188	var buff [1024]byte
13189	ringBuffer := smithyio.NewRingBuffer(buff[:])
13190
13191	body := io.TeeReader(response.Body, ringBuffer)
13192	decoder := json.NewDecoder(body)
13193	decoder.UseNumber()
13194	var shape interface{}
13195	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13196		var snapshot bytes.Buffer
13197		io.Copy(&snapshot, ringBuffer)
13198		err = &smithy.DeserializationError{
13199			Err:      fmt.Errorf("failed to decode response body, %w", err),
13200			Snapshot: snapshot.Bytes(),
13201		}
13202		return out, metadata, err
13203	}
13204
13205	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(&output, shape)
13206	if err != nil {
13207		var snapshot bytes.Buffer
13208		io.Copy(&snapshot, ringBuffer)
13209		err = &smithy.DeserializationError{
13210			Err:      fmt.Errorf("failed to decode response body, %w", err),
13211			Snapshot: snapshot.Bytes(),
13212		}
13213		return out, metadata, err
13214	}
13215
13216	return out, metadata, err
13217}
13218
13219func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13220	var errorBuffer bytes.Buffer
13221	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13222		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13223	}
13224	errorBody := bytes.NewReader(errorBuffer.Bytes())
13225
13226	errorCode := "UnknownError"
13227	errorMessage := errorCode
13228
13229	code := response.Header.Get("X-Amzn-ErrorType")
13230	if len(code) != 0 {
13231		errorCode = restjson.SanitizeErrorCode(code)
13232	}
13233
13234	var buff [1024]byte
13235	ringBuffer := smithyio.NewRingBuffer(buff[:])
13236
13237	body := io.TeeReader(errorBody, ringBuffer)
13238	decoder := json.NewDecoder(body)
13239	decoder.UseNumber()
13240	code, message, err := restjson.GetErrorInfo(decoder)
13241	if err != nil {
13242		var snapshot bytes.Buffer
13243		io.Copy(&snapshot, ringBuffer)
13244		err = &smithy.DeserializationError{
13245			Err:      fmt.Errorf("failed to decode response body, %w", err),
13246			Snapshot: snapshot.Bytes(),
13247		}
13248		return err
13249	}
13250
13251	errorBody.Seek(0, io.SeekStart)
13252	if len(code) != 0 {
13253		errorCode = restjson.SanitizeErrorCode(code)
13254	}
13255	if len(message) != 0 {
13256		errorMessage = message
13257	}
13258
13259	switch {
13260	case strings.EqualFold("AccessDeniedException", errorCode):
13261		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13262
13263	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13264		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13265
13266	case strings.EqualFold("InvalidInputException", errorCode):
13267		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13268
13269	case strings.EqualFold("NotFoundException", errorCode):
13270		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13271
13272	case strings.EqualFold("OperationFailureException", errorCode):
13273		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13274
13275	case strings.EqualFold("ServiceException", errorCode):
13276		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13277
13278	case strings.EqualFold("UnauthenticatedException", errorCode):
13279		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13280
13281	default:
13282		genericError := &smithy.GenericAPIError{
13283			Code:    errorCode,
13284			Message: errorMessage,
13285		}
13286		return genericError
13287
13288	}
13289}
13290
13291type awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents struct {
13292}
13293
13294func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) ID() string {
13295	return "OperationDeserializer"
13296}
13297
13298func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13299	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13300) {
13301	out, metadata, err = next.HandleDeserialize(ctx, in)
13302	if err != nil {
13303		return out, metadata, err
13304	}
13305
13306	response, ok := out.RawResponse.(*smithyhttp.Response)
13307	if !ok {
13308		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13309	}
13310
13311	if response.StatusCode < 200 || response.StatusCode >= 300 {
13312		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response, &metadata)
13313	}
13314	output := &GetRelationalDatabaseLogEventsOutput{}
13315	out.Result = output
13316
13317	var buff [1024]byte
13318	ringBuffer := smithyio.NewRingBuffer(buff[:])
13319
13320	body := io.TeeReader(response.Body, ringBuffer)
13321	decoder := json.NewDecoder(body)
13322	decoder.UseNumber()
13323	var shape interface{}
13324	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13325		var snapshot bytes.Buffer
13326		io.Copy(&snapshot, ringBuffer)
13327		err = &smithy.DeserializationError{
13328			Err:      fmt.Errorf("failed to decode response body, %w", err),
13329			Snapshot: snapshot.Bytes(),
13330		}
13331		return out, metadata, err
13332	}
13333
13334	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(&output, shape)
13335	if err != nil {
13336		var snapshot bytes.Buffer
13337		io.Copy(&snapshot, ringBuffer)
13338		err = &smithy.DeserializationError{
13339			Err:      fmt.Errorf("failed to decode response body, %w", err),
13340			Snapshot: snapshot.Bytes(),
13341		}
13342		return out, metadata, err
13343	}
13344
13345	return out, metadata, err
13346}
13347
13348func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13349	var errorBuffer bytes.Buffer
13350	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13351		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13352	}
13353	errorBody := bytes.NewReader(errorBuffer.Bytes())
13354
13355	errorCode := "UnknownError"
13356	errorMessage := errorCode
13357
13358	code := response.Header.Get("X-Amzn-ErrorType")
13359	if len(code) != 0 {
13360		errorCode = restjson.SanitizeErrorCode(code)
13361	}
13362
13363	var buff [1024]byte
13364	ringBuffer := smithyio.NewRingBuffer(buff[:])
13365
13366	body := io.TeeReader(errorBody, ringBuffer)
13367	decoder := json.NewDecoder(body)
13368	decoder.UseNumber()
13369	code, message, err := restjson.GetErrorInfo(decoder)
13370	if err != nil {
13371		var snapshot bytes.Buffer
13372		io.Copy(&snapshot, ringBuffer)
13373		err = &smithy.DeserializationError{
13374			Err:      fmt.Errorf("failed to decode response body, %w", err),
13375			Snapshot: snapshot.Bytes(),
13376		}
13377		return err
13378	}
13379
13380	errorBody.Seek(0, io.SeekStart)
13381	if len(code) != 0 {
13382		errorCode = restjson.SanitizeErrorCode(code)
13383	}
13384	if len(message) != 0 {
13385		errorMessage = message
13386	}
13387
13388	switch {
13389	case strings.EqualFold("AccessDeniedException", errorCode):
13390		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13391
13392	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13393		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13394
13395	case strings.EqualFold("InvalidInputException", errorCode):
13396		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13397
13398	case strings.EqualFold("NotFoundException", errorCode):
13399		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13400
13401	case strings.EqualFold("OperationFailureException", errorCode):
13402		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13403
13404	case strings.EqualFold("ServiceException", errorCode):
13405		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13406
13407	case strings.EqualFold("UnauthenticatedException", errorCode):
13408		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13409
13410	default:
13411		genericError := &smithy.GenericAPIError{
13412			Code:    errorCode,
13413			Message: errorMessage,
13414		}
13415		return genericError
13416
13417	}
13418}
13419
13420type awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams struct {
13421}
13422
13423func (*awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) ID() string {
13424	return "OperationDeserializer"
13425}
13426
13427func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseLogStreams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13428	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13429) {
13430	out, metadata, err = next.HandleDeserialize(ctx, in)
13431	if err != nil {
13432		return out, metadata, err
13433	}
13434
13435	response, ok := out.RawResponse.(*smithyhttp.Response)
13436	if !ok {
13437		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13438	}
13439
13440	if response.StatusCode < 200 || response.StatusCode >= 300 {
13441		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response, &metadata)
13442	}
13443	output := &GetRelationalDatabaseLogStreamsOutput{}
13444	out.Result = output
13445
13446	var buff [1024]byte
13447	ringBuffer := smithyio.NewRingBuffer(buff[:])
13448
13449	body := io.TeeReader(response.Body, ringBuffer)
13450	decoder := json.NewDecoder(body)
13451	decoder.UseNumber()
13452	var shape interface{}
13453	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13454		var snapshot bytes.Buffer
13455		io.Copy(&snapshot, ringBuffer)
13456		err = &smithy.DeserializationError{
13457			Err:      fmt.Errorf("failed to decode response body, %w", err),
13458			Snapshot: snapshot.Bytes(),
13459		}
13460		return out, metadata, err
13461	}
13462
13463	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(&output, shape)
13464	if err != nil {
13465		var snapshot bytes.Buffer
13466		io.Copy(&snapshot, ringBuffer)
13467		err = &smithy.DeserializationError{
13468			Err:      fmt.Errorf("failed to decode response body, %w", err),
13469			Snapshot: snapshot.Bytes(),
13470		}
13471		return out, metadata, err
13472	}
13473
13474	return out, metadata, err
13475}
13476
13477func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseLogStreams(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13478	var errorBuffer bytes.Buffer
13479	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13480		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13481	}
13482	errorBody := bytes.NewReader(errorBuffer.Bytes())
13483
13484	errorCode := "UnknownError"
13485	errorMessage := errorCode
13486
13487	code := response.Header.Get("X-Amzn-ErrorType")
13488	if len(code) != 0 {
13489		errorCode = restjson.SanitizeErrorCode(code)
13490	}
13491
13492	var buff [1024]byte
13493	ringBuffer := smithyio.NewRingBuffer(buff[:])
13494
13495	body := io.TeeReader(errorBody, ringBuffer)
13496	decoder := json.NewDecoder(body)
13497	decoder.UseNumber()
13498	code, message, err := restjson.GetErrorInfo(decoder)
13499	if err != nil {
13500		var snapshot bytes.Buffer
13501		io.Copy(&snapshot, ringBuffer)
13502		err = &smithy.DeserializationError{
13503			Err:      fmt.Errorf("failed to decode response body, %w", err),
13504			Snapshot: snapshot.Bytes(),
13505		}
13506		return err
13507	}
13508
13509	errorBody.Seek(0, io.SeekStart)
13510	if len(code) != 0 {
13511		errorCode = restjson.SanitizeErrorCode(code)
13512	}
13513	if len(message) != 0 {
13514		errorMessage = message
13515	}
13516
13517	switch {
13518	case strings.EqualFold("AccessDeniedException", errorCode):
13519		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13520
13521	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13522		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13523
13524	case strings.EqualFold("InvalidInputException", errorCode):
13525		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13526
13527	case strings.EqualFold("NotFoundException", errorCode):
13528		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13529
13530	case strings.EqualFold("OperationFailureException", errorCode):
13531		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13532
13533	case strings.EqualFold("ServiceException", errorCode):
13534		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13535
13536	case strings.EqualFold("UnauthenticatedException", errorCode):
13537		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13538
13539	default:
13540		genericError := &smithy.GenericAPIError{
13541			Code:    errorCode,
13542			Message: errorMessage,
13543		}
13544		return genericError
13545
13546	}
13547}
13548
13549type awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword struct {
13550}
13551
13552func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) ID() string {
13553	return "OperationDeserializer"
13554}
13555
13556func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMasterUserPassword) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13557	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13558) {
13559	out, metadata, err = next.HandleDeserialize(ctx, in)
13560	if err != nil {
13561		return out, metadata, err
13562	}
13563
13564	response, ok := out.RawResponse.(*smithyhttp.Response)
13565	if !ok {
13566		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13567	}
13568
13569	if response.StatusCode < 200 || response.StatusCode >= 300 {
13570		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response, &metadata)
13571	}
13572	output := &GetRelationalDatabaseMasterUserPasswordOutput{}
13573	out.Result = output
13574
13575	var buff [1024]byte
13576	ringBuffer := smithyio.NewRingBuffer(buff[:])
13577
13578	body := io.TeeReader(response.Body, ringBuffer)
13579	decoder := json.NewDecoder(body)
13580	decoder.UseNumber()
13581	var shape interface{}
13582	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13583		var snapshot bytes.Buffer
13584		io.Copy(&snapshot, ringBuffer)
13585		err = &smithy.DeserializationError{
13586			Err:      fmt.Errorf("failed to decode response body, %w", err),
13587			Snapshot: snapshot.Bytes(),
13588		}
13589		return out, metadata, err
13590	}
13591
13592	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(&output, shape)
13593	if err != nil {
13594		var snapshot bytes.Buffer
13595		io.Copy(&snapshot, ringBuffer)
13596		err = &smithy.DeserializationError{
13597			Err:      fmt.Errorf("failed to decode response body, %w", err),
13598			Snapshot: snapshot.Bytes(),
13599		}
13600		return out, metadata, err
13601	}
13602
13603	return out, metadata, err
13604}
13605
13606func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMasterUserPassword(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13607	var errorBuffer bytes.Buffer
13608	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13609		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13610	}
13611	errorBody := bytes.NewReader(errorBuffer.Bytes())
13612
13613	errorCode := "UnknownError"
13614	errorMessage := errorCode
13615
13616	code := response.Header.Get("X-Amzn-ErrorType")
13617	if len(code) != 0 {
13618		errorCode = restjson.SanitizeErrorCode(code)
13619	}
13620
13621	var buff [1024]byte
13622	ringBuffer := smithyio.NewRingBuffer(buff[:])
13623
13624	body := io.TeeReader(errorBody, ringBuffer)
13625	decoder := json.NewDecoder(body)
13626	decoder.UseNumber()
13627	code, message, err := restjson.GetErrorInfo(decoder)
13628	if err != nil {
13629		var snapshot bytes.Buffer
13630		io.Copy(&snapshot, ringBuffer)
13631		err = &smithy.DeserializationError{
13632			Err:      fmt.Errorf("failed to decode response body, %w", err),
13633			Snapshot: snapshot.Bytes(),
13634		}
13635		return err
13636	}
13637
13638	errorBody.Seek(0, io.SeekStart)
13639	if len(code) != 0 {
13640		errorCode = restjson.SanitizeErrorCode(code)
13641	}
13642	if len(message) != 0 {
13643		errorMessage = message
13644	}
13645
13646	switch {
13647	case strings.EqualFold("AccessDeniedException", errorCode):
13648		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13649
13650	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13651		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13652
13653	case strings.EqualFold("InvalidInputException", errorCode):
13654		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13655
13656	case strings.EqualFold("NotFoundException", errorCode):
13657		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13658
13659	case strings.EqualFold("OperationFailureException", errorCode):
13660		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13661
13662	case strings.EqualFold("ServiceException", errorCode):
13663		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13664
13665	case strings.EqualFold("UnauthenticatedException", errorCode):
13666		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13667
13668	default:
13669		genericError := &smithy.GenericAPIError{
13670			Code:    errorCode,
13671			Message: errorMessage,
13672		}
13673		return genericError
13674
13675	}
13676}
13677
13678type awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData struct {
13679}
13680
13681func (*awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) ID() string {
13682	return "OperationDeserializer"
13683}
13684
13685func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseMetricData) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13686	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13687) {
13688	out, metadata, err = next.HandleDeserialize(ctx, in)
13689	if err != nil {
13690		return out, metadata, err
13691	}
13692
13693	response, ok := out.RawResponse.(*smithyhttp.Response)
13694	if !ok {
13695		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13696	}
13697
13698	if response.StatusCode < 200 || response.StatusCode >= 300 {
13699		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response, &metadata)
13700	}
13701	output := &GetRelationalDatabaseMetricDataOutput{}
13702	out.Result = output
13703
13704	var buff [1024]byte
13705	ringBuffer := smithyio.NewRingBuffer(buff[:])
13706
13707	body := io.TeeReader(response.Body, ringBuffer)
13708	decoder := json.NewDecoder(body)
13709	decoder.UseNumber()
13710	var shape interface{}
13711	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13712		var snapshot bytes.Buffer
13713		io.Copy(&snapshot, ringBuffer)
13714		err = &smithy.DeserializationError{
13715			Err:      fmt.Errorf("failed to decode response body, %w", err),
13716			Snapshot: snapshot.Bytes(),
13717		}
13718		return out, metadata, err
13719	}
13720
13721	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(&output, shape)
13722	if err != nil {
13723		var snapshot bytes.Buffer
13724		io.Copy(&snapshot, ringBuffer)
13725		err = &smithy.DeserializationError{
13726			Err:      fmt.Errorf("failed to decode response body, %w", err),
13727			Snapshot: snapshot.Bytes(),
13728		}
13729		return out, metadata, err
13730	}
13731
13732	return out, metadata, err
13733}
13734
13735func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseMetricData(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13736	var errorBuffer bytes.Buffer
13737	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13738		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13739	}
13740	errorBody := bytes.NewReader(errorBuffer.Bytes())
13741
13742	errorCode := "UnknownError"
13743	errorMessage := errorCode
13744
13745	code := response.Header.Get("X-Amzn-ErrorType")
13746	if len(code) != 0 {
13747		errorCode = restjson.SanitizeErrorCode(code)
13748	}
13749
13750	var buff [1024]byte
13751	ringBuffer := smithyio.NewRingBuffer(buff[:])
13752
13753	body := io.TeeReader(errorBody, ringBuffer)
13754	decoder := json.NewDecoder(body)
13755	decoder.UseNumber()
13756	code, message, err := restjson.GetErrorInfo(decoder)
13757	if err != nil {
13758		var snapshot bytes.Buffer
13759		io.Copy(&snapshot, ringBuffer)
13760		err = &smithy.DeserializationError{
13761			Err:      fmt.Errorf("failed to decode response body, %w", err),
13762			Snapshot: snapshot.Bytes(),
13763		}
13764		return err
13765	}
13766
13767	errorBody.Seek(0, io.SeekStart)
13768	if len(code) != 0 {
13769		errorCode = restjson.SanitizeErrorCode(code)
13770	}
13771	if len(message) != 0 {
13772		errorMessage = message
13773	}
13774
13775	switch {
13776	case strings.EqualFold("AccessDeniedException", errorCode):
13777		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13778
13779	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13780		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13781
13782	case strings.EqualFold("InvalidInputException", errorCode):
13783		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13784
13785	case strings.EqualFold("NotFoundException", errorCode):
13786		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13787
13788	case strings.EqualFold("OperationFailureException", errorCode):
13789		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13790
13791	case strings.EqualFold("ServiceException", errorCode):
13792		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13793
13794	case strings.EqualFold("UnauthenticatedException", errorCode):
13795		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13796
13797	default:
13798		genericError := &smithy.GenericAPIError{
13799			Code:    errorCode,
13800			Message: errorMessage,
13801		}
13802		return genericError
13803
13804	}
13805}
13806
13807type awsAwsjson11_deserializeOpGetRelationalDatabaseParameters struct {
13808}
13809
13810func (*awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) ID() string {
13811	return "OperationDeserializer"
13812}
13813
13814func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13815	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13816) {
13817	out, metadata, err = next.HandleDeserialize(ctx, in)
13818	if err != nil {
13819		return out, metadata, err
13820	}
13821
13822	response, ok := out.RawResponse.(*smithyhttp.Response)
13823	if !ok {
13824		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13825	}
13826
13827	if response.StatusCode < 200 || response.StatusCode >= 300 {
13828		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response, &metadata)
13829	}
13830	output := &GetRelationalDatabaseParametersOutput{}
13831	out.Result = output
13832
13833	var buff [1024]byte
13834	ringBuffer := smithyio.NewRingBuffer(buff[:])
13835
13836	body := io.TeeReader(response.Body, ringBuffer)
13837	decoder := json.NewDecoder(body)
13838	decoder.UseNumber()
13839	var shape interface{}
13840	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13841		var snapshot bytes.Buffer
13842		io.Copy(&snapshot, ringBuffer)
13843		err = &smithy.DeserializationError{
13844			Err:      fmt.Errorf("failed to decode response body, %w", err),
13845			Snapshot: snapshot.Bytes(),
13846		}
13847		return out, metadata, err
13848	}
13849
13850	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(&output, shape)
13851	if err != nil {
13852		var snapshot bytes.Buffer
13853		io.Copy(&snapshot, ringBuffer)
13854		err = &smithy.DeserializationError{
13855			Err:      fmt.Errorf("failed to decode response body, %w", err),
13856			Snapshot: snapshot.Bytes(),
13857		}
13858		return out, metadata, err
13859	}
13860
13861	return out, metadata, err
13862}
13863
13864func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13865	var errorBuffer bytes.Buffer
13866	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13867		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13868	}
13869	errorBody := bytes.NewReader(errorBuffer.Bytes())
13870
13871	errorCode := "UnknownError"
13872	errorMessage := errorCode
13873
13874	code := response.Header.Get("X-Amzn-ErrorType")
13875	if len(code) != 0 {
13876		errorCode = restjson.SanitizeErrorCode(code)
13877	}
13878
13879	var buff [1024]byte
13880	ringBuffer := smithyio.NewRingBuffer(buff[:])
13881
13882	body := io.TeeReader(errorBody, ringBuffer)
13883	decoder := json.NewDecoder(body)
13884	decoder.UseNumber()
13885	code, message, err := restjson.GetErrorInfo(decoder)
13886	if err != nil {
13887		var snapshot bytes.Buffer
13888		io.Copy(&snapshot, ringBuffer)
13889		err = &smithy.DeserializationError{
13890			Err:      fmt.Errorf("failed to decode response body, %w", err),
13891			Snapshot: snapshot.Bytes(),
13892		}
13893		return err
13894	}
13895
13896	errorBody.Seek(0, io.SeekStart)
13897	if len(code) != 0 {
13898		errorCode = restjson.SanitizeErrorCode(code)
13899	}
13900	if len(message) != 0 {
13901		errorMessage = message
13902	}
13903
13904	switch {
13905	case strings.EqualFold("AccessDeniedException", errorCode):
13906		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
13907
13908	case strings.EqualFold("AccountSetupInProgressException", errorCode):
13909		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
13910
13911	case strings.EqualFold("InvalidInputException", errorCode):
13912		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
13913
13914	case strings.EqualFold("NotFoundException", errorCode):
13915		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
13916
13917	case strings.EqualFold("OperationFailureException", errorCode):
13918		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
13919
13920	case strings.EqualFold("ServiceException", errorCode):
13921		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
13922
13923	case strings.EqualFold("UnauthenticatedException", errorCode):
13924		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
13925
13926	default:
13927		genericError := &smithy.GenericAPIError{
13928			Code:    errorCode,
13929			Message: errorMessage,
13930		}
13931		return genericError
13932
13933	}
13934}
13935
13936type awsAwsjson11_deserializeOpGetRelationalDatabases struct {
13937}
13938
13939func (*awsAwsjson11_deserializeOpGetRelationalDatabases) ID() string {
13940	return "OperationDeserializer"
13941}
13942
13943func (m *awsAwsjson11_deserializeOpGetRelationalDatabases) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
13944	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
13945) {
13946	out, metadata, err = next.HandleDeserialize(ctx, in)
13947	if err != nil {
13948		return out, metadata, err
13949	}
13950
13951	response, ok := out.RawResponse.(*smithyhttp.Response)
13952	if !ok {
13953		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
13954	}
13955
13956	if response.StatusCode < 200 || response.StatusCode >= 300 {
13957		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response, &metadata)
13958	}
13959	output := &GetRelationalDatabasesOutput{}
13960	out.Result = output
13961
13962	var buff [1024]byte
13963	ringBuffer := smithyio.NewRingBuffer(buff[:])
13964
13965	body := io.TeeReader(response.Body, ringBuffer)
13966	decoder := json.NewDecoder(body)
13967	decoder.UseNumber()
13968	var shape interface{}
13969	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
13970		var snapshot bytes.Buffer
13971		io.Copy(&snapshot, ringBuffer)
13972		err = &smithy.DeserializationError{
13973			Err:      fmt.Errorf("failed to decode response body, %w", err),
13974			Snapshot: snapshot.Bytes(),
13975		}
13976		return out, metadata, err
13977	}
13978
13979	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(&output, shape)
13980	if err != nil {
13981		var snapshot bytes.Buffer
13982		io.Copy(&snapshot, ringBuffer)
13983		err = &smithy.DeserializationError{
13984			Err:      fmt.Errorf("failed to decode response body, %w", err),
13985			Snapshot: snapshot.Bytes(),
13986		}
13987		return out, metadata, err
13988	}
13989
13990	return out, metadata, err
13991}
13992
13993func awsAwsjson11_deserializeOpErrorGetRelationalDatabases(response *smithyhttp.Response, metadata *middleware.Metadata) error {
13994	var errorBuffer bytes.Buffer
13995	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
13996		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
13997	}
13998	errorBody := bytes.NewReader(errorBuffer.Bytes())
13999
14000	errorCode := "UnknownError"
14001	errorMessage := errorCode
14002
14003	code := response.Header.Get("X-Amzn-ErrorType")
14004	if len(code) != 0 {
14005		errorCode = restjson.SanitizeErrorCode(code)
14006	}
14007
14008	var buff [1024]byte
14009	ringBuffer := smithyio.NewRingBuffer(buff[:])
14010
14011	body := io.TeeReader(errorBody, ringBuffer)
14012	decoder := json.NewDecoder(body)
14013	decoder.UseNumber()
14014	code, message, err := restjson.GetErrorInfo(decoder)
14015	if err != nil {
14016		var snapshot bytes.Buffer
14017		io.Copy(&snapshot, ringBuffer)
14018		err = &smithy.DeserializationError{
14019			Err:      fmt.Errorf("failed to decode response body, %w", err),
14020			Snapshot: snapshot.Bytes(),
14021		}
14022		return err
14023	}
14024
14025	errorBody.Seek(0, io.SeekStart)
14026	if len(code) != 0 {
14027		errorCode = restjson.SanitizeErrorCode(code)
14028	}
14029	if len(message) != 0 {
14030		errorMessage = message
14031	}
14032
14033	switch {
14034	case strings.EqualFold("AccessDeniedException", errorCode):
14035		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14036
14037	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14038		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14039
14040	case strings.EqualFold("InvalidInputException", errorCode):
14041		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14042
14043	case strings.EqualFold("NotFoundException", errorCode):
14044		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14045
14046	case strings.EqualFold("OperationFailureException", errorCode):
14047		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14048
14049	case strings.EqualFold("ServiceException", errorCode):
14050		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14051
14052	case strings.EqualFold("UnauthenticatedException", errorCode):
14053		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14054
14055	default:
14056		genericError := &smithy.GenericAPIError{
14057			Code:    errorCode,
14058			Message: errorMessage,
14059		}
14060		return genericError
14061
14062	}
14063}
14064
14065type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot struct {
14066}
14067
14068func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) ID() string {
14069	return "OperationDeserializer"
14070}
14071
14072func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14073	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14074) {
14075	out, metadata, err = next.HandleDeserialize(ctx, in)
14076	if err != nil {
14077		return out, metadata, err
14078	}
14079
14080	response, ok := out.RawResponse.(*smithyhttp.Response)
14081	if !ok {
14082		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14083	}
14084
14085	if response.StatusCode < 200 || response.StatusCode >= 300 {
14086		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response, &metadata)
14087	}
14088	output := &GetRelationalDatabaseSnapshotOutput{}
14089	out.Result = output
14090
14091	var buff [1024]byte
14092	ringBuffer := smithyio.NewRingBuffer(buff[:])
14093
14094	body := io.TeeReader(response.Body, ringBuffer)
14095	decoder := json.NewDecoder(body)
14096	decoder.UseNumber()
14097	var shape interface{}
14098	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14099		var snapshot bytes.Buffer
14100		io.Copy(&snapshot, ringBuffer)
14101		err = &smithy.DeserializationError{
14102			Err:      fmt.Errorf("failed to decode response body, %w", err),
14103			Snapshot: snapshot.Bytes(),
14104		}
14105		return out, metadata, err
14106	}
14107
14108	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(&output, shape)
14109	if err != nil {
14110		var snapshot bytes.Buffer
14111		io.Copy(&snapshot, ringBuffer)
14112		err = &smithy.DeserializationError{
14113			Err:      fmt.Errorf("failed to decode response body, %w", err),
14114			Snapshot: snapshot.Bytes(),
14115		}
14116		return out, metadata, err
14117	}
14118
14119	return out, metadata, err
14120}
14121
14122func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14123	var errorBuffer bytes.Buffer
14124	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14125		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14126	}
14127	errorBody := bytes.NewReader(errorBuffer.Bytes())
14128
14129	errorCode := "UnknownError"
14130	errorMessage := errorCode
14131
14132	code := response.Header.Get("X-Amzn-ErrorType")
14133	if len(code) != 0 {
14134		errorCode = restjson.SanitizeErrorCode(code)
14135	}
14136
14137	var buff [1024]byte
14138	ringBuffer := smithyio.NewRingBuffer(buff[:])
14139
14140	body := io.TeeReader(errorBody, ringBuffer)
14141	decoder := json.NewDecoder(body)
14142	decoder.UseNumber()
14143	code, message, err := restjson.GetErrorInfo(decoder)
14144	if err != nil {
14145		var snapshot bytes.Buffer
14146		io.Copy(&snapshot, ringBuffer)
14147		err = &smithy.DeserializationError{
14148			Err:      fmt.Errorf("failed to decode response body, %w", err),
14149			Snapshot: snapshot.Bytes(),
14150		}
14151		return err
14152	}
14153
14154	errorBody.Seek(0, io.SeekStart)
14155	if len(code) != 0 {
14156		errorCode = restjson.SanitizeErrorCode(code)
14157	}
14158	if len(message) != 0 {
14159		errorMessage = message
14160	}
14161
14162	switch {
14163	case strings.EqualFold("AccessDeniedException", errorCode):
14164		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14165
14166	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14167		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14168
14169	case strings.EqualFold("InvalidInputException", errorCode):
14170		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14171
14172	case strings.EqualFold("NotFoundException", errorCode):
14173		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14174
14175	case strings.EqualFold("OperationFailureException", errorCode):
14176		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14177
14178	case strings.EqualFold("ServiceException", errorCode):
14179		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14180
14181	case strings.EqualFold("UnauthenticatedException", errorCode):
14182		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14183
14184	default:
14185		genericError := &smithy.GenericAPIError{
14186			Code:    errorCode,
14187			Message: errorMessage,
14188		}
14189		return genericError
14190
14191	}
14192}
14193
14194type awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots struct {
14195}
14196
14197func (*awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) ID() string {
14198	return "OperationDeserializer"
14199}
14200
14201func (m *awsAwsjson11_deserializeOpGetRelationalDatabaseSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14202	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14203) {
14204	out, metadata, err = next.HandleDeserialize(ctx, in)
14205	if err != nil {
14206		return out, metadata, err
14207	}
14208
14209	response, ok := out.RawResponse.(*smithyhttp.Response)
14210	if !ok {
14211		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14212	}
14213
14214	if response.StatusCode < 200 || response.StatusCode >= 300 {
14215		return out, metadata, awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response, &metadata)
14216	}
14217	output := &GetRelationalDatabaseSnapshotsOutput{}
14218	out.Result = output
14219
14220	var buff [1024]byte
14221	ringBuffer := smithyio.NewRingBuffer(buff[:])
14222
14223	body := io.TeeReader(response.Body, ringBuffer)
14224	decoder := json.NewDecoder(body)
14225	decoder.UseNumber()
14226	var shape interface{}
14227	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14228		var snapshot bytes.Buffer
14229		io.Copy(&snapshot, ringBuffer)
14230		err = &smithy.DeserializationError{
14231			Err:      fmt.Errorf("failed to decode response body, %w", err),
14232			Snapshot: snapshot.Bytes(),
14233		}
14234		return out, metadata, err
14235	}
14236
14237	err = awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(&output, shape)
14238	if err != nil {
14239		var snapshot bytes.Buffer
14240		io.Copy(&snapshot, ringBuffer)
14241		err = &smithy.DeserializationError{
14242			Err:      fmt.Errorf("failed to decode response body, %w", err),
14243			Snapshot: snapshot.Bytes(),
14244		}
14245		return out, metadata, err
14246	}
14247
14248	return out, metadata, err
14249}
14250
14251func awsAwsjson11_deserializeOpErrorGetRelationalDatabaseSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14252	var errorBuffer bytes.Buffer
14253	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14254		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14255	}
14256	errorBody := bytes.NewReader(errorBuffer.Bytes())
14257
14258	errorCode := "UnknownError"
14259	errorMessage := errorCode
14260
14261	code := response.Header.Get("X-Amzn-ErrorType")
14262	if len(code) != 0 {
14263		errorCode = restjson.SanitizeErrorCode(code)
14264	}
14265
14266	var buff [1024]byte
14267	ringBuffer := smithyio.NewRingBuffer(buff[:])
14268
14269	body := io.TeeReader(errorBody, ringBuffer)
14270	decoder := json.NewDecoder(body)
14271	decoder.UseNumber()
14272	code, message, err := restjson.GetErrorInfo(decoder)
14273	if err != nil {
14274		var snapshot bytes.Buffer
14275		io.Copy(&snapshot, ringBuffer)
14276		err = &smithy.DeserializationError{
14277			Err:      fmt.Errorf("failed to decode response body, %w", err),
14278			Snapshot: snapshot.Bytes(),
14279		}
14280		return err
14281	}
14282
14283	errorBody.Seek(0, io.SeekStart)
14284	if len(code) != 0 {
14285		errorCode = restjson.SanitizeErrorCode(code)
14286	}
14287	if len(message) != 0 {
14288		errorMessage = message
14289	}
14290
14291	switch {
14292	case strings.EqualFold("AccessDeniedException", errorCode):
14293		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14294
14295	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14296		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14297
14298	case strings.EqualFold("InvalidInputException", errorCode):
14299		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14300
14301	case strings.EqualFold("NotFoundException", errorCode):
14302		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14303
14304	case strings.EqualFold("OperationFailureException", errorCode):
14305		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14306
14307	case strings.EqualFold("ServiceException", errorCode):
14308		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14309
14310	case strings.EqualFold("UnauthenticatedException", errorCode):
14311		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14312
14313	default:
14314		genericError := &smithy.GenericAPIError{
14315			Code:    errorCode,
14316			Message: errorMessage,
14317		}
14318		return genericError
14319
14320	}
14321}
14322
14323type awsAwsjson11_deserializeOpGetStaticIp struct {
14324}
14325
14326func (*awsAwsjson11_deserializeOpGetStaticIp) ID() string {
14327	return "OperationDeserializer"
14328}
14329
14330func (m *awsAwsjson11_deserializeOpGetStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14331	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14332) {
14333	out, metadata, err = next.HandleDeserialize(ctx, in)
14334	if err != nil {
14335		return out, metadata, err
14336	}
14337
14338	response, ok := out.RawResponse.(*smithyhttp.Response)
14339	if !ok {
14340		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14341	}
14342
14343	if response.StatusCode < 200 || response.StatusCode >= 300 {
14344		return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIp(response, &metadata)
14345	}
14346	output := &GetStaticIpOutput{}
14347	out.Result = output
14348
14349	var buff [1024]byte
14350	ringBuffer := smithyio.NewRingBuffer(buff[:])
14351
14352	body := io.TeeReader(response.Body, ringBuffer)
14353	decoder := json.NewDecoder(body)
14354	decoder.UseNumber()
14355	var shape interface{}
14356	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14357		var snapshot bytes.Buffer
14358		io.Copy(&snapshot, ringBuffer)
14359		err = &smithy.DeserializationError{
14360			Err:      fmt.Errorf("failed to decode response body, %w", err),
14361			Snapshot: snapshot.Bytes(),
14362		}
14363		return out, metadata, err
14364	}
14365
14366	err = awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(&output, shape)
14367	if err != nil {
14368		var snapshot bytes.Buffer
14369		io.Copy(&snapshot, ringBuffer)
14370		err = &smithy.DeserializationError{
14371			Err:      fmt.Errorf("failed to decode response body, %w", err),
14372			Snapshot: snapshot.Bytes(),
14373		}
14374		return out, metadata, err
14375	}
14376
14377	return out, metadata, err
14378}
14379
14380func awsAwsjson11_deserializeOpErrorGetStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14381	var errorBuffer bytes.Buffer
14382	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14383		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14384	}
14385	errorBody := bytes.NewReader(errorBuffer.Bytes())
14386
14387	errorCode := "UnknownError"
14388	errorMessage := errorCode
14389
14390	code := response.Header.Get("X-Amzn-ErrorType")
14391	if len(code) != 0 {
14392		errorCode = restjson.SanitizeErrorCode(code)
14393	}
14394
14395	var buff [1024]byte
14396	ringBuffer := smithyio.NewRingBuffer(buff[:])
14397
14398	body := io.TeeReader(errorBody, ringBuffer)
14399	decoder := json.NewDecoder(body)
14400	decoder.UseNumber()
14401	code, message, err := restjson.GetErrorInfo(decoder)
14402	if err != nil {
14403		var snapshot bytes.Buffer
14404		io.Copy(&snapshot, ringBuffer)
14405		err = &smithy.DeserializationError{
14406			Err:      fmt.Errorf("failed to decode response body, %w", err),
14407			Snapshot: snapshot.Bytes(),
14408		}
14409		return err
14410	}
14411
14412	errorBody.Seek(0, io.SeekStart)
14413	if len(code) != 0 {
14414		errorCode = restjson.SanitizeErrorCode(code)
14415	}
14416	if len(message) != 0 {
14417		errorMessage = message
14418	}
14419
14420	switch {
14421	case strings.EqualFold("AccessDeniedException", errorCode):
14422		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14423
14424	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14425		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14426
14427	case strings.EqualFold("InvalidInputException", errorCode):
14428		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14429
14430	case strings.EqualFold("NotFoundException", errorCode):
14431		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14432
14433	case strings.EqualFold("OperationFailureException", errorCode):
14434		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14435
14436	case strings.EqualFold("ServiceException", errorCode):
14437		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14438
14439	case strings.EqualFold("UnauthenticatedException", errorCode):
14440		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14441
14442	default:
14443		genericError := &smithy.GenericAPIError{
14444			Code:    errorCode,
14445			Message: errorMessage,
14446		}
14447		return genericError
14448
14449	}
14450}
14451
14452type awsAwsjson11_deserializeOpGetStaticIps struct {
14453}
14454
14455func (*awsAwsjson11_deserializeOpGetStaticIps) ID() string {
14456	return "OperationDeserializer"
14457}
14458
14459func (m *awsAwsjson11_deserializeOpGetStaticIps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14460	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14461) {
14462	out, metadata, err = next.HandleDeserialize(ctx, in)
14463	if err != nil {
14464		return out, metadata, err
14465	}
14466
14467	response, ok := out.RawResponse.(*smithyhttp.Response)
14468	if !ok {
14469		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14470	}
14471
14472	if response.StatusCode < 200 || response.StatusCode >= 300 {
14473		return out, metadata, awsAwsjson11_deserializeOpErrorGetStaticIps(response, &metadata)
14474	}
14475	output := &GetStaticIpsOutput{}
14476	out.Result = output
14477
14478	var buff [1024]byte
14479	ringBuffer := smithyio.NewRingBuffer(buff[:])
14480
14481	body := io.TeeReader(response.Body, ringBuffer)
14482	decoder := json.NewDecoder(body)
14483	decoder.UseNumber()
14484	var shape interface{}
14485	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14486		var snapshot bytes.Buffer
14487		io.Copy(&snapshot, ringBuffer)
14488		err = &smithy.DeserializationError{
14489			Err:      fmt.Errorf("failed to decode response body, %w", err),
14490			Snapshot: snapshot.Bytes(),
14491		}
14492		return out, metadata, err
14493	}
14494
14495	err = awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(&output, shape)
14496	if err != nil {
14497		var snapshot bytes.Buffer
14498		io.Copy(&snapshot, ringBuffer)
14499		err = &smithy.DeserializationError{
14500			Err:      fmt.Errorf("failed to decode response body, %w", err),
14501			Snapshot: snapshot.Bytes(),
14502		}
14503		return out, metadata, err
14504	}
14505
14506	return out, metadata, err
14507}
14508
14509func awsAwsjson11_deserializeOpErrorGetStaticIps(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14510	var errorBuffer bytes.Buffer
14511	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14512		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14513	}
14514	errorBody := bytes.NewReader(errorBuffer.Bytes())
14515
14516	errorCode := "UnknownError"
14517	errorMessage := errorCode
14518
14519	code := response.Header.Get("X-Amzn-ErrorType")
14520	if len(code) != 0 {
14521		errorCode = restjson.SanitizeErrorCode(code)
14522	}
14523
14524	var buff [1024]byte
14525	ringBuffer := smithyio.NewRingBuffer(buff[:])
14526
14527	body := io.TeeReader(errorBody, ringBuffer)
14528	decoder := json.NewDecoder(body)
14529	decoder.UseNumber()
14530	code, message, err := restjson.GetErrorInfo(decoder)
14531	if err != nil {
14532		var snapshot bytes.Buffer
14533		io.Copy(&snapshot, ringBuffer)
14534		err = &smithy.DeserializationError{
14535			Err:      fmt.Errorf("failed to decode response body, %w", err),
14536			Snapshot: snapshot.Bytes(),
14537		}
14538		return err
14539	}
14540
14541	errorBody.Seek(0, io.SeekStart)
14542	if len(code) != 0 {
14543		errorCode = restjson.SanitizeErrorCode(code)
14544	}
14545	if len(message) != 0 {
14546		errorMessage = message
14547	}
14548
14549	switch {
14550	case strings.EqualFold("AccessDeniedException", errorCode):
14551		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14552
14553	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14554		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14555
14556	case strings.EqualFold("InvalidInputException", errorCode):
14557		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14558
14559	case strings.EqualFold("NotFoundException", errorCode):
14560		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14561
14562	case strings.EqualFold("OperationFailureException", errorCode):
14563		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14564
14565	case strings.EqualFold("ServiceException", errorCode):
14566		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14567
14568	case strings.EqualFold("UnauthenticatedException", errorCode):
14569		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14570
14571	default:
14572		genericError := &smithy.GenericAPIError{
14573			Code:    errorCode,
14574			Message: errorMessage,
14575		}
14576		return genericError
14577
14578	}
14579}
14580
14581type awsAwsjson11_deserializeOpImportKeyPair struct {
14582}
14583
14584func (*awsAwsjson11_deserializeOpImportKeyPair) ID() string {
14585	return "OperationDeserializer"
14586}
14587
14588func (m *awsAwsjson11_deserializeOpImportKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14589	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14590) {
14591	out, metadata, err = next.HandleDeserialize(ctx, in)
14592	if err != nil {
14593		return out, metadata, err
14594	}
14595
14596	response, ok := out.RawResponse.(*smithyhttp.Response)
14597	if !ok {
14598		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14599	}
14600
14601	if response.StatusCode < 200 || response.StatusCode >= 300 {
14602		return out, metadata, awsAwsjson11_deserializeOpErrorImportKeyPair(response, &metadata)
14603	}
14604	output := &ImportKeyPairOutput{}
14605	out.Result = output
14606
14607	var buff [1024]byte
14608	ringBuffer := smithyio.NewRingBuffer(buff[:])
14609
14610	body := io.TeeReader(response.Body, ringBuffer)
14611	decoder := json.NewDecoder(body)
14612	decoder.UseNumber()
14613	var shape interface{}
14614	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14615		var snapshot bytes.Buffer
14616		io.Copy(&snapshot, ringBuffer)
14617		err = &smithy.DeserializationError{
14618			Err:      fmt.Errorf("failed to decode response body, %w", err),
14619			Snapshot: snapshot.Bytes(),
14620		}
14621		return out, metadata, err
14622	}
14623
14624	err = awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(&output, shape)
14625	if err != nil {
14626		var snapshot bytes.Buffer
14627		io.Copy(&snapshot, ringBuffer)
14628		err = &smithy.DeserializationError{
14629			Err:      fmt.Errorf("failed to decode response body, %w", err),
14630			Snapshot: snapshot.Bytes(),
14631		}
14632		return out, metadata, err
14633	}
14634
14635	return out, metadata, err
14636}
14637
14638func awsAwsjson11_deserializeOpErrorImportKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14639	var errorBuffer bytes.Buffer
14640	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14641		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14642	}
14643	errorBody := bytes.NewReader(errorBuffer.Bytes())
14644
14645	errorCode := "UnknownError"
14646	errorMessage := errorCode
14647
14648	code := response.Header.Get("X-Amzn-ErrorType")
14649	if len(code) != 0 {
14650		errorCode = restjson.SanitizeErrorCode(code)
14651	}
14652
14653	var buff [1024]byte
14654	ringBuffer := smithyio.NewRingBuffer(buff[:])
14655
14656	body := io.TeeReader(errorBody, ringBuffer)
14657	decoder := json.NewDecoder(body)
14658	decoder.UseNumber()
14659	code, message, err := restjson.GetErrorInfo(decoder)
14660	if err != nil {
14661		var snapshot bytes.Buffer
14662		io.Copy(&snapshot, ringBuffer)
14663		err = &smithy.DeserializationError{
14664			Err:      fmt.Errorf("failed to decode response body, %w", err),
14665			Snapshot: snapshot.Bytes(),
14666		}
14667		return err
14668	}
14669
14670	errorBody.Seek(0, io.SeekStart)
14671	if len(code) != 0 {
14672		errorCode = restjson.SanitizeErrorCode(code)
14673	}
14674	if len(message) != 0 {
14675		errorMessage = message
14676	}
14677
14678	switch {
14679	case strings.EqualFold("AccessDeniedException", errorCode):
14680		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14681
14682	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14683		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14684
14685	case strings.EqualFold("InvalidInputException", errorCode):
14686		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14687
14688	case strings.EqualFold("NotFoundException", errorCode):
14689		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14690
14691	case strings.EqualFold("OperationFailureException", errorCode):
14692		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14693
14694	case strings.EqualFold("ServiceException", errorCode):
14695		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14696
14697	case strings.EqualFold("UnauthenticatedException", errorCode):
14698		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14699
14700	default:
14701		genericError := &smithy.GenericAPIError{
14702			Code:    errorCode,
14703			Message: errorMessage,
14704		}
14705		return genericError
14706
14707	}
14708}
14709
14710type awsAwsjson11_deserializeOpIsVpcPeered struct {
14711}
14712
14713func (*awsAwsjson11_deserializeOpIsVpcPeered) ID() string {
14714	return "OperationDeserializer"
14715}
14716
14717func (m *awsAwsjson11_deserializeOpIsVpcPeered) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14718	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14719) {
14720	out, metadata, err = next.HandleDeserialize(ctx, in)
14721	if err != nil {
14722		return out, metadata, err
14723	}
14724
14725	response, ok := out.RawResponse.(*smithyhttp.Response)
14726	if !ok {
14727		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14728	}
14729
14730	if response.StatusCode < 200 || response.StatusCode >= 300 {
14731		return out, metadata, awsAwsjson11_deserializeOpErrorIsVpcPeered(response, &metadata)
14732	}
14733	output := &IsVpcPeeredOutput{}
14734	out.Result = output
14735
14736	var buff [1024]byte
14737	ringBuffer := smithyio.NewRingBuffer(buff[:])
14738
14739	body := io.TeeReader(response.Body, ringBuffer)
14740	decoder := json.NewDecoder(body)
14741	decoder.UseNumber()
14742	var shape interface{}
14743	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14744		var snapshot bytes.Buffer
14745		io.Copy(&snapshot, ringBuffer)
14746		err = &smithy.DeserializationError{
14747			Err:      fmt.Errorf("failed to decode response body, %w", err),
14748			Snapshot: snapshot.Bytes(),
14749		}
14750		return out, metadata, err
14751	}
14752
14753	err = awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(&output, shape)
14754	if err != nil {
14755		var snapshot bytes.Buffer
14756		io.Copy(&snapshot, ringBuffer)
14757		err = &smithy.DeserializationError{
14758			Err:      fmt.Errorf("failed to decode response body, %w", err),
14759			Snapshot: snapshot.Bytes(),
14760		}
14761		return out, metadata, err
14762	}
14763
14764	return out, metadata, err
14765}
14766
14767func awsAwsjson11_deserializeOpErrorIsVpcPeered(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14768	var errorBuffer bytes.Buffer
14769	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14770		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14771	}
14772	errorBody := bytes.NewReader(errorBuffer.Bytes())
14773
14774	errorCode := "UnknownError"
14775	errorMessage := errorCode
14776
14777	code := response.Header.Get("X-Amzn-ErrorType")
14778	if len(code) != 0 {
14779		errorCode = restjson.SanitizeErrorCode(code)
14780	}
14781
14782	var buff [1024]byte
14783	ringBuffer := smithyio.NewRingBuffer(buff[:])
14784
14785	body := io.TeeReader(errorBody, ringBuffer)
14786	decoder := json.NewDecoder(body)
14787	decoder.UseNumber()
14788	code, message, err := restjson.GetErrorInfo(decoder)
14789	if err != nil {
14790		var snapshot bytes.Buffer
14791		io.Copy(&snapshot, ringBuffer)
14792		err = &smithy.DeserializationError{
14793			Err:      fmt.Errorf("failed to decode response body, %w", err),
14794			Snapshot: snapshot.Bytes(),
14795		}
14796		return err
14797	}
14798
14799	errorBody.Seek(0, io.SeekStart)
14800	if len(code) != 0 {
14801		errorCode = restjson.SanitizeErrorCode(code)
14802	}
14803	if len(message) != 0 {
14804		errorMessage = message
14805	}
14806
14807	switch {
14808	case strings.EqualFold("AccessDeniedException", errorCode):
14809		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14810
14811	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14812		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14813
14814	case strings.EqualFold("InvalidInputException", errorCode):
14815		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14816
14817	case strings.EqualFold("NotFoundException", errorCode):
14818		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14819
14820	case strings.EqualFold("OperationFailureException", errorCode):
14821		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14822
14823	case strings.EqualFold("ServiceException", errorCode):
14824		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14825
14826	case strings.EqualFold("UnauthenticatedException", errorCode):
14827		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14828
14829	default:
14830		genericError := &smithy.GenericAPIError{
14831			Code:    errorCode,
14832			Message: errorMessage,
14833		}
14834		return genericError
14835
14836	}
14837}
14838
14839type awsAwsjson11_deserializeOpOpenInstancePublicPorts struct {
14840}
14841
14842func (*awsAwsjson11_deserializeOpOpenInstancePublicPorts) ID() string {
14843	return "OperationDeserializer"
14844}
14845
14846func (m *awsAwsjson11_deserializeOpOpenInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14847	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14848) {
14849	out, metadata, err = next.HandleDeserialize(ctx, in)
14850	if err != nil {
14851		return out, metadata, err
14852	}
14853
14854	response, ok := out.RawResponse.(*smithyhttp.Response)
14855	if !ok {
14856		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14857	}
14858
14859	if response.StatusCode < 200 || response.StatusCode >= 300 {
14860		return out, metadata, awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response, &metadata)
14861	}
14862	output := &OpenInstancePublicPortsOutput{}
14863	out.Result = output
14864
14865	var buff [1024]byte
14866	ringBuffer := smithyio.NewRingBuffer(buff[:])
14867
14868	body := io.TeeReader(response.Body, ringBuffer)
14869	decoder := json.NewDecoder(body)
14870	decoder.UseNumber()
14871	var shape interface{}
14872	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
14873		var snapshot bytes.Buffer
14874		io.Copy(&snapshot, ringBuffer)
14875		err = &smithy.DeserializationError{
14876			Err:      fmt.Errorf("failed to decode response body, %w", err),
14877			Snapshot: snapshot.Bytes(),
14878		}
14879		return out, metadata, err
14880	}
14881
14882	err = awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(&output, shape)
14883	if err != nil {
14884		var snapshot bytes.Buffer
14885		io.Copy(&snapshot, ringBuffer)
14886		err = &smithy.DeserializationError{
14887			Err:      fmt.Errorf("failed to decode response body, %w", err),
14888			Snapshot: snapshot.Bytes(),
14889		}
14890		return out, metadata, err
14891	}
14892
14893	return out, metadata, err
14894}
14895
14896func awsAwsjson11_deserializeOpErrorOpenInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
14897	var errorBuffer bytes.Buffer
14898	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
14899		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
14900	}
14901	errorBody := bytes.NewReader(errorBuffer.Bytes())
14902
14903	errorCode := "UnknownError"
14904	errorMessage := errorCode
14905
14906	code := response.Header.Get("X-Amzn-ErrorType")
14907	if len(code) != 0 {
14908		errorCode = restjson.SanitizeErrorCode(code)
14909	}
14910
14911	var buff [1024]byte
14912	ringBuffer := smithyio.NewRingBuffer(buff[:])
14913
14914	body := io.TeeReader(errorBody, ringBuffer)
14915	decoder := json.NewDecoder(body)
14916	decoder.UseNumber()
14917	code, message, err := restjson.GetErrorInfo(decoder)
14918	if err != nil {
14919		var snapshot bytes.Buffer
14920		io.Copy(&snapshot, ringBuffer)
14921		err = &smithy.DeserializationError{
14922			Err:      fmt.Errorf("failed to decode response body, %w", err),
14923			Snapshot: snapshot.Bytes(),
14924		}
14925		return err
14926	}
14927
14928	errorBody.Seek(0, io.SeekStart)
14929	if len(code) != 0 {
14930		errorCode = restjson.SanitizeErrorCode(code)
14931	}
14932	if len(message) != 0 {
14933		errorMessage = message
14934	}
14935
14936	switch {
14937	case strings.EqualFold("AccessDeniedException", errorCode):
14938		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
14939
14940	case strings.EqualFold("AccountSetupInProgressException", errorCode):
14941		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
14942
14943	case strings.EqualFold("InvalidInputException", errorCode):
14944		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
14945
14946	case strings.EqualFold("NotFoundException", errorCode):
14947		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
14948
14949	case strings.EqualFold("OperationFailureException", errorCode):
14950		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
14951
14952	case strings.EqualFold("ServiceException", errorCode):
14953		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
14954
14955	case strings.EqualFold("UnauthenticatedException", errorCode):
14956		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
14957
14958	default:
14959		genericError := &smithy.GenericAPIError{
14960			Code:    errorCode,
14961			Message: errorMessage,
14962		}
14963		return genericError
14964
14965	}
14966}
14967
14968type awsAwsjson11_deserializeOpPeerVpc struct {
14969}
14970
14971func (*awsAwsjson11_deserializeOpPeerVpc) ID() string {
14972	return "OperationDeserializer"
14973}
14974
14975func (m *awsAwsjson11_deserializeOpPeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
14976	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
14977) {
14978	out, metadata, err = next.HandleDeserialize(ctx, in)
14979	if err != nil {
14980		return out, metadata, err
14981	}
14982
14983	response, ok := out.RawResponse.(*smithyhttp.Response)
14984	if !ok {
14985		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
14986	}
14987
14988	if response.StatusCode < 200 || response.StatusCode >= 300 {
14989		return out, metadata, awsAwsjson11_deserializeOpErrorPeerVpc(response, &metadata)
14990	}
14991	output := &PeerVpcOutput{}
14992	out.Result = output
14993
14994	var buff [1024]byte
14995	ringBuffer := smithyio.NewRingBuffer(buff[:])
14996
14997	body := io.TeeReader(response.Body, ringBuffer)
14998	decoder := json.NewDecoder(body)
14999	decoder.UseNumber()
15000	var shape interface{}
15001	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15002		var snapshot bytes.Buffer
15003		io.Copy(&snapshot, ringBuffer)
15004		err = &smithy.DeserializationError{
15005			Err:      fmt.Errorf("failed to decode response body, %w", err),
15006			Snapshot: snapshot.Bytes(),
15007		}
15008		return out, metadata, err
15009	}
15010
15011	err = awsAwsjson11_deserializeOpDocumentPeerVpcOutput(&output, shape)
15012	if err != nil {
15013		var snapshot bytes.Buffer
15014		io.Copy(&snapshot, ringBuffer)
15015		err = &smithy.DeserializationError{
15016			Err:      fmt.Errorf("failed to decode response body, %w", err),
15017			Snapshot: snapshot.Bytes(),
15018		}
15019		return out, metadata, err
15020	}
15021
15022	return out, metadata, err
15023}
15024
15025func awsAwsjson11_deserializeOpErrorPeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15026	var errorBuffer bytes.Buffer
15027	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15028		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15029	}
15030	errorBody := bytes.NewReader(errorBuffer.Bytes())
15031
15032	errorCode := "UnknownError"
15033	errorMessage := errorCode
15034
15035	code := response.Header.Get("X-Amzn-ErrorType")
15036	if len(code) != 0 {
15037		errorCode = restjson.SanitizeErrorCode(code)
15038	}
15039
15040	var buff [1024]byte
15041	ringBuffer := smithyio.NewRingBuffer(buff[:])
15042
15043	body := io.TeeReader(errorBody, ringBuffer)
15044	decoder := json.NewDecoder(body)
15045	decoder.UseNumber()
15046	code, message, err := restjson.GetErrorInfo(decoder)
15047	if err != nil {
15048		var snapshot bytes.Buffer
15049		io.Copy(&snapshot, ringBuffer)
15050		err = &smithy.DeserializationError{
15051			Err:      fmt.Errorf("failed to decode response body, %w", err),
15052			Snapshot: snapshot.Bytes(),
15053		}
15054		return err
15055	}
15056
15057	errorBody.Seek(0, io.SeekStart)
15058	if len(code) != 0 {
15059		errorCode = restjson.SanitizeErrorCode(code)
15060	}
15061	if len(message) != 0 {
15062		errorMessage = message
15063	}
15064
15065	switch {
15066	case strings.EqualFold("AccessDeniedException", errorCode):
15067		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15068
15069	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15070		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15071
15072	case strings.EqualFold("InvalidInputException", errorCode):
15073		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15074
15075	case strings.EqualFold("NotFoundException", errorCode):
15076		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15077
15078	case strings.EqualFold("OperationFailureException", errorCode):
15079		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15080
15081	case strings.EqualFold("ServiceException", errorCode):
15082		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15083
15084	case strings.EqualFold("UnauthenticatedException", errorCode):
15085		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15086
15087	default:
15088		genericError := &smithy.GenericAPIError{
15089			Code:    errorCode,
15090			Message: errorMessage,
15091		}
15092		return genericError
15093
15094	}
15095}
15096
15097type awsAwsjson11_deserializeOpPutAlarm struct {
15098}
15099
15100func (*awsAwsjson11_deserializeOpPutAlarm) ID() string {
15101	return "OperationDeserializer"
15102}
15103
15104func (m *awsAwsjson11_deserializeOpPutAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15105	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15106) {
15107	out, metadata, err = next.HandleDeserialize(ctx, in)
15108	if err != nil {
15109		return out, metadata, err
15110	}
15111
15112	response, ok := out.RawResponse.(*smithyhttp.Response)
15113	if !ok {
15114		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15115	}
15116
15117	if response.StatusCode < 200 || response.StatusCode >= 300 {
15118		return out, metadata, awsAwsjson11_deserializeOpErrorPutAlarm(response, &metadata)
15119	}
15120	output := &PutAlarmOutput{}
15121	out.Result = output
15122
15123	var buff [1024]byte
15124	ringBuffer := smithyio.NewRingBuffer(buff[:])
15125
15126	body := io.TeeReader(response.Body, ringBuffer)
15127	decoder := json.NewDecoder(body)
15128	decoder.UseNumber()
15129	var shape interface{}
15130	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15131		var snapshot bytes.Buffer
15132		io.Copy(&snapshot, ringBuffer)
15133		err = &smithy.DeserializationError{
15134			Err:      fmt.Errorf("failed to decode response body, %w", err),
15135			Snapshot: snapshot.Bytes(),
15136		}
15137		return out, metadata, err
15138	}
15139
15140	err = awsAwsjson11_deserializeOpDocumentPutAlarmOutput(&output, shape)
15141	if err != nil {
15142		var snapshot bytes.Buffer
15143		io.Copy(&snapshot, ringBuffer)
15144		err = &smithy.DeserializationError{
15145			Err:      fmt.Errorf("failed to decode response body, %w", err),
15146			Snapshot: snapshot.Bytes(),
15147		}
15148		return out, metadata, err
15149	}
15150
15151	return out, metadata, err
15152}
15153
15154func awsAwsjson11_deserializeOpErrorPutAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15155	var errorBuffer bytes.Buffer
15156	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15157		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15158	}
15159	errorBody := bytes.NewReader(errorBuffer.Bytes())
15160
15161	errorCode := "UnknownError"
15162	errorMessage := errorCode
15163
15164	code := response.Header.Get("X-Amzn-ErrorType")
15165	if len(code) != 0 {
15166		errorCode = restjson.SanitizeErrorCode(code)
15167	}
15168
15169	var buff [1024]byte
15170	ringBuffer := smithyio.NewRingBuffer(buff[:])
15171
15172	body := io.TeeReader(errorBody, ringBuffer)
15173	decoder := json.NewDecoder(body)
15174	decoder.UseNumber()
15175	code, message, err := restjson.GetErrorInfo(decoder)
15176	if err != nil {
15177		var snapshot bytes.Buffer
15178		io.Copy(&snapshot, ringBuffer)
15179		err = &smithy.DeserializationError{
15180			Err:      fmt.Errorf("failed to decode response body, %w", err),
15181			Snapshot: snapshot.Bytes(),
15182		}
15183		return err
15184	}
15185
15186	errorBody.Seek(0, io.SeekStart)
15187	if len(code) != 0 {
15188		errorCode = restjson.SanitizeErrorCode(code)
15189	}
15190	if len(message) != 0 {
15191		errorMessage = message
15192	}
15193
15194	switch {
15195	case strings.EqualFold("AccessDeniedException", errorCode):
15196		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15197
15198	case strings.EqualFold("InvalidInputException", errorCode):
15199		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15200
15201	case strings.EqualFold("NotFoundException", errorCode):
15202		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15203
15204	case strings.EqualFold("OperationFailureException", errorCode):
15205		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15206
15207	case strings.EqualFold("ServiceException", errorCode):
15208		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15209
15210	case strings.EqualFold("UnauthenticatedException", errorCode):
15211		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15212
15213	default:
15214		genericError := &smithy.GenericAPIError{
15215			Code:    errorCode,
15216			Message: errorMessage,
15217		}
15218		return genericError
15219
15220	}
15221}
15222
15223type awsAwsjson11_deserializeOpPutInstancePublicPorts struct {
15224}
15225
15226func (*awsAwsjson11_deserializeOpPutInstancePublicPorts) ID() string {
15227	return "OperationDeserializer"
15228}
15229
15230func (m *awsAwsjson11_deserializeOpPutInstancePublicPorts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15231	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15232) {
15233	out, metadata, err = next.HandleDeserialize(ctx, in)
15234	if err != nil {
15235		return out, metadata, err
15236	}
15237
15238	response, ok := out.RawResponse.(*smithyhttp.Response)
15239	if !ok {
15240		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15241	}
15242
15243	if response.StatusCode < 200 || response.StatusCode >= 300 {
15244		return out, metadata, awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response, &metadata)
15245	}
15246	output := &PutInstancePublicPortsOutput{}
15247	out.Result = output
15248
15249	var buff [1024]byte
15250	ringBuffer := smithyio.NewRingBuffer(buff[:])
15251
15252	body := io.TeeReader(response.Body, ringBuffer)
15253	decoder := json.NewDecoder(body)
15254	decoder.UseNumber()
15255	var shape interface{}
15256	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15257		var snapshot bytes.Buffer
15258		io.Copy(&snapshot, ringBuffer)
15259		err = &smithy.DeserializationError{
15260			Err:      fmt.Errorf("failed to decode response body, %w", err),
15261			Snapshot: snapshot.Bytes(),
15262		}
15263		return out, metadata, err
15264	}
15265
15266	err = awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(&output, shape)
15267	if err != nil {
15268		var snapshot bytes.Buffer
15269		io.Copy(&snapshot, ringBuffer)
15270		err = &smithy.DeserializationError{
15271			Err:      fmt.Errorf("failed to decode response body, %w", err),
15272			Snapshot: snapshot.Bytes(),
15273		}
15274		return out, metadata, err
15275	}
15276
15277	return out, metadata, err
15278}
15279
15280func awsAwsjson11_deserializeOpErrorPutInstancePublicPorts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15281	var errorBuffer bytes.Buffer
15282	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15283		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15284	}
15285	errorBody := bytes.NewReader(errorBuffer.Bytes())
15286
15287	errorCode := "UnknownError"
15288	errorMessage := errorCode
15289
15290	code := response.Header.Get("X-Amzn-ErrorType")
15291	if len(code) != 0 {
15292		errorCode = restjson.SanitizeErrorCode(code)
15293	}
15294
15295	var buff [1024]byte
15296	ringBuffer := smithyio.NewRingBuffer(buff[:])
15297
15298	body := io.TeeReader(errorBody, ringBuffer)
15299	decoder := json.NewDecoder(body)
15300	decoder.UseNumber()
15301	code, message, err := restjson.GetErrorInfo(decoder)
15302	if err != nil {
15303		var snapshot bytes.Buffer
15304		io.Copy(&snapshot, ringBuffer)
15305		err = &smithy.DeserializationError{
15306			Err:      fmt.Errorf("failed to decode response body, %w", err),
15307			Snapshot: snapshot.Bytes(),
15308		}
15309		return err
15310	}
15311
15312	errorBody.Seek(0, io.SeekStart)
15313	if len(code) != 0 {
15314		errorCode = restjson.SanitizeErrorCode(code)
15315	}
15316	if len(message) != 0 {
15317		errorMessage = message
15318	}
15319
15320	switch {
15321	case strings.EqualFold("AccessDeniedException", errorCode):
15322		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15323
15324	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15325		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15326
15327	case strings.EqualFold("InvalidInputException", errorCode):
15328		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15329
15330	case strings.EqualFold("NotFoundException", errorCode):
15331		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15332
15333	case strings.EqualFold("OperationFailureException", errorCode):
15334		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15335
15336	case strings.EqualFold("ServiceException", errorCode):
15337		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15338
15339	case strings.EqualFold("UnauthenticatedException", errorCode):
15340		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15341
15342	default:
15343		genericError := &smithy.GenericAPIError{
15344			Code:    errorCode,
15345			Message: errorMessage,
15346		}
15347		return genericError
15348
15349	}
15350}
15351
15352type awsAwsjson11_deserializeOpRebootInstance struct {
15353}
15354
15355func (*awsAwsjson11_deserializeOpRebootInstance) ID() string {
15356	return "OperationDeserializer"
15357}
15358
15359func (m *awsAwsjson11_deserializeOpRebootInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15360	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15361) {
15362	out, metadata, err = next.HandleDeserialize(ctx, in)
15363	if err != nil {
15364		return out, metadata, err
15365	}
15366
15367	response, ok := out.RawResponse.(*smithyhttp.Response)
15368	if !ok {
15369		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15370	}
15371
15372	if response.StatusCode < 200 || response.StatusCode >= 300 {
15373		return out, metadata, awsAwsjson11_deserializeOpErrorRebootInstance(response, &metadata)
15374	}
15375	output := &RebootInstanceOutput{}
15376	out.Result = output
15377
15378	var buff [1024]byte
15379	ringBuffer := smithyio.NewRingBuffer(buff[:])
15380
15381	body := io.TeeReader(response.Body, ringBuffer)
15382	decoder := json.NewDecoder(body)
15383	decoder.UseNumber()
15384	var shape interface{}
15385	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15386		var snapshot bytes.Buffer
15387		io.Copy(&snapshot, ringBuffer)
15388		err = &smithy.DeserializationError{
15389			Err:      fmt.Errorf("failed to decode response body, %w", err),
15390			Snapshot: snapshot.Bytes(),
15391		}
15392		return out, metadata, err
15393	}
15394
15395	err = awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(&output, shape)
15396	if err != nil {
15397		var snapshot bytes.Buffer
15398		io.Copy(&snapshot, ringBuffer)
15399		err = &smithy.DeserializationError{
15400			Err:      fmt.Errorf("failed to decode response body, %w", err),
15401			Snapshot: snapshot.Bytes(),
15402		}
15403		return out, metadata, err
15404	}
15405
15406	return out, metadata, err
15407}
15408
15409func awsAwsjson11_deserializeOpErrorRebootInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15410	var errorBuffer bytes.Buffer
15411	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15412		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15413	}
15414	errorBody := bytes.NewReader(errorBuffer.Bytes())
15415
15416	errorCode := "UnknownError"
15417	errorMessage := errorCode
15418
15419	code := response.Header.Get("X-Amzn-ErrorType")
15420	if len(code) != 0 {
15421		errorCode = restjson.SanitizeErrorCode(code)
15422	}
15423
15424	var buff [1024]byte
15425	ringBuffer := smithyio.NewRingBuffer(buff[:])
15426
15427	body := io.TeeReader(errorBody, ringBuffer)
15428	decoder := json.NewDecoder(body)
15429	decoder.UseNumber()
15430	code, message, err := restjson.GetErrorInfo(decoder)
15431	if err != nil {
15432		var snapshot bytes.Buffer
15433		io.Copy(&snapshot, ringBuffer)
15434		err = &smithy.DeserializationError{
15435			Err:      fmt.Errorf("failed to decode response body, %w", err),
15436			Snapshot: snapshot.Bytes(),
15437		}
15438		return err
15439	}
15440
15441	errorBody.Seek(0, io.SeekStart)
15442	if len(code) != 0 {
15443		errorCode = restjson.SanitizeErrorCode(code)
15444	}
15445	if len(message) != 0 {
15446		errorMessage = message
15447	}
15448
15449	switch {
15450	case strings.EqualFold("AccessDeniedException", errorCode):
15451		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15452
15453	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15454		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15455
15456	case strings.EqualFold("InvalidInputException", errorCode):
15457		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15458
15459	case strings.EqualFold("NotFoundException", errorCode):
15460		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15461
15462	case strings.EqualFold("OperationFailureException", errorCode):
15463		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15464
15465	case strings.EqualFold("ServiceException", errorCode):
15466		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15467
15468	case strings.EqualFold("UnauthenticatedException", errorCode):
15469		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15470
15471	default:
15472		genericError := &smithy.GenericAPIError{
15473			Code:    errorCode,
15474			Message: errorMessage,
15475		}
15476		return genericError
15477
15478	}
15479}
15480
15481type awsAwsjson11_deserializeOpRebootRelationalDatabase struct {
15482}
15483
15484func (*awsAwsjson11_deserializeOpRebootRelationalDatabase) ID() string {
15485	return "OperationDeserializer"
15486}
15487
15488func (m *awsAwsjson11_deserializeOpRebootRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15489	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15490) {
15491	out, metadata, err = next.HandleDeserialize(ctx, in)
15492	if err != nil {
15493		return out, metadata, err
15494	}
15495
15496	response, ok := out.RawResponse.(*smithyhttp.Response)
15497	if !ok {
15498		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15499	}
15500
15501	if response.StatusCode < 200 || response.StatusCode >= 300 {
15502		return out, metadata, awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response, &metadata)
15503	}
15504	output := &RebootRelationalDatabaseOutput{}
15505	out.Result = output
15506
15507	var buff [1024]byte
15508	ringBuffer := smithyio.NewRingBuffer(buff[:])
15509
15510	body := io.TeeReader(response.Body, ringBuffer)
15511	decoder := json.NewDecoder(body)
15512	decoder.UseNumber()
15513	var shape interface{}
15514	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15515		var snapshot bytes.Buffer
15516		io.Copy(&snapshot, ringBuffer)
15517		err = &smithy.DeserializationError{
15518			Err:      fmt.Errorf("failed to decode response body, %w", err),
15519			Snapshot: snapshot.Bytes(),
15520		}
15521		return out, metadata, err
15522	}
15523
15524	err = awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(&output, shape)
15525	if err != nil {
15526		var snapshot bytes.Buffer
15527		io.Copy(&snapshot, ringBuffer)
15528		err = &smithy.DeserializationError{
15529			Err:      fmt.Errorf("failed to decode response body, %w", err),
15530			Snapshot: snapshot.Bytes(),
15531		}
15532		return out, metadata, err
15533	}
15534
15535	return out, metadata, err
15536}
15537
15538func awsAwsjson11_deserializeOpErrorRebootRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15539	var errorBuffer bytes.Buffer
15540	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15541		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15542	}
15543	errorBody := bytes.NewReader(errorBuffer.Bytes())
15544
15545	errorCode := "UnknownError"
15546	errorMessage := errorCode
15547
15548	code := response.Header.Get("X-Amzn-ErrorType")
15549	if len(code) != 0 {
15550		errorCode = restjson.SanitizeErrorCode(code)
15551	}
15552
15553	var buff [1024]byte
15554	ringBuffer := smithyio.NewRingBuffer(buff[:])
15555
15556	body := io.TeeReader(errorBody, ringBuffer)
15557	decoder := json.NewDecoder(body)
15558	decoder.UseNumber()
15559	code, message, err := restjson.GetErrorInfo(decoder)
15560	if err != nil {
15561		var snapshot bytes.Buffer
15562		io.Copy(&snapshot, ringBuffer)
15563		err = &smithy.DeserializationError{
15564			Err:      fmt.Errorf("failed to decode response body, %w", err),
15565			Snapshot: snapshot.Bytes(),
15566		}
15567		return err
15568	}
15569
15570	errorBody.Seek(0, io.SeekStart)
15571	if len(code) != 0 {
15572		errorCode = restjson.SanitizeErrorCode(code)
15573	}
15574	if len(message) != 0 {
15575		errorMessage = message
15576	}
15577
15578	switch {
15579	case strings.EqualFold("AccessDeniedException", errorCode):
15580		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15581
15582	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15583		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15584
15585	case strings.EqualFold("InvalidInputException", errorCode):
15586		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15587
15588	case strings.EqualFold("NotFoundException", errorCode):
15589		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15590
15591	case strings.EqualFold("OperationFailureException", errorCode):
15592		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15593
15594	case strings.EqualFold("ServiceException", errorCode):
15595		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15596
15597	case strings.EqualFold("UnauthenticatedException", errorCode):
15598		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15599
15600	default:
15601		genericError := &smithy.GenericAPIError{
15602			Code:    errorCode,
15603			Message: errorMessage,
15604		}
15605		return genericError
15606
15607	}
15608}
15609
15610type awsAwsjson11_deserializeOpRegisterContainerImage struct {
15611}
15612
15613func (*awsAwsjson11_deserializeOpRegisterContainerImage) ID() string {
15614	return "OperationDeserializer"
15615}
15616
15617func (m *awsAwsjson11_deserializeOpRegisterContainerImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15618	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15619) {
15620	out, metadata, err = next.HandleDeserialize(ctx, in)
15621	if err != nil {
15622		return out, metadata, err
15623	}
15624
15625	response, ok := out.RawResponse.(*smithyhttp.Response)
15626	if !ok {
15627		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15628	}
15629
15630	if response.StatusCode < 200 || response.StatusCode >= 300 {
15631		return out, metadata, awsAwsjson11_deserializeOpErrorRegisterContainerImage(response, &metadata)
15632	}
15633	output := &RegisterContainerImageOutput{}
15634	out.Result = output
15635
15636	var buff [1024]byte
15637	ringBuffer := smithyio.NewRingBuffer(buff[:])
15638
15639	body := io.TeeReader(response.Body, ringBuffer)
15640	decoder := json.NewDecoder(body)
15641	decoder.UseNumber()
15642	var shape interface{}
15643	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15644		var snapshot bytes.Buffer
15645		io.Copy(&snapshot, ringBuffer)
15646		err = &smithy.DeserializationError{
15647			Err:      fmt.Errorf("failed to decode response body, %w", err),
15648			Snapshot: snapshot.Bytes(),
15649		}
15650		return out, metadata, err
15651	}
15652
15653	err = awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(&output, shape)
15654	if err != nil {
15655		var snapshot bytes.Buffer
15656		io.Copy(&snapshot, ringBuffer)
15657		err = &smithy.DeserializationError{
15658			Err:      fmt.Errorf("failed to decode response body, %w", err),
15659			Snapshot: snapshot.Bytes(),
15660		}
15661		return out, metadata, err
15662	}
15663
15664	return out, metadata, err
15665}
15666
15667func awsAwsjson11_deserializeOpErrorRegisterContainerImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15668	var errorBuffer bytes.Buffer
15669	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15670		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15671	}
15672	errorBody := bytes.NewReader(errorBuffer.Bytes())
15673
15674	errorCode := "UnknownError"
15675	errorMessage := errorCode
15676
15677	code := response.Header.Get("X-Amzn-ErrorType")
15678	if len(code) != 0 {
15679		errorCode = restjson.SanitizeErrorCode(code)
15680	}
15681
15682	var buff [1024]byte
15683	ringBuffer := smithyio.NewRingBuffer(buff[:])
15684
15685	body := io.TeeReader(errorBody, ringBuffer)
15686	decoder := json.NewDecoder(body)
15687	decoder.UseNumber()
15688	code, message, err := restjson.GetErrorInfo(decoder)
15689	if err != nil {
15690		var snapshot bytes.Buffer
15691		io.Copy(&snapshot, ringBuffer)
15692		err = &smithy.DeserializationError{
15693			Err:      fmt.Errorf("failed to decode response body, %w", err),
15694			Snapshot: snapshot.Bytes(),
15695		}
15696		return err
15697	}
15698
15699	errorBody.Seek(0, io.SeekStart)
15700	if len(code) != 0 {
15701		errorCode = restjson.SanitizeErrorCode(code)
15702	}
15703	if len(message) != 0 {
15704		errorMessage = message
15705	}
15706
15707	switch {
15708	case strings.EqualFold("AccessDeniedException", errorCode):
15709		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15710
15711	case strings.EqualFold("InvalidInputException", errorCode):
15712		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15713
15714	case strings.EqualFold("NotFoundException", errorCode):
15715		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15716
15717	case strings.EqualFold("ServiceException", errorCode):
15718		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15719
15720	case strings.EqualFold("UnauthenticatedException", errorCode):
15721		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15722
15723	default:
15724		genericError := &smithy.GenericAPIError{
15725			Code:    errorCode,
15726			Message: errorMessage,
15727		}
15728		return genericError
15729
15730	}
15731}
15732
15733type awsAwsjson11_deserializeOpReleaseStaticIp struct {
15734}
15735
15736func (*awsAwsjson11_deserializeOpReleaseStaticIp) ID() string {
15737	return "OperationDeserializer"
15738}
15739
15740func (m *awsAwsjson11_deserializeOpReleaseStaticIp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15741	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15742) {
15743	out, metadata, err = next.HandleDeserialize(ctx, in)
15744	if err != nil {
15745		return out, metadata, err
15746	}
15747
15748	response, ok := out.RawResponse.(*smithyhttp.Response)
15749	if !ok {
15750		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15751	}
15752
15753	if response.StatusCode < 200 || response.StatusCode >= 300 {
15754		return out, metadata, awsAwsjson11_deserializeOpErrorReleaseStaticIp(response, &metadata)
15755	}
15756	output := &ReleaseStaticIpOutput{}
15757	out.Result = output
15758
15759	var buff [1024]byte
15760	ringBuffer := smithyio.NewRingBuffer(buff[:])
15761
15762	body := io.TeeReader(response.Body, ringBuffer)
15763	decoder := json.NewDecoder(body)
15764	decoder.UseNumber()
15765	var shape interface{}
15766	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15767		var snapshot bytes.Buffer
15768		io.Copy(&snapshot, ringBuffer)
15769		err = &smithy.DeserializationError{
15770			Err:      fmt.Errorf("failed to decode response body, %w", err),
15771			Snapshot: snapshot.Bytes(),
15772		}
15773		return out, metadata, err
15774	}
15775
15776	err = awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(&output, shape)
15777	if err != nil {
15778		var snapshot bytes.Buffer
15779		io.Copy(&snapshot, ringBuffer)
15780		err = &smithy.DeserializationError{
15781			Err:      fmt.Errorf("failed to decode response body, %w", err),
15782			Snapshot: snapshot.Bytes(),
15783		}
15784		return out, metadata, err
15785	}
15786
15787	return out, metadata, err
15788}
15789
15790func awsAwsjson11_deserializeOpErrorReleaseStaticIp(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15791	var errorBuffer bytes.Buffer
15792	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15793		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15794	}
15795	errorBody := bytes.NewReader(errorBuffer.Bytes())
15796
15797	errorCode := "UnknownError"
15798	errorMessage := errorCode
15799
15800	code := response.Header.Get("X-Amzn-ErrorType")
15801	if len(code) != 0 {
15802		errorCode = restjson.SanitizeErrorCode(code)
15803	}
15804
15805	var buff [1024]byte
15806	ringBuffer := smithyio.NewRingBuffer(buff[:])
15807
15808	body := io.TeeReader(errorBody, ringBuffer)
15809	decoder := json.NewDecoder(body)
15810	decoder.UseNumber()
15811	code, message, err := restjson.GetErrorInfo(decoder)
15812	if err != nil {
15813		var snapshot bytes.Buffer
15814		io.Copy(&snapshot, ringBuffer)
15815		err = &smithy.DeserializationError{
15816			Err:      fmt.Errorf("failed to decode response body, %w", err),
15817			Snapshot: snapshot.Bytes(),
15818		}
15819		return err
15820	}
15821
15822	errorBody.Seek(0, io.SeekStart)
15823	if len(code) != 0 {
15824		errorCode = restjson.SanitizeErrorCode(code)
15825	}
15826	if len(message) != 0 {
15827		errorMessage = message
15828	}
15829
15830	switch {
15831	case strings.EqualFold("AccessDeniedException", errorCode):
15832		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15833
15834	case strings.EqualFold("AccountSetupInProgressException", errorCode):
15835		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
15836
15837	case strings.EqualFold("InvalidInputException", errorCode):
15838		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15839
15840	case strings.EqualFold("NotFoundException", errorCode):
15841		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15842
15843	case strings.EqualFold("OperationFailureException", errorCode):
15844		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15845
15846	case strings.EqualFold("ServiceException", errorCode):
15847		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15848
15849	case strings.EqualFold("UnauthenticatedException", errorCode):
15850		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15851
15852	default:
15853		genericError := &smithy.GenericAPIError{
15854			Code:    errorCode,
15855			Message: errorMessage,
15856		}
15857		return genericError
15858
15859	}
15860}
15861
15862type awsAwsjson11_deserializeOpResetDistributionCache struct {
15863}
15864
15865func (*awsAwsjson11_deserializeOpResetDistributionCache) ID() string {
15866	return "OperationDeserializer"
15867}
15868
15869func (m *awsAwsjson11_deserializeOpResetDistributionCache) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15870	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15871) {
15872	out, metadata, err = next.HandleDeserialize(ctx, in)
15873	if err != nil {
15874		return out, metadata, err
15875	}
15876
15877	response, ok := out.RawResponse.(*smithyhttp.Response)
15878	if !ok {
15879		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
15880	}
15881
15882	if response.StatusCode < 200 || response.StatusCode >= 300 {
15883		return out, metadata, awsAwsjson11_deserializeOpErrorResetDistributionCache(response, &metadata)
15884	}
15885	output := &ResetDistributionCacheOutput{}
15886	out.Result = output
15887
15888	var buff [1024]byte
15889	ringBuffer := smithyio.NewRingBuffer(buff[:])
15890
15891	body := io.TeeReader(response.Body, ringBuffer)
15892	decoder := json.NewDecoder(body)
15893	decoder.UseNumber()
15894	var shape interface{}
15895	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
15896		var snapshot bytes.Buffer
15897		io.Copy(&snapshot, ringBuffer)
15898		err = &smithy.DeserializationError{
15899			Err:      fmt.Errorf("failed to decode response body, %w", err),
15900			Snapshot: snapshot.Bytes(),
15901		}
15902		return out, metadata, err
15903	}
15904
15905	err = awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(&output, shape)
15906	if err != nil {
15907		var snapshot bytes.Buffer
15908		io.Copy(&snapshot, ringBuffer)
15909		err = &smithy.DeserializationError{
15910			Err:      fmt.Errorf("failed to decode response body, %w", err),
15911			Snapshot: snapshot.Bytes(),
15912		}
15913		return out, metadata, err
15914	}
15915
15916	return out, metadata, err
15917}
15918
15919func awsAwsjson11_deserializeOpErrorResetDistributionCache(response *smithyhttp.Response, metadata *middleware.Metadata) error {
15920	var errorBuffer bytes.Buffer
15921	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
15922		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
15923	}
15924	errorBody := bytes.NewReader(errorBuffer.Bytes())
15925
15926	errorCode := "UnknownError"
15927	errorMessage := errorCode
15928
15929	code := response.Header.Get("X-Amzn-ErrorType")
15930	if len(code) != 0 {
15931		errorCode = restjson.SanitizeErrorCode(code)
15932	}
15933
15934	var buff [1024]byte
15935	ringBuffer := smithyio.NewRingBuffer(buff[:])
15936
15937	body := io.TeeReader(errorBody, ringBuffer)
15938	decoder := json.NewDecoder(body)
15939	decoder.UseNumber()
15940	code, message, err := restjson.GetErrorInfo(decoder)
15941	if err != nil {
15942		var snapshot bytes.Buffer
15943		io.Copy(&snapshot, ringBuffer)
15944		err = &smithy.DeserializationError{
15945			Err:      fmt.Errorf("failed to decode response body, %w", err),
15946			Snapshot: snapshot.Bytes(),
15947		}
15948		return err
15949	}
15950
15951	errorBody.Seek(0, io.SeekStart)
15952	if len(code) != 0 {
15953		errorCode = restjson.SanitizeErrorCode(code)
15954	}
15955	if len(message) != 0 {
15956		errorMessage = message
15957	}
15958
15959	switch {
15960	case strings.EqualFold("AccessDeniedException", errorCode):
15961		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
15962
15963	case strings.EqualFold("InvalidInputException", errorCode):
15964		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
15965
15966	case strings.EqualFold("NotFoundException", errorCode):
15967		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
15968
15969	case strings.EqualFold("OperationFailureException", errorCode):
15970		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
15971
15972	case strings.EqualFold("ServiceException", errorCode):
15973		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
15974
15975	case strings.EqualFold("UnauthenticatedException", errorCode):
15976		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
15977
15978	default:
15979		genericError := &smithy.GenericAPIError{
15980			Code:    errorCode,
15981			Message: errorMessage,
15982		}
15983		return genericError
15984
15985	}
15986}
15987
15988type awsAwsjson11_deserializeOpSendContactMethodVerification struct {
15989}
15990
15991func (*awsAwsjson11_deserializeOpSendContactMethodVerification) ID() string {
15992	return "OperationDeserializer"
15993}
15994
15995func (m *awsAwsjson11_deserializeOpSendContactMethodVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
15996	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
15997) {
15998	out, metadata, err = next.HandleDeserialize(ctx, in)
15999	if err != nil {
16000		return out, metadata, err
16001	}
16002
16003	response, ok := out.RawResponse.(*smithyhttp.Response)
16004	if !ok {
16005		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16006	}
16007
16008	if response.StatusCode < 200 || response.StatusCode >= 300 {
16009		return out, metadata, awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response, &metadata)
16010	}
16011	output := &SendContactMethodVerificationOutput{}
16012	out.Result = output
16013
16014	var buff [1024]byte
16015	ringBuffer := smithyio.NewRingBuffer(buff[:])
16016
16017	body := io.TeeReader(response.Body, ringBuffer)
16018	decoder := json.NewDecoder(body)
16019	decoder.UseNumber()
16020	var shape interface{}
16021	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16022		var snapshot bytes.Buffer
16023		io.Copy(&snapshot, ringBuffer)
16024		err = &smithy.DeserializationError{
16025			Err:      fmt.Errorf("failed to decode response body, %w", err),
16026			Snapshot: snapshot.Bytes(),
16027		}
16028		return out, metadata, err
16029	}
16030
16031	err = awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(&output, shape)
16032	if err != nil {
16033		var snapshot bytes.Buffer
16034		io.Copy(&snapshot, ringBuffer)
16035		err = &smithy.DeserializationError{
16036			Err:      fmt.Errorf("failed to decode response body, %w", err),
16037			Snapshot: snapshot.Bytes(),
16038		}
16039		return out, metadata, err
16040	}
16041
16042	return out, metadata, err
16043}
16044
16045func awsAwsjson11_deserializeOpErrorSendContactMethodVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16046	var errorBuffer bytes.Buffer
16047	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16048		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16049	}
16050	errorBody := bytes.NewReader(errorBuffer.Bytes())
16051
16052	errorCode := "UnknownError"
16053	errorMessage := errorCode
16054
16055	code := response.Header.Get("X-Amzn-ErrorType")
16056	if len(code) != 0 {
16057		errorCode = restjson.SanitizeErrorCode(code)
16058	}
16059
16060	var buff [1024]byte
16061	ringBuffer := smithyio.NewRingBuffer(buff[:])
16062
16063	body := io.TeeReader(errorBody, ringBuffer)
16064	decoder := json.NewDecoder(body)
16065	decoder.UseNumber()
16066	code, message, err := restjson.GetErrorInfo(decoder)
16067	if err != nil {
16068		var snapshot bytes.Buffer
16069		io.Copy(&snapshot, ringBuffer)
16070		err = &smithy.DeserializationError{
16071			Err:      fmt.Errorf("failed to decode response body, %w", err),
16072			Snapshot: snapshot.Bytes(),
16073		}
16074		return err
16075	}
16076
16077	errorBody.Seek(0, io.SeekStart)
16078	if len(code) != 0 {
16079		errorCode = restjson.SanitizeErrorCode(code)
16080	}
16081	if len(message) != 0 {
16082		errorMessage = message
16083	}
16084
16085	switch {
16086	case strings.EqualFold("AccessDeniedException", errorCode):
16087		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16088
16089	case strings.EqualFold("InvalidInputException", errorCode):
16090		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16091
16092	case strings.EqualFold("NotFoundException", errorCode):
16093		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16094
16095	case strings.EqualFold("OperationFailureException", errorCode):
16096		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16097
16098	case strings.EqualFold("ServiceException", errorCode):
16099		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16100
16101	case strings.EqualFold("UnauthenticatedException", errorCode):
16102		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16103
16104	default:
16105		genericError := &smithy.GenericAPIError{
16106			Code:    errorCode,
16107			Message: errorMessage,
16108		}
16109		return genericError
16110
16111	}
16112}
16113
16114type awsAwsjson11_deserializeOpSetIpAddressType struct {
16115}
16116
16117func (*awsAwsjson11_deserializeOpSetIpAddressType) ID() string {
16118	return "OperationDeserializer"
16119}
16120
16121func (m *awsAwsjson11_deserializeOpSetIpAddressType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16122	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16123) {
16124	out, metadata, err = next.HandleDeserialize(ctx, in)
16125	if err != nil {
16126		return out, metadata, err
16127	}
16128
16129	response, ok := out.RawResponse.(*smithyhttp.Response)
16130	if !ok {
16131		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16132	}
16133
16134	if response.StatusCode < 200 || response.StatusCode >= 300 {
16135		return out, metadata, awsAwsjson11_deserializeOpErrorSetIpAddressType(response, &metadata)
16136	}
16137	output := &SetIpAddressTypeOutput{}
16138	out.Result = output
16139
16140	var buff [1024]byte
16141	ringBuffer := smithyio.NewRingBuffer(buff[:])
16142
16143	body := io.TeeReader(response.Body, ringBuffer)
16144	decoder := json.NewDecoder(body)
16145	decoder.UseNumber()
16146	var shape interface{}
16147	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16148		var snapshot bytes.Buffer
16149		io.Copy(&snapshot, ringBuffer)
16150		err = &smithy.DeserializationError{
16151			Err:      fmt.Errorf("failed to decode response body, %w", err),
16152			Snapshot: snapshot.Bytes(),
16153		}
16154		return out, metadata, err
16155	}
16156
16157	err = awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(&output, shape)
16158	if err != nil {
16159		var snapshot bytes.Buffer
16160		io.Copy(&snapshot, ringBuffer)
16161		err = &smithy.DeserializationError{
16162			Err:      fmt.Errorf("failed to decode response body, %w", err),
16163			Snapshot: snapshot.Bytes(),
16164		}
16165		return out, metadata, err
16166	}
16167
16168	return out, metadata, err
16169}
16170
16171func awsAwsjson11_deserializeOpErrorSetIpAddressType(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16172	var errorBuffer bytes.Buffer
16173	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16174		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16175	}
16176	errorBody := bytes.NewReader(errorBuffer.Bytes())
16177
16178	errorCode := "UnknownError"
16179	errorMessage := errorCode
16180
16181	code := response.Header.Get("X-Amzn-ErrorType")
16182	if len(code) != 0 {
16183		errorCode = restjson.SanitizeErrorCode(code)
16184	}
16185
16186	var buff [1024]byte
16187	ringBuffer := smithyio.NewRingBuffer(buff[:])
16188
16189	body := io.TeeReader(errorBody, ringBuffer)
16190	decoder := json.NewDecoder(body)
16191	decoder.UseNumber()
16192	code, message, err := restjson.GetErrorInfo(decoder)
16193	if err != nil {
16194		var snapshot bytes.Buffer
16195		io.Copy(&snapshot, ringBuffer)
16196		err = &smithy.DeserializationError{
16197			Err:      fmt.Errorf("failed to decode response body, %w", err),
16198			Snapshot: snapshot.Bytes(),
16199		}
16200		return err
16201	}
16202
16203	errorBody.Seek(0, io.SeekStart)
16204	if len(code) != 0 {
16205		errorCode = restjson.SanitizeErrorCode(code)
16206	}
16207	if len(message) != 0 {
16208		errorMessage = message
16209	}
16210
16211	switch {
16212	case strings.EqualFold("AccessDeniedException", errorCode):
16213		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16214
16215	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16216		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16217
16218	case strings.EqualFold("InvalidInputException", errorCode):
16219		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16220
16221	case strings.EqualFold("NotFoundException", errorCode):
16222		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16223
16224	case strings.EqualFold("OperationFailureException", errorCode):
16225		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16226
16227	case strings.EqualFold("ServiceException", errorCode):
16228		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16229
16230	case strings.EqualFold("UnauthenticatedException", errorCode):
16231		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16232
16233	default:
16234		genericError := &smithy.GenericAPIError{
16235			Code:    errorCode,
16236			Message: errorMessage,
16237		}
16238		return genericError
16239
16240	}
16241}
16242
16243type awsAwsjson11_deserializeOpStartInstance struct {
16244}
16245
16246func (*awsAwsjson11_deserializeOpStartInstance) ID() string {
16247	return "OperationDeserializer"
16248}
16249
16250func (m *awsAwsjson11_deserializeOpStartInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16251	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16252) {
16253	out, metadata, err = next.HandleDeserialize(ctx, in)
16254	if err != nil {
16255		return out, metadata, err
16256	}
16257
16258	response, ok := out.RawResponse.(*smithyhttp.Response)
16259	if !ok {
16260		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16261	}
16262
16263	if response.StatusCode < 200 || response.StatusCode >= 300 {
16264		return out, metadata, awsAwsjson11_deserializeOpErrorStartInstance(response, &metadata)
16265	}
16266	output := &StartInstanceOutput{}
16267	out.Result = output
16268
16269	var buff [1024]byte
16270	ringBuffer := smithyio.NewRingBuffer(buff[:])
16271
16272	body := io.TeeReader(response.Body, ringBuffer)
16273	decoder := json.NewDecoder(body)
16274	decoder.UseNumber()
16275	var shape interface{}
16276	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16277		var snapshot bytes.Buffer
16278		io.Copy(&snapshot, ringBuffer)
16279		err = &smithy.DeserializationError{
16280			Err:      fmt.Errorf("failed to decode response body, %w", err),
16281			Snapshot: snapshot.Bytes(),
16282		}
16283		return out, metadata, err
16284	}
16285
16286	err = awsAwsjson11_deserializeOpDocumentStartInstanceOutput(&output, shape)
16287	if err != nil {
16288		var snapshot bytes.Buffer
16289		io.Copy(&snapshot, ringBuffer)
16290		err = &smithy.DeserializationError{
16291			Err:      fmt.Errorf("failed to decode response body, %w", err),
16292			Snapshot: snapshot.Bytes(),
16293		}
16294		return out, metadata, err
16295	}
16296
16297	return out, metadata, err
16298}
16299
16300func awsAwsjson11_deserializeOpErrorStartInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16301	var errorBuffer bytes.Buffer
16302	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16303		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16304	}
16305	errorBody := bytes.NewReader(errorBuffer.Bytes())
16306
16307	errorCode := "UnknownError"
16308	errorMessage := errorCode
16309
16310	code := response.Header.Get("X-Amzn-ErrorType")
16311	if len(code) != 0 {
16312		errorCode = restjson.SanitizeErrorCode(code)
16313	}
16314
16315	var buff [1024]byte
16316	ringBuffer := smithyio.NewRingBuffer(buff[:])
16317
16318	body := io.TeeReader(errorBody, ringBuffer)
16319	decoder := json.NewDecoder(body)
16320	decoder.UseNumber()
16321	code, message, err := restjson.GetErrorInfo(decoder)
16322	if err != nil {
16323		var snapshot bytes.Buffer
16324		io.Copy(&snapshot, ringBuffer)
16325		err = &smithy.DeserializationError{
16326			Err:      fmt.Errorf("failed to decode response body, %w", err),
16327			Snapshot: snapshot.Bytes(),
16328		}
16329		return err
16330	}
16331
16332	errorBody.Seek(0, io.SeekStart)
16333	if len(code) != 0 {
16334		errorCode = restjson.SanitizeErrorCode(code)
16335	}
16336	if len(message) != 0 {
16337		errorMessage = message
16338	}
16339
16340	switch {
16341	case strings.EqualFold("AccessDeniedException", errorCode):
16342		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16343
16344	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16345		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16346
16347	case strings.EqualFold("InvalidInputException", errorCode):
16348		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16349
16350	case strings.EqualFold("NotFoundException", errorCode):
16351		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16352
16353	case strings.EqualFold("OperationFailureException", errorCode):
16354		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16355
16356	case strings.EqualFold("ServiceException", errorCode):
16357		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16358
16359	case strings.EqualFold("UnauthenticatedException", errorCode):
16360		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16361
16362	default:
16363		genericError := &smithy.GenericAPIError{
16364			Code:    errorCode,
16365			Message: errorMessage,
16366		}
16367		return genericError
16368
16369	}
16370}
16371
16372type awsAwsjson11_deserializeOpStartRelationalDatabase struct {
16373}
16374
16375func (*awsAwsjson11_deserializeOpStartRelationalDatabase) ID() string {
16376	return "OperationDeserializer"
16377}
16378
16379func (m *awsAwsjson11_deserializeOpStartRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16380	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16381) {
16382	out, metadata, err = next.HandleDeserialize(ctx, in)
16383	if err != nil {
16384		return out, metadata, err
16385	}
16386
16387	response, ok := out.RawResponse.(*smithyhttp.Response)
16388	if !ok {
16389		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16390	}
16391
16392	if response.StatusCode < 200 || response.StatusCode >= 300 {
16393		return out, metadata, awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response, &metadata)
16394	}
16395	output := &StartRelationalDatabaseOutput{}
16396	out.Result = output
16397
16398	var buff [1024]byte
16399	ringBuffer := smithyio.NewRingBuffer(buff[:])
16400
16401	body := io.TeeReader(response.Body, ringBuffer)
16402	decoder := json.NewDecoder(body)
16403	decoder.UseNumber()
16404	var shape interface{}
16405	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16406		var snapshot bytes.Buffer
16407		io.Copy(&snapshot, ringBuffer)
16408		err = &smithy.DeserializationError{
16409			Err:      fmt.Errorf("failed to decode response body, %w", err),
16410			Snapshot: snapshot.Bytes(),
16411		}
16412		return out, metadata, err
16413	}
16414
16415	err = awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(&output, shape)
16416	if err != nil {
16417		var snapshot bytes.Buffer
16418		io.Copy(&snapshot, ringBuffer)
16419		err = &smithy.DeserializationError{
16420			Err:      fmt.Errorf("failed to decode response body, %w", err),
16421			Snapshot: snapshot.Bytes(),
16422		}
16423		return out, metadata, err
16424	}
16425
16426	return out, metadata, err
16427}
16428
16429func awsAwsjson11_deserializeOpErrorStartRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16430	var errorBuffer bytes.Buffer
16431	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16432		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16433	}
16434	errorBody := bytes.NewReader(errorBuffer.Bytes())
16435
16436	errorCode := "UnknownError"
16437	errorMessage := errorCode
16438
16439	code := response.Header.Get("X-Amzn-ErrorType")
16440	if len(code) != 0 {
16441		errorCode = restjson.SanitizeErrorCode(code)
16442	}
16443
16444	var buff [1024]byte
16445	ringBuffer := smithyio.NewRingBuffer(buff[:])
16446
16447	body := io.TeeReader(errorBody, ringBuffer)
16448	decoder := json.NewDecoder(body)
16449	decoder.UseNumber()
16450	code, message, err := restjson.GetErrorInfo(decoder)
16451	if err != nil {
16452		var snapshot bytes.Buffer
16453		io.Copy(&snapshot, ringBuffer)
16454		err = &smithy.DeserializationError{
16455			Err:      fmt.Errorf("failed to decode response body, %w", err),
16456			Snapshot: snapshot.Bytes(),
16457		}
16458		return err
16459	}
16460
16461	errorBody.Seek(0, io.SeekStart)
16462	if len(code) != 0 {
16463		errorCode = restjson.SanitizeErrorCode(code)
16464	}
16465	if len(message) != 0 {
16466		errorMessage = message
16467	}
16468
16469	switch {
16470	case strings.EqualFold("AccessDeniedException", errorCode):
16471		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16472
16473	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16474		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16475
16476	case strings.EqualFold("InvalidInputException", errorCode):
16477		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16478
16479	case strings.EqualFold("NotFoundException", errorCode):
16480		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16481
16482	case strings.EqualFold("OperationFailureException", errorCode):
16483		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16484
16485	case strings.EqualFold("ServiceException", errorCode):
16486		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16487
16488	case strings.EqualFold("UnauthenticatedException", errorCode):
16489		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16490
16491	default:
16492		genericError := &smithy.GenericAPIError{
16493			Code:    errorCode,
16494			Message: errorMessage,
16495		}
16496		return genericError
16497
16498	}
16499}
16500
16501type awsAwsjson11_deserializeOpStopInstance struct {
16502}
16503
16504func (*awsAwsjson11_deserializeOpStopInstance) ID() string {
16505	return "OperationDeserializer"
16506}
16507
16508func (m *awsAwsjson11_deserializeOpStopInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16509	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16510) {
16511	out, metadata, err = next.HandleDeserialize(ctx, in)
16512	if err != nil {
16513		return out, metadata, err
16514	}
16515
16516	response, ok := out.RawResponse.(*smithyhttp.Response)
16517	if !ok {
16518		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16519	}
16520
16521	if response.StatusCode < 200 || response.StatusCode >= 300 {
16522		return out, metadata, awsAwsjson11_deserializeOpErrorStopInstance(response, &metadata)
16523	}
16524	output := &StopInstanceOutput{}
16525	out.Result = output
16526
16527	var buff [1024]byte
16528	ringBuffer := smithyio.NewRingBuffer(buff[:])
16529
16530	body := io.TeeReader(response.Body, ringBuffer)
16531	decoder := json.NewDecoder(body)
16532	decoder.UseNumber()
16533	var shape interface{}
16534	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16535		var snapshot bytes.Buffer
16536		io.Copy(&snapshot, ringBuffer)
16537		err = &smithy.DeserializationError{
16538			Err:      fmt.Errorf("failed to decode response body, %w", err),
16539			Snapshot: snapshot.Bytes(),
16540		}
16541		return out, metadata, err
16542	}
16543
16544	err = awsAwsjson11_deserializeOpDocumentStopInstanceOutput(&output, shape)
16545	if err != nil {
16546		var snapshot bytes.Buffer
16547		io.Copy(&snapshot, ringBuffer)
16548		err = &smithy.DeserializationError{
16549			Err:      fmt.Errorf("failed to decode response body, %w", err),
16550			Snapshot: snapshot.Bytes(),
16551		}
16552		return out, metadata, err
16553	}
16554
16555	return out, metadata, err
16556}
16557
16558func awsAwsjson11_deserializeOpErrorStopInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16559	var errorBuffer bytes.Buffer
16560	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16561		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16562	}
16563	errorBody := bytes.NewReader(errorBuffer.Bytes())
16564
16565	errorCode := "UnknownError"
16566	errorMessage := errorCode
16567
16568	code := response.Header.Get("X-Amzn-ErrorType")
16569	if len(code) != 0 {
16570		errorCode = restjson.SanitizeErrorCode(code)
16571	}
16572
16573	var buff [1024]byte
16574	ringBuffer := smithyio.NewRingBuffer(buff[:])
16575
16576	body := io.TeeReader(errorBody, ringBuffer)
16577	decoder := json.NewDecoder(body)
16578	decoder.UseNumber()
16579	code, message, err := restjson.GetErrorInfo(decoder)
16580	if err != nil {
16581		var snapshot bytes.Buffer
16582		io.Copy(&snapshot, ringBuffer)
16583		err = &smithy.DeserializationError{
16584			Err:      fmt.Errorf("failed to decode response body, %w", err),
16585			Snapshot: snapshot.Bytes(),
16586		}
16587		return err
16588	}
16589
16590	errorBody.Seek(0, io.SeekStart)
16591	if len(code) != 0 {
16592		errorCode = restjson.SanitizeErrorCode(code)
16593	}
16594	if len(message) != 0 {
16595		errorMessage = message
16596	}
16597
16598	switch {
16599	case strings.EqualFold("AccessDeniedException", errorCode):
16600		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16601
16602	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16603		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16604
16605	case strings.EqualFold("InvalidInputException", errorCode):
16606		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16607
16608	case strings.EqualFold("NotFoundException", errorCode):
16609		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16610
16611	case strings.EqualFold("OperationFailureException", errorCode):
16612		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16613
16614	case strings.EqualFold("ServiceException", errorCode):
16615		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16616
16617	case strings.EqualFold("UnauthenticatedException", errorCode):
16618		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16619
16620	default:
16621		genericError := &smithy.GenericAPIError{
16622			Code:    errorCode,
16623			Message: errorMessage,
16624		}
16625		return genericError
16626
16627	}
16628}
16629
16630type awsAwsjson11_deserializeOpStopRelationalDatabase struct {
16631}
16632
16633func (*awsAwsjson11_deserializeOpStopRelationalDatabase) ID() string {
16634	return "OperationDeserializer"
16635}
16636
16637func (m *awsAwsjson11_deserializeOpStopRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16638	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16639) {
16640	out, metadata, err = next.HandleDeserialize(ctx, in)
16641	if err != nil {
16642		return out, metadata, err
16643	}
16644
16645	response, ok := out.RawResponse.(*smithyhttp.Response)
16646	if !ok {
16647		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16648	}
16649
16650	if response.StatusCode < 200 || response.StatusCode >= 300 {
16651		return out, metadata, awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response, &metadata)
16652	}
16653	output := &StopRelationalDatabaseOutput{}
16654	out.Result = output
16655
16656	var buff [1024]byte
16657	ringBuffer := smithyio.NewRingBuffer(buff[:])
16658
16659	body := io.TeeReader(response.Body, ringBuffer)
16660	decoder := json.NewDecoder(body)
16661	decoder.UseNumber()
16662	var shape interface{}
16663	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16664		var snapshot bytes.Buffer
16665		io.Copy(&snapshot, ringBuffer)
16666		err = &smithy.DeserializationError{
16667			Err:      fmt.Errorf("failed to decode response body, %w", err),
16668			Snapshot: snapshot.Bytes(),
16669		}
16670		return out, metadata, err
16671	}
16672
16673	err = awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(&output, shape)
16674	if err != nil {
16675		var snapshot bytes.Buffer
16676		io.Copy(&snapshot, ringBuffer)
16677		err = &smithy.DeserializationError{
16678			Err:      fmt.Errorf("failed to decode response body, %w", err),
16679			Snapshot: snapshot.Bytes(),
16680		}
16681		return out, metadata, err
16682	}
16683
16684	return out, metadata, err
16685}
16686
16687func awsAwsjson11_deserializeOpErrorStopRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16688	var errorBuffer bytes.Buffer
16689	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16690		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16691	}
16692	errorBody := bytes.NewReader(errorBuffer.Bytes())
16693
16694	errorCode := "UnknownError"
16695	errorMessage := errorCode
16696
16697	code := response.Header.Get("X-Amzn-ErrorType")
16698	if len(code) != 0 {
16699		errorCode = restjson.SanitizeErrorCode(code)
16700	}
16701
16702	var buff [1024]byte
16703	ringBuffer := smithyio.NewRingBuffer(buff[:])
16704
16705	body := io.TeeReader(errorBody, ringBuffer)
16706	decoder := json.NewDecoder(body)
16707	decoder.UseNumber()
16708	code, message, err := restjson.GetErrorInfo(decoder)
16709	if err != nil {
16710		var snapshot bytes.Buffer
16711		io.Copy(&snapshot, ringBuffer)
16712		err = &smithy.DeserializationError{
16713			Err:      fmt.Errorf("failed to decode response body, %w", err),
16714			Snapshot: snapshot.Bytes(),
16715		}
16716		return err
16717	}
16718
16719	errorBody.Seek(0, io.SeekStart)
16720	if len(code) != 0 {
16721		errorCode = restjson.SanitizeErrorCode(code)
16722	}
16723	if len(message) != 0 {
16724		errorMessage = message
16725	}
16726
16727	switch {
16728	case strings.EqualFold("AccessDeniedException", errorCode):
16729		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16730
16731	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16732		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16733
16734	case strings.EqualFold("InvalidInputException", errorCode):
16735		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16736
16737	case strings.EqualFold("NotFoundException", errorCode):
16738		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16739
16740	case strings.EqualFold("OperationFailureException", errorCode):
16741		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16742
16743	case strings.EqualFold("ServiceException", errorCode):
16744		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16745
16746	case strings.EqualFold("UnauthenticatedException", errorCode):
16747		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16748
16749	default:
16750		genericError := &smithy.GenericAPIError{
16751			Code:    errorCode,
16752			Message: errorMessage,
16753		}
16754		return genericError
16755
16756	}
16757}
16758
16759type awsAwsjson11_deserializeOpTagResource struct {
16760}
16761
16762func (*awsAwsjson11_deserializeOpTagResource) ID() string {
16763	return "OperationDeserializer"
16764}
16765
16766func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16767	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16768) {
16769	out, metadata, err = next.HandleDeserialize(ctx, in)
16770	if err != nil {
16771		return out, metadata, err
16772	}
16773
16774	response, ok := out.RawResponse.(*smithyhttp.Response)
16775	if !ok {
16776		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16777	}
16778
16779	if response.StatusCode < 200 || response.StatusCode >= 300 {
16780		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
16781	}
16782	output := &TagResourceOutput{}
16783	out.Result = output
16784
16785	var buff [1024]byte
16786	ringBuffer := smithyio.NewRingBuffer(buff[:])
16787
16788	body := io.TeeReader(response.Body, ringBuffer)
16789	decoder := json.NewDecoder(body)
16790	decoder.UseNumber()
16791	var shape interface{}
16792	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16793		var snapshot bytes.Buffer
16794		io.Copy(&snapshot, ringBuffer)
16795		err = &smithy.DeserializationError{
16796			Err:      fmt.Errorf("failed to decode response body, %w", err),
16797			Snapshot: snapshot.Bytes(),
16798		}
16799		return out, metadata, err
16800	}
16801
16802	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
16803	if err != nil {
16804		var snapshot bytes.Buffer
16805		io.Copy(&snapshot, ringBuffer)
16806		err = &smithy.DeserializationError{
16807			Err:      fmt.Errorf("failed to decode response body, %w", err),
16808			Snapshot: snapshot.Bytes(),
16809		}
16810		return out, metadata, err
16811	}
16812
16813	return out, metadata, err
16814}
16815
16816func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16817	var errorBuffer bytes.Buffer
16818	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16819		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16820	}
16821	errorBody := bytes.NewReader(errorBuffer.Bytes())
16822
16823	errorCode := "UnknownError"
16824	errorMessage := errorCode
16825
16826	code := response.Header.Get("X-Amzn-ErrorType")
16827	if len(code) != 0 {
16828		errorCode = restjson.SanitizeErrorCode(code)
16829	}
16830
16831	var buff [1024]byte
16832	ringBuffer := smithyio.NewRingBuffer(buff[:])
16833
16834	body := io.TeeReader(errorBody, ringBuffer)
16835	decoder := json.NewDecoder(body)
16836	decoder.UseNumber()
16837	code, message, err := restjson.GetErrorInfo(decoder)
16838	if err != nil {
16839		var snapshot bytes.Buffer
16840		io.Copy(&snapshot, ringBuffer)
16841		err = &smithy.DeserializationError{
16842			Err:      fmt.Errorf("failed to decode response body, %w", err),
16843			Snapshot: snapshot.Bytes(),
16844		}
16845		return err
16846	}
16847
16848	errorBody.Seek(0, io.SeekStart)
16849	if len(code) != 0 {
16850		errorCode = restjson.SanitizeErrorCode(code)
16851	}
16852	if len(message) != 0 {
16853		errorMessage = message
16854	}
16855
16856	switch {
16857	case strings.EqualFold("AccessDeniedException", errorCode):
16858		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16859
16860	case strings.EqualFold("AccountSetupInProgressException", errorCode):
16861		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
16862
16863	case strings.EqualFold("InvalidInputException", errorCode):
16864		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16865
16866	case strings.EqualFold("NotFoundException", errorCode):
16867		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16868
16869	case strings.EqualFold("OperationFailureException", errorCode):
16870		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16871
16872	case strings.EqualFold("ServiceException", errorCode):
16873		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
16874
16875	case strings.EqualFold("UnauthenticatedException", errorCode):
16876		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
16877
16878	default:
16879		genericError := &smithy.GenericAPIError{
16880			Code:    errorCode,
16881			Message: errorMessage,
16882		}
16883		return genericError
16884
16885	}
16886}
16887
16888type awsAwsjson11_deserializeOpTestAlarm struct {
16889}
16890
16891func (*awsAwsjson11_deserializeOpTestAlarm) ID() string {
16892	return "OperationDeserializer"
16893}
16894
16895func (m *awsAwsjson11_deserializeOpTestAlarm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
16896	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
16897) {
16898	out, metadata, err = next.HandleDeserialize(ctx, in)
16899	if err != nil {
16900		return out, metadata, err
16901	}
16902
16903	response, ok := out.RawResponse.(*smithyhttp.Response)
16904	if !ok {
16905		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
16906	}
16907
16908	if response.StatusCode < 200 || response.StatusCode >= 300 {
16909		return out, metadata, awsAwsjson11_deserializeOpErrorTestAlarm(response, &metadata)
16910	}
16911	output := &TestAlarmOutput{}
16912	out.Result = output
16913
16914	var buff [1024]byte
16915	ringBuffer := smithyio.NewRingBuffer(buff[:])
16916
16917	body := io.TeeReader(response.Body, ringBuffer)
16918	decoder := json.NewDecoder(body)
16919	decoder.UseNumber()
16920	var shape interface{}
16921	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
16922		var snapshot bytes.Buffer
16923		io.Copy(&snapshot, ringBuffer)
16924		err = &smithy.DeserializationError{
16925			Err:      fmt.Errorf("failed to decode response body, %w", err),
16926			Snapshot: snapshot.Bytes(),
16927		}
16928		return out, metadata, err
16929	}
16930
16931	err = awsAwsjson11_deserializeOpDocumentTestAlarmOutput(&output, shape)
16932	if err != nil {
16933		var snapshot bytes.Buffer
16934		io.Copy(&snapshot, ringBuffer)
16935		err = &smithy.DeserializationError{
16936			Err:      fmt.Errorf("failed to decode response body, %w", err),
16937			Snapshot: snapshot.Bytes(),
16938		}
16939		return out, metadata, err
16940	}
16941
16942	return out, metadata, err
16943}
16944
16945func awsAwsjson11_deserializeOpErrorTestAlarm(response *smithyhttp.Response, metadata *middleware.Metadata) error {
16946	var errorBuffer bytes.Buffer
16947	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
16948		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
16949	}
16950	errorBody := bytes.NewReader(errorBuffer.Bytes())
16951
16952	errorCode := "UnknownError"
16953	errorMessage := errorCode
16954
16955	code := response.Header.Get("X-Amzn-ErrorType")
16956	if len(code) != 0 {
16957		errorCode = restjson.SanitizeErrorCode(code)
16958	}
16959
16960	var buff [1024]byte
16961	ringBuffer := smithyio.NewRingBuffer(buff[:])
16962
16963	body := io.TeeReader(errorBody, ringBuffer)
16964	decoder := json.NewDecoder(body)
16965	decoder.UseNumber()
16966	code, message, err := restjson.GetErrorInfo(decoder)
16967	if err != nil {
16968		var snapshot bytes.Buffer
16969		io.Copy(&snapshot, ringBuffer)
16970		err = &smithy.DeserializationError{
16971			Err:      fmt.Errorf("failed to decode response body, %w", err),
16972			Snapshot: snapshot.Bytes(),
16973		}
16974		return err
16975	}
16976
16977	errorBody.Seek(0, io.SeekStart)
16978	if len(code) != 0 {
16979		errorCode = restjson.SanitizeErrorCode(code)
16980	}
16981	if len(message) != 0 {
16982		errorMessage = message
16983	}
16984
16985	switch {
16986	case strings.EqualFold("AccessDeniedException", errorCode):
16987		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
16988
16989	case strings.EqualFold("InvalidInputException", errorCode):
16990		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
16991
16992	case strings.EqualFold("NotFoundException", errorCode):
16993		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
16994
16995	case strings.EqualFold("OperationFailureException", errorCode):
16996		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
16997
16998	case strings.EqualFold("ServiceException", errorCode):
16999		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17000
17001	case strings.EqualFold("UnauthenticatedException", errorCode):
17002		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17003
17004	default:
17005		genericError := &smithy.GenericAPIError{
17006			Code:    errorCode,
17007			Message: errorMessage,
17008		}
17009		return genericError
17010
17011	}
17012}
17013
17014type awsAwsjson11_deserializeOpUnpeerVpc struct {
17015}
17016
17017func (*awsAwsjson11_deserializeOpUnpeerVpc) ID() string {
17018	return "OperationDeserializer"
17019}
17020
17021func (m *awsAwsjson11_deserializeOpUnpeerVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17022	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17023) {
17024	out, metadata, err = next.HandleDeserialize(ctx, in)
17025	if err != nil {
17026		return out, metadata, err
17027	}
17028
17029	response, ok := out.RawResponse.(*smithyhttp.Response)
17030	if !ok {
17031		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17032	}
17033
17034	if response.StatusCode < 200 || response.StatusCode >= 300 {
17035		return out, metadata, awsAwsjson11_deserializeOpErrorUnpeerVpc(response, &metadata)
17036	}
17037	output := &UnpeerVpcOutput{}
17038	out.Result = output
17039
17040	var buff [1024]byte
17041	ringBuffer := smithyio.NewRingBuffer(buff[:])
17042
17043	body := io.TeeReader(response.Body, ringBuffer)
17044	decoder := json.NewDecoder(body)
17045	decoder.UseNumber()
17046	var shape interface{}
17047	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17048		var snapshot bytes.Buffer
17049		io.Copy(&snapshot, ringBuffer)
17050		err = &smithy.DeserializationError{
17051			Err:      fmt.Errorf("failed to decode response body, %w", err),
17052			Snapshot: snapshot.Bytes(),
17053		}
17054		return out, metadata, err
17055	}
17056
17057	err = awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(&output, shape)
17058	if err != nil {
17059		var snapshot bytes.Buffer
17060		io.Copy(&snapshot, ringBuffer)
17061		err = &smithy.DeserializationError{
17062			Err:      fmt.Errorf("failed to decode response body, %w", err),
17063			Snapshot: snapshot.Bytes(),
17064		}
17065		return out, metadata, err
17066	}
17067
17068	return out, metadata, err
17069}
17070
17071func awsAwsjson11_deserializeOpErrorUnpeerVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17072	var errorBuffer bytes.Buffer
17073	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17074		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17075	}
17076	errorBody := bytes.NewReader(errorBuffer.Bytes())
17077
17078	errorCode := "UnknownError"
17079	errorMessage := errorCode
17080
17081	code := response.Header.Get("X-Amzn-ErrorType")
17082	if len(code) != 0 {
17083		errorCode = restjson.SanitizeErrorCode(code)
17084	}
17085
17086	var buff [1024]byte
17087	ringBuffer := smithyio.NewRingBuffer(buff[:])
17088
17089	body := io.TeeReader(errorBody, ringBuffer)
17090	decoder := json.NewDecoder(body)
17091	decoder.UseNumber()
17092	code, message, err := restjson.GetErrorInfo(decoder)
17093	if err != nil {
17094		var snapshot bytes.Buffer
17095		io.Copy(&snapshot, ringBuffer)
17096		err = &smithy.DeserializationError{
17097			Err:      fmt.Errorf("failed to decode response body, %w", err),
17098			Snapshot: snapshot.Bytes(),
17099		}
17100		return err
17101	}
17102
17103	errorBody.Seek(0, io.SeekStart)
17104	if len(code) != 0 {
17105		errorCode = restjson.SanitizeErrorCode(code)
17106	}
17107	if len(message) != 0 {
17108		errorMessage = message
17109	}
17110
17111	switch {
17112	case strings.EqualFold("AccessDeniedException", errorCode):
17113		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17114
17115	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17116		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17117
17118	case strings.EqualFold("InvalidInputException", errorCode):
17119		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17120
17121	case strings.EqualFold("NotFoundException", errorCode):
17122		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17123
17124	case strings.EqualFold("OperationFailureException", errorCode):
17125		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17126
17127	case strings.EqualFold("ServiceException", errorCode):
17128		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17129
17130	case strings.EqualFold("UnauthenticatedException", errorCode):
17131		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17132
17133	default:
17134		genericError := &smithy.GenericAPIError{
17135			Code:    errorCode,
17136			Message: errorMessage,
17137		}
17138		return genericError
17139
17140	}
17141}
17142
17143type awsAwsjson11_deserializeOpUntagResource struct {
17144}
17145
17146func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
17147	return "OperationDeserializer"
17148}
17149
17150func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17151	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17152) {
17153	out, metadata, err = next.HandleDeserialize(ctx, in)
17154	if err != nil {
17155		return out, metadata, err
17156	}
17157
17158	response, ok := out.RawResponse.(*smithyhttp.Response)
17159	if !ok {
17160		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17161	}
17162
17163	if response.StatusCode < 200 || response.StatusCode >= 300 {
17164		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
17165	}
17166	output := &UntagResourceOutput{}
17167	out.Result = output
17168
17169	var buff [1024]byte
17170	ringBuffer := smithyio.NewRingBuffer(buff[:])
17171
17172	body := io.TeeReader(response.Body, ringBuffer)
17173	decoder := json.NewDecoder(body)
17174	decoder.UseNumber()
17175	var shape interface{}
17176	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17177		var snapshot bytes.Buffer
17178		io.Copy(&snapshot, ringBuffer)
17179		err = &smithy.DeserializationError{
17180			Err:      fmt.Errorf("failed to decode response body, %w", err),
17181			Snapshot: snapshot.Bytes(),
17182		}
17183		return out, metadata, err
17184	}
17185
17186	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
17187	if err != nil {
17188		var snapshot bytes.Buffer
17189		io.Copy(&snapshot, ringBuffer)
17190		err = &smithy.DeserializationError{
17191			Err:      fmt.Errorf("failed to decode response body, %w", err),
17192			Snapshot: snapshot.Bytes(),
17193		}
17194		return out, metadata, err
17195	}
17196
17197	return out, metadata, err
17198}
17199
17200func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17201	var errorBuffer bytes.Buffer
17202	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17203		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17204	}
17205	errorBody := bytes.NewReader(errorBuffer.Bytes())
17206
17207	errorCode := "UnknownError"
17208	errorMessage := errorCode
17209
17210	code := response.Header.Get("X-Amzn-ErrorType")
17211	if len(code) != 0 {
17212		errorCode = restjson.SanitizeErrorCode(code)
17213	}
17214
17215	var buff [1024]byte
17216	ringBuffer := smithyio.NewRingBuffer(buff[:])
17217
17218	body := io.TeeReader(errorBody, ringBuffer)
17219	decoder := json.NewDecoder(body)
17220	decoder.UseNumber()
17221	code, message, err := restjson.GetErrorInfo(decoder)
17222	if err != nil {
17223		var snapshot bytes.Buffer
17224		io.Copy(&snapshot, ringBuffer)
17225		err = &smithy.DeserializationError{
17226			Err:      fmt.Errorf("failed to decode response body, %w", err),
17227			Snapshot: snapshot.Bytes(),
17228		}
17229		return err
17230	}
17231
17232	errorBody.Seek(0, io.SeekStart)
17233	if len(code) != 0 {
17234		errorCode = restjson.SanitizeErrorCode(code)
17235	}
17236	if len(message) != 0 {
17237		errorMessage = message
17238	}
17239
17240	switch {
17241	case strings.EqualFold("AccessDeniedException", errorCode):
17242		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17243
17244	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17245		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17246
17247	case strings.EqualFold("InvalidInputException", errorCode):
17248		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17249
17250	case strings.EqualFold("NotFoundException", errorCode):
17251		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17252
17253	case strings.EqualFold("OperationFailureException", errorCode):
17254		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17255
17256	case strings.EqualFold("ServiceException", errorCode):
17257		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17258
17259	case strings.EqualFold("UnauthenticatedException", errorCode):
17260		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17261
17262	default:
17263		genericError := &smithy.GenericAPIError{
17264			Code:    errorCode,
17265			Message: errorMessage,
17266		}
17267		return genericError
17268
17269	}
17270}
17271
17272type awsAwsjson11_deserializeOpUpdateContainerService struct {
17273}
17274
17275func (*awsAwsjson11_deserializeOpUpdateContainerService) ID() string {
17276	return "OperationDeserializer"
17277}
17278
17279func (m *awsAwsjson11_deserializeOpUpdateContainerService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17280	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17281) {
17282	out, metadata, err = next.HandleDeserialize(ctx, in)
17283	if err != nil {
17284		return out, metadata, err
17285	}
17286
17287	response, ok := out.RawResponse.(*smithyhttp.Response)
17288	if !ok {
17289		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17290	}
17291
17292	if response.StatusCode < 200 || response.StatusCode >= 300 {
17293		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerService(response, &metadata)
17294	}
17295	output := &UpdateContainerServiceOutput{}
17296	out.Result = output
17297
17298	var buff [1024]byte
17299	ringBuffer := smithyio.NewRingBuffer(buff[:])
17300
17301	body := io.TeeReader(response.Body, ringBuffer)
17302	decoder := json.NewDecoder(body)
17303	decoder.UseNumber()
17304	var shape interface{}
17305	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17306		var snapshot bytes.Buffer
17307		io.Copy(&snapshot, ringBuffer)
17308		err = &smithy.DeserializationError{
17309			Err:      fmt.Errorf("failed to decode response body, %w", err),
17310			Snapshot: snapshot.Bytes(),
17311		}
17312		return out, metadata, err
17313	}
17314
17315	err = awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(&output, shape)
17316	if err != nil {
17317		var snapshot bytes.Buffer
17318		io.Copy(&snapshot, ringBuffer)
17319		err = &smithy.DeserializationError{
17320			Err:      fmt.Errorf("failed to decode response body, %w", err),
17321			Snapshot: snapshot.Bytes(),
17322		}
17323		return out, metadata, err
17324	}
17325
17326	return out, metadata, err
17327}
17328
17329func awsAwsjson11_deserializeOpErrorUpdateContainerService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17330	var errorBuffer bytes.Buffer
17331	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17332		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17333	}
17334	errorBody := bytes.NewReader(errorBuffer.Bytes())
17335
17336	errorCode := "UnknownError"
17337	errorMessage := errorCode
17338
17339	code := response.Header.Get("X-Amzn-ErrorType")
17340	if len(code) != 0 {
17341		errorCode = restjson.SanitizeErrorCode(code)
17342	}
17343
17344	var buff [1024]byte
17345	ringBuffer := smithyio.NewRingBuffer(buff[:])
17346
17347	body := io.TeeReader(errorBody, ringBuffer)
17348	decoder := json.NewDecoder(body)
17349	decoder.UseNumber()
17350	code, message, err := restjson.GetErrorInfo(decoder)
17351	if err != nil {
17352		var snapshot bytes.Buffer
17353		io.Copy(&snapshot, ringBuffer)
17354		err = &smithy.DeserializationError{
17355			Err:      fmt.Errorf("failed to decode response body, %w", err),
17356			Snapshot: snapshot.Bytes(),
17357		}
17358		return err
17359	}
17360
17361	errorBody.Seek(0, io.SeekStart)
17362	if len(code) != 0 {
17363		errorCode = restjson.SanitizeErrorCode(code)
17364	}
17365	if len(message) != 0 {
17366		errorMessage = message
17367	}
17368
17369	switch {
17370	case strings.EqualFold("AccessDeniedException", errorCode):
17371		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17372
17373	case strings.EqualFold("InvalidInputException", errorCode):
17374		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17375
17376	case strings.EqualFold("NotFoundException", errorCode):
17377		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17378
17379	case strings.EqualFold("ServiceException", errorCode):
17380		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17381
17382	case strings.EqualFold("UnauthenticatedException", errorCode):
17383		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17384
17385	default:
17386		genericError := &smithy.GenericAPIError{
17387			Code:    errorCode,
17388			Message: errorMessage,
17389		}
17390		return genericError
17391
17392	}
17393}
17394
17395type awsAwsjson11_deserializeOpUpdateDistribution struct {
17396}
17397
17398func (*awsAwsjson11_deserializeOpUpdateDistribution) ID() string {
17399	return "OperationDeserializer"
17400}
17401
17402func (m *awsAwsjson11_deserializeOpUpdateDistribution) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17403	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17404) {
17405	out, metadata, err = next.HandleDeserialize(ctx, in)
17406	if err != nil {
17407		return out, metadata, err
17408	}
17409
17410	response, ok := out.RawResponse.(*smithyhttp.Response)
17411	if !ok {
17412		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17413	}
17414
17415	if response.StatusCode < 200 || response.StatusCode >= 300 {
17416		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistribution(response, &metadata)
17417	}
17418	output := &UpdateDistributionOutput{}
17419	out.Result = output
17420
17421	var buff [1024]byte
17422	ringBuffer := smithyio.NewRingBuffer(buff[:])
17423
17424	body := io.TeeReader(response.Body, ringBuffer)
17425	decoder := json.NewDecoder(body)
17426	decoder.UseNumber()
17427	var shape interface{}
17428	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17429		var snapshot bytes.Buffer
17430		io.Copy(&snapshot, ringBuffer)
17431		err = &smithy.DeserializationError{
17432			Err:      fmt.Errorf("failed to decode response body, %w", err),
17433			Snapshot: snapshot.Bytes(),
17434		}
17435		return out, metadata, err
17436	}
17437
17438	err = awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(&output, shape)
17439	if err != nil {
17440		var snapshot bytes.Buffer
17441		io.Copy(&snapshot, ringBuffer)
17442		err = &smithy.DeserializationError{
17443			Err:      fmt.Errorf("failed to decode response body, %w", err),
17444			Snapshot: snapshot.Bytes(),
17445		}
17446		return out, metadata, err
17447	}
17448
17449	return out, metadata, err
17450}
17451
17452func awsAwsjson11_deserializeOpErrorUpdateDistribution(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17453	var errorBuffer bytes.Buffer
17454	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17455		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17456	}
17457	errorBody := bytes.NewReader(errorBuffer.Bytes())
17458
17459	errorCode := "UnknownError"
17460	errorMessage := errorCode
17461
17462	code := response.Header.Get("X-Amzn-ErrorType")
17463	if len(code) != 0 {
17464		errorCode = restjson.SanitizeErrorCode(code)
17465	}
17466
17467	var buff [1024]byte
17468	ringBuffer := smithyio.NewRingBuffer(buff[:])
17469
17470	body := io.TeeReader(errorBody, ringBuffer)
17471	decoder := json.NewDecoder(body)
17472	decoder.UseNumber()
17473	code, message, err := restjson.GetErrorInfo(decoder)
17474	if err != nil {
17475		var snapshot bytes.Buffer
17476		io.Copy(&snapshot, ringBuffer)
17477		err = &smithy.DeserializationError{
17478			Err:      fmt.Errorf("failed to decode response body, %w", err),
17479			Snapshot: snapshot.Bytes(),
17480		}
17481		return err
17482	}
17483
17484	errorBody.Seek(0, io.SeekStart)
17485	if len(code) != 0 {
17486		errorCode = restjson.SanitizeErrorCode(code)
17487	}
17488	if len(message) != 0 {
17489		errorMessage = message
17490	}
17491
17492	switch {
17493	case strings.EqualFold("AccessDeniedException", errorCode):
17494		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17495
17496	case strings.EqualFold("InvalidInputException", errorCode):
17497		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17498
17499	case strings.EqualFold("NotFoundException", errorCode):
17500		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17501
17502	case strings.EqualFold("OperationFailureException", errorCode):
17503		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17504
17505	case strings.EqualFold("ServiceException", errorCode):
17506		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17507
17508	case strings.EqualFold("UnauthenticatedException", errorCode):
17509		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17510
17511	default:
17512		genericError := &smithy.GenericAPIError{
17513			Code:    errorCode,
17514			Message: errorMessage,
17515		}
17516		return genericError
17517
17518	}
17519}
17520
17521type awsAwsjson11_deserializeOpUpdateDistributionBundle struct {
17522}
17523
17524func (*awsAwsjson11_deserializeOpUpdateDistributionBundle) ID() string {
17525	return "OperationDeserializer"
17526}
17527
17528func (m *awsAwsjson11_deserializeOpUpdateDistributionBundle) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17529	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17530) {
17531	out, metadata, err = next.HandleDeserialize(ctx, in)
17532	if err != nil {
17533		return out, metadata, err
17534	}
17535
17536	response, ok := out.RawResponse.(*smithyhttp.Response)
17537	if !ok {
17538		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17539	}
17540
17541	if response.StatusCode < 200 || response.StatusCode >= 300 {
17542		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response, &metadata)
17543	}
17544	output := &UpdateDistributionBundleOutput{}
17545	out.Result = output
17546
17547	var buff [1024]byte
17548	ringBuffer := smithyio.NewRingBuffer(buff[:])
17549
17550	body := io.TeeReader(response.Body, ringBuffer)
17551	decoder := json.NewDecoder(body)
17552	decoder.UseNumber()
17553	var shape interface{}
17554	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17555		var snapshot bytes.Buffer
17556		io.Copy(&snapshot, ringBuffer)
17557		err = &smithy.DeserializationError{
17558			Err:      fmt.Errorf("failed to decode response body, %w", err),
17559			Snapshot: snapshot.Bytes(),
17560		}
17561		return out, metadata, err
17562	}
17563
17564	err = awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(&output, shape)
17565	if err != nil {
17566		var snapshot bytes.Buffer
17567		io.Copy(&snapshot, ringBuffer)
17568		err = &smithy.DeserializationError{
17569			Err:      fmt.Errorf("failed to decode response body, %w", err),
17570			Snapshot: snapshot.Bytes(),
17571		}
17572		return out, metadata, err
17573	}
17574
17575	return out, metadata, err
17576}
17577
17578func awsAwsjson11_deserializeOpErrorUpdateDistributionBundle(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17579	var errorBuffer bytes.Buffer
17580	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17581		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17582	}
17583	errorBody := bytes.NewReader(errorBuffer.Bytes())
17584
17585	errorCode := "UnknownError"
17586	errorMessage := errorCode
17587
17588	code := response.Header.Get("X-Amzn-ErrorType")
17589	if len(code) != 0 {
17590		errorCode = restjson.SanitizeErrorCode(code)
17591	}
17592
17593	var buff [1024]byte
17594	ringBuffer := smithyio.NewRingBuffer(buff[:])
17595
17596	body := io.TeeReader(errorBody, ringBuffer)
17597	decoder := json.NewDecoder(body)
17598	decoder.UseNumber()
17599	code, message, err := restjson.GetErrorInfo(decoder)
17600	if err != nil {
17601		var snapshot bytes.Buffer
17602		io.Copy(&snapshot, ringBuffer)
17603		err = &smithy.DeserializationError{
17604			Err:      fmt.Errorf("failed to decode response body, %w", err),
17605			Snapshot: snapshot.Bytes(),
17606		}
17607		return err
17608	}
17609
17610	errorBody.Seek(0, io.SeekStart)
17611	if len(code) != 0 {
17612		errorCode = restjson.SanitizeErrorCode(code)
17613	}
17614	if len(message) != 0 {
17615		errorMessage = message
17616	}
17617
17618	switch {
17619	case strings.EqualFold("AccessDeniedException", errorCode):
17620		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17621
17622	case strings.EqualFold("InvalidInputException", errorCode):
17623		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17624
17625	case strings.EqualFold("NotFoundException", errorCode):
17626		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17627
17628	case strings.EqualFold("OperationFailureException", errorCode):
17629		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17630
17631	case strings.EqualFold("ServiceException", errorCode):
17632		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17633
17634	case strings.EqualFold("UnauthenticatedException", errorCode):
17635		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17636
17637	default:
17638		genericError := &smithy.GenericAPIError{
17639			Code:    errorCode,
17640			Message: errorMessage,
17641		}
17642		return genericError
17643
17644	}
17645}
17646
17647type awsAwsjson11_deserializeOpUpdateDomainEntry struct {
17648}
17649
17650func (*awsAwsjson11_deserializeOpUpdateDomainEntry) ID() string {
17651	return "OperationDeserializer"
17652}
17653
17654func (m *awsAwsjson11_deserializeOpUpdateDomainEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17655	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17656) {
17657	out, metadata, err = next.HandleDeserialize(ctx, in)
17658	if err != nil {
17659		return out, metadata, err
17660	}
17661
17662	response, ok := out.RawResponse.(*smithyhttp.Response)
17663	if !ok {
17664		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17665	}
17666
17667	if response.StatusCode < 200 || response.StatusCode >= 300 {
17668		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response, &metadata)
17669	}
17670	output := &UpdateDomainEntryOutput{}
17671	out.Result = output
17672
17673	var buff [1024]byte
17674	ringBuffer := smithyio.NewRingBuffer(buff[:])
17675
17676	body := io.TeeReader(response.Body, ringBuffer)
17677	decoder := json.NewDecoder(body)
17678	decoder.UseNumber()
17679	var shape interface{}
17680	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17681		var snapshot bytes.Buffer
17682		io.Copy(&snapshot, ringBuffer)
17683		err = &smithy.DeserializationError{
17684			Err:      fmt.Errorf("failed to decode response body, %w", err),
17685			Snapshot: snapshot.Bytes(),
17686		}
17687		return out, metadata, err
17688	}
17689
17690	err = awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(&output, shape)
17691	if err != nil {
17692		var snapshot bytes.Buffer
17693		io.Copy(&snapshot, ringBuffer)
17694		err = &smithy.DeserializationError{
17695			Err:      fmt.Errorf("failed to decode response body, %w", err),
17696			Snapshot: snapshot.Bytes(),
17697		}
17698		return out, metadata, err
17699	}
17700
17701	return out, metadata, err
17702}
17703
17704func awsAwsjson11_deserializeOpErrorUpdateDomainEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17705	var errorBuffer bytes.Buffer
17706	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17707		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17708	}
17709	errorBody := bytes.NewReader(errorBuffer.Bytes())
17710
17711	errorCode := "UnknownError"
17712	errorMessage := errorCode
17713
17714	code := response.Header.Get("X-Amzn-ErrorType")
17715	if len(code) != 0 {
17716		errorCode = restjson.SanitizeErrorCode(code)
17717	}
17718
17719	var buff [1024]byte
17720	ringBuffer := smithyio.NewRingBuffer(buff[:])
17721
17722	body := io.TeeReader(errorBody, ringBuffer)
17723	decoder := json.NewDecoder(body)
17724	decoder.UseNumber()
17725	code, message, err := restjson.GetErrorInfo(decoder)
17726	if err != nil {
17727		var snapshot bytes.Buffer
17728		io.Copy(&snapshot, ringBuffer)
17729		err = &smithy.DeserializationError{
17730			Err:      fmt.Errorf("failed to decode response body, %w", err),
17731			Snapshot: snapshot.Bytes(),
17732		}
17733		return err
17734	}
17735
17736	errorBody.Seek(0, io.SeekStart)
17737	if len(code) != 0 {
17738		errorCode = restjson.SanitizeErrorCode(code)
17739	}
17740	if len(message) != 0 {
17741		errorMessage = message
17742	}
17743
17744	switch {
17745	case strings.EqualFold("AccessDeniedException", errorCode):
17746		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17747
17748	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17749		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17750
17751	case strings.EqualFold("InvalidInputException", errorCode):
17752		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17753
17754	case strings.EqualFold("NotFoundException", errorCode):
17755		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17756
17757	case strings.EqualFold("OperationFailureException", errorCode):
17758		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17759
17760	case strings.EqualFold("ServiceException", errorCode):
17761		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17762
17763	case strings.EqualFold("UnauthenticatedException", errorCode):
17764		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17765
17766	default:
17767		genericError := &smithy.GenericAPIError{
17768			Code:    errorCode,
17769			Message: errorMessage,
17770		}
17771		return genericError
17772
17773	}
17774}
17775
17776type awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute struct {
17777}
17778
17779func (*awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) ID() string {
17780	return "OperationDeserializer"
17781}
17782
17783func (m *awsAwsjson11_deserializeOpUpdateLoadBalancerAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17784	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17785) {
17786	out, metadata, err = next.HandleDeserialize(ctx, in)
17787	if err != nil {
17788		return out, metadata, err
17789	}
17790
17791	response, ok := out.RawResponse.(*smithyhttp.Response)
17792	if !ok {
17793		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17794	}
17795
17796	if response.StatusCode < 200 || response.StatusCode >= 300 {
17797		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response, &metadata)
17798	}
17799	output := &UpdateLoadBalancerAttributeOutput{}
17800	out.Result = output
17801
17802	var buff [1024]byte
17803	ringBuffer := smithyio.NewRingBuffer(buff[:])
17804
17805	body := io.TeeReader(response.Body, ringBuffer)
17806	decoder := json.NewDecoder(body)
17807	decoder.UseNumber()
17808	var shape interface{}
17809	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17810		var snapshot bytes.Buffer
17811		io.Copy(&snapshot, ringBuffer)
17812		err = &smithy.DeserializationError{
17813			Err:      fmt.Errorf("failed to decode response body, %w", err),
17814			Snapshot: snapshot.Bytes(),
17815		}
17816		return out, metadata, err
17817	}
17818
17819	err = awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(&output, shape)
17820	if err != nil {
17821		var snapshot bytes.Buffer
17822		io.Copy(&snapshot, ringBuffer)
17823		err = &smithy.DeserializationError{
17824			Err:      fmt.Errorf("failed to decode response body, %w", err),
17825			Snapshot: snapshot.Bytes(),
17826		}
17827		return out, metadata, err
17828	}
17829
17830	return out, metadata, err
17831}
17832
17833func awsAwsjson11_deserializeOpErrorUpdateLoadBalancerAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17834	var errorBuffer bytes.Buffer
17835	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17836		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17837	}
17838	errorBody := bytes.NewReader(errorBuffer.Bytes())
17839
17840	errorCode := "UnknownError"
17841	errorMessage := errorCode
17842
17843	code := response.Header.Get("X-Amzn-ErrorType")
17844	if len(code) != 0 {
17845		errorCode = restjson.SanitizeErrorCode(code)
17846	}
17847
17848	var buff [1024]byte
17849	ringBuffer := smithyio.NewRingBuffer(buff[:])
17850
17851	body := io.TeeReader(errorBody, ringBuffer)
17852	decoder := json.NewDecoder(body)
17853	decoder.UseNumber()
17854	code, message, err := restjson.GetErrorInfo(decoder)
17855	if err != nil {
17856		var snapshot bytes.Buffer
17857		io.Copy(&snapshot, ringBuffer)
17858		err = &smithy.DeserializationError{
17859			Err:      fmt.Errorf("failed to decode response body, %w", err),
17860			Snapshot: snapshot.Bytes(),
17861		}
17862		return err
17863	}
17864
17865	errorBody.Seek(0, io.SeekStart)
17866	if len(code) != 0 {
17867		errorCode = restjson.SanitizeErrorCode(code)
17868	}
17869	if len(message) != 0 {
17870		errorMessage = message
17871	}
17872
17873	switch {
17874	case strings.EqualFold("AccessDeniedException", errorCode):
17875		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
17876
17877	case strings.EqualFold("AccountSetupInProgressException", errorCode):
17878		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
17879
17880	case strings.EqualFold("InvalidInputException", errorCode):
17881		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
17882
17883	case strings.EqualFold("NotFoundException", errorCode):
17884		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
17885
17886	case strings.EqualFold("OperationFailureException", errorCode):
17887		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
17888
17889	case strings.EqualFold("ServiceException", errorCode):
17890		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
17891
17892	case strings.EqualFold("UnauthenticatedException", errorCode):
17893		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
17894
17895	default:
17896		genericError := &smithy.GenericAPIError{
17897			Code:    errorCode,
17898			Message: errorMessage,
17899		}
17900		return genericError
17901
17902	}
17903}
17904
17905type awsAwsjson11_deserializeOpUpdateRelationalDatabase struct {
17906}
17907
17908func (*awsAwsjson11_deserializeOpUpdateRelationalDatabase) ID() string {
17909	return "OperationDeserializer"
17910}
17911
17912func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabase) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
17913	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
17914) {
17915	out, metadata, err = next.HandleDeserialize(ctx, in)
17916	if err != nil {
17917		return out, metadata, err
17918	}
17919
17920	response, ok := out.RawResponse.(*smithyhttp.Response)
17921	if !ok {
17922		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
17923	}
17924
17925	if response.StatusCode < 200 || response.StatusCode >= 300 {
17926		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response, &metadata)
17927	}
17928	output := &UpdateRelationalDatabaseOutput{}
17929	out.Result = output
17930
17931	var buff [1024]byte
17932	ringBuffer := smithyio.NewRingBuffer(buff[:])
17933
17934	body := io.TeeReader(response.Body, ringBuffer)
17935	decoder := json.NewDecoder(body)
17936	decoder.UseNumber()
17937	var shape interface{}
17938	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
17939		var snapshot bytes.Buffer
17940		io.Copy(&snapshot, ringBuffer)
17941		err = &smithy.DeserializationError{
17942			Err:      fmt.Errorf("failed to decode response body, %w", err),
17943			Snapshot: snapshot.Bytes(),
17944		}
17945		return out, metadata, err
17946	}
17947
17948	err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(&output, shape)
17949	if err != nil {
17950		var snapshot bytes.Buffer
17951		io.Copy(&snapshot, ringBuffer)
17952		err = &smithy.DeserializationError{
17953			Err:      fmt.Errorf("failed to decode response body, %w", err),
17954			Snapshot: snapshot.Bytes(),
17955		}
17956		return out, metadata, err
17957	}
17958
17959	return out, metadata, err
17960}
17961
17962func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabase(response *smithyhttp.Response, metadata *middleware.Metadata) error {
17963	var errorBuffer bytes.Buffer
17964	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
17965		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
17966	}
17967	errorBody := bytes.NewReader(errorBuffer.Bytes())
17968
17969	errorCode := "UnknownError"
17970	errorMessage := errorCode
17971
17972	code := response.Header.Get("X-Amzn-ErrorType")
17973	if len(code) != 0 {
17974		errorCode = restjson.SanitizeErrorCode(code)
17975	}
17976
17977	var buff [1024]byte
17978	ringBuffer := smithyio.NewRingBuffer(buff[:])
17979
17980	body := io.TeeReader(errorBody, ringBuffer)
17981	decoder := json.NewDecoder(body)
17982	decoder.UseNumber()
17983	code, message, err := restjson.GetErrorInfo(decoder)
17984	if err != nil {
17985		var snapshot bytes.Buffer
17986		io.Copy(&snapshot, ringBuffer)
17987		err = &smithy.DeserializationError{
17988			Err:      fmt.Errorf("failed to decode response body, %w", err),
17989			Snapshot: snapshot.Bytes(),
17990		}
17991		return err
17992	}
17993
17994	errorBody.Seek(0, io.SeekStart)
17995	if len(code) != 0 {
17996		errorCode = restjson.SanitizeErrorCode(code)
17997	}
17998	if len(message) != 0 {
17999		errorMessage = message
18000	}
18001
18002	switch {
18003	case strings.EqualFold("AccessDeniedException", errorCode):
18004		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18005
18006	case strings.EqualFold("AccountSetupInProgressException", errorCode):
18007		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18008
18009	case strings.EqualFold("InvalidInputException", errorCode):
18010		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18011
18012	case strings.EqualFold("NotFoundException", errorCode):
18013		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18014
18015	case strings.EqualFold("OperationFailureException", errorCode):
18016		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18017
18018	case strings.EqualFold("ServiceException", errorCode):
18019		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18020
18021	case strings.EqualFold("UnauthenticatedException", errorCode):
18022		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18023
18024	default:
18025		genericError := &smithy.GenericAPIError{
18026			Code:    errorCode,
18027			Message: errorMessage,
18028		}
18029		return genericError
18030
18031	}
18032}
18033
18034type awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters struct {
18035}
18036
18037func (*awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) ID() string {
18038	return "OperationDeserializer"
18039}
18040
18041func (m *awsAwsjson11_deserializeOpUpdateRelationalDatabaseParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
18042	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
18043) {
18044	out, metadata, err = next.HandleDeserialize(ctx, in)
18045	if err != nil {
18046		return out, metadata, err
18047	}
18048
18049	response, ok := out.RawResponse.(*smithyhttp.Response)
18050	if !ok {
18051		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
18052	}
18053
18054	if response.StatusCode < 200 || response.StatusCode >= 300 {
18055		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response, &metadata)
18056	}
18057	output := &UpdateRelationalDatabaseParametersOutput{}
18058	out.Result = output
18059
18060	var buff [1024]byte
18061	ringBuffer := smithyio.NewRingBuffer(buff[:])
18062
18063	body := io.TeeReader(response.Body, ringBuffer)
18064	decoder := json.NewDecoder(body)
18065	decoder.UseNumber()
18066	var shape interface{}
18067	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18068		var snapshot bytes.Buffer
18069		io.Copy(&snapshot, ringBuffer)
18070		err = &smithy.DeserializationError{
18071			Err:      fmt.Errorf("failed to decode response body, %w", err),
18072			Snapshot: snapshot.Bytes(),
18073		}
18074		return out, metadata, err
18075	}
18076
18077	err = awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(&output, shape)
18078	if err != nil {
18079		var snapshot bytes.Buffer
18080		io.Copy(&snapshot, ringBuffer)
18081		err = &smithy.DeserializationError{
18082			Err:      fmt.Errorf("failed to decode response body, %w", err),
18083			Snapshot: snapshot.Bytes(),
18084		}
18085		return out, metadata, err
18086	}
18087
18088	return out, metadata, err
18089}
18090
18091func awsAwsjson11_deserializeOpErrorUpdateRelationalDatabaseParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
18092	var errorBuffer bytes.Buffer
18093	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
18094		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
18095	}
18096	errorBody := bytes.NewReader(errorBuffer.Bytes())
18097
18098	errorCode := "UnknownError"
18099	errorMessage := errorCode
18100
18101	code := response.Header.Get("X-Amzn-ErrorType")
18102	if len(code) != 0 {
18103		errorCode = restjson.SanitizeErrorCode(code)
18104	}
18105
18106	var buff [1024]byte
18107	ringBuffer := smithyio.NewRingBuffer(buff[:])
18108
18109	body := io.TeeReader(errorBody, ringBuffer)
18110	decoder := json.NewDecoder(body)
18111	decoder.UseNumber()
18112	code, message, err := restjson.GetErrorInfo(decoder)
18113	if err != nil {
18114		var snapshot bytes.Buffer
18115		io.Copy(&snapshot, ringBuffer)
18116		err = &smithy.DeserializationError{
18117			Err:      fmt.Errorf("failed to decode response body, %w", err),
18118			Snapshot: snapshot.Bytes(),
18119		}
18120		return err
18121	}
18122
18123	errorBody.Seek(0, io.SeekStart)
18124	if len(code) != 0 {
18125		errorCode = restjson.SanitizeErrorCode(code)
18126	}
18127	if len(message) != 0 {
18128		errorMessage = message
18129	}
18130
18131	switch {
18132	case strings.EqualFold("AccessDeniedException", errorCode):
18133		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
18134
18135	case strings.EqualFold("AccountSetupInProgressException", errorCode):
18136		return awsAwsjson11_deserializeErrorAccountSetupInProgressException(response, errorBody)
18137
18138	case strings.EqualFold("InvalidInputException", errorCode):
18139		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
18140
18141	case strings.EqualFold("NotFoundException", errorCode):
18142		return awsAwsjson11_deserializeErrorNotFoundException(response, errorBody)
18143
18144	case strings.EqualFold("OperationFailureException", errorCode):
18145		return awsAwsjson11_deserializeErrorOperationFailureException(response, errorBody)
18146
18147	case strings.EqualFold("ServiceException", errorCode):
18148		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
18149
18150	case strings.EqualFold("UnauthenticatedException", errorCode):
18151		return awsAwsjson11_deserializeErrorUnauthenticatedException(response, errorBody)
18152
18153	default:
18154		genericError := &smithy.GenericAPIError{
18155			Code:    errorCode,
18156			Message: errorMessage,
18157		}
18158		return genericError
18159
18160	}
18161}
18162
18163func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18164	var buff [1024]byte
18165	ringBuffer := smithyio.NewRingBuffer(buff[:])
18166
18167	body := io.TeeReader(errorBody, ringBuffer)
18168	decoder := json.NewDecoder(body)
18169	decoder.UseNumber()
18170	var shape interface{}
18171	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18172		var snapshot bytes.Buffer
18173		io.Copy(&snapshot, ringBuffer)
18174		err = &smithy.DeserializationError{
18175			Err:      fmt.Errorf("failed to decode response body, %w", err),
18176			Snapshot: snapshot.Bytes(),
18177		}
18178		return err
18179	}
18180
18181	output := &types.AccessDeniedException{}
18182	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
18183
18184	if err != nil {
18185		var snapshot bytes.Buffer
18186		io.Copy(&snapshot, ringBuffer)
18187		err = &smithy.DeserializationError{
18188			Err:      fmt.Errorf("failed to decode response body, %w", err),
18189			Snapshot: snapshot.Bytes(),
18190		}
18191		return err
18192	}
18193
18194	errorBody.Seek(0, io.SeekStart)
18195	return output
18196}
18197
18198func awsAwsjson11_deserializeErrorAccountSetupInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18199	var buff [1024]byte
18200	ringBuffer := smithyio.NewRingBuffer(buff[:])
18201
18202	body := io.TeeReader(errorBody, ringBuffer)
18203	decoder := json.NewDecoder(body)
18204	decoder.UseNumber()
18205	var shape interface{}
18206	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18207		var snapshot bytes.Buffer
18208		io.Copy(&snapshot, ringBuffer)
18209		err = &smithy.DeserializationError{
18210			Err:      fmt.Errorf("failed to decode response body, %w", err),
18211			Snapshot: snapshot.Bytes(),
18212		}
18213		return err
18214	}
18215
18216	output := &types.AccountSetupInProgressException{}
18217	err := awsAwsjson11_deserializeDocumentAccountSetupInProgressException(&output, shape)
18218
18219	if err != nil {
18220		var snapshot bytes.Buffer
18221		io.Copy(&snapshot, ringBuffer)
18222		err = &smithy.DeserializationError{
18223			Err:      fmt.Errorf("failed to decode response body, %w", err),
18224			Snapshot: snapshot.Bytes(),
18225		}
18226		return err
18227	}
18228
18229	errorBody.Seek(0, io.SeekStart)
18230	return output
18231}
18232
18233func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18234	var buff [1024]byte
18235	ringBuffer := smithyio.NewRingBuffer(buff[:])
18236
18237	body := io.TeeReader(errorBody, ringBuffer)
18238	decoder := json.NewDecoder(body)
18239	decoder.UseNumber()
18240	var shape interface{}
18241	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18242		var snapshot bytes.Buffer
18243		io.Copy(&snapshot, ringBuffer)
18244		err = &smithy.DeserializationError{
18245			Err:      fmt.Errorf("failed to decode response body, %w", err),
18246			Snapshot: snapshot.Bytes(),
18247		}
18248		return err
18249	}
18250
18251	output := &types.InvalidInputException{}
18252	err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape)
18253
18254	if err != nil {
18255		var snapshot bytes.Buffer
18256		io.Copy(&snapshot, ringBuffer)
18257		err = &smithy.DeserializationError{
18258			Err:      fmt.Errorf("failed to decode response body, %w", err),
18259			Snapshot: snapshot.Bytes(),
18260		}
18261		return err
18262	}
18263
18264	errorBody.Seek(0, io.SeekStart)
18265	return output
18266}
18267
18268func awsAwsjson11_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18269	var buff [1024]byte
18270	ringBuffer := smithyio.NewRingBuffer(buff[:])
18271
18272	body := io.TeeReader(errorBody, ringBuffer)
18273	decoder := json.NewDecoder(body)
18274	decoder.UseNumber()
18275	var shape interface{}
18276	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18277		var snapshot bytes.Buffer
18278		io.Copy(&snapshot, ringBuffer)
18279		err = &smithy.DeserializationError{
18280			Err:      fmt.Errorf("failed to decode response body, %w", err),
18281			Snapshot: snapshot.Bytes(),
18282		}
18283		return err
18284	}
18285
18286	output := &types.NotFoundException{}
18287	err := awsAwsjson11_deserializeDocumentNotFoundException(&output, shape)
18288
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 err
18297	}
18298
18299	errorBody.Seek(0, io.SeekStart)
18300	return output
18301}
18302
18303func awsAwsjson11_deserializeErrorOperationFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18304	var buff [1024]byte
18305	ringBuffer := smithyio.NewRingBuffer(buff[:])
18306
18307	body := io.TeeReader(errorBody, ringBuffer)
18308	decoder := json.NewDecoder(body)
18309	decoder.UseNumber()
18310	var shape interface{}
18311	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18312		var snapshot bytes.Buffer
18313		io.Copy(&snapshot, ringBuffer)
18314		err = &smithy.DeserializationError{
18315			Err:      fmt.Errorf("failed to decode response body, %w", err),
18316			Snapshot: snapshot.Bytes(),
18317		}
18318		return err
18319	}
18320
18321	output := &types.OperationFailureException{}
18322	err := awsAwsjson11_deserializeDocumentOperationFailureException(&output, shape)
18323
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	return output
18336}
18337
18338func awsAwsjson11_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18339	var buff [1024]byte
18340	ringBuffer := smithyio.NewRingBuffer(buff[:])
18341
18342	body := io.TeeReader(errorBody, ringBuffer)
18343	decoder := json.NewDecoder(body)
18344	decoder.UseNumber()
18345	var shape interface{}
18346	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18347		var snapshot bytes.Buffer
18348		io.Copy(&snapshot, ringBuffer)
18349		err = &smithy.DeserializationError{
18350			Err:      fmt.Errorf("failed to decode response body, %w", err),
18351			Snapshot: snapshot.Bytes(),
18352		}
18353		return err
18354	}
18355
18356	output := &types.ServiceException{}
18357	err := awsAwsjson11_deserializeDocumentServiceException(&output, shape)
18358
18359	if err != nil {
18360		var snapshot bytes.Buffer
18361		io.Copy(&snapshot, ringBuffer)
18362		err = &smithy.DeserializationError{
18363			Err:      fmt.Errorf("failed to decode response body, %w", err),
18364			Snapshot: snapshot.Bytes(),
18365		}
18366		return err
18367	}
18368
18369	errorBody.Seek(0, io.SeekStart)
18370	return output
18371}
18372
18373func awsAwsjson11_deserializeErrorUnauthenticatedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
18374	var buff [1024]byte
18375	ringBuffer := smithyio.NewRingBuffer(buff[:])
18376
18377	body := io.TeeReader(errorBody, ringBuffer)
18378	decoder := json.NewDecoder(body)
18379	decoder.UseNumber()
18380	var shape interface{}
18381	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
18382		var snapshot bytes.Buffer
18383		io.Copy(&snapshot, ringBuffer)
18384		err = &smithy.DeserializationError{
18385			Err:      fmt.Errorf("failed to decode response body, %w", err),
18386			Snapshot: snapshot.Bytes(),
18387		}
18388		return err
18389	}
18390
18391	output := &types.UnauthenticatedException{}
18392	err := awsAwsjson11_deserializeDocumentUnauthenticatedException(&output, shape)
18393
18394	if err != nil {
18395		var snapshot bytes.Buffer
18396		io.Copy(&snapshot, ringBuffer)
18397		err = &smithy.DeserializationError{
18398			Err:      fmt.Errorf("failed to decode response body, %w", err),
18399			Snapshot: snapshot.Bytes(),
18400		}
18401		return err
18402	}
18403
18404	errorBody.Seek(0, io.SeekStart)
18405	return output
18406}
18407
18408func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
18409	if v == nil {
18410		return fmt.Errorf("unexpected nil of type %T", v)
18411	}
18412	if value == nil {
18413		return nil
18414	}
18415
18416	shape, ok := value.(map[string]interface{})
18417	if !ok {
18418		return fmt.Errorf("unexpected JSON type %v", value)
18419	}
18420
18421	var sv *types.AccessDeniedException
18422	if *v == nil {
18423		sv = &types.AccessDeniedException{}
18424	} else {
18425		sv = *v
18426	}
18427
18428	for key, value := range shape {
18429		switch key {
18430		case "code":
18431			if value != nil {
18432				jtv, ok := value.(string)
18433				if !ok {
18434					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18435				}
18436				sv.Code = ptr.String(jtv)
18437			}
18438
18439		case "docs":
18440			if value != nil {
18441				jtv, ok := value.(string)
18442				if !ok {
18443					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18444				}
18445				sv.Docs = ptr.String(jtv)
18446			}
18447
18448		case "message":
18449			if value != nil {
18450				jtv, ok := value.(string)
18451				if !ok {
18452					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18453				}
18454				sv.Message = ptr.String(jtv)
18455			}
18456
18457		case "tip":
18458			if value != nil {
18459				jtv, ok := value.(string)
18460				if !ok {
18461					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18462				}
18463				sv.Tip = ptr.String(jtv)
18464			}
18465
18466		default:
18467			_, _ = key, value
18468
18469		}
18470	}
18471	*v = sv
18472	return nil
18473}
18474
18475func awsAwsjson11_deserializeDocumentAccountSetupInProgressException(v **types.AccountSetupInProgressException, value interface{}) error {
18476	if v == nil {
18477		return fmt.Errorf("unexpected nil of type %T", v)
18478	}
18479	if value == nil {
18480		return nil
18481	}
18482
18483	shape, ok := value.(map[string]interface{})
18484	if !ok {
18485		return fmt.Errorf("unexpected JSON type %v", value)
18486	}
18487
18488	var sv *types.AccountSetupInProgressException
18489	if *v == nil {
18490		sv = &types.AccountSetupInProgressException{}
18491	} else {
18492		sv = *v
18493	}
18494
18495	for key, value := range shape {
18496		switch key {
18497		case "code":
18498			if value != nil {
18499				jtv, ok := value.(string)
18500				if !ok {
18501					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18502				}
18503				sv.Code = ptr.String(jtv)
18504			}
18505
18506		case "docs":
18507			if value != nil {
18508				jtv, ok := value.(string)
18509				if !ok {
18510					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18511				}
18512				sv.Docs = ptr.String(jtv)
18513			}
18514
18515		case "message":
18516			if value != nil {
18517				jtv, ok := value.(string)
18518				if !ok {
18519					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18520				}
18521				sv.Message = ptr.String(jtv)
18522			}
18523
18524		case "tip":
18525			if value != nil {
18526				jtv, ok := value.(string)
18527				if !ok {
18528					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18529				}
18530				sv.Tip = ptr.String(jtv)
18531			}
18532
18533		default:
18534			_, _ = key, value
18535
18536		}
18537	}
18538	*v = sv
18539	return nil
18540}
18541
18542func awsAwsjson11_deserializeDocumentAddOn(v **types.AddOn, value interface{}) error {
18543	if v == nil {
18544		return fmt.Errorf("unexpected nil of type %T", v)
18545	}
18546	if value == nil {
18547		return nil
18548	}
18549
18550	shape, ok := value.(map[string]interface{})
18551	if !ok {
18552		return fmt.Errorf("unexpected JSON type %v", value)
18553	}
18554
18555	var sv *types.AddOn
18556	if *v == nil {
18557		sv = &types.AddOn{}
18558	} else {
18559		sv = *v
18560	}
18561
18562	for key, value := range shape {
18563		switch key {
18564		case "name":
18565			if value != nil {
18566				jtv, ok := value.(string)
18567				if !ok {
18568					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18569				}
18570				sv.Name = ptr.String(jtv)
18571			}
18572
18573		case "nextSnapshotTimeOfDay":
18574			if value != nil {
18575				jtv, ok := value.(string)
18576				if !ok {
18577					return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
18578				}
18579				sv.NextSnapshotTimeOfDay = ptr.String(jtv)
18580			}
18581
18582		case "snapshotTimeOfDay":
18583			if value != nil {
18584				jtv, ok := value.(string)
18585				if !ok {
18586					return fmt.Errorf("expected TimeOfDay to be of type string, got %T instead", value)
18587				}
18588				sv.SnapshotTimeOfDay = ptr.String(jtv)
18589			}
18590
18591		case "status":
18592			if value != nil {
18593				jtv, ok := value.(string)
18594				if !ok {
18595					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18596				}
18597				sv.Status = ptr.String(jtv)
18598			}
18599
18600		default:
18601			_, _ = key, value
18602
18603		}
18604	}
18605	*v = sv
18606	return nil
18607}
18608
18609func awsAwsjson11_deserializeDocumentAddOnList(v *[]types.AddOn, value interface{}) error {
18610	if v == nil {
18611		return fmt.Errorf("unexpected nil of type %T", v)
18612	}
18613	if value == nil {
18614		return nil
18615	}
18616
18617	shape, ok := value.([]interface{})
18618	if !ok {
18619		return fmt.Errorf("unexpected JSON type %v", value)
18620	}
18621
18622	var cv []types.AddOn
18623	if *v == nil {
18624		cv = []types.AddOn{}
18625	} else {
18626		cv = *v
18627	}
18628
18629	for _, value := range shape {
18630		var col types.AddOn
18631		destAddr := &col
18632		if err := awsAwsjson11_deserializeDocumentAddOn(&destAddr, value); err != nil {
18633			return err
18634		}
18635		col = *destAddr
18636		cv = append(cv, col)
18637
18638	}
18639	*v = cv
18640	return nil
18641}
18642
18643func awsAwsjson11_deserializeDocumentAlarm(v **types.Alarm, value interface{}) error {
18644	if v == nil {
18645		return fmt.Errorf("unexpected nil of type %T", v)
18646	}
18647	if value == nil {
18648		return nil
18649	}
18650
18651	shape, ok := value.(map[string]interface{})
18652	if !ok {
18653		return fmt.Errorf("unexpected JSON type %v", value)
18654	}
18655
18656	var sv *types.Alarm
18657	if *v == nil {
18658		sv = &types.Alarm{}
18659	} else {
18660		sv = *v
18661	}
18662
18663	for key, value := range shape {
18664		switch key {
18665		case "arn":
18666			if value != nil {
18667				jtv, ok := value.(string)
18668				if !ok {
18669					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
18670				}
18671				sv.Arn = ptr.String(jtv)
18672			}
18673
18674		case "comparisonOperator":
18675			if value != nil {
18676				jtv, ok := value.(string)
18677				if !ok {
18678					return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
18679				}
18680				sv.ComparisonOperator = types.ComparisonOperator(jtv)
18681			}
18682
18683		case "contactProtocols":
18684			if err := awsAwsjson11_deserializeDocumentContactProtocolsList(&sv.ContactProtocols, value); err != nil {
18685				return err
18686			}
18687
18688		case "createdAt":
18689			if value != nil {
18690				jtv, ok := value.(json.Number)
18691				if !ok {
18692					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
18693				}
18694				f64, err := jtv.Float64()
18695				if err != nil {
18696					return err
18697				}
18698				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
18699			}
18700
18701		case "datapointsToAlarm":
18702			if value != nil {
18703				jtv, ok := value.(json.Number)
18704				if !ok {
18705					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
18706				}
18707				i64, err := jtv.Int64()
18708				if err != nil {
18709					return err
18710				}
18711				sv.DatapointsToAlarm = ptr.Int32(int32(i64))
18712			}
18713
18714		case "evaluationPeriods":
18715			if value != nil {
18716				jtv, ok := value.(json.Number)
18717				if !ok {
18718					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
18719				}
18720				i64, err := jtv.Int64()
18721				if err != nil {
18722					return err
18723				}
18724				sv.EvaluationPeriods = ptr.Int32(int32(i64))
18725			}
18726
18727		case "location":
18728			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
18729				return err
18730			}
18731
18732		case "metricName":
18733			if value != nil {
18734				jtv, ok := value.(string)
18735				if !ok {
18736					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
18737				}
18738				sv.MetricName = types.MetricName(jtv)
18739			}
18740
18741		case "monitoredResourceInfo":
18742			if err := awsAwsjson11_deserializeDocumentMonitoredResourceInfo(&sv.MonitoredResourceInfo, value); err != nil {
18743				return err
18744			}
18745
18746		case "name":
18747			if value != nil {
18748				jtv, ok := value.(string)
18749				if !ok {
18750					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
18751				}
18752				sv.Name = ptr.String(jtv)
18753			}
18754
18755		case "notificationEnabled":
18756			if value != nil {
18757				jtv, ok := value.(bool)
18758				if !ok {
18759					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
18760				}
18761				sv.NotificationEnabled = ptr.Bool(jtv)
18762			}
18763
18764		case "notificationTriggers":
18765			if err := awsAwsjson11_deserializeDocumentNotificationTriggerList(&sv.NotificationTriggers, value); err != nil {
18766				return err
18767			}
18768
18769		case "period":
18770			if value != nil {
18771				jtv, ok := value.(json.Number)
18772				if !ok {
18773					return fmt.Errorf("expected MetricPeriod to be json.Number, got %T instead", value)
18774				}
18775				i64, err := jtv.Int64()
18776				if err != nil {
18777					return err
18778				}
18779				sv.Period = int32(i64)
18780			}
18781
18782		case "resourceType":
18783			if value != nil {
18784				jtv, ok := value.(string)
18785				if !ok {
18786					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
18787				}
18788				sv.ResourceType = types.ResourceType(jtv)
18789			}
18790
18791		case "state":
18792			if value != nil {
18793				jtv, ok := value.(string)
18794				if !ok {
18795					return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
18796				}
18797				sv.State = types.AlarmState(jtv)
18798			}
18799
18800		case "statistic":
18801			if value != nil {
18802				jtv, ok := value.(string)
18803				if !ok {
18804					return fmt.Errorf("expected MetricStatistic to be of type string, got %T instead", value)
18805				}
18806				sv.Statistic = types.MetricStatistic(jtv)
18807			}
18808
18809		case "supportCode":
18810			if value != nil {
18811				jtv, ok := value.(string)
18812				if !ok {
18813					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18814				}
18815				sv.SupportCode = ptr.String(jtv)
18816			}
18817
18818		case "threshold":
18819			if value != nil {
18820				jtv, ok := value.(json.Number)
18821				if !ok {
18822					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
18823				}
18824				f64, err := jtv.Float64()
18825				if err != nil {
18826					return err
18827				}
18828				sv.Threshold = ptr.Float64(f64)
18829			}
18830
18831		case "treatMissingData":
18832			if value != nil {
18833				jtv, ok := value.(string)
18834				if !ok {
18835					return fmt.Errorf("expected TreatMissingData to be of type string, got %T instead", value)
18836				}
18837				sv.TreatMissingData = types.TreatMissingData(jtv)
18838			}
18839
18840		case "unit":
18841			if value != nil {
18842				jtv, ok := value.(string)
18843				if !ok {
18844					return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
18845				}
18846				sv.Unit = types.MetricUnit(jtv)
18847			}
18848
18849		default:
18850			_, _ = key, value
18851
18852		}
18853	}
18854	*v = sv
18855	return nil
18856}
18857
18858func awsAwsjson11_deserializeDocumentAlarmsList(v *[]types.Alarm, value interface{}) error {
18859	if v == nil {
18860		return fmt.Errorf("unexpected nil of type %T", v)
18861	}
18862	if value == nil {
18863		return nil
18864	}
18865
18866	shape, ok := value.([]interface{})
18867	if !ok {
18868		return fmt.Errorf("unexpected JSON type %v", value)
18869	}
18870
18871	var cv []types.Alarm
18872	if *v == nil {
18873		cv = []types.Alarm{}
18874	} else {
18875		cv = *v
18876	}
18877
18878	for _, value := range shape {
18879		var col types.Alarm
18880		destAddr := &col
18881		if err := awsAwsjson11_deserializeDocumentAlarm(&destAddr, value); err != nil {
18882			return err
18883		}
18884		col = *destAddr
18885		cv = append(cv, col)
18886
18887	}
18888	*v = cv
18889	return nil
18890}
18891
18892func awsAwsjson11_deserializeDocumentAttachedDisk(v **types.AttachedDisk, value interface{}) error {
18893	if v == nil {
18894		return fmt.Errorf("unexpected nil of type %T", v)
18895	}
18896	if value == nil {
18897		return nil
18898	}
18899
18900	shape, ok := value.(map[string]interface{})
18901	if !ok {
18902		return fmt.Errorf("unexpected JSON type %v", value)
18903	}
18904
18905	var sv *types.AttachedDisk
18906	if *v == nil {
18907		sv = &types.AttachedDisk{}
18908	} else {
18909		sv = *v
18910	}
18911
18912	for key, value := range shape {
18913		switch key {
18914		case "path":
18915			if value != nil {
18916				jtv, ok := value.(string)
18917				if !ok {
18918					return fmt.Errorf("expected string to be of type string, got %T instead", value)
18919				}
18920				sv.Path = ptr.String(jtv)
18921			}
18922
18923		case "sizeInGb":
18924			if value != nil {
18925				jtv, ok := value.(json.Number)
18926				if !ok {
18927					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
18928				}
18929				i64, err := jtv.Int64()
18930				if err != nil {
18931					return err
18932				}
18933				sv.SizeInGb = ptr.Int32(int32(i64))
18934			}
18935
18936		default:
18937			_, _ = key, value
18938
18939		}
18940	}
18941	*v = sv
18942	return nil
18943}
18944
18945func awsAwsjson11_deserializeDocumentAttachedDiskList(v *[]types.AttachedDisk, value interface{}) error {
18946	if v == nil {
18947		return fmt.Errorf("unexpected nil of type %T", v)
18948	}
18949	if value == nil {
18950		return nil
18951	}
18952
18953	shape, ok := value.([]interface{})
18954	if !ok {
18955		return fmt.Errorf("unexpected JSON type %v", value)
18956	}
18957
18958	var cv []types.AttachedDisk
18959	if *v == nil {
18960		cv = []types.AttachedDisk{}
18961	} else {
18962		cv = *v
18963	}
18964
18965	for _, value := range shape {
18966		var col types.AttachedDisk
18967		destAddr := &col
18968		if err := awsAwsjson11_deserializeDocumentAttachedDisk(&destAddr, value); err != nil {
18969			return err
18970		}
18971		col = *destAddr
18972		cv = append(cv, col)
18973
18974	}
18975	*v = cv
18976	return nil
18977}
18978
18979func awsAwsjson11_deserializeDocumentAutoSnapshotDetails(v **types.AutoSnapshotDetails, value interface{}) error {
18980	if v == nil {
18981		return fmt.Errorf("unexpected nil of type %T", v)
18982	}
18983	if value == nil {
18984		return nil
18985	}
18986
18987	shape, ok := value.(map[string]interface{})
18988	if !ok {
18989		return fmt.Errorf("unexpected JSON type %v", value)
18990	}
18991
18992	var sv *types.AutoSnapshotDetails
18993	if *v == nil {
18994		sv = &types.AutoSnapshotDetails{}
18995	} else {
18996		sv = *v
18997	}
18998
18999	for key, value := range shape {
19000		switch key {
19001		case "createdAt":
19002			if value != nil {
19003				jtv, ok := value.(json.Number)
19004				if !ok {
19005					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19006				}
19007				f64, err := jtv.Float64()
19008				if err != nil {
19009					return err
19010				}
19011				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
19012			}
19013
19014		case "date":
19015			if value != nil {
19016				jtv, ok := value.(string)
19017				if !ok {
19018					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19019				}
19020				sv.Date = ptr.String(jtv)
19021			}
19022
19023		case "fromAttachedDisks":
19024			if err := awsAwsjson11_deserializeDocumentAttachedDiskList(&sv.FromAttachedDisks, value); err != nil {
19025				return err
19026			}
19027
19028		case "status":
19029			if value != nil {
19030				jtv, ok := value.(string)
19031				if !ok {
19032					return fmt.Errorf("expected AutoSnapshotStatus to be of type string, got %T instead", value)
19033				}
19034				sv.Status = types.AutoSnapshotStatus(jtv)
19035			}
19036
19037		default:
19038			_, _ = key, value
19039
19040		}
19041	}
19042	*v = sv
19043	return nil
19044}
19045
19046func awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(v *[]types.AutoSnapshotDetails, value interface{}) error {
19047	if v == nil {
19048		return fmt.Errorf("unexpected nil of type %T", v)
19049	}
19050	if value == nil {
19051		return nil
19052	}
19053
19054	shape, ok := value.([]interface{})
19055	if !ok {
19056		return fmt.Errorf("unexpected JSON type %v", value)
19057	}
19058
19059	var cv []types.AutoSnapshotDetails
19060	if *v == nil {
19061		cv = []types.AutoSnapshotDetails{}
19062	} else {
19063		cv = *v
19064	}
19065
19066	for _, value := range shape {
19067		var col types.AutoSnapshotDetails
19068		destAddr := &col
19069		if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetails(&destAddr, value); err != nil {
19070			return err
19071		}
19072		col = *destAddr
19073		cv = append(cv, col)
19074
19075	}
19076	*v = cv
19077	return nil
19078}
19079
19080func awsAwsjson11_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, value interface{}) error {
19081	if v == nil {
19082		return fmt.Errorf("unexpected nil of type %T", v)
19083	}
19084	if value == nil {
19085		return nil
19086	}
19087
19088	shape, ok := value.(map[string]interface{})
19089	if !ok {
19090		return fmt.Errorf("unexpected JSON type %v", value)
19091	}
19092
19093	var sv *types.AvailabilityZone
19094	if *v == nil {
19095		sv = &types.AvailabilityZone{}
19096	} else {
19097		sv = *v
19098	}
19099
19100	for key, value := range shape {
19101		switch key {
19102		case "state":
19103			if value != nil {
19104				jtv, ok := value.(string)
19105				if !ok {
19106					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19107				}
19108				sv.State = ptr.String(jtv)
19109			}
19110
19111		case "zoneName":
19112			if value != nil {
19113				jtv, ok := value.(string)
19114				if !ok {
19115					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19116				}
19117				sv.ZoneName = ptr.String(jtv)
19118			}
19119
19120		default:
19121			_, _ = key, value
19122
19123		}
19124	}
19125	*v = sv
19126	return nil
19127}
19128
19129func awsAwsjson11_deserializeDocumentAvailabilityZoneList(v *[]types.AvailabilityZone, value interface{}) error {
19130	if v == nil {
19131		return fmt.Errorf("unexpected nil of type %T", v)
19132	}
19133	if value == nil {
19134		return nil
19135	}
19136
19137	shape, ok := value.([]interface{})
19138	if !ok {
19139		return fmt.Errorf("unexpected JSON type %v", value)
19140	}
19141
19142	var cv []types.AvailabilityZone
19143	if *v == nil {
19144		cv = []types.AvailabilityZone{}
19145	} else {
19146		cv = *v
19147	}
19148
19149	for _, value := range shape {
19150		var col types.AvailabilityZone
19151		destAddr := &col
19152		if err := awsAwsjson11_deserializeDocumentAvailabilityZone(&destAddr, value); err != nil {
19153			return err
19154		}
19155		col = *destAddr
19156		cv = append(cv, col)
19157
19158	}
19159	*v = cv
19160	return nil
19161}
19162
19163func awsAwsjson11_deserializeDocumentBlueprint(v **types.Blueprint, value interface{}) error {
19164	if v == nil {
19165		return fmt.Errorf("unexpected nil of type %T", v)
19166	}
19167	if value == nil {
19168		return nil
19169	}
19170
19171	shape, ok := value.(map[string]interface{})
19172	if !ok {
19173		return fmt.Errorf("unexpected JSON type %v", value)
19174	}
19175
19176	var sv *types.Blueprint
19177	if *v == nil {
19178		sv = &types.Blueprint{}
19179	} else {
19180		sv = *v
19181	}
19182
19183	for key, value := range shape {
19184		switch key {
19185		case "blueprintId":
19186			if value != nil {
19187				jtv, ok := value.(string)
19188				if !ok {
19189					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19190				}
19191				sv.BlueprintId = ptr.String(jtv)
19192			}
19193
19194		case "description":
19195			if value != nil {
19196				jtv, ok := value.(string)
19197				if !ok {
19198					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19199				}
19200				sv.Description = ptr.String(jtv)
19201			}
19202
19203		case "group":
19204			if value != nil {
19205				jtv, ok := value.(string)
19206				if !ok {
19207					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19208				}
19209				sv.Group = ptr.String(jtv)
19210			}
19211
19212		case "isActive":
19213			if value != nil {
19214				jtv, ok := value.(bool)
19215				if !ok {
19216					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
19217				}
19218				sv.IsActive = ptr.Bool(jtv)
19219			}
19220
19221		case "licenseUrl":
19222			if value != nil {
19223				jtv, ok := value.(string)
19224				if !ok {
19225					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19226				}
19227				sv.LicenseUrl = ptr.String(jtv)
19228			}
19229
19230		case "minPower":
19231			if value != nil {
19232				jtv, ok := value.(json.Number)
19233				if !ok {
19234					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
19235				}
19236				i64, err := jtv.Int64()
19237				if err != nil {
19238					return err
19239				}
19240				sv.MinPower = ptr.Int32(int32(i64))
19241			}
19242
19243		case "name":
19244			if value != nil {
19245				jtv, ok := value.(string)
19246				if !ok {
19247					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
19248				}
19249				sv.Name = ptr.String(jtv)
19250			}
19251
19252		case "platform":
19253			if value != nil {
19254				jtv, ok := value.(string)
19255				if !ok {
19256					return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
19257				}
19258				sv.Platform = types.InstancePlatform(jtv)
19259			}
19260
19261		case "productUrl":
19262			if value != nil {
19263				jtv, ok := value.(string)
19264				if !ok {
19265					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19266				}
19267				sv.ProductUrl = ptr.String(jtv)
19268			}
19269
19270		case "type":
19271			if value != nil {
19272				jtv, ok := value.(string)
19273				if !ok {
19274					return fmt.Errorf("expected BlueprintType to be of type string, got %T instead", value)
19275				}
19276				sv.Type = types.BlueprintType(jtv)
19277			}
19278
19279		case "version":
19280			if value != nil {
19281				jtv, ok := value.(string)
19282				if !ok {
19283					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19284				}
19285				sv.Version = ptr.String(jtv)
19286			}
19287
19288		case "versionCode":
19289			if value != nil {
19290				jtv, ok := value.(string)
19291				if !ok {
19292					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19293				}
19294				sv.VersionCode = ptr.String(jtv)
19295			}
19296
19297		default:
19298			_, _ = key, value
19299
19300		}
19301	}
19302	*v = sv
19303	return nil
19304}
19305
19306func awsAwsjson11_deserializeDocumentBlueprintList(v *[]types.Blueprint, value interface{}) error {
19307	if v == nil {
19308		return fmt.Errorf("unexpected nil of type %T", v)
19309	}
19310	if value == nil {
19311		return nil
19312	}
19313
19314	shape, ok := value.([]interface{})
19315	if !ok {
19316		return fmt.Errorf("unexpected JSON type %v", value)
19317	}
19318
19319	var cv []types.Blueprint
19320	if *v == nil {
19321		cv = []types.Blueprint{}
19322	} else {
19323		cv = *v
19324	}
19325
19326	for _, value := range shape {
19327		var col types.Blueprint
19328		destAddr := &col
19329		if err := awsAwsjson11_deserializeDocumentBlueprint(&destAddr, value); err != nil {
19330			return err
19331		}
19332		col = *destAddr
19333		cv = append(cv, col)
19334
19335	}
19336	*v = cv
19337	return nil
19338}
19339
19340func awsAwsjson11_deserializeDocumentBundle(v **types.Bundle, value interface{}) error {
19341	if v == nil {
19342		return fmt.Errorf("unexpected nil of type %T", v)
19343	}
19344	if value == nil {
19345		return nil
19346	}
19347
19348	shape, ok := value.(map[string]interface{})
19349	if !ok {
19350		return fmt.Errorf("unexpected JSON type %v", value)
19351	}
19352
19353	var sv *types.Bundle
19354	if *v == nil {
19355		sv = &types.Bundle{}
19356	} else {
19357		sv = *v
19358	}
19359
19360	for key, value := range shape {
19361		switch key {
19362		case "bundleId":
19363			if value != nil {
19364				jtv, ok := value.(string)
19365				if !ok {
19366					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19367				}
19368				sv.BundleId = ptr.String(jtv)
19369			}
19370
19371		case "cpuCount":
19372			if value != nil {
19373				jtv, ok := value.(json.Number)
19374				if !ok {
19375					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
19376				}
19377				i64, err := jtv.Int64()
19378				if err != nil {
19379					return err
19380				}
19381				sv.CpuCount = ptr.Int32(int32(i64))
19382			}
19383
19384		case "diskSizeInGb":
19385			if value != nil {
19386				jtv, ok := value.(json.Number)
19387				if !ok {
19388					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
19389				}
19390				i64, err := jtv.Int64()
19391				if err != nil {
19392					return err
19393				}
19394				sv.DiskSizeInGb = ptr.Int32(int32(i64))
19395			}
19396
19397		case "instanceType":
19398			if value != nil {
19399				jtv, ok := value.(string)
19400				if !ok {
19401					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19402				}
19403				sv.InstanceType = ptr.String(jtv)
19404			}
19405
19406		case "isActive":
19407			if value != nil {
19408				jtv, ok := value.(bool)
19409				if !ok {
19410					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
19411				}
19412				sv.IsActive = ptr.Bool(jtv)
19413			}
19414
19415		case "name":
19416			if value != nil {
19417				jtv, ok := value.(string)
19418				if !ok {
19419					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19420				}
19421				sv.Name = ptr.String(jtv)
19422			}
19423
19424		case "power":
19425			if value != nil {
19426				jtv, ok := value.(json.Number)
19427				if !ok {
19428					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
19429				}
19430				i64, err := jtv.Int64()
19431				if err != nil {
19432					return err
19433				}
19434				sv.Power = ptr.Int32(int32(i64))
19435			}
19436
19437		case "price":
19438			if value != nil {
19439				jtv, ok := value.(json.Number)
19440				if !ok {
19441					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
19442				}
19443				f64, err := jtv.Float64()
19444				if err != nil {
19445					return err
19446				}
19447				sv.Price = ptr.Float32(float32(f64))
19448			}
19449
19450		case "ramSizeInGb":
19451			if value != nil {
19452				jtv, ok := value.(json.Number)
19453				if !ok {
19454					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
19455				}
19456				f64, err := jtv.Float64()
19457				if err != nil {
19458					return err
19459				}
19460				sv.RamSizeInGb = ptr.Float32(float32(f64))
19461			}
19462
19463		case "supportedPlatforms":
19464			if err := awsAwsjson11_deserializeDocumentInstancePlatformList(&sv.SupportedPlatforms, value); err != nil {
19465				return err
19466			}
19467
19468		case "transferPerMonthInGb":
19469			if value != nil {
19470				jtv, ok := value.(json.Number)
19471				if !ok {
19472					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
19473				}
19474				i64, err := jtv.Int64()
19475				if err != nil {
19476					return err
19477				}
19478				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
19479			}
19480
19481		default:
19482			_, _ = key, value
19483
19484		}
19485	}
19486	*v = sv
19487	return nil
19488}
19489
19490func awsAwsjson11_deserializeDocumentBundleList(v *[]types.Bundle, value interface{}) error {
19491	if v == nil {
19492		return fmt.Errorf("unexpected nil of type %T", v)
19493	}
19494	if value == nil {
19495		return nil
19496	}
19497
19498	shape, ok := value.([]interface{})
19499	if !ok {
19500		return fmt.Errorf("unexpected JSON type %v", value)
19501	}
19502
19503	var cv []types.Bundle
19504	if *v == nil {
19505		cv = []types.Bundle{}
19506	} else {
19507		cv = *v
19508	}
19509
19510	for _, value := range shape {
19511		var col types.Bundle
19512		destAddr := &col
19513		if err := awsAwsjson11_deserializeDocumentBundle(&destAddr, value); err != nil {
19514			return err
19515		}
19516		col = *destAddr
19517		cv = append(cv, col)
19518
19519	}
19520	*v = cv
19521	return nil
19522}
19523
19524func awsAwsjson11_deserializeDocumentCacheBehavior(v **types.CacheBehavior, value interface{}) error {
19525	if v == nil {
19526		return fmt.Errorf("unexpected nil of type %T", v)
19527	}
19528	if value == nil {
19529		return nil
19530	}
19531
19532	shape, ok := value.(map[string]interface{})
19533	if !ok {
19534		return fmt.Errorf("unexpected JSON type %v", value)
19535	}
19536
19537	var sv *types.CacheBehavior
19538	if *v == nil {
19539		sv = &types.CacheBehavior{}
19540	} else {
19541		sv = *v
19542	}
19543
19544	for key, value := range shape {
19545		switch key {
19546		case "behavior":
19547			if value != nil {
19548				jtv, ok := value.(string)
19549				if !ok {
19550					return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
19551				}
19552				sv.Behavior = types.BehaviorEnum(jtv)
19553			}
19554
19555		default:
19556			_, _ = key, value
19557
19558		}
19559	}
19560	*v = sv
19561	return nil
19562}
19563
19564func awsAwsjson11_deserializeDocumentCacheBehaviorList(v *[]types.CacheBehaviorPerPath, value interface{}) error {
19565	if v == nil {
19566		return fmt.Errorf("unexpected nil of type %T", v)
19567	}
19568	if value == nil {
19569		return nil
19570	}
19571
19572	shape, ok := value.([]interface{})
19573	if !ok {
19574		return fmt.Errorf("unexpected JSON type %v", value)
19575	}
19576
19577	var cv []types.CacheBehaviorPerPath
19578	if *v == nil {
19579		cv = []types.CacheBehaviorPerPath{}
19580	} else {
19581		cv = *v
19582	}
19583
19584	for _, value := range shape {
19585		var col types.CacheBehaviorPerPath
19586		destAddr := &col
19587		if err := awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(&destAddr, value); err != nil {
19588			return err
19589		}
19590		col = *destAddr
19591		cv = append(cv, col)
19592
19593	}
19594	*v = cv
19595	return nil
19596}
19597
19598func awsAwsjson11_deserializeDocumentCacheBehaviorPerPath(v **types.CacheBehaviorPerPath, value interface{}) error {
19599	if v == nil {
19600		return fmt.Errorf("unexpected nil of type %T", v)
19601	}
19602	if value == nil {
19603		return nil
19604	}
19605
19606	shape, ok := value.(map[string]interface{})
19607	if !ok {
19608		return fmt.Errorf("unexpected JSON type %v", value)
19609	}
19610
19611	var sv *types.CacheBehaviorPerPath
19612	if *v == nil {
19613		sv = &types.CacheBehaviorPerPath{}
19614	} else {
19615		sv = *v
19616	}
19617
19618	for key, value := range shape {
19619		switch key {
19620		case "behavior":
19621			if value != nil {
19622				jtv, ok := value.(string)
19623				if !ok {
19624					return fmt.Errorf("expected BehaviorEnum to be of type string, got %T instead", value)
19625				}
19626				sv.Behavior = types.BehaviorEnum(jtv)
19627			}
19628
19629		case "path":
19630			if value != nil {
19631				jtv, ok := value.(string)
19632				if !ok {
19633					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19634				}
19635				sv.Path = ptr.String(jtv)
19636			}
19637
19638		default:
19639			_, _ = key, value
19640
19641		}
19642	}
19643	*v = sv
19644	return nil
19645}
19646
19647func awsAwsjson11_deserializeDocumentCacheSettings(v **types.CacheSettings, value interface{}) error {
19648	if v == nil {
19649		return fmt.Errorf("unexpected nil of type %T", v)
19650	}
19651	if value == nil {
19652		return nil
19653	}
19654
19655	shape, ok := value.(map[string]interface{})
19656	if !ok {
19657		return fmt.Errorf("unexpected JSON type %v", value)
19658	}
19659
19660	var sv *types.CacheSettings
19661	if *v == nil {
19662		sv = &types.CacheSettings{}
19663	} else {
19664		sv = *v
19665	}
19666
19667	for key, value := range shape {
19668		switch key {
19669		case "allowedHTTPMethods":
19670			if value != nil {
19671				jtv, ok := value.(string)
19672				if !ok {
19673					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19674				}
19675				sv.AllowedHTTPMethods = ptr.String(jtv)
19676			}
19677
19678		case "cachedHTTPMethods":
19679			if value != nil {
19680				jtv, ok := value.(string)
19681				if !ok {
19682					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19683				}
19684				sv.CachedHTTPMethods = ptr.String(jtv)
19685			}
19686
19687		case "defaultTTL":
19688			if value != nil {
19689				jtv, ok := value.(json.Number)
19690				if !ok {
19691					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
19692				}
19693				i64, err := jtv.Int64()
19694				if err != nil {
19695					return err
19696				}
19697				sv.DefaultTTL = ptr.Int64(i64)
19698			}
19699
19700		case "forwardedCookies":
19701			if err := awsAwsjson11_deserializeDocumentCookieObject(&sv.ForwardedCookies, value); err != nil {
19702				return err
19703			}
19704
19705		case "forwardedHeaders":
19706			if err := awsAwsjson11_deserializeDocumentHeaderObject(&sv.ForwardedHeaders, value); err != nil {
19707				return err
19708			}
19709
19710		case "forwardedQueryStrings":
19711			if err := awsAwsjson11_deserializeDocumentQueryStringObject(&sv.ForwardedQueryStrings, value); err != nil {
19712				return err
19713			}
19714
19715		case "maximumTTL":
19716			if value != nil {
19717				jtv, ok := value.(json.Number)
19718				if !ok {
19719					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
19720				}
19721				i64, err := jtv.Int64()
19722				if err != nil {
19723					return err
19724				}
19725				sv.MaximumTTL = ptr.Int64(i64)
19726			}
19727
19728		case "minimumTTL":
19729			if value != nil {
19730				jtv, ok := value.(json.Number)
19731				if !ok {
19732					return fmt.Errorf("expected long to be json.Number, got %T instead", value)
19733				}
19734				i64, err := jtv.Int64()
19735				if err != nil {
19736					return err
19737				}
19738				sv.MinimumTTL = ptr.Int64(i64)
19739			}
19740
19741		default:
19742			_, _ = key, value
19743
19744		}
19745	}
19746	*v = sv
19747	return nil
19748}
19749
19750func awsAwsjson11_deserializeDocumentCertificate(v **types.Certificate, value interface{}) error {
19751	if v == nil {
19752		return fmt.Errorf("unexpected nil of type %T", v)
19753	}
19754	if value == nil {
19755		return nil
19756	}
19757
19758	shape, ok := value.(map[string]interface{})
19759	if !ok {
19760		return fmt.Errorf("unexpected JSON type %v", value)
19761	}
19762
19763	var sv *types.Certificate
19764	if *v == nil {
19765		sv = &types.Certificate{}
19766	} else {
19767		sv = *v
19768	}
19769
19770	for key, value := range shape {
19771		switch key {
19772		case "arn":
19773			if value != nil {
19774				jtv, ok := value.(string)
19775				if !ok {
19776					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
19777				}
19778				sv.Arn = ptr.String(jtv)
19779			}
19780
19781		case "createdAt":
19782			if value != nil {
19783				jtv, ok := value.(json.Number)
19784				if !ok {
19785					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19786				}
19787				f64, err := jtv.Float64()
19788				if err != nil {
19789					return err
19790				}
19791				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
19792			}
19793
19794		case "domainName":
19795			if value != nil {
19796				jtv, ok := value.(string)
19797				if !ok {
19798					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
19799				}
19800				sv.DomainName = ptr.String(jtv)
19801			}
19802
19803		case "domainValidationRecords":
19804			if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
19805				return err
19806			}
19807
19808		case "eligibleToRenew":
19809			if value != nil {
19810				jtv, ok := value.(string)
19811				if !ok {
19812					return fmt.Errorf("expected EligibleToRenew to be of type string, got %T instead", value)
19813				}
19814				sv.EligibleToRenew = ptr.String(jtv)
19815			}
19816
19817		case "inUseResourceCount":
19818			if value != nil {
19819				jtv, ok := value.(json.Number)
19820				if !ok {
19821					return fmt.Errorf("expected InUseResourceCount to be json.Number, got %T instead", value)
19822				}
19823				i64, err := jtv.Int64()
19824				if err != nil {
19825					return err
19826				}
19827				sv.InUseResourceCount = int32(i64)
19828			}
19829
19830		case "issuedAt":
19831			if value != nil {
19832				jtv, ok := value.(json.Number)
19833				if !ok {
19834					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19835				}
19836				f64, err := jtv.Float64()
19837				if err != nil {
19838					return err
19839				}
19840				sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
19841			}
19842
19843		case "issuerCA":
19844			if value != nil {
19845				jtv, ok := value.(string)
19846				if !ok {
19847					return fmt.Errorf("expected IssuerCA to be of type string, got %T instead", value)
19848				}
19849				sv.IssuerCA = ptr.String(jtv)
19850			}
19851
19852		case "keyAlgorithm":
19853			if value != nil {
19854				jtv, ok := value.(string)
19855				if !ok {
19856					return fmt.Errorf("expected KeyAlgorithm to be of type string, got %T instead", value)
19857				}
19858				sv.KeyAlgorithm = ptr.String(jtv)
19859			}
19860
19861		case "name":
19862			if value != nil {
19863				jtv, ok := value.(string)
19864				if !ok {
19865					return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
19866				}
19867				sv.Name = ptr.String(jtv)
19868			}
19869
19870		case "notAfter":
19871			if value != nil {
19872				jtv, ok := value.(json.Number)
19873				if !ok {
19874					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19875				}
19876				f64, err := jtv.Float64()
19877				if err != nil {
19878					return err
19879				}
19880				sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
19881			}
19882
19883		case "notBefore":
19884			if value != nil {
19885				jtv, ok := value.(json.Number)
19886				if !ok {
19887					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19888				}
19889				f64, err := jtv.Float64()
19890				if err != nil {
19891					return err
19892				}
19893				sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
19894			}
19895
19896		case "renewalSummary":
19897			if err := awsAwsjson11_deserializeDocumentRenewalSummary(&sv.RenewalSummary, value); err != nil {
19898				return err
19899			}
19900
19901		case "requestFailureReason":
19902			if value != nil {
19903				jtv, ok := value.(string)
19904				if !ok {
19905					return fmt.Errorf("expected RequestFailureReason to be of type string, got %T instead", value)
19906				}
19907				sv.RequestFailureReason = ptr.String(jtv)
19908			}
19909
19910		case "revocationReason":
19911			if value != nil {
19912				jtv, ok := value.(string)
19913				if !ok {
19914					return fmt.Errorf("expected RevocationReason to be of type string, got %T instead", value)
19915				}
19916				sv.RevocationReason = ptr.String(jtv)
19917			}
19918
19919		case "revokedAt":
19920			if value != nil {
19921				jtv, ok := value.(json.Number)
19922				if !ok {
19923					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
19924				}
19925				f64, err := jtv.Float64()
19926				if err != nil {
19927					return err
19928				}
19929				sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
19930			}
19931
19932		case "serialNumber":
19933			if value != nil {
19934				jtv, ok := value.(string)
19935				if !ok {
19936					return fmt.Errorf("expected SerialNumber to be of type string, got %T instead", value)
19937				}
19938				sv.SerialNumber = ptr.String(jtv)
19939			}
19940
19941		case "status":
19942			if value != nil {
19943				jtv, ok := value.(string)
19944				if !ok {
19945					return fmt.Errorf("expected CertificateStatus to be of type string, got %T instead", value)
19946				}
19947				sv.Status = types.CertificateStatus(jtv)
19948			}
19949
19950		case "subjectAlternativeNames":
19951			if err := awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(&sv.SubjectAlternativeNames, value); err != nil {
19952				return err
19953			}
19954
19955		case "supportCode":
19956			if value != nil {
19957				jtv, ok := value.(string)
19958				if !ok {
19959					return fmt.Errorf("expected string to be of type string, got %T instead", value)
19960				}
19961				sv.SupportCode = ptr.String(jtv)
19962			}
19963
19964		case "tags":
19965			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
19966				return err
19967			}
19968
19969		default:
19970			_, _ = key, value
19971
19972		}
19973	}
19974	*v = sv
19975	return nil
19976}
19977
19978func awsAwsjson11_deserializeDocumentCertificateSummary(v **types.CertificateSummary, value interface{}) error {
19979	if v == nil {
19980		return fmt.Errorf("unexpected nil of type %T", v)
19981	}
19982	if value == nil {
19983		return nil
19984	}
19985
19986	shape, ok := value.(map[string]interface{})
19987	if !ok {
19988		return fmt.Errorf("unexpected JSON type %v", value)
19989	}
19990
19991	var sv *types.CertificateSummary
19992	if *v == nil {
19993		sv = &types.CertificateSummary{}
19994	} else {
19995		sv = *v
19996	}
19997
19998	for key, value := range shape {
19999		switch key {
20000		case "certificateArn":
20001			if value != nil {
20002				jtv, ok := value.(string)
20003				if !ok {
20004					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20005				}
20006				sv.CertificateArn = ptr.String(jtv)
20007			}
20008
20009		case "certificateDetail":
20010			if err := awsAwsjson11_deserializeDocumentCertificate(&sv.CertificateDetail, value); err != nil {
20011				return err
20012			}
20013
20014		case "certificateName":
20015			if value != nil {
20016				jtv, ok := value.(string)
20017				if !ok {
20018					return fmt.Errorf("expected CertificateName to be of type string, got %T instead", value)
20019				}
20020				sv.CertificateName = ptr.String(jtv)
20021			}
20022
20023		case "domainName":
20024			if value != nil {
20025				jtv, ok := value.(string)
20026				if !ok {
20027					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
20028				}
20029				sv.DomainName = ptr.String(jtv)
20030			}
20031
20032		case "tags":
20033			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
20034				return err
20035			}
20036
20037		default:
20038			_, _ = key, value
20039
20040		}
20041	}
20042	*v = sv
20043	return nil
20044}
20045
20046func awsAwsjson11_deserializeDocumentCertificateSummaryList(v *[]types.CertificateSummary, value interface{}) error {
20047	if v == nil {
20048		return fmt.Errorf("unexpected nil of type %T", v)
20049	}
20050	if value == nil {
20051		return nil
20052	}
20053
20054	shape, ok := value.([]interface{})
20055	if !ok {
20056		return fmt.Errorf("unexpected JSON type %v", value)
20057	}
20058
20059	var cv []types.CertificateSummary
20060	if *v == nil {
20061		cv = []types.CertificateSummary{}
20062	} else {
20063		cv = *v
20064	}
20065
20066	for _, value := range shape {
20067		var col types.CertificateSummary
20068		destAddr := &col
20069		if err := awsAwsjson11_deserializeDocumentCertificateSummary(&destAddr, value); err != nil {
20070			return err
20071		}
20072		col = *destAddr
20073		cv = append(cv, col)
20074
20075	}
20076	*v = cv
20077	return nil
20078}
20079
20080func awsAwsjson11_deserializeDocumentCloudFormationStackRecord(v **types.CloudFormationStackRecord, value interface{}) error {
20081	if v == nil {
20082		return fmt.Errorf("unexpected nil of type %T", v)
20083	}
20084	if value == nil {
20085		return nil
20086	}
20087
20088	shape, ok := value.(map[string]interface{})
20089	if !ok {
20090		return fmt.Errorf("unexpected JSON type %v", value)
20091	}
20092
20093	var sv *types.CloudFormationStackRecord
20094	if *v == nil {
20095		sv = &types.CloudFormationStackRecord{}
20096	} else {
20097		sv = *v
20098	}
20099
20100	for key, value := range shape {
20101		switch key {
20102		case "arn":
20103			if value != nil {
20104				jtv, ok := value.(string)
20105				if !ok {
20106					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20107				}
20108				sv.Arn = ptr.String(jtv)
20109			}
20110
20111		case "createdAt":
20112			if value != nil {
20113				jtv, ok := value.(json.Number)
20114				if !ok {
20115					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
20116				}
20117				f64, err := jtv.Float64()
20118				if err != nil {
20119					return err
20120				}
20121				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20122			}
20123
20124		case "destinationInfo":
20125			if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
20126				return err
20127			}
20128
20129		case "location":
20130			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
20131				return err
20132			}
20133
20134		case "name":
20135			if value != nil {
20136				jtv, ok := value.(string)
20137				if !ok {
20138					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
20139				}
20140				sv.Name = ptr.String(jtv)
20141			}
20142
20143		case "resourceType":
20144			if value != nil {
20145				jtv, ok := value.(string)
20146				if !ok {
20147					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
20148				}
20149				sv.ResourceType = types.ResourceType(jtv)
20150			}
20151
20152		case "sourceInfo":
20153			if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(&sv.SourceInfo, value); err != nil {
20154				return err
20155			}
20156
20157		case "state":
20158			if value != nil {
20159				jtv, ok := value.(string)
20160				if !ok {
20161					return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
20162				}
20163				sv.State = types.RecordState(jtv)
20164			}
20165
20166		default:
20167			_, _ = key, value
20168
20169		}
20170	}
20171	*v = sv
20172	return nil
20173}
20174
20175func awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(v *[]types.CloudFormationStackRecord, value interface{}) error {
20176	if v == nil {
20177		return fmt.Errorf("unexpected nil of type %T", v)
20178	}
20179	if value == nil {
20180		return nil
20181	}
20182
20183	shape, ok := value.([]interface{})
20184	if !ok {
20185		return fmt.Errorf("unexpected JSON type %v", value)
20186	}
20187
20188	var cv []types.CloudFormationStackRecord
20189	if *v == nil {
20190		cv = []types.CloudFormationStackRecord{}
20191	} else {
20192		cv = *v
20193	}
20194
20195	for _, value := range shape {
20196		var col types.CloudFormationStackRecord
20197		destAddr := &col
20198		if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecord(&destAddr, value); err != nil {
20199			return err
20200		}
20201		col = *destAddr
20202		cv = append(cv, col)
20203
20204	}
20205	*v = cv
20206	return nil
20207}
20208
20209func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(v **types.CloudFormationStackRecordSourceInfo, value interface{}) error {
20210	if v == nil {
20211		return fmt.Errorf("unexpected nil of type %T", v)
20212	}
20213	if value == nil {
20214		return nil
20215	}
20216
20217	shape, ok := value.(map[string]interface{})
20218	if !ok {
20219		return fmt.Errorf("unexpected JSON type %v", value)
20220	}
20221
20222	var sv *types.CloudFormationStackRecordSourceInfo
20223	if *v == nil {
20224		sv = &types.CloudFormationStackRecordSourceInfo{}
20225	} else {
20226		sv = *v
20227	}
20228
20229	for key, value := range shape {
20230		switch key {
20231		case "arn":
20232			if value != nil {
20233				jtv, ok := value.(string)
20234				if !ok {
20235					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20236				}
20237				sv.Arn = ptr.String(jtv)
20238			}
20239
20240		case "name":
20241			if value != nil {
20242				jtv, ok := value.(string)
20243				if !ok {
20244					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20245				}
20246				sv.Name = ptr.String(jtv)
20247			}
20248
20249		case "resourceType":
20250			if value != nil {
20251				jtv, ok := value.(string)
20252				if !ok {
20253					return fmt.Errorf("expected CloudFormationStackRecordSourceType to be of type string, got %T instead", value)
20254				}
20255				sv.ResourceType = types.CloudFormationStackRecordSourceType(jtv)
20256			}
20257
20258		default:
20259			_, _ = key, value
20260
20261		}
20262	}
20263	*v = sv
20264	return nil
20265}
20266
20267func awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfoList(v *[]types.CloudFormationStackRecordSourceInfo, value interface{}) error {
20268	if v == nil {
20269		return fmt.Errorf("unexpected nil of type %T", v)
20270	}
20271	if value == nil {
20272		return nil
20273	}
20274
20275	shape, ok := value.([]interface{})
20276	if !ok {
20277		return fmt.Errorf("unexpected JSON type %v", value)
20278	}
20279
20280	var cv []types.CloudFormationStackRecordSourceInfo
20281	if *v == nil {
20282		cv = []types.CloudFormationStackRecordSourceInfo{}
20283	} else {
20284		cv = *v
20285	}
20286
20287	for _, value := range shape {
20288		var col types.CloudFormationStackRecordSourceInfo
20289		destAddr := &col
20290		if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordSourceInfo(&destAddr, value); err != nil {
20291			return err
20292		}
20293		col = *destAddr
20294		cv = append(cv, col)
20295
20296	}
20297	*v = cv
20298	return nil
20299}
20300
20301func awsAwsjson11_deserializeDocumentContactMethod(v **types.ContactMethod, value interface{}) error {
20302	if v == nil {
20303		return fmt.Errorf("unexpected nil of type %T", v)
20304	}
20305	if value == nil {
20306		return nil
20307	}
20308
20309	shape, ok := value.(map[string]interface{})
20310	if !ok {
20311		return fmt.Errorf("unexpected JSON type %v", value)
20312	}
20313
20314	var sv *types.ContactMethod
20315	if *v == nil {
20316		sv = &types.ContactMethod{}
20317	} else {
20318		sv = *v
20319	}
20320
20321	for key, value := range shape {
20322		switch key {
20323		case "arn":
20324			if value != nil {
20325				jtv, ok := value.(string)
20326				if !ok {
20327					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20328				}
20329				sv.Arn = ptr.String(jtv)
20330			}
20331
20332		case "contactEndpoint":
20333			if value != nil {
20334				jtv, ok := value.(string)
20335				if !ok {
20336					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20337				}
20338				sv.ContactEndpoint = ptr.String(jtv)
20339			}
20340
20341		case "createdAt":
20342			if value != nil {
20343				jtv, ok := value.(json.Number)
20344				if !ok {
20345					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
20346				}
20347				f64, err := jtv.Float64()
20348				if err != nil {
20349					return err
20350				}
20351				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20352			}
20353
20354		case "location":
20355			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
20356				return err
20357			}
20358
20359		case "name":
20360			if value != nil {
20361				jtv, ok := value.(string)
20362				if !ok {
20363					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
20364				}
20365				sv.Name = ptr.String(jtv)
20366			}
20367
20368		case "protocol":
20369			if value != nil {
20370				jtv, ok := value.(string)
20371				if !ok {
20372					return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
20373				}
20374				sv.Protocol = types.ContactProtocol(jtv)
20375			}
20376
20377		case "resourceType":
20378			if value != nil {
20379				jtv, ok := value.(string)
20380				if !ok {
20381					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
20382				}
20383				sv.ResourceType = types.ResourceType(jtv)
20384			}
20385
20386		case "status":
20387			if value != nil {
20388				jtv, ok := value.(string)
20389				if !ok {
20390					return fmt.Errorf("expected ContactMethodStatus to be of type string, got %T instead", value)
20391				}
20392				sv.Status = types.ContactMethodStatus(jtv)
20393			}
20394
20395		case "supportCode":
20396			if value != nil {
20397				jtv, ok := value.(string)
20398				if !ok {
20399					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20400				}
20401				sv.SupportCode = ptr.String(jtv)
20402			}
20403
20404		default:
20405			_, _ = key, value
20406
20407		}
20408	}
20409	*v = sv
20410	return nil
20411}
20412
20413func awsAwsjson11_deserializeDocumentContactMethodsList(v *[]types.ContactMethod, value interface{}) error {
20414	if v == nil {
20415		return fmt.Errorf("unexpected nil of type %T", v)
20416	}
20417	if value == nil {
20418		return nil
20419	}
20420
20421	shape, ok := value.([]interface{})
20422	if !ok {
20423		return fmt.Errorf("unexpected JSON type %v", value)
20424	}
20425
20426	var cv []types.ContactMethod
20427	if *v == nil {
20428		cv = []types.ContactMethod{}
20429	} else {
20430		cv = *v
20431	}
20432
20433	for _, value := range shape {
20434		var col types.ContactMethod
20435		destAddr := &col
20436		if err := awsAwsjson11_deserializeDocumentContactMethod(&destAddr, value); err != nil {
20437			return err
20438		}
20439		col = *destAddr
20440		cv = append(cv, col)
20441
20442	}
20443	*v = cv
20444	return nil
20445}
20446
20447func awsAwsjson11_deserializeDocumentContactProtocolsList(v *[]types.ContactProtocol, value interface{}) error {
20448	if v == nil {
20449		return fmt.Errorf("unexpected nil of type %T", v)
20450	}
20451	if value == nil {
20452		return nil
20453	}
20454
20455	shape, ok := value.([]interface{})
20456	if !ok {
20457		return fmt.Errorf("unexpected JSON type %v", value)
20458	}
20459
20460	var cv []types.ContactProtocol
20461	if *v == nil {
20462		cv = []types.ContactProtocol{}
20463	} else {
20464		cv = *v
20465	}
20466
20467	for _, value := range shape {
20468		var col types.ContactProtocol
20469		if value != nil {
20470			jtv, ok := value.(string)
20471			if !ok {
20472				return fmt.Errorf("expected ContactProtocol to be of type string, got %T instead", value)
20473			}
20474			col = types.ContactProtocol(jtv)
20475		}
20476		cv = append(cv, col)
20477
20478	}
20479	*v = cv
20480	return nil
20481}
20482
20483func awsAwsjson11_deserializeDocumentContainer(v **types.Container, value interface{}) error {
20484	if v == nil {
20485		return fmt.Errorf("unexpected nil of type %T", v)
20486	}
20487	if value == nil {
20488		return nil
20489	}
20490
20491	shape, ok := value.(map[string]interface{})
20492	if !ok {
20493		return fmt.Errorf("unexpected JSON type %v", value)
20494	}
20495
20496	var sv *types.Container
20497	if *v == nil {
20498		sv = &types.Container{}
20499	} else {
20500		sv = *v
20501	}
20502
20503	for key, value := range shape {
20504		switch key {
20505		case "command":
20506			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
20507				return err
20508			}
20509
20510		case "environment":
20511			if err := awsAwsjson11_deserializeDocumentEnvironment(&sv.Environment, value); err != nil {
20512				return err
20513			}
20514
20515		case "image":
20516			if value != nil {
20517				jtv, ok := value.(string)
20518				if !ok {
20519					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20520				}
20521				sv.Image = ptr.String(jtv)
20522			}
20523
20524		case "ports":
20525			if err := awsAwsjson11_deserializeDocumentPortMap(&sv.Ports, value); err != nil {
20526				return err
20527			}
20528
20529		default:
20530			_, _ = key, value
20531
20532		}
20533	}
20534	*v = sv
20535	return nil
20536}
20537
20538func awsAwsjson11_deserializeDocumentContainerImage(v **types.ContainerImage, value interface{}) error {
20539	if v == nil {
20540		return fmt.Errorf("unexpected nil of type %T", v)
20541	}
20542	if value == nil {
20543		return nil
20544	}
20545
20546	shape, ok := value.(map[string]interface{})
20547	if !ok {
20548		return fmt.Errorf("unexpected JSON type %v", value)
20549	}
20550
20551	var sv *types.ContainerImage
20552	if *v == nil {
20553		sv = &types.ContainerImage{}
20554	} else {
20555		sv = *v
20556	}
20557
20558	for key, value := range shape {
20559		switch key {
20560		case "createdAt":
20561			if value != nil {
20562				jtv, ok := value.(json.Number)
20563				if !ok {
20564					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
20565				}
20566				f64, err := jtv.Float64()
20567				if err != nil {
20568					return err
20569				}
20570				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20571			}
20572
20573		case "digest":
20574			if value != nil {
20575				jtv, ok := value.(string)
20576				if !ok {
20577					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20578				}
20579				sv.Digest = ptr.String(jtv)
20580			}
20581
20582		case "image":
20583			if value != nil {
20584				jtv, ok := value.(string)
20585				if !ok {
20586					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20587				}
20588				sv.Image = ptr.String(jtv)
20589			}
20590
20591		default:
20592			_, _ = key, value
20593
20594		}
20595	}
20596	*v = sv
20597	return nil
20598}
20599
20600func awsAwsjson11_deserializeDocumentContainerImageList(v *[]types.ContainerImage, value interface{}) error {
20601	if v == nil {
20602		return fmt.Errorf("unexpected nil of type %T", v)
20603	}
20604	if value == nil {
20605		return nil
20606	}
20607
20608	shape, ok := value.([]interface{})
20609	if !ok {
20610		return fmt.Errorf("unexpected JSON type %v", value)
20611	}
20612
20613	var cv []types.ContainerImage
20614	if *v == nil {
20615		cv = []types.ContainerImage{}
20616	} else {
20617		cv = *v
20618	}
20619
20620	for _, value := range shape {
20621		var col types.ContainerImage
20622		destAddr := &col
20623		if err := awsAwsjson11_deserializeDocumentContainerImage(&destAddr, value); err != nil {
20624			return err
20625		}
20626		col = *destAddr
20627		cv = append(cv, col)
20628
20629	}
20630	*v = cv
20631	return nil
20632}
20633
20634func awsAwsjson11_deserializeDocumentContainerMap(v *map[string]types.Container, value interface{}) error {
20635	if v == nil {
20636		return fmt.Errorf("unexpected nil of type %T", v)
20637	}
20638	if value == nil {
20639		return nil
20640	}
20641
20642	shape, ok := value.(map[string]interface{})
20643	if !ok {
20644		return fmt.Errorf("unexpected JSON type %v", value)
20645	}
20646
20647	var mv map[string]types.Container
20648	if *v == nil {
20649		mv = map[string]types.Container{}
20650	} else {
20651		mv = *v
20652	}
20653
20654	for key, value := range shape {
20655		var parsedVal types.Container
20656		mapVar := parsedVal
20657		destAddr := &mapVar
20658		if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil {
20659			return err
20660		}
20661		parsedVal = *destAddr
20662		mv[key] = parsedVal
20663
20664	}
20665	*v = mv
20666	return nil
20667}
20668
20669func awsAwsjson11_deserializeDocumentContainerService(v **types.ContainerService, value interface{}) error {
20670	if v == nil {
20671		return fmt.Errorf("unexpected nil of type %T", v)
20672	}
20673	if value == nil {
20674		return nil
20675	}
20676
20677	shape, ok := value.(map[string]interface{})
20678	if !ok {
20679		return fmt.Errorf("unexpected JSON type %v", value)
20680	}
20681
20682	var sv *types.ContainerService
20683	if *v == nil {
20684		sv = &types.ContainerService{}
20685	} else {
20686		sv = *v
20687	}
20688
20689	for key, value := range shape {
20690		switch key {
20691		case "arn":
20692			if value != nil {
20693				jtv, ok := value.(string)
20694				if !ok {
20695					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
20696				}
20697				sv.Arn = ptr.String(jtv)
20698			}
20699
20700		case "containerServiceName":
20701			if value != nil {
20702				jtv, ok := value.(string)
20703				if !ok {
20704					return fmt.Errorf("expected ContainerServiceName to be of type string, got %T instead", value)
20705				}
20706				sv.ContainerServiceName = ptr.String(jtv)
20707			}
20708
20709		case "createdAt":
20710			if value != nil {
20711				jtv, ok := value.(json.Number)
20712				if !ok {
20713					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
20714				}
20715				f64, err := jtv.Float64()
20716				if err != nil {
20717					return err
20718				}
20719				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20720			}
20721
20722		case "currentDeployment":
20723			if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.CurrentDeployment, value); err != nil {
20724				return err
20725			}
20726
20727		case "isDisabled":
20728			if value != nil {
20729				jtv, ok := value.(bool)
20730				if !ok {
20731					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
20732				}
20733				sv.IsDisabled = ptr.Bool(jtv)
20734			}
20735
20736		case "location":
20737			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
20738				return err
20739			}
20740
20741		case "nextDeployment":
20742			if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&sv.NextDeployment, value); err != nil {
20743				return err
20744			}
20745
20746		case "power":
20747			if value != nil {
20748				jtv, ok := value.(string)
20749				if !ok {
20750					return fmt.Errorf("expected ContainerServicePowerName to be of type string, got %T instead", value)
20751				}
20752				sv.Power = types.ContainerServicePowerName(jtv)
20753			}
20754
20755		case "powerId":
20756			if value != nil {
20757				jtv, ok := value.(string)
20758				if !ok {
20759					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20760				}
20761				sv.PowerId = ptr.String(jtv)
20762			}
20763
20764		case "principalArn":
20765			if value != nil {
20766				jtv, ok := value.(string)
20767				if !ok {
20768					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20769				}
20770				sv.PrincipalArn = ptr.String(jtv)
20771			}
20772
20773		case "privateDomainName":
20774			if value != nil {
20775				jtv, ok := value.(string)
20776				if !ok {
20777					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20778				}
20779				sv.PrivateDomainName = ptr.String(jtv)
20780			}
20781
20782		case "publicDomainNames":
20783			if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomains(&sv.PublicDomainNames, value); err != nil {
20784				return err
20785			}
20786
20787		case "resourceType":
20788			if value != nil {
20789				jtv, ok := value.(string)
20790				if !ok {
20791					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
20792				}
20793				sv.ResourceType = types.ResourceType(jtv)
20794			}
20795
20796		case "scale":
20797			if value != nil {
20798				jtv, ok := value.(json.Number)
20799				if !ok {
20800					return fmt.Errorf("expected ContainerServiceScale to be json.Number, got %T instead", value)
20801				}
20802				i64, err := jtv.Int64()
20803				if err != nil {
20804					return err
20805				}
20806				sv.Scale = ptr.Int32(int32(i64))
20807			}
20808
20809		case "state":
20810			if value != nil {
20811				jtv, ok := value.(string)
20812				if !ok {
20813					return fmt.Errorf("expected ContainerServiceState to be of type string, got %T instead", value)
20814				}
20815				sv.State = types.ContainerServiceState(jtv)
20816			}
20817
20818		case "stateDetail":
20819			if err := awsAwsjson11_deserializeDocumentContainerServiceStateDetail(&sv.StateDetail, value); err != nil {
20820				return err
20821			}
20822
20823		case "tags":
20824			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
20825				return err
20826			}
20827
20828		case "url":
20829			if value != nil {
20830				jtv, ok := value.(string)
20831				if !ok {
20832					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20833				}
20834				sv.Url = ptr.String(jtv)
20835			}
20836
20837		default:
20838			_, _ = key, value
20839
20840		}
20841	}
20842	*v = sv
20843	return nil
20844}
20845
20846func awsAwsjson11_deserializeDocumentContainerServiceDeployment(v **types.ContainerServiceDeployment, value interface{}) error {
20847	if v == nil {
20848		return fmt.Errorf("unexpected nil of type %T", v)
20849	}
20850	if value == nil {
20851		return nil
20852	}
20853
20854	shape, ok := value.(map[string]interface{})
20855	if !ok {
20856		return fmt.Errorf("unexpected JSON type %v", value)
20857	}
20858
20859	var sv *types.ContainerServiceDeployment
20860	if *v == nil {
20861		sv = &types.ContainerServiceDeployment{}
20862	} else {
20863		sv = *v
20864	}
20865
20866	for key, value := range shape {
20867		switch key {
20868		case "containers":
20869			if err := awsAwsjson11_deserializeDocumentContainerMap(&sv.Containers, value); err != nil {
20870				return err
20871			}
20872
20873		case "createdAt":
20874			if value != nil {
20875				jtv, ok := value.(json.Number)
20876				if !ok {
20877					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
20878				}
20879				f64, err := jtv.Float64()
20880				if err != nil {
20881					return err
20882				}
20883				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
20884			}
20885
20886		case "publicEndpoint":
20887			if err := awsAwsjson11_deserializeDocumentContainerServiceEndpoint(&sv.PublicEndpoint, value); err != nil {
20888				return err
20889			}
20890
20891		case "state":
20892			if value != nil {
20893				jtv, ok := value.(string)
20894				if !ok {
20895					return fmt.Errorf("expected ContainerServiceDeploymentState to be of type string, got %T instead", value)
20896				}
20897				sv.State = types.ContainerServiceDeploymentState(jtv)
20898			}
20899
20900		case "version":
20901			if value != nil {
20902				jtv, ok := value.(json.Number)
20903				if !ok {
20904					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20905				}
20906				i64, err := jtv.Int64()
20907				if err != nil {
20908					return err
20909				}
20910				sv.Version = ptr.Int32(int32(i64))
20911			}
20912
20913		default:
20914			_, _ = key, value
20915
20916		}
20917	}
20918	*v = sv
20919	return nil
20920}
20921
20922func awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(v *[]types.ContainerServiceDeployment, value interface{}) error {
20923	if v == nil {
20924		return fmt.Errorf("unexpected nil of type %T", v)
20925	}
20926	if value == nil {
20927		return nil
20928	}
20929
20930	shape, ok := value.([]interface{})
20931	if !ok {
20932		return fmt.Errorf("unexpected JSON type %v", value)
20933	}
20934
20935	var cv []types.ContainerServiceDeployment
20936	if *v == nil {
20937		cv = []types.ContainerServiceDeployment{}
20938	} else {
20939		cv = *v
20940	}
20941
20942	for _, value := range shape {
20943		var col types.ContainerServiceDeployment
20944		destAddr := &col
20945		if err := awsAwsjson11_deserializeDocumentContainerServiceDeployment(&destAddr, value); err != nil {
20946			return err
20947		}
20948		col = *destAddr
20949		cv = append(cv, col)
20950
20951	}
20952	*v = cv
20953	return nil
20954}
20955
20956func awsAwsjson11_deserializeDocumentContainerServiceEndpoint(v **types.ContainerServiceEndpoint, value interface{}) error {
20957	if v == nil {
20958		return fmt.Errorf("unexpected nil of type %T", v)
20959	}
20960	if value == nil {
20961		return nil
20962	}
20963
20964	shape, ok := value.(map[string]interface{})
20965	if !ok {
20966		return fmt.Errorf("unexpected JSON type %v", value)
20967	}
20968
20969	var sv *types.ContainerServiceEndpoint
20970	if *v == nil {
20971		sv = &types.ContainerServiceEndpoint{}
20972	} else {
20973		sv = *v
20974	}
20975
20976	for key, value := range shape {
20977		switch key {
20978		case "containerName":
20979			if value != nil {
20980				jtv, ok := value.(string)
20981				if !ok {
20982					return fmt.Errorf("expected string to be of type string, got %T instead", value)
20983				}
20984				sv.ContainerName = ptr.String(jtv)
20985			}
20986
20987		case "containerPort":
20988			if value != nil {
20989				jtv, ok := value.(json.Number)
20990				if !ok {
20991					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
20992				}
20993				i64, err := jtv.Int64()
20994				if err != nil {
20995					return err
20996				}
20997				sv.ContainerPort = ptr.Int32(int32(i64))
20998			}
20999
21000		case "healthCheck":
21001			if err := awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(&sv.HealthCheck, value); err != nil {
21002				return err
21003			}
21004
21005		default:
21006			_, _ = key, value
21007
21008		}
21009	}
21010	*v = sv
21011	return nil
21012}
21013
21014func awsAwsjson11_deserializeDocumentContainerServiceHealthCheckConfig(v **types.ContainerServiceHealthCheckConfig, value interface{}) error {
21015	if v == nil {
21016		return fmt.Errorf("unexpected nil of type %T", v)
21017	}
21018	if value == nil {
21019		return nil
21020	}
21021
21022	shape, ok := value.(map[string]interface{})
21023	if !ok {
21024		return fmt.Errorf("unexpected JSON type %v", value)
21025	}
21026
21027	var sv *types.ContainerServiceHealthCheckConfig
21028	if *v == nil {
21029		sv = &types.ContainerServiceHealthCheckConfig{}
21030	} else {
21031		sv = *v
21032	}
21033
21034	for key, value := range shape {
21035		switch key {
21036		case "healthyThreshold":
21037			if value != nil {
21038				jtv, ok := value.(json.Number)
21039				if !ok {
21040					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21041				}
21042				i64, err := jtv.Int64()
21043				if err != nil {
21044					return err
21045				}
21046				sv.HealthyThreshold = ptr.Int32(int32(i64))
21047			}
21048
21049		case "intervalSeconds":
21050			if value != nil {
21051				jtv, ok := value.(json.Number)
21052				if !ok {
21053					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21054				}
21055				i64, err := jtv.Int64()
21056				if err != nil {
21057					return err
21058				}
21059				sv.IntervalSeconds = ptr.Int32(int32(i64))
21060			}
21061
21062		case "path":
21063			if value != nil {
21064				jtv, ok := value.(string)
21065				if !ok {
21066					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21067				}
21068				sv.Path = ptr.String(jtv)
21069			}
21070
21071		case "successCodes":
21072			if value != nil {
21073				jtv, ok := value.(string)
21074				if !ok {
21075					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21076				}
21077				sv.SuccessCodes = ptr.String(jtv)
21078			}
21079
21080		case "timeoutSeconds":
21081			if value != nil {
21082				jtv, ok := value.(json.Number)
21083				if !ok {
21084					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21085				}
21086				i64, err := jtv.Int64()
21087				if err != nil {
21088					return err
21089				}
21090				sv.TimeoutSeconds = ptr.Int32(int32(i64))
21091			}
21092
21093		case "unhealthyThreshold":
21094			if value != nil {
21095				jtv, ok := value.(json.Number)
21096				if !ok {
21097					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21098				}
21099				i64, err := jtv.Int64()
21100				if err != nil {
21101					return err
21102				}
21103				sv.UnhealthyThreshold = ptr.Int32(int32(i64))
21104			}
21105
21106		default:
21107			_, _ = key, value
21108
21109		}
21110	}
21111	*v = sv
21112	return nil
21113}
21114
21115func awsAwsjson11_deserializeDocumentContainerServiceList(v *[]types.ContainerService, value interface{}) error {
21116	if v == nil {
21117		return fmt.Errorf("unexpected nil of type %T", v)
21118	}
21119	if value == nil {
21120		return nil
21121	}
21122
21123	shape, ok := value.([]interface{})
21124	if !ok {
21125		return fmt.Errorf("unexpected JSON type %v", value)
21126	}
21127
21128	var cv []types.ContainerService
21129	if *v == nil {
21130		cv = []types.ContainerService{}
21131	} else {
21132		cv = *v
21133	}
21134
21135	for _, value := range shape {
21136		var col types.ContainerService
21137		destAddr := &col
21138		if err := awsAwsjson11_deserializeDocumentContainerService(&destAddr, value); err != nil {
21139			return err
21140		}
21141		col = *destAddr
21142		cv = append(cv, col)
21143
21144	}
21145	*v = cv
21146	return nil
21147}
21148
21149func awsAwsjson11_deserializeDocumentContainerServiceLogEvent(v **types.ContainerServiceLogEvent, value interface{}) error {
21150	if v == nil {
21151		return fmt.Errorf("unexpected nil of type %T", v)
21152	}
21153	if value == nil {
21154		return nil
21155	}
21156
21157	shape, ok := value.(map[string]interface{})
21158	if !ok {
21159		return fmt.Errorf("unexpected JSON type %v", value)
21160	}
21161
21162	var sv *types.ContainerServiceLogEvent
21163	if *v == nil {
21164		sv = &types.ContainerServiceLogEvent{}
21165	} else {
21166		sv = *v
21167	}
21168
21169	for key, value := range shape {
21170		switch key {
21171		case "createdAt":
21172			if value != nil {
21173				jtv, ok := value.(json.Number)
21174				if !ok {
21175					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
21176				}
21177				f64, err := jtv.Float64()
21178				if err != nil {
21179					return err
21180				}
21181				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21182			}
21183
21184		case "message":
21185			if value != nil {
21186				jtv, ok := value.(string)
21187				if !ok {
21188					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21189				}
21190				sv.Message = ptr.String(jtv)
21191			}
21192
21193		default:
21194			_, _ = key, value
21195
21196		}
21197	}
21198	*v = sv
21199	return nil
21200}
21201
21202func awsAwsjson11_deserializeDocumentContainerServiceLogEventList(v *[]types.ContainerServiceLogEvent, value interface{}) error {
21203	if v == nil {
21204		return fmt.Errorf("unexpected nil of type %T", v)
21205	}
21206	if value == nil {
21207		return nil
21208	}
21209
21210	shape, ok := value.([]interface{})
21211	if !ok {
21212		return fmt.Errorf("unexpected JSON type %v", value)
21213	}
21214
21215	var cv []types.ContainerServiceLogEvent
21216	if *v == nil {
21217		cv = []types.ContainerServiceLogEvent{}
21218	} else {
21219		cv = *v
21220	}
21221
21222	for _, value := range shape {
21223		var col types.ContainerServiceLogEvent
21224		destAddr := &col
21225		if err := awsAwsjson11_deserializeDocumentContainerServiceLogEvent(&destAddr, value); err != nil {
21226			return err
21227		}
21228		col = *destAddr
21229		cv = append(cv, col)
21230
21231	}
21232	*v = cv
21233	return nil
21234}
21235
21236func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(v *map[string]string, value interface{}) error {
21237	if v == nil {
21238		return fmt.Errorf("unexpected nil of type %T", v)
21239	}
21240	if value == nil {
21241		return nil
21242	}
21243
21244	shape, ok := value.(map[string]interface{})
21245	if !ok {
21246		return fmt.Errorf("unexpected JSON type %v", value)
21247	}
21248
21249	var mv map[string]string
21250	if *v == nil {
21251		mv = map[string]string{}
21252	} else {
21253		mv = *v
21254	}
21255
21256	for key, value := range shape {
21257		var parsedVal string
21258		if value != nil {
21259			jtv, ok := value.(string)
21260			if !ok {
21261				return fmt.Errorf("expected string to be of type string, got %T instead", value)
21262			}
21263			parsedVal = jtv
21264		}
21265		mv[key] = parsedVal
21266
21267	}
21268	*v = mv
21269	return nil
21270}
21271
21272func awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(v *[]map[string]string, value interface{}) error {
21273	if v == nil {
21274		return fmt.Errorf("unexpected nil of type %T", v)
21275	}
21276	if value == nil {
21277		return nil
21278	}
21279
21280	shape, ok := value.([]interface{})
21281	if !ok {
21282		return fmt.Errorf("unexpected JSON type %v", value)
21283	}
21284
21285	var cv []map[string]string
21286	if *v == nil {
21287		cv = []map[string]string{}
21288	} else {
21289		cv = *v
21290	}
21291
21292	for _, value := range shape {
21293		var col map[string]string
21294		if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntry(&col, value); err != nil {
21295			return err
21296		}
21297		cv = append(cv, col)
21298
21299	}
21300	*v = cv
21301	return nil
21302}
21303
21304func awsAwsjson11_deserializeDocumentContainerServicePower(v **types.ContainerServicePower, value interface{}) error {
21305	if v == nil {
21306		return fmt.Errorf("unexpected nil of type %T", v)
21307	}
21308	if value == nil {
21309		return nil
21310	}
21311
21312	shape, ok := value.(map[string]interface{})
21313	if !ok {
21314		return fmt.Errorf("unexpected JSON type %v", value)
21315	}
21316
21317	var sv *types.ContainerServicePower
21318	if *v == nil {
21319		sv = &types.ContainerServicePower{}
21320	} else {
21321		sv = *v
21322	}
21323
21324	for key, value := range shape {
21325		switch key {
21326		case "cpuCount":
21327			if value != nil {
21328				jtv, ok := value.(json.Number)
21329				if !ok {
21330					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
21331				}
21332				f64, err := jtv.Float64()
21333				if err != nil {
21334					return err
21335				}
21336				sv.CpuCount = ptr.Float32(float32(f64))
21337			}
21338
21339		case "isActive":
21340			if value != nil {
21341				jtv, ok := value.(bool)
21342				if !ok {
21343					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21344				}
21345				sv.IsActive = ptr.Bool(jtv)
21346			}
21347
21348		case "name":
21349			if value != nil {
21350				jtv, ok := value.(string)
21351				if !ok {
21352					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21353				}
21354				sv.Name = ptr.String(jtv)
21355			}
21356
21357		case "powerId":
21358			if value != nil {
21359				jtv, ok := value.(string)
21360				if !ok {
21361					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21362				}
21363				sv.PowerId = ptr.String(jtv)
21364			}
21365
21366		case "price":
21367			if value != nil {
21368				jtv, ok := value.(json.Number)
21369				if !ok {
21370					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
21371				}
21372				f64, err := jtv.Float64()
21373				if err != nil {
21374					return err
21375				}
21376				sv.Price = ptr.Float32(float32(f64))
21377			}
21378
21379		case "ramSizeInGb":
21380			if value != nil {
21381				jtv, ok := value.(json.Number)
21382				if !ok {
21383					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
21384				}
21385				f64, err := jtv.Float64()
21386				if err != nil {
21387					return err
21388				}
21389				sv.RamSizeInGb = ptr.Float32(float32(f64))
21390			}
21391
21392		default:
21393			_, _ = key, value
21394
21395		}
21396	}
21397	*v = sv
21398	return nil
21399}
21400
21401func awsAwsjson11_deserializeDocumentContainerServicePowerList(v *[]types.ContainerServicePower, value interface{}) error {
21402	if v == nil {
21403		return fmt.Errorf("unexpected nil of type %T", v)
21404	}
21405	if value == nil {
21406		return nil
21407	}
21408
21409	shape, ok := value.([]interface{})
21410	if !ok {
21411		return fmt.Errorf("unexpected JSON type %v", value)
21412	}
21413
21414	var cv []types.ContainerServicePower
21415	if *v == nil {
21416		cv = []types.ContainerServicePower{}
21417	} else {
21418		cv = *v
21419	}
21420
21421	for _, value := range shape {
21422		var col types.ContainerServicePower
21423		destAddr := &col
21424		if err := awsAwsjson11_deserializeDocumentContainerServicePower(&destAddr, value); err != nil {
21425			return err
21426		}
21427		col = *destAddr
21428		cv = append(cv, col)
21429
21430	}
21431	*v = cv
21432	return nil
21433}
21434
21435func awsAwsjson11_deserializeDocumentContainerServicePublicDomains(v *map[string][]string, value interface{}) error {
21436	if v == nil {
21437		return fmt.Errorf("unexpected nil of type %T", v)
21438	}
21439	if value == nil {
21440		return nil
21441	}
21442
21443	shape, ok := value.(map[string]interface{})
21444	if !ok {
21445		return fmt.Errorf("unexpected JSON type %v", value)
21446	}
21447
21448	var mv map[string][]string
21449	if *v == nil {
21450		mv = map[string][]string{}
21451	} else {
21452		mv = *v
21453	}
21454
21455	for key, value := range shape {
21456		var parsedVal []string
21457		mapVar := parsedVal
21458		if err := awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(&mapVar, value); err != nil {
21459			return err
21460		}
21461		parsedVal = mapVar
21462		mv[key] = parsedVal
21463
21464	}
21465	*v = mv
21466	return nil
21467}
21468
21469func awsAwsjson11_deserializeDocumentContainerServicePublicDomainsList(v *[]string, value interface{}) error {
21470	if v == nil {
21471		return fmt.Errorf("unexpected nil of type %T", v)
21472	}
21473	if value == nil {
21474		return nil
21475	}
21476
21477	shape, ok := value.([]interface{})
21478	if !ok {
21479		return fmt.Errorf("unexpected JSON type %v", value)
21480	}
21481
21482	var cv []string
21483	if *v == nil {
21484		cv = []string{}
21485	} else {
21486		cv = *v
21487	}
21488
21489	for _, value := range shape {
21490		var col string
21491		if value != nil {
21492			jtv, ok := value.(string)
21493			if !ok {
21494				return fmt.Errorf("expected string to be of type string, got %T instead", value)
21495			}
21496			col = jtv
21497		}
21498		cv = append(cv, col)
21499
21500	}
21501	*v = cv
21502	return nil
21503}
21504
21505func awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(v **types.ContainerServiceRegistryLogin, value interface{}) error {
21506	if v == nil {
21507		return fmt.Errorf("unexpected nil of type %T", v)
21508	}
21509	if value == nil {
21510		return nil
21511	}
21512
21513	shape, ok := value.(map[string]interface{})
21514	if !ok {
21515		return fmt.Errorf("unexpected JSON type %v", value)
21516	}
21517
21518	var sv *types.ContainerServiceRegistryLogin
21519	if *v == nil {
21520		sv = &types.ContainerServiceRegistryLogin{}
21521	} else {
21522		sv = *v
21523	}
21524
21525	for key, value := range shape {
21526		switch key {
21527		case "expiresAt":
21528			if value != nil {
21529				jtv, ok := value.(json.Number)
21530				if !ok {
21531					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
21532				}
21533				f64, err := jtv.Float64()
21534				if err != nil {
21535					return err
21536				}
21537				sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21538			}
21539
21540		case "password":
21541			if value != nil {
21542				jtv, ok := value.(string)
21543				if !ok {
21544					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21545				}
21546				sv.Password = ptr.String(jtv)
21547			}
21548
21549		case "registry":
21550			if value != nil {
21551				jtv, ok := value.(string)
21552				if !ok {
21553					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21554				}
21555				sv.Registry = ptr.String(jtv)
21556			}
21557
21558		case "username":
21559			if value != nil {
21560				jtv, ok := value.(string)
21561				if !ok {
21562					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21563				}
21564				sv.Username = ptr.String(jtv)
21565			}
21566
21567		default:
21568			_, _ = key, value
21569
21570		}
21571	}
21572	*v = sv
21573	return nil
21574}
21575
21576func awsAwsjson11_deserializeDocumentContainerServiceStateDetail(v **types.ContainerServiceStateDetail, value interface{}) error {
21577	if v == nil {
21578		return fmt.Errorf("unexpected nil of type %T", v)
21579	}
21580	if value == nil {
21581		return nil
21582	}
21583
21584	shape, ok := value.(map[string]interface{})
21585	if !ok {
21586		return fmt.Errorf("unexpected JSON type %v", value)
21587	}
21588
21589	var sv *types.ContainerServiceStateDetail
21590	if *v == nil {
21591		sv = &types.ContainerServiceStateDetail{}
21592	} else {
21593		sv = *v
21594	}
21595
21596	for key, value := range shape {
21597		switch key {
21598		case "code":
21599			if value != nil {
21600				jtv, ok := value.(string)
21601				if !ok {
21602					return fmt.Errorf("expected ContainerServiceStateDetailCode to be of type string, got %T instead", value)
21603				}
21604				sv.Code = types.ContainerServiceStateDetailCode(jtv)
21605			}
21606
21607		case "message":
21608			if value != nil {
21609				jtv, ok := value.(string)
21610				if !ok {
21611					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21612				}
21613				sv.Message = ptr.String(jtv)
21614			}
21615
21616		default:
21617			_, _ = key, value
21618
21619		}
21620	}
21621	*v = sv
21622	return nil
21623}
21624
21625func awsAwsjson11_deserializeDocumentCookieObject(v **types.CookieObject, value interface{}) error {
21626	if v == nil {
21627		return fmt.Errorf("unexpected nil of type %T", v)
21628	}
21629	if value == nil {
21630		return nil
21631	}
21632
21633	shape, ok := value.(map[string]interface{})
21634	if !ok {
21635		return fmt.Errorf("unexpected JSON type %v", value)
21636	}
21637
21638	var sv *types.CookieObject
21639	if *v == nil {
21640		sv = &types.CookieObject{}
21641	} else {
21642		sv = *v
21643	}
21644
21645	for key, value := range shape {
21646		switch key {
21647		case "cookiesAllowList":
21648			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CookiesAllowList, value); err != nil {
21649				return err
21650			}
21651
21652		case "option":
21653			if value != nil {
21654				jtv, ok := value.(string)
21655				if !ok {
21656					return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
21657				}
21658				sv.Option = types.ForwardValues(jtv)
21659			}
21660
21661		default:
21662			_, _ = key, value
21663
21664		}
21665	}
21666	*v = sv
21667	return nil
21668}
21669
21670func awsAwsjson11_deserializeDocumentDestinationInfo(v **types.DestinationInfo, value interface{}) error {
21671	if v == nil {
21672		return fmt.Errorf("unexpected nil of type %T", v)
21673	}
21674	if value == nil {
21675		return nil
21676	}
21677
21678	shape, ok := value.(map[string]interface{})
21679	if !ok {
21680		return fmt.Errorf("unexpected JSON type %v", value)
21681	}
21682
21683	var sv *types.DestinationInfo
21684	if *v == nil {
21685		sv = &types.DestinationInfo{}
21686	} else {
21687		sv = *v
21688	}
21689
21690	for key, value := range shape {
21691		switch key {
21692		case "id":
21693			if value != nil {
21694				jtv, ok := value.(string)
21695				if !ok {
21696					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21697				}
21698				sv.Id = ptr.String(jtv)
21699			}
21700
21701		case "service":
21702			if value != nil {
21703				jtv, ok := value.(string)
21704				if !ok {
21705					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21706				}
21707				sv.Service = ptr.String(jtv)
21708			}
21709
21710		default:
21711			_, _ = key, value
21712
21713		}
21714	}
21715	*v = sv
21716	return nil
21717}
21718
21719func awsAwsjson11_deserializeDocumentDisk(v **types.Disk, value interface{}) error {
21720	if v == nil {
21721		return fmt.Errorf("unexpected nil of type %T", v)
21722	}
21723	if value == nil {
21724		return nil
21725	}
21726
21727	shape, ok := value.(map[string]interface{})
21728	if !ok {
21729		return fmt.Errorf("unexpected JSON type %v", value)
21730	}
21731
21732	var sv *types.Disk
21733	if *v == nil {
21734		sv = &types.Disk{}
21735	} else {
21736		sv = *v
21737	}
21738
21739	for key, value := range shape {
21740		switch key {
21741		case "addOns":
21742			if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
21743				return err
21744			}
21745
21746		case "arn":
21747			if value != nil {
21748				jtv, ok := value.(string)
21749				if !ok {
21750					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21751				}
21752				sv.Arn = ptr.String(jtv)
21753			}
21754
21755		case "attachedTo":
21756			if value != nil {
21757				jtv, ok := value.(string)
21758				if !ok {
21759					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
21760				}
21761				sv.AttachedTo = ptr.String(jtv)
21762			}
21763
21764		case "attachmentState":
21765			if value != nil {
21766				jtv, ok := value.(string)
21767				if !ok {
21768					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21769				}
21770				sv.AttachmentState = ptr.String(jtv)
21771			}
21772
21773		case "createdAt":
21774			if value != nil {
21775				jtv, ok := value.(json.Number)
21776				if !ok {
21777					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
21778				}
21779				f64, err := jtv.Float64()
21780				if err != nil {
21781					return err
21782				}
21783				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
21784			}
21785
21786		case "gbInUse":
21787			if value != nil {
21788				jtv, ok := value.(json.Number)
21789				if !ok {
21790					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21791				}
21792				i64, err := jtv.Int64()
21793				if err != nil {
21794					return err
21795				}
21796				sv.GbInUse = ptr.Int32(int32(i64))
21797			}
21798
21799		case "iops":
21800			if value != nil {
21801				jtv, ok := value.(json.Number)
21802				if !ok {
21803					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21804				}
21805				i64, err := jtv.Int64()
21806				if err != nil {
21807					return err
21808				}
21809				sv.Iops = ptr.Int32(int32(i64))
21810			}
21811
21812		case "isAttached":
21813			if value != nil {
21814				jtv, ok := value.(bool)
21815				if !ok {
21816					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21817				}
21818				sv.IsAttached = ptr.Bool(jtv)
21819			}
21820
21821		case "isSystemDisk":
21822			if value != nil {
21823				jtv, ok := value.(bool)
21824				if !ok {
21825					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21826				}
21827				sv.IsSystemDisk = ptr.Bool(jtv)
21828			}
21829
21830		case "location":
21831			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
21832				return err
21833			}
21834
21835		case "name":
21836			if value != nil {
21837				jtv, ok := value.(string)
21838				if !ok {
21839					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
21840				}
21841				sv.Name = ptr.String(jtv)
21842			}
21843
21844		case "path":
21845			if value != nil {
21846				jtv, ok := value.(string)
21847				if !ok {
21848					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21849				}
21850				sv.Path = ptr.String(jtv)
21851			}
21852
21853		case "resourceType":
21854			if value != nil {
21855				jtv, ok := value.(string)
21856				if !ok {
21857					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
21858				}
21859				sv.ResourceType = types.ResourceType(jtv)
21860			}
21861
21862		case "sizeInGb":
21863			if value != nil {
21864				jtv, ok := value.(json.Number)
21865				if !ok {
21866					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21867				}
21868				i64, err := jtv.Int64()
21869				if err != nil {
21870					return err
21871				}
21872				sv.SizeInGb = ptr.Int32(int32(i64))
21873			}
21874
21875		case "state":
21876			if value != nil {
21877				jtv, ok := value.(string)
21878				if !ok {
21879					return fmt.Errorf("expected DiskState to be of type string, got %T instead", value)
21880				}
21881				sv.State = types.DiskState(jtv)
21882			}
21883
21884		case "supportCode":
21885			if value != nil {
21886				jtv, ok := value.(string)
21887				if !ok {
21888					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21889				}
21890				sv.SupportCode = ptr.String(jtv)
21891			}
21892
21893		case "tags":
21894			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
21895				return err
21896			}
21897
21898		default:
21899			_, _ = key, value
21900
21901		}
21902	}
21903	*v = sv
21904	return nil
21905}
21906
21907func awsAwsjson11_deserializeDocumentDiskInfo(v **types.DiskInfo, value interface{}) error {
21908	if v == nil {
21909		return fmt.Errorf("unexpected nil of type %T", v)
21910	}
21911	if value == nil {
21912		return nil
21913	}
21914
21915	shape, ok := value.(map[string]interface{})
21916	if !ok {
21917		return fmt.Errorf("unexpected JSON type %v", value)
21918	}
21919
21920	var sv *types.DiskInfo
21921	if *v == nil {
21922		sv = &types.DiskInfo{}
21923	} else {
21924		sv = *v
21925	}
21926
21927	for key, value := range shape {
21928		switch key {
21929		case "isSystemDisk":
21930			if value != nil {
21931				jtv, ok := value.(bool)
21932				if !ok {
21933					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
21934				}
21935				sv.IsSystemDisk = ptr.Bool(jtv)
21936			}
21937
21938		case "name":
21939			if value != nil {
21940				jtv, ok := value.(string)
21941				if !ok {
21942					return fmt.Errorf("expected string to be of type string, got %T instead", value)
21943				}
21944				sv.Name = ptr.String(jtv)
21945			}
21946
21947		case "path":
21948			if value != nil {
21949				jtv, ok := value.(string)
21950				if !ok {
21951					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
21952				}
21953				sv.Path = ptr.String(jtv)
21954			}
21955
21956		case "sizeInGb":
21957			if value != nil {
21958				jtv, ok := value.(json.Number)
21959				if !ok {
21960					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
21961				}
21962				i64, err := jtv.Int64()
21963				if err != nil {
21964					return err
21965				}
21966				sv.SizeInGb = ptr.Int32(int32(i64))
21967			}
21968
21969		default:
21970			_, _ = key, value
21971
21972		}
21973	}
21974	*v = sv
21975	return nil
21976}
21977
21978func awsAwsjson11_deserializeDocumentDiskInfoList(v *[]types.DiskInfo, value interface{}) error {
21979	if v == nil {
21980		return fmt.Errorf("unexpected nil of type %T", v)
21981	}
21982	if value == nil {
21983		return nil
21984	}
21985
21986	shape, ok := value.([]interface{})
21987	if !ok {
21988		return fmt.Errorf("unexpected JSON type %v", value)
21989	}
21990
21991	var cv []types.DiskInfo
21992	if *v == nil {
21993		cv = []types.DiskInfo{}
21994	} else {
21995		cv = *v
21996	}
21997
21998	for _, value := range shape {
21999		var col types.DiskInfo
22000		destAddr := &col
22001		if err := awsAwsjson11_deserializeDocumentDiskInfo(&destAddr, value); err != nil {
22002			return err
22003		}
22004		col = *destAddr
22005		cv = append(cv, col)
22006
22007	}
22008	*v = cv
22009	return nil
22010}
22011
22012func awsAwsjson11_deserializeDocumentDiskList(v *[]types.Disk, value interface{}) error {
22013	if v == nil {
22014		return fmt.Errorf("unexpected nil of type %T", v)
22015	}
22016	if value == nil {
22017		return nil
22018	}
22019
22020	shape, ok := value.([]interface{})
22021	if !ok {
22022		return fmt.Errorf("unexpected JSON type %v", value)
22023	}
22024
22025	var cv []types.Disk
22026	if *v == nil {
22027		cv = []types.Disk{}
22028	} else {
22029		cv = *v
22030	}
22031
22032	for _, value := range shape {
22033		var col types.Disk
22034		destAddr := &col
22035		if err := awsAwsjson11_deserializeDocumentDisk(&destAddr, value); err != nil {
22036			return err
22037		}
22038		col = *destAddr
22039		cv = append(cv, col)
22040
22041	}
22042	*v = cv
22043	return nil
22044}
22045
22046func awsAwsjson11_deserializeDocumentDiskSnapshot(v **types.DiskSnapshot, value interface{}) error {
22047	if v == nil {
22048		return fmt.Errorf("unexpected nil of type %T", v)
22049	}
22050	if value == nil {
22051		return nil
22052	}
22053
22054	shape, ok := value.(map[string]interface{})
22055	if !ok {
22056		return fmt.Errorf("unexpected JSON type %v", value)
22057	}
22058
22059	var sv *types.DiskSnapshot
22060	if *v == nil {
22061		sv = &types.DiskSnapshot{}
22062	} else {
22063		sv = *v
22064	}
22065
22066	for key, value := range shape {
22067		switch key {
22068		case "arn":
22069			if value != nil {
22070				jtv, ok := value.(string)
22071				if !ok {
22072					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22073				}
22074				sv.Arn = ptr.String(jtv)
22075			}
22076
22077		case "createdAt":
22078			if value != nil {
22079				jtv, ok := value.(json.Number)
22080				if !ok {
22081					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
22082				}
22083				f64, err := jtv.Float64()
22084				if err != nil {
22085					return err
22086				}
22087				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22088			}
22089
22090		case "fromDiskArn":
22091			if value != nil {
22092				jtv, ok := value.(string)
22093				if !ok {
22094					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22095				}
22096				sv.FromDiskArn = ptr.String(jtv)
22097			}
22098
22099		case "fromDiskName":
22100			if value != nil {
22101				jtv, ok := value.(string)
22102				if !ok {
22103					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22104				}
22105				sv.FromDiskName = ptr.String(jtv)
22106			}
22107
22108		case "fromInstanceArn":
22109			if value != nil {
22110				jtv, ok := value.(string)
22111				if !ok {
22112					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22113				}
22114				sv.FromInstanceArn = ptr.String(jtv)
22115			}
22116
22117		case "fromInstanceName":
22118			if value != nil {
22119				jtv, ok := value.(string)
22120				if !ok {
22121					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22122				}
22123				sv.FromInstanceName = ptr.String(jtv)
22124			}
22125
22126		case "isFromAutoSnapshot":
22127			if value != nil {
22128				jtv, ok := value.(bool)
22129				if !ok {
22130					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22131				}
22132				sv.IsFromAutoSnapshot = ptr.Bool(jtv)
22133			}
22134
22135		case "location":
22136			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22137				return err
22138			}
22139
22140		case "name":
22141			if value != nil {
22142				jtv, ok := value.(string)
22143				if !ok {
22144					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22145				}
22146				sv.Name = ptr.String(jtv)
22147			}
22148
22149		case "progress":
22150			if value != nil {
22151				jtv, ok := value.(string)
22152				if !ok {
22153					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22154				}
22155				sv.Progress = ptr.String(jtv)
22156			}
22157
22158		case "resourceType":
22159			if value != nil {
22160				jtv, ok := value.(string)
22161				if !ok {
22162					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22163				}
22164				sv.ResourceType = types.ResourceType(jtv)
22165			}
22166
22167		case "sizeInGb":
22168			if value != nil {
22169				jtv, ok := value.(json.Number)
22170				if !ok {
22171					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22172				}
22173				i64, err := jtv.Int64()
22174				if err != nil {
22175					return err
22176				}
22177				sv.SizeInGb = ptr.Int32(int32(i64))
22178			}
22179
22180		case "state":
22181			if value != nil {
22182				jtv, ok := value.(string)
22183				if !ok {
22184					return fmt.Errorf("expected DiskSnapshotState to be of type string, got %T instead", value)
22185				}
22186				sv.State = types.DiskSnapshotState(jtv)
22187			}
22188
22189		case "supportCode":
22190			if value != nil {
22191				jtv, ok := value.(string)
22192				if !ok {
22193					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22194				}
22195				sv.SupportCode = ptr.String(jtv)
22196			}
22197
22198		case "tags":
22199			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22200				return err
22201			}
22202
22203		default:
22204			_, _ = key, value
22205
22206		}
22207	}
22208	*v = sv
22209	return nil
22210}
22211
22212func awsAwsjson11_deserializeDocumentDiskSnapshotInfo(v **types.DiskSnapshotInfo, value interface{}) error {
22213	if v == nil {
22214		return fmt.Errorf("unexpected nil of type %T", v)
22215	}
22216	if value == nil {
22217		return nil
22218	}
22219
22220	shape, ok := value.(map[string]interface{})
22221	if !ok {
22222		return fmt.Errorf("unexpected JSON type %v", value)
22223	}
22224
22225	var sv *types.DiskSnapshotInfo
22226	if *v == nil {
22227		sv = &types.DiskSnapshotInfo{}
22228	} else {
22229		sv = *v
22230	}
22231
22232	for key, value := range shape {
22233		switch key {
22234		case "sizeInGb":
22235			if value != nil {
22236				jtv, ok := value.(json.Number)
22237				if !ok {
22238					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22239				}
22240				i64, err := jtv.Int64()
22241				if err != nil {
22242					return err
22243				}
22244				sv.SizeInGb = ptr.Int32(int32(i64))
22245			}
22246
22247		default:
22248			_, _ = key, value
22249
22250		}
22251	}
22252	*v = sv
22253	return nil
22254}
22255
22256func awsAwsjson11_deserializeDocumentDiskSnapshotList(v *[]types.DiskSnapshot, value interface{}) error {
22257	if v == nil {
22258		return fmt.Errorf("unexpected nil of type %T", v)
22259	}
22260	if value == nil {
22261		return nil
22262	}
22263
22264	shape, ok := value.([]interface{})
22265	if !ok {
22266		return fmt.Errorf("unexpected JSON type %v", value)
22267	}
22268
22269	var cv []types.DiskSnapshot
22270	if *v == nil {
22271		cv = []types.DiskSnapshot{}
22272	} else {
22273		cv = *v
22274	}
22275
22276	for _, value := range shape {
22277		var col types.DiskSnapshot
22278		destAddr := &col
22279		if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&destAddr, value); err != nil {
22280			return err
22281		}
22282		col = *destAddr
22283		cv = append(cv, col)
22284
22285	}
22286	*v = cv
22287	return nil
22288}
22289
22290func awsAwsjson11_deserializeDocumentDistributionBundle(v **types.DistributionBundle, value interface{}) error {
22291	if v == nil {
22292		return fmt.Errorf("unexpected nil of type %T", v)
22293	}
22294	if value == nil {
22295		return nil
22296	}
22297
22298	shape, ok := value.(map[string]interface{})
22299	if !ok {
22300		return fmt.Errorf("unexpected JSON type %v", value)
22301	}
22302
22303	var sv *types.DistributionBundle
22304	if *v == nil {
22305		sv = &types.DistributionBundle{}
22306	} else {
22307		sv = *v
22308	}
22309
22310	for key, value := range shape {
22311		switch key {
22312		case "bundleId":
22313			if value != nil {
22314				jtv, ok := value.(string)
22315				if !ok {
22316					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22317				}
22318				sv.BundleId = ptr.String(jtv)
22319			}
22320
22321		case "isActive":
22322			if value != nil {
22323				jtv, ok := value.(bool)
22324				if !ok {
22325					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22326				}
22327				sv.IsActive = ptr.Bool(jtv)
22328			}
22329
22330		case "name":
22331			if value != nil {
22332				jtv, ok := value.(string)
22333				if !ok {
22334					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22335				}
22336				sv.Name = ptr.String(jtv)
22337			}
22338
22339		case "price":
22340			if value != nil {
22341				jtv, ok := value.(json.Number)
22342				if !ok {
22343					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
22344				}
22345				f64, err := jtv.Float64()
22346				if err != nil {
22347					return err
22348				}
22349				sv.Price = ptr.Float32(float32(f64))
22350			}
22351
22352		case "transferPerMonthInGb":
22353			if value != nil {
22354				jtv, ok := value.(json.Number)
22355				if !ok {
22356					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
22357				}
22358				i64, err := jtv.Int64()
22359				if err != nil {
22360					return err
22361				}
22362				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
22363			}
22364
22365		default:
22366			_, _ = key, value
22367
22368		}
22369	}
22370	*v = sv
22371	return nil
22372}
22373
22374func awsAwsjson11_deserializeDocumentDistributionBundleList(v *[]types.DistributionBundle, value interface{}) error {
22375	if v == nil {
22376		return fmt.Errorf("unexpected nil of type %T", v)
22377	}
22378	if value == nil {
22379		return nil
22380	}
22381
22382	shape, ok := value.([]interface{})
22383	if !ok {
22384		return fmt.Errorf("unexpected JSON type %v", value)
22385	}
22386
22387	var cv []types.DistributionBundle
22388	if *v == nil {
22389		cv = []types.DistributionBundle{}
22390	} else {
22391		cv = *v
22392	}
22393
22394	for _, value := range shape {
22395		var col types.DistributionBundle
22396		destAddr := &col
22397		if err := awsAwsjson11_deserializeDocumentDistributionBundle(&destAddr, value); err != nil {
22398			return err
22399		}
22400		col = *destAddr
22401		cv = append(cv, col)
22402
22403	}
22404	*v = cv
22405	return nil
22406}
22407
22408func awsAwsjson11_deserializeDocumentDistributionList(v *[]types.LightsailDistribution, value interface{}) error {
22409	if v == nil {
22410		return fmt.Errorf("unexpected nil of type %T", v)
22411	}
22412	if value == nil {
22413		return nil
22414	}
22415
22416	shape, ok := value.([]interface{})
22417	if !ok {
22418		return fmt.Errorf("unexpected JSON type %v", value)
22419	}
22420
22421	var cv []types.LightsailDistribution
22422	if *v == nil {
22423		cv = []types.LightsailDistribution{}
22424	} else {
22425		cv = *v
22426	}
22427
22428	for _, value := range shape {
22429		var col types.LightsailDistribution
22430		destAddr := &col
22431		if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&destAddr, value); err != nil {
22432			return err
22433		}
22434		col = *destAddr
22435		cv = append(cv, col)
22436
22437	}
22438	*v = cv
22439	return nil
22440}
22441
22442func awsAwsjson11_deserializeDocumentDomain(v **types.Domain, value interface{}) error {
22443	if v == nil {
22444		return fmt.Errorf("unexpected nil of type %T", v)
22445	}
22446	if value == nil {
22447		return nil
22448	}
22449
22450	shape, ok := value.(map[string]interface{})
22451	if !ok {
22452		return fmt.Errorf("unexpected JSON type %v", value)
22453	}
22454
22455	var sv *types.Domain
22456	if *v == nil {
22457		sv = &types.Domain{}
22458	} else {
22459		sv = *v
22460	}
22461
22462	for key, value := range shape {
22463		switch key {
22464		case "arn":
22465			if value != nil {
22466				jtv, ok := value.(string)
22467				if !ok {
22468					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22469				}
22470				sv.Arn = ptr.String(jtv)
22471			}
22472
22473		case "createdAt":
22474			if value != nil {
22475				jtv, ok := value.(json.Number)
22476				if !ok {
22477					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
22478				}
22479				f64, err := jtv.Float64()
22480				if err != nil {
22481					return err
22482				}
22483				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22484			}
22485
22486		case "domainEntries":
22487			if err := awsAwsjson11_deserializeDocumentDomainEntryList(&sv.DomainEntries, value); err != nil {
22488				return err
22489			}
22490
22491		case "location":
22492			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22493				return err
22494			}
22495
22496		case "name":
22497			if value != nil {
22498				jtv, ok := value.(string)
22499				if !ok {
22500					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22501				}
22502				sv.Name = ptr.String(jtv)
22503			}
22504
22505		case "resourceType":
22506			if value != nil {
22507				jtv, ok := value.(string)
22508				if !ok {
22509					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22510				}
22511				sv.ResourceType = types.ResourceType(jtv)
22512			}
22513
22514		case "supportCode":
22515			if value != nil {
22516				jtv, ok := value.(string)
22517				if !ok {
22518					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22519				}
22520				sv.SupportCode = ptr.String(jtv)
22521			}
22522
22523		case "tags":
22524			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
22525				return err
22526			}
22527
22528		default:
22529			_, _ = key, value
22530
22531		}
22532	}
22533	*v = sv
22534	return nil
22535}
22536
22537func awsAwsjson11_deserializeDocumentDomainEntry(v **types.DomainEntry, value interface{}) error {
22538	if v == nil {
22539		return fmt.Errorf("unexpected nil of type %T", v)
22540	}
22541	if value == nil {
22542		return nil
22543	}
22544
22545	shape, ok := value.(map[string]interface{})
22546	if !ok {
22547		return fmt.Errorf("unexpected JSON type %v", value)
22548	}
22549
22550	var sv *types.DomainEntry
22551	if *v == nil {
22552		sv = &types.DomainEntry{}
22553	} else {
22554		sv = *v
22555	}
22556
22557	for key, value := range shape {
22558		switch key {
22559		case "id":
22560			if value != nil {
22561				jtv, ok := value.(string)
22562				if !ok {
22563					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22564				}
22565				sv.Id = ptr.String(jtv)
22566			}
22567
22568		case "isAlias":
22569			if value != nil {
22570				jtv, ok := value.(bool)
22571				if !ok {
22572					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
22573				}
22574				sv.IsAlias = ptr.Bool(jtv)
22575			}
22576
22577		case "name":
22578			if value != nil {
22579				jtv, ok := value.(string)
22580				if !ok {
22581					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
22582				}
22583				sv.Name = ptr.String(jtv)
22584			}
22585
22586		case "options":
22587			if err := awsAwsjson11_deserializeDocumentDomainEntryOptions(&sv.Options, value); err != nil {
22588				return err
22589			}
22590
22591		case "target":
22592			if value != nil {
22593				jtv, ok := value.(string)
22594				if !ok {
22595					return fmt.Errorf("expected string to be of type string, got %T instead", value)
22596				}
22597				sv.Target = ptr.String(jtv)
22598			}
22599
22600		case "type":
22601			if value != nil {
22602				jtv, ok := value.(string)
22603				if !ok {
22604					return fmt.Errorf("expected DomainEntryType to be of type string, got %T instead", value)
22605				}
22606				sv.Type = ptr.String(jtv)
22607			}
22608
22609		default:
22610			_, _ = key, value
22611
22612		}
22613	}
22614	*v = sv
22615	return nil
22616}
22617
22618func awsAwsjson11_deserializeDocumentDomainEntryList(v *[]types.DomainEntry, value interface{}) error {
22619	if v == nil {
22620		return fmt.Errorf("unexpected nil of type %T", v)
22621	}
22622	if value == nil {
22623		return nil
22624	}
22625
22626	shape, ok := value.([]interface{})
22627	if !ok {
22628		return fmt.Errorf("unexpected JSON type %v", value)
22629	}
22630
22631	var cv []types.DomainEntry
22632	if *v == nil {
22633		cv = []types.DomainEntry{}
22634	} else {
22635		cv = *v
22636	}
22637
22638	for _, value := range shape {
22639		var col types.DomainEntry
22640		destAddr := &col
22641		if err := awsAwsjson11_deserializeDocumentDomainEntry(&destAddr, value); err != nil {
22642			return err
22643		}
22644		col = *destAddr
22645		cv = append(cv, col)
22646
22647	}
22648	*v = cv
22649	return nil
22650}
22651
22652func awsAwsjson11_deserializeDocumentDomainEntryOptions(v *map[string]string, value interface{}) error {
22653	if v == nil {
22654		return fmt.Errorf("unexpected nil of type %T", v)
22655	}
22656	if value == nil {
22657		return nil
22658	}
22659
22660	shape, ok := value.(map[string]interface{})
22661	if !ok {
22662		return fmt.Errorf("unexpected JSON type %v", value)
22663	}
22664
22665	var mv map[string]string
22666	if *v == nil {
22667		mv = map[string]string{}
22668	} else {
22669		mv = *v
22670	}
22671
22672	for key, value := range shape {
22673		var parsedVal string
22674		if value != nil {
22675			jtv, ok := value.(string)
22676			if !ok {
22677				return fmt.Errorf("expected string to be of type string, got %T instead", value)
22678			}
22679			parsedVal = jtv
22680		}
22681		mv[key] = parsedVal
22682
22683	}
22684	*v = mv
22685	return nil
22686}
22687
22688func awsAwsjson11_deserializeDocumentDomainList(v *[]types.Domain, value interface{}) error {
22689	if v == nil {
22690		return fmt.Errorf("unexpected nil of type %T", v)
22691	}
22692	if value == nil {
22693		return nil
22694	}
22695
22696	shape, ok := value.([]interface{})
22697	if !ok {
22698		return fmt.Errorf("unexpected JSON type %v", value)
22699	}
22700
22701	var cv []types.Domain
22702	if *v == nil {
22703		cv = []types.Domain{}
22704	} else {
22705		cv = *v
22706	}
22707
22708	for _, value := range shape {
22709		var col types.Domain
22710		destAddr := &col
22711		if err := awsAwsjson11_deserializeDocumentDomain(&destAddr, value); err != nil {
22712			return err
22713		}
22714		col = *destAddr
22715		cv = append(cv, col)
22716
22717	}
22718	*v = cv
22719	return nil
22720}
22721
22722func awsAwsjson11_deserializeDocumentDomainValidationRecord(v **types.DomainValidationRecord, value interface{}) error {
22723	if v == nil {
22724		return fmt.Errorf("unexpected nil of type %T", v)
22725	}
22726	if value == nil {
22727		return nil
22728	}
22729
22730	shape, ok := value.(map[string]interface{})
22731	if !ok {
22732		return fmt.Errorf("unexpected JSON type %v", value)
22733	}
22734
22735	var sv *types.DomainValidationRecord
22736	if *v == nil {
22737		sv = &types.DomainValidationRecord{}
22738	} else {
22739		sv = *v
22740	}
22741
22742	for key, value := range shape {
22743		switch key {
22744		case "domainName":
22745			if value != nil {
22746				jtv, ok := value.(string)
22747				if !ok {
22748					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
22749				}
22750				sv.DomainName = ptr.String(jtv)
22751			}
22752
22753		case "resourceRecord":
22754			if err := awsAwsjson11_deserializeDocumentResourceRecord(&sv.ResourceRecord, value); err != nil {
22755				return err
22756			}
22757
22758		default:
22759			_, _ = key, value
22760
22761		}
22762	}
22763	*v = sv
22764	return nil
22765}
22766
22767func awsAwsjson11_deserializeDocumentDomainValidationRecordList(v *[]types.DomainValidationRecord, value interface{}) error {
22768	if v == nil {
22769		return fmt.Errorf("unexpected nil of type %T", v)
22770	}
22771	if value == nil {
22772		return nil
22773	}
22774
22775	shape, ok := value.([]interface{})
22776	if !ok {
22777		return fmt.Errorf("unexpected JSON type %v", value)
22778	}
22779
22780	var cv []types.DomainValidationRecord
22781	if *v == nil {
22782		cv = []types.DomainValidationRecord{}
22783	} else {
22784		cv = *v
22785	}
22786
22787	for _, value := range shape {
22788		var col types.DomainValidationRecord
22789		destAddr := &col
22790		if err := awsAwsjson11_deserializeDocumentDomainValidationRecord(&destAddr, value); err != nil {
22791			return err
22792		}
22793		col = *destAddr
22794		cv = append(cv, col)
22795
22796	}
22797	*v = cv
22798	return nil
22799}
22800
22801func awsAwsjson11_deserializeDocumentEnvironment(v *map[string]string, value interface{}) error {
22802	if v == nil {
22803		return fmt.Errorf("unexpected nil of type %T", v)
22804	}
22805	if value == nil {
22806		return nil
22807	}
22808
22809	shape, ok := value.(map[string]interface{})
22810	if !ok {
22811		return fmt.Errorf("unexpected JSON type %v", value)
22812	}
22813
22814	var mv map[string]string
22815	if *v == nil {
22816		mv = map[string]string{}
22817	} else {
22818		mv = *v
22819	}
22820
22821	for key, value := range shape {
22822		var parsedVal string
22823		if value != nil {
22824			jtv, ok := value.(string)
22825			if !ok {
22826				return fmt.Errorf("expected string to be of type string, got %T instead", value)
22827			}
22828			parsedVal = jtv
22829		}
22830		mv[key] = parsedVal
22831
22832	}
22833	*v = mv
22834	return nil
22835}
22836
22837func awsAwsjson11_deserializeDocumentExportSnapshotRecord(v **types.ExportSnapshotRecord, value interface{}) error {
22838	if v == nil {
22839		return fmt.Errorf("unexpected nil of type %T", v)
22840	}
22841	if value == nil {
22842		return nil
22843	}
22844
22845	shape, ok := value.(map[string]interface{})
22846	if !ok {
22847		return fmt.Errorf("unexpected JSON type %v", value)
22848	}
22849
22850	var sv *types.ExportSnapshotRecord
22851	if *v == nil {
22852		sv = &types.ExportSnapshotRecord{}
22853	} else {
22854		sv = *v
22855	}
22856
22857	for key, value := range shape {
22858		switch key {
22859		case "arn":
22860			if value != nil {
22861				jtv, ok := value.(string)
22862				if !ok {
22863					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22864				}
22865				sv.Arn = ptr.String(jtv)
22866			}
22867
22868		case "createdAt":
22869			if value != nil {
22870				jtv, ok := value.(json.Number)
22871				if !ok {
22872					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
22873				}
22874				f64, err := jtv.Float64()
22875				if err != nil {
22876					return err
22877				}
22878				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
22879			}
22880
22881		case "destinationInfo":
22882			if err := awsAwsjson11_deserializeDocumentDestinationInfo(&sv.DestinationInfo, value); err != nil {
22883				return err
22884			}
22885
22886		case "location":
22887			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
22888				return err
22889			}
22890
22891		case "name":
22892			if value != nil {
22893				jtv, ok := value.(string)
22894				if !ok {
22895					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
22896				}
22897				sv.Name = ptr.String(jtv)
22898			}
22899
22900		case "resourceType":
22901			if value != nil {
22902				jtv, ok := value.(string)
22903				if !ok {
22904					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
22905				}
22906				sv.ResourceType = types.ResourceType(jtv)
22907			}
22908
22909		case "sourceInfo":
22910			if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(&sv.SourceInfo, value); err != nil {
22911				return err
22912			}
22913
22914		case "state":
22915			if value != nil {
22916				jtv, ok := value.(string)
22917				if !ok {
22918					return fmt.Errorf("expected RecordState to be of type string, got %T instead", value)
22919				}
22920				sv.State = types.RecordState(jtv)
22921			}
22922
22923		default:
22924			_, _ = key, value
22925
22926		}
22927	}
22928	*v = sv
22929	return nil
22930}
22931
22932func awsAwsjson11_deserializeDocumentExportSnapshotRecordList(v *[]types.ExportSnapshotRecord, value interface{}) error {
22933	if v == nil {
22934		return fmt.Errorf("unexpected nil of type %T", v)
22935	}
22936	if value == nil {
22937		return nil
22938	}
22939
22940	shape, ok := value.([]interface{})
22941	if !ok {
22942		return fmt.Errorf("unexpected JSON type %v", value)
22943	}
22944
22945	var cv []types.ExportSnapshotRecord
22946	if *v == nil {
22947		cv = []types.ExportSnapshotRecord{}
22948	} else {
22949		cv = *v
22950	}
22951
22952	for _, value := range shape {
22953		var col types.ExportSnapshotRecord
22954		destAddr := &col
22955		if err := awsAwsjson11_deserializeDocumentExportSnapshotRecord(&destAddr, value); err != nil {
22956			return err
22957		}
22958		col = *destAddr
22959		cv = append(cv, col)
22960
22961	}
22962	*v = cv
22963	return nil
22964}
22965
22966func awsAwsjson11_deserializeDocumentExportSnapshotRecordSourceInfo(v **types.ExportSnapshotRecordSourceInfo, value interface{}) error {
22967	if v == nil {
22968		return fmt.Errorf("unexpected nil of type %T", v)
22969	}
22970	if value == nil {
22971		return nil
22972	}
22973
22974	shape, ok := value.(map[string]interface{})
22975	if !ok {
22976		return fmt.Errorf("unexpected JSON type %v", value)
22977	}
22978
22979	var sv *types.ExportSnapshotRecordSourceInfo
22980	if *v == nil {
22981		sv = &types.ExportSnapshotRecordSourceInfo{}
22982	} else {
22983		sv = *v
22984	}
22985
22986	for key, value := range shape {
22987		switch key {
22988		case "arn":
22989			if value != nil {
22990				jtv, ok := value.(string)
22991				if !ok {
22992					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
22993				}
22994				sv.Arn = ptr.String(jtv)
22995			}
22996
22997		case "createdAt":
22998			if value != nil {
22999				jtv, ok := value.(json.Number)
23000				if !ok {
23001					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23002				}
23003				f64, err := jtv.Float64()
23004				if err != nil {
23005					return err
23006				}
23007				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23008			}
23009
23010		case "diskSnapshotInfo":
23011			if err := awsAwsjson11_deserializeDocumentDiskSnapshotInfo(&sv.DiskSnapshotInfo, value); err != nil {
23012				return err
23013			}
23014
23015		case "fromResourceArn":
23016			if value != nil {
23017				jtv, ok := value.(string)
23018				if !ok {
23019					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23020				}
23021				sv.FromResourceArn = ptr.String(jtv)
23022			}
23023
23024		case "fromResourceName":
23025			if value != nil {
23026				jtv, ok := value.(string)
23027				if !ok {
23028					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23029				}
23030				sv.FromResourceName = ptr.String(jtv)
23031			}
23032
23033		case "instanceSnapshotInfo":
23034			if err := awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(&sv.InstanceSnapshotInfo, value); err != nil {
23035				return err
23036			}
23037
23038		case "name":
23039			if value != nil {
23040				jtv, ok := value.(string)
23041				if !ok {
23042					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23043				}
23044				sv.Name = ptr.String(jtv)
23045			}
23046
23047		case "resourceType":
23048			if value != nil {
23049				jtv, ok := value.(string)
23050				if !ok {
23051					return fmt.Errorf("expected ExportSnapshotRecordSourceType to be of type string, got %T instead", value)
23052				}
23053				sv.ResourceType = types.ExportSnapshotRecordSourceType(jtv)
23054			}
23055
23056		default:
23057			_, _ = key, value
23058
23059		}
23060	}
23061	*v = sv
23062	return nil
23063}
23064
23065func awsAwsjson11_deserializeDocumentHeaderForwardList(v *[]types.HeaderEnum, value interface{}) error {
23066	if v == nil {
23067		return fmt.Errorf("unexpected nil of type %T", v)
23068	}
23069	if value == nil {
23070		return nil
23071	}
23072
23073	shape, ok := value.([]interface{})
23074	if !ok {
23075		return fmt.Errorf("unexpected JSON type %v", value)
23076	}
23077
23078	var cv []types.HeaderEnum
23079	if *v == nil {
23080		cv = []types.HeaderEnum{}
23081	} else {
23082		cv = *v
23083	}
23084
23085	for _, value := range shape {
23086		var col types.HeaderEnum
23087		if value != nil {
23088			jtv, ok := value.(string)
23089			if !ok {
23090				return fmt.Errorf("expected HeaderEnum to be of type string, got %T instead", value)
23091			}
23092			col = types.HeaderEnum(jtv)
23093		}
23094		cv = append(cv, col)
23095
23096	}
23097	*v = cv
23098	return nil
23099}
23100
23101func awsAwsjson11_deserializeDocumentHeaderObject(v **types.HeaderObject, value interface{}) error {
23102	if v == nil {
23103		return fmt.Errorf("unexpected nil of type %T", v)
23104	}
23105	if value == nil {
23106		return nil
23107	}
23108
23109	shape, ok := value.(map[string]interface{})
23110	if !ok {
23111		return fmt.Errorf("unexpected JSON type %v", value)
23112	}
23113
23114	var sv *types.HeaderObject
23115	if *v == nil {
23116		sv = &types.HeaderObject{}
23117	} else {
23118		sv = *v
23119	}
23120
23121	for key, value := range shape {
23122		switch key {
23123		case "headersAllowList":
23124			if err := awsAwsjson11_deserializeDocumentHeaderForwardList(&sv.HeadersAllowList, value); err != nil {
23125				return err
23126			}
23127
23128		case "option":
23129			if value != nil {
23130				jtv, ok := value.(string)
23131				if !ok {
23132					return fmt.Errorf("expected ForwardValues to be of type string, got %T instead", value)
23133				}
23134				sv.Option = types.ForwardValues(jtv)
23135			}
23136
23137		default:
23138			_, _ = key, value
23139
23140		}
23141	}
23142	*v = sv
23143	return nil
23144}
23145
23146func awsAwsjson11_deserializeDocumentHostKeyAttributes(v **types.HostKeyAttributes, value interface{}) error {
23147	if v == nil {
23148		return fmt.Errorf("unexpected nil of type %T", v)
23149	}
23150	if value == nil {
23151		return nil
23152	}
23153
23154	shape, ok := value.(map[string]interface{})
23155	if !ok {
23156		return fmt.Errorf("unexpected JSON type %v", value)
23157	}
23158
23159	var sv *types.HostKeyAttributes
23160	if *v == nil {
23161		sv = &types.HostKeyAttributes{}
23162	} else {
23163		sv = *v
23164	}
23165
23166	for key, value := range shape {
23167		switch key {
23168		case "algorithm":
23169			if value != nil {
23170				jtv, ok := value.(string)
23171				if !ok {
23172					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23173				}
23174				sv.Algorithm = ptr.String(jtv)
23175			}
23176
23177		case "fingerprintSHA1":
23178			if value != nil {
23179				jtv, ok := value.(string)
23180				if !ok {
23181					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23182				}
23183				sv.FingerprintSHA1 = ptr.String(jtv)
23184			}
23185
23186		case "fingerprintSHA256":
23187			if value != nil {
23188				jtv, ok := value.(string)
23189				if !ok {
23190					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23191				}
23192				sv.FingerprintSHA256 = ptr.String(jtv)
23193			}
23194
23195		case "notValidAfter":
23196			if value != nil {
23197				jtv, ok := value.(json.Number)
23198				if !ok {
23199					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23200				}
23201				f64, err := jtv.Float64()
23202				if err != nil {
23203					return err
23204				}
23205				sv.NotValidAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
23206			}
23207
23208		case "notValidBefore":
23209			if value != nil {
23210				jtv, ok := value.(json.Number)
23211				if !ok {
23212					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23213				}
23214				f64, err := jtv.Float64()
23215				if err != nil {
23216					return err
23217				}
23218				sv.NotValidBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
23219			}
23220
23221		case "publicKey":
23222			if value != nil {
23223				jtv, ok := value.(string)
23224				if !ok {
23225					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23226				}
23227				sv.PublicKey = ptr.String(jtv)
23228			}
23229
23230		case "witnessedAt":
23231			if value != nil {
23232				jtv, ok := value.(json.Number)
23233				if !ok {
23234					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23235				}
23236				f64, err := jtv.Float64()
23237				if err != nil {
23238					return err
23239				}
23240				sv.WitnessedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23241			}
23242
23243		default:
23244			_, _ = key, value
23245
23246		}
23247	}
23248	*v = sv
23249	return nil
23250}
23251
23252func awsAwsjson11_deserializeDocumentHostKeysList(v *[]types.HostKeyAttributes, value interface{}) error {
23253	if v == nil {
23254		return fmt.Errorf("unexpected nil of type %T", v)
23255	}
23256	if value == nil {
23257		return nil
23258	}
23259
23260	shape, ok := value.([]interface{})
23261	if !ok {
23262		return fmt.Errorf("unexpected JSON type %v", value)
23263	}
23264
23265	var cv []types.HostKeyAttributes
23266	if *v == nil {
23267		cv = []types.HostKeyAttributes{}
23268	} else {
23269		cv = *v
23270	}
23271
23272	for _, value := range shape {
23273		var col types.HostKeyAttributes
23274		destAddr := &col
23275		if err := awsAwsjson11_deserializeDocumentHostKeyAttributes(&destAddr, value); err != nil {
23276			return err
23277		}
23278		col = *destAddr
23279		cv = append(cv, col)
23280
23281	}
23282	*v = cv
23283	return nil
23284}
23285
23286func awsAwsjson11_deserializeDocumentInstance(v **types.Instance, value interface{}) error {
23287	if v == nil {
23288		return fmt.Errorf("unexpected nil of type %T", v)
23289	}
23290	if value == nil {
23291		return nil
23292	}
23293
23294	shape, ok := value.(map[string]interface{})
23295	if !ok {
23296		return fmt.Errorf("unexpected JSON type %v", value)
23297	}
23298
23299	var sv *types.Instance
23300	if *v == nil {
23301		sv = &types.Instance{}
23302	} else {
23303		sv = *v
23304	}
23305
23306	for key, value := range shape {
23307		switch key {
23308		case "addOns":
23309			if err := awsAwsjson11_deserializeDocumentAddOnList(&sv.AddOns, value); err != nil {
23310				return err
23311			}
23312
23313		case "arn":
23314			if value != nil {
23315				jtv, ok := value.(string)
23316				if !ok {
23317					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23318				}
23319				sv.Arn = ptr.String(jtv)
23320			}
23321
23322		case "blueprintId":
23323			if value != nil {
23324				jtv, ok := value.(string)
23325				if !ok {
23326					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23327				}
23328				sv.BlueprintId = ptr.String(jtv)
23329			}
23330
23331		case "blueprintName":
23332			if value != nil {
23333				jtv, ok := value.(string)
23334				if !ok {
23335					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23336				}
23337				sv.BlueprintName = ptr.String(jtv)
23338			}
23339
23340		case "bundleId":
23341			if value != nil {
23342				jtv, ok := value.(string)
23343				if !ok {
23344					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23345				}
23346				sv.BundleId = ptr.String(jtv)
23347			}
23348
23349		case "createdAt":
23350			if value != nil {
23351				jtv, ok := value.(json.Number)
23352				if !ok {
23353					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23354				}
23355				f64, err := jtv.Float64()
23356				if err != nil {
23357					return err
23358				}
23359				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23360			}
23361
23362		case "hardware":
23363			if err := awsAwsjson11_deserializeDocumentInstanceHardware(&sv.Hardware, value); err != nil {
23364				return err
23365			}
23366
23367		case "ipAddressType":
23368			if value != nil {
23369				jtv, ok := value.(string)
23370				if !ok {
23371					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
23372				}
23373				sv.IpAddressType = types.IpAddressType(jtv)
23374			}
23375
23376		case "ipv6Addresses":
23377			if err := awsAwsjson11_deserializeDocumentIpv6AddressList(&sv.Ipv6Addresses, value); err != nil {
23378				return err
23379			}
23380
23381		case "isStaticIp":
23382			if value != nil {
23383				jtv, ok := value.(bool)
23384				if !ok {
23385					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
23386				}
23387				sv.IsStaticIp = ptr.Bool(jtv)
23388			}
23389
23390		case "location":
23391			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
23392				return err
23393			}
23394
23395		case "name":
23396			if value != nil {
23397				jtv, ok := value.(string)
23398				if !ok {
23399					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
23400				}
23401				sv.Name = ptr.String(jtv)
23402			}
23403
23404		case "networking":
23405			if err := awsAwsjson11_deserializeDocumentInstanceNetworking(&sv.Networking, value); err != nil {
23406				return err
23407			}
23408
23409		case "privateIpAddress":
23410			if value != nil {
23411				jtv, ok := value.(string)
23412				if !ok {
23413					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
23414				}
23415				sv.PrivateIpAddress = ptr.String(jtv)
23416			}
23417
23418		case "publicIpAddress":
23419			if value != nil {
23420				jtv, ok := value.(string)
23421				if !ok {
23422					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
23423				}
23424				sv.PublicIpAddress = ptr.String(jtv)
23425			}
23426
23427		case "resourceType":
23428			if value != nil {
23429				jtv, ok := value.(string)
23430				if !ok {
23431					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
23432				}
23433				sv.ResourceType = types.ResourceType(jtv)
23434			}
23435
23436		case "sshKeyName":
23437			if value != nil {
23438				jtv, ok := value.(string)
23439				if !ok {
23440					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
23441				}
23442				sv.SshKeyName = ptr.String(jtv)
23443			}
23444
23445		case "state":
23446			if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
23447				return err
23448			}
23449
23450		case "supportCode":
23451			if value != nil {
23452				jtv, ok := value.(string)
23453				if !ok {
23454					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23455				}
23456				sv.SupportCode = ptr.String(jtv)
23457			}
23458
23459		case "tags":
23460			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
23461				return err
23462			}
23463
23464		case "username":
23465			if value != nil {
23466				jtv, ok := value.(string)
23467				if !ok {
23468					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
23469				}
23470				sv.Username = ptr.String(jtv)
23471			}
23472
23473		default:
23474			_, _ = key, value
23475
23476		}
23477	}
23478	*v = sv
23479	return nil
23480}
23481
23482func awsAwsjson11_deserializeDocumentInstanceAccessDetails(v **types.InstanceAccessDetails, value interface{}) error {
23483	if v == nil {
23484		return fmt.Errorf("unexpected nil of type %T", v)
23485	}
23486	if value == nil {
23487		return nil
23488	}
23489
23490	shape, ok := value.(map[string]interface{})
23491	if !ok {
23492		return fmt.Errorf("unexpected JSON type %v", value)
23493	}
23494
23495	var sv *types.InstanceAccessDetails
23496	if *v == nil {
23497		sv = &types.InstanceAccessDetails{}
23498	} else {
23499		sv = *v
23500	}
23501
23502	for key, value := range shape {
23503		switch key {
23504		case "certKey":
23505			if value != nil {
23506				jtv, ok := value.(string)
23507				if !ok {
23508					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23509				}
23510				sv.CertKey = ptr.String(jtv)
23511			}
23512
23513		case "expiresAt":
23514			if value != nil {
23515				jtv, ok := value.(json.Number)
23516				if !ok {
23517					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
23518				}
23519				f64, err := jtv.Float64()
23520				if err != nil {
23521					return err
23522				}
23523				sv.ExpiresAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
23524			}
23525
23526		case "hostKeys":
23527			if err := awsAwsjson11_deserializeDocumentHostKeysList(&sv.HostKeys, value); err != nil {
23528				return err
23529			}
23530
23531		case "instanceName":
23532			if value != nil {
23533				jtv, ok := value.(string)
23534				if !ok {
23535					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
23536				}
23537				sv.InstanceName = ptr.String(jtv)
23538			}
23539
23540		case "ipAddress":
23541			if value != nil {
23542				jtv, ok := value.(string)
23543				if !ok {
23544					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
23545				}
23546				sv.IpAddress = ptr.String(jtv)
23547			}
23548
23549		case "password":
23550			if value != nil {
23551				jtv, ok := value.(string)
23552				if !ok {
23553					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23554				}
23555				sv.Password = ptr.String(jtv)
23556			}
23557
23558		case "passwordData":
23559			if err := awsAwsjson11_deserializeDocumentPasswordData(&sv.PasswordData, value); err != nil {
23560				return err
23561			}
23562
23563		case "privateKey":
23564			if value != nil {
23565				jtv, ok := value.(string)
23566				if !ok {
23567					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23568				}
23569				sv.PrivateKey = ptr.String(jtv)
23570			}
23571
23572		case "protocol":
23573			if value != nil {
23574				jtv, ok := value.(string)
23575				if !ok {
23576					return fmt.Errorf("expected InstanceAccessProtocol to be of type string, got %T instead", value)
23577				}
23578				sv.Protocol = types.InstanceAccessProtocol(jtv)
23579			}
23580
23581		case "username":
23582			if value != nil {
23583				jtv, ok := value.(string)
23584				if !ok {
23585					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23586				}
23587				sv.Username = ptr.String(jtv)
23588			}
23589
23590		default:
23591			_, _ = key, value
23592
23593		}
23594	}
23595	*v = sv
23596	return nil
23597}
23598
23599func awsAwsjson11_deserializeDocumentInstanceHardware(v **types.InstanceHardware, value interface{}) error {
23600	if v == nil {
23601		return fmt.Errorf("unexpected nil of type %T", v)
23602	}
23603	if value == nil {
23604		return nil
23605	}
23606
23607	shape, ok := value.(map[string]interface{})
23608	if !ok {
23609		return fmt.Errorf("unexpected JSON type %v", value)
23610	}
23611
23612	var sv *types.InstanceHardware
23613	if *v == nil {
23614		sv = &types.InstanceHardware{}
23615	} else {
23616		sv = *v
23617	}
23618
23619	for key, value := range shape {
23620		switch key {
23621		case "cpuCount":
23622			if value != nil {
23623				jtv, ok := value.(json.Number)
23624				if !ok {
23625					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
23626				}
23627				i64, err := jtv.Int64()
23628				if err != nil {
23629					return err
23630				}
23631				sv.CpuCount = ptr.Int32(int32(i64))
23632			}
23633
23634		case "disks":
23635			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
23636				return err
23637			}
23638
23639		case "ramSizeInGb":
23640			if value != nil {
23641				jtv, ok := value.(json.Number)
23642				if !ok {
23643					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
23644				}
23645				f64, err := jtv.Float64()
23646				if err != nil {
23647					return err
23648				}
23649				sv.RamSizeInGb = ptr.Float32(float32(f64))
23650			}
23651
23652		default:
23653			_, _ = key, value
23654
23655		}
23656	}
23657	*v = sv
23658	return nil
23659}
23660
23661func awsAwsjson11_deserializeDocumentInstanceHealthSummary(v **types.InstanceHealthSummary, value interface{}) error {
23662	if v == nil {
23663		return fmt.Errorf("unexpected nil of type %T", v)
23664	}
23665	if value == nil {
23666		return nil
23667	}
23668
23669	shape, ok := value.(map[string]interface{})
23670	if !ok {
23671		return fmt.Errorf("unexpected JSON type %v", value)
23672	}
23673
23674	var sv *types.InstanceHealthSummary
23675	if *v == nil {
23676		sv = &types.InstanceHealthSummary{}
23677	} else {
23678		sv = *v
23679	}
23680
23681	for key, value := range shape {
23682		switch key {
23683		case "instanceHealth":
23684			if value != nil {
23685				jtv, ok := value.(string)
23686				if !ok {
23687					return fmt.Errorf("expected InstanceHealthState to be of type string, got %T instead", value)
23688				}
23689				sv.InstanceHealth = types.InstanceHealthState(jtv)
23690			}
23691
23692		case "instanceHealthReason":
23693			if value != nil {
23694				jtv, ok := value.(string)
23695				if !ok {
23696					return fmt.Errorf("expected InstanceHealthReason to be of type string, got %T instead", value)
23697				}
23698				sv.InstanceHealthReason = types.InstanceHealthReason(jtv)
23699			}
23700
23701		case "instanceName":
23702			if value != nil {
23703				jtv, ok := value.(string)
23704				if !ok {
23705					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
23706				}
23707				sv.InstanceName = ptr.String(jtv)
23708			}
23709
23710		default:
23711			_, _ = key, value
23712
23713		}
23714	}
23715	*v = sv
23716	return nil
23717}
23718
23719func awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(v *[]types.InstanceHealthSummary, value interface{}) error {
23720	if v == nil {
23721		return fmt.Errorf("unexpected nil of type %T", v)
23722	}
23723	if value == nil {
23724		return nil
23725	}
23726
23727	shape, ok := value.([]interface{})
23728	if !ok {
23729		return fmt.Errorf("unexpected JSON type %v", value)
23730	}
23731
23732	var cv []types.InstanceHealthSummary
23733	if *v == nil {
23734		cv = []types.InstanceHealthSummary{}
23735	} else {
23736		cv = *v
23737	}
23738
23739	for _, value := range shape {
23740		var col types.InstanceHealthSummary
23741		destAddr := &col
23742		if err := awsAwsjson11_deserializeDocumentInstanceHealthSummary(&destAddr, value); err != nil {
23743			return err
23744		}
23745		col = *destAddr
23746		cv = append(cv, col)
23747
23748	}
23749	*v = cv
23750	return nil
23751}
23752
23753func awsAwsjson11_deserializeDocumentInstanceList(v *[]types.Instance, value interface{}) error {
23754	if v == nil {
23755		return fmt.Errorf("unexpected nil of type %T", v)
23756	}
23757	if value == nil {
23758		return nil
23759	}
23760
23761	shape, ok := value.([]interface{})
23762	if !ok {
23763		return fmt.Errorf("unexpected JSON type %v", value)
23764	}
23765
23766	var cv []types.Instance
23767	if *v == nil {
23768		cv = []types.Instance{}
23769	} else {
23770		cv = *v
23771	}
23772
23773	for _, value := range shape {
23774		var col types.Instance
23775		destAddr := &col
23776		if err := awsAwsjson11_deserializeDocumentInstance(&destAddr, value); err != nil {
23777			return err
23778		}
23779		col = *destAddr
23780		cv = append(cv, col)
23781
23782	}
23783	*v = cv
23784	return nil
23785}
23786
23787func awsAwsjson11_deserializeDocumentInstanceNetworking(v **types.InstanceNetworking, value interface{}) error {
23788	if v == nil {
23789		return fmt.Errorf("unexpected nil of type %T", v)
23790	}
23791	if value == nil {
23792		return nil
23793	}
23794
23795	shape, ok := value.(map[string]interface{})
23796	if !ok {
23797		return fmt.Errorf("unexpected JSON type %v", value)
23798	}
23799
23800	var sv *types.InstanceNetworking
23801	if *v == nil {
23802		sv = &types.InstanceNetworking{}
23803	} else {
23804		sv = *v
23805	}
23806
23807	for key, value := range shape {
23808		switch key {
23809		case "monthlyTransfer":
23810			if err := awsAwsjson11_deserializeDocumentMonthlyTransfer(&sv.MonthlyTransfer, value); err != nil {
23811				return err
23812			}
23813
23814		case "ports":
23815			if err := awsAwsjson11_deserializeDocumentInstancePortInfoList(&sv.Ports, value); err != nil {
23816				return err
23817			}
23818
23819		default:
23820			_, _ = key, value
23821
23822		}
23823	}
23824	*v = sv
23825	return nil
23826}
23827
23828func awsAwsjson11_deserializeDocumentInstancePlatformList(v *[]types.InstancePlatform, value interface{}) error {
23829	if v == nil {
23830		return fmt.Errorf("unexpected nil of type %T", v)
23831	}
23832	if value == nil {
23833		return nil
23834	}
23835
23836	shape, ok := value.([]interface{})
23837	if !ok {
23838		return fmt.Errorf("unexpected JSON type %v", value)
23839	}
23840
23841	var cv []types.InstancePlatform
23842	if *v == nil {
23843		cv = []types.InstancePlatform{}
23844	} else {
23845		cv = *v
23846	}
23847
23848	for _, value := range shape {
23849		var col types.InstancePlatform
23850		if value != nil {
23851			jtv, ok := value.(string)
23852			if !ok {
23853				return fmt.Errorf("expected InstancePlatform to be of type string, got %T instead", value)
23854			}
23855			col = types.InstancePlatform(jtv)
23856		}
23857		cv = append(cv, col)
23858
23859	}
23860	*v = cv
23861	return nil
23862}
23863
23864func awsAwsjson11_deserializeDocumentInstancePortInfo(v **types.InstancePortInfo, value interface{}) error {
23865	if v == nil {
23866		return fmt.Errorf("unexpected nil of type %T", v)
23867	}
23868	if value == nil {
23869		return nil
23870	}
23871
23872	shape, ok := value.(map[string]interface{})
23873	if !ok {
23874		return fmt.Errorf("unexpected JSON type %v", value)
23875	}
23876
23877	var sv *types.InstancePortInfo
23878	if *v == nil {
23879		sv = &types.InstancePortInfo{}
23880	} else {
23881		sv = *v
23882	}
23883
23884	for key, value := range shape {
23885		switch key {
23886		case "accessDirection":
23887			if value != nil {
23888				jtv, ok := value.(string)
23889				if !ok {
23890					return fmt.Errorf("expected AccessDirection to be of type string, got %T instead", value)
23891				}
23892				sv.AccessDirection = types.AccessDirection(jtv)
23893			}
23894
23895		case "accessFrom":
23896			if value != nil {
23897				jtv, ok := value.(string)
23898				if !ok {
23899					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23900				}
23901				sv.AccessFrom = ptr.String(jtv)
23902			}
23903
23904		case "accessType":
23905			if value != nil {
23906				jtv, ok := value.(string)
23907				if !ok {
23908					return fmt.Errorf("expected PortAccessType to be of type string, got %T instead", value)
23909				}
23910				sv.AccessType = types.PortAccessType(jtv)
23911			}
23912
23913		case "cidrListAliases":
23914			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
23915				return err
23916			}
23917
23918		case "cidrs":
23919			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
23920				return err
23921			}
23922
23923		case "commonName":
23924			if value != nil {
23925				jtv, ok := value.(string)
23926				if !ok {
23927					return fmt.Errorf("expected string to be of type string, got %T instead", value)
23928				}
23929				sv.CommonName = ptr.String(jtv)
23930			}
23931
23932		case "fromPort":
23933			if value != nil {
23934				jtv, ok := value.(json.Number)
23935				if !ok {
23936					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
23937				}
23938				i64, err := jtv.Int64()
23939				if err != nil {
23940					return err
23941				}
23942				sv.FromPort = int32(i64)
23943			}
23944
23945		case "ipv6Cidrs":
23946			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
23947				return err
23948			}
23949
23950		case "protocol":
23951			if value != nil {
23952				jtv, ok := value.(string)
23953				if !ok {
23954					return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
23955				}
23956				sv.Protocol = types.NetworkProtocol(jtv)
23957			}
23958
23959		case "toPort":
23960			if value != nil {
23961				jtv, ok := value.(json.Number)
23962				if !ok {
23963					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
23964				}
23965				i64, err := jtv.Int64()
23966				if err != nil {
23967					return err
23968				}
23969				sv.ToPort = int32(i64)
23970			}
23971
23972		default:
23973			_, _ = key, value
23974
23975		}
23976	}
23977	*v = sv
23978	return nil
23979}
23980
23981func awsAwsjson11_deserializeDocumentInstancePortInfoList(v *[]types.InstancePortInfo, value interface{}) error {
23982	if v == nil {
23983		return fmt.Errorf("unexpected nil of type %T", v)
23984	}
23985	if value == nil {
23986		return nil
23987	}
23988
23989	shape, ok := value.([]interface{})
23990	if !ok {
23991		return fmt.Errorf("unexpected JSON type %v", value)
23992	}
23993
23994	var cv []types.InstancePortInfo
23995	if *v == nil {
23996		cv = []types.InstancePortInfo{}
23997	} else {
23998		cv = *v
23999	}
24000
24001	for _, value := range shape {
24002		var col types.InstancePortInfo
24003		destAddr := &col
24004		if err := awsAwsjson11_deserializeDocumentInstancePortInfo(&destAddr, value); err != nil {
24005			return err
24006		}
24007		col = *destAddr
24008		cv = append(cv, col)
24009
24010	}
24011	*v = cv
24012	return nil
24013}
24014
24015func awsAwsjson11_deserializeDocumentInstancePortState(v **types.InstancePortState, value interface{}) error {
24016	if v == nil {
24017		return fmt.Errorf("unexpected nil of type %T", v)
24018	}
24019	if value == nil {
24020		return nil
24021	}
24022
24023	shape, ok := value.(map[string]interface{})
24024	if !ok {
24025		return fmt.Errorf("unexpected JSON type %v", value)
24026	}
24027
24028	var sv *types.InstancePortState
24029	if *v == nil {
24030		sv = &types.InstancePortState{}
24031	} else {
24032		sv = *v
24033	}
24034
24035	for key, value := range shape {
24036		switch key {
24037		case "cidrListAliases":
24038			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CidrListAliases, value); err != nil {
24039				return err
24040			}
24041
24042		case "cidrs":
24043			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Cidrs, value); err != nil {
24044				return err
24045			}
24046
24047		case "fromPort":
24048			if value != nil {
24049				jtv, ok := value.(json.Number)
24050				if !ok {
24051					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
24052				}
24053				i64, err := jtv.Int64()
24054				if err != nil {
24055					return err
24056				}
24057				sv.FromPort = int32(i64)
24058			}
24059
24060		case "ipv6Cidrs":
24061			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Ipv6Cidrs, value); err != nil {
24062				return err
24063			}
24064
24065		case "protocol":
24066			if value != nil {
24067				jtv, ok := value.(string)
24068				if !ok {
24069					return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
24070				}
24071				sv.Protocol = types.NetworkProtocol(jtv)
24072			}
24073
24074		case "state":
24075			if value != nil {
24076				jtv, ok := value.(string)
24077				if !ok {
24078					return fmt.Errorf("expected PortState to be of type string, got %T instead", value)
24079				}
24080				sv.State = types.PortState(jtv)
24081			}
24082
24083		case "toPort":
24084			if value != nil {
24085				jtv, ok := value.(json.Number)
24086				if !ok {
24087					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
24088				}
24089				i64, err := jtv.Int64()
24090				if err != nil {
24091					return err
24092				}
24093				sv.ToPort = int32(i64)
24094			}
24095
24096		default:
24097			_, _ = key, value
24098
24099		}
24100	}
24101	*v = sv
24102	return nil
24103}
24104
24105func awsAwsjson11_deserializeDocumentInstancePortStateList(v *[]types.InstancePortState, value interface{}) error {
24106	if v == nil {
24107		return fmt.Errorf("unexpected nil of type %T", v)
24108	}
24109	if value == nil {
24110		return nil
24111	}
24112
24113	shape, ok := value.([]interface{})
24114	if !ok {
24115		return fmt.Errorf("unexpected JSON type %v", value)
24116	}
24117
24118	var cv []types.InstancePortState
24119	if *v == nil {
24120		cv = []types.InstancePortState{}
24121	} else {
24122		cv = *v
24123	}
24124
24125	for _, value := range shape {
24126		var col types.InstancePortState
24127		destAddr := &col
24128		if err := awsAwsjson11_deserializeDocumentInstancePortState(&destAddr, value); err != nil {
24129			return err
24130		}
24131		col = *destAddr
24132		cv = append(cv, col)
24133
24134	}
24135	*v = cv
24136	return nil
24137}
24138
24139func awsAwsjson11_deserializeDocumentInstanceSnapshot(v **types.InstanceSnapshot, value interface{}) error {
24140	if v == nil {
24141		return fmt.Errorf("unexpected nil of type %T", v)
24142	}
24143	if value == nil {
24144		return nil
24145	}
24146
24147	shape, ok := value.(map[string]interface{})
24148	if !ok {
24149		return fmt.Errorf("unexpected JSON type %v", value)
24150	}
24151
24152	var sv *types.InstanceSnapshot
24153	if *v == nil {
24154		sv = &types.InstanceSnapshot{}
24155	} else {
24156		sv = *v
24157	}
24158
24159	for key, value := range shape {
24160		switch key {
24161		case "arn":
24162			if value != nil {
24163				jtv, ok := value.(string)
24164				if !ok {
24165					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24166				}
24167				sv.Arn = ptr.String(jtv)
24168			}
24169
24170		case "createdAt":
24171			if value != nil {
24172				jtv, ok := value.(json.Number)
24173				if !ok {
24174					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
24175				}
24176				f64, err := jtv.Float64()
24177				if err != nil {
24178					return err
24179				}
24180				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24181			}
24182
24183		case "fromAttachedDisks":
24184			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.FromAttachedDisks, value); err != nil {
24185				return err
24186			}
24187
24188		case "fromBlueprintId":
24189			if value != nil {
24190				jtv, ok := value.(string)
24191				if !ok {
24192					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24193				}
24194				sv.FromBlueprintId = ptr.String(jtv)
24195			}
24196
24197		case "fromBundleId":
24198			if value != nil {
24199				jtv, ok := value.(string)
24200				if !ok {
24201					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24202				}
24203				sv.FromBundleId = ptr.String(jtv)
24204			}
24205
24206		case "fromInstanceArn":
24207			if value != nil {
24208				jtv, ok := value.(string)
24209				if !ok {
24210					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24211				}
24212				sv.FromInstanceArn = ptr.String(jtv)
24213			}
24214
24215		case "fromInstanceName":
24216			if value != nil {
24217				jtv, ok := value.(string)
24218				if !ok {
24219					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24220				}
24221				sv.FromInstanceName = ptr.String(jtv)
24222			}
24223
24224		case "isFromAutoSnapshot":
24225			if value != nil {
24226				jtv, ok := value.(bool)
24227				if !ok {
24228					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24229				}
24230				sv.IsFromAutoSnapshot = ptr.Bool(jtv)
24231			}
24232
24233		case "location":
24234			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24235				return err
24236			}
24237
24238		case "name":
24239			if value != nil {
24240				jtv, ok := value.(string)
24241				if !ok {
24242					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24243				}
24244				sv.Name = ptr.String(jtv)
24245			}
24246
24247		case "progress":
24248			if value != nil {
24249				jtv, ok := value.(string)
24250				if !ok {
24251					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24252				}
24253				sv.Progress = ptr.String(jtv)
24254			}
24255
24256		case "resourceType":
24257			if value != nil {
24258				jtv, ok := value.(string)
24259				if !ok {
24260					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24261				}
24262				sv.ResourceType = types.ResourceType(jtv)
24263			}
24264
24265		case "sizeInGb":
24266			if value != nil {
24267				jtv, ok := value.(json.Number)
24268				if !ok {
24269					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24270				}
24271				i64, err := jtv.Int64()
24272				if err != nil {
24273					return err
24274				}
24275				sv.SizeInGb = ptr.Int32(int32(i64))
24276			}
24277
24278		case "state":
24279			if value != nil {
24280				jtv, ok := value.(string)
24281				if !ok {
24282					return fmt.Errorf("expected InstanceSnapshotState to be of type string, got %T instead", value)
24283				}
24284				sv.State = types.InstanceSnapshotState(jtv)
24285			}
24286
24287		case "supportCode":
24288			if value != nil {
24289				jtv, ok := value.(string)
24290				if !ok {
24291					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24292				}
24293				sv.SupportCode = ptr.String(jtv)
24294			}
24295
24296		case "tags":
24297			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24298				return err
24299			}
24300
24301		default:
24302			_, _ = key, value
24303
24304		}
24305	}
24306	*v = sv
24307	return nil
24308}
24309
24310func awsAwsjson11_deserializeDocumentInstanceSnapshotInfo(v **types.InstanceSnapshotInfo, value interface{}) error {
24311	if v == nil {
24312		return fmt.Errorf("unexpected nil of type %T", v)
24313	}
24314	if value == nil {
24315		return nil
24316	}
24317
24318	shape, ok := value.(map[string]interface{})
24319	if !ok {
24320		return fmt.Errorf("unexpected JSON type %v", value)
24321	}
24322
24323	var sv *types.InstanceSnapshotInfo
24324	if *v == nil {
24325		sv = &types.InstanceSnapshotInfo{}
24326	} else {
24327		sv = *v
24328	}
24329
24330	for key, value := range shape {
24331		switch key {
24332		case "fromBlueprintId":
24333			if value != nil {
24334				jtv, ok := value.(string)
24335				if !ok {
24336					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24337				}
24338				sv.FromBlueprintId = ptr.String(jtv)
24339			}
24340
24341		case "fromBundleId":
24342			if value != nil {
24343				jtv, ok := value.(string)
24344				if !ok {
24345					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24346				}
24347				sv.FromBundleId = ptr.String(jtv)
24348			}
24349
24350		case "fromDiskInfo":
24351			if err := awsAwsjson11_deserializeDocumentDiskInfoList(&sv.FromDiskInfo, value); err != nil {
24352				return err
24353			}
24354
24355		default:
24356			_, _ = key, value
24357
24358		}
24359	}
24360	*v = sv
24361	return nil
24362}
24363
24364func awsAwsjson11_deserializeDocumentInstanceSnapshotList(v *[]types.InstanceSnapshot, value interface{}) error {
24365	if v == nil {
24366		return fmt.Errorf("unexpected nil of type %T", v)
24367	}
24368	if value == nil {
24369		return nil
24370	}
24371
24372	shape, ok := value.([]interface{})
24373	if !ok {
24374		return fmt.Errorf("unexpected JSON type %v", value)
24375	}
24376
24377	var cv []types.InstanceSnapshot
24378	if *v == nil {
24379		cv = []types.InstanceSnapshot{}
24380	} else {
24381		cv = *v
24382	}
24383
24384	for _, value := range shape {
24385		var col types.InstanceSnapshot
24386		destAddr := &col
24387		if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&destAddr, value); err != nil {
24388			return err
24389		}
24390		col = *destAddr
24391		cv = append(cv, col)
24392
24393	}
24394	*v = cv
24395	return nil
24396}
24397
24398func awsAwsjson11_deserializeDocumentInstanceState(v **types.InstanceState, value interface{}) error {
24399	if v == nil {
24400		return fmt.Errorf("unexpected nil of type %T", v)
24401	}
24402	if value == nil {
24403		return nil
24404	}
24405
24406	shape, ok := value.(map[string]interface{})
24407	if !ok {
24408		return fmt.Errorf("unexpected JSON type %v", value)
24409	}
24410
24411	var sv *types.InstanceState
24412	if *v == nil {
24413		sv = &types.InstanceState{}
24414	} else {
24415		sv = *v
24416	}
24417
24418	for key, value := range shape {
24419		switch key {
24420		case "code":
24421			if value != nil {
24422				jtv, ok := value.(json.Number)
24423				if !ok {
24424					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24425				}
24426				i64, err := jtv.Int64()
24427				if err != nil {
24428					return err
24429				}
24430				sv.Code = ptr.Int32(int32(i64))
24431			}
24432
24433		case "name":
24434			if value != nil {
24435				jtv, ok := value.(string)
24436				if !ok {
24437					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24438				}
24439				sv.Name = ptr.String(jtv)
24440			}
24441
24442		default:
24443			_, _ = key, value
24444
24445		}
24446	}
24447	*v = sv
24448	return nil
24449}
24450
24451func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
24452	if v == nil {
24453		return fmt.Errorf("unexpected nil of type %T", v)
24454	}
24455	if value == nil {
24456		return nil
24457	}
24458
24459	shape, ok := value.(map[string]interface{})
24460	if !ok {
24461		return fmt.Errorf("unexpected JSON type %v", value)
24462	}
24463
24464	var sv *types.InvalidInputException
24465	if *v == nil {
24466		sv = &types.InvalidInputException{}
24467	} else {
24468		sv = *v
24469	}
24470
24471	for key, value := range shape {
24472		switch key {
24473		case "code":
24474			if value != nil {
24475				jtv, ok := value.(string)
24476				if !ok {
24477					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24478				}
24479				sv.Code = ptr.String(jtv)
24480			}
24481
24482		case "docs":
24483			if value != nil {
24484				jtv, ok := value.(string)
24485				if !ok {
24486					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24487				}
24488				sv.Docs = ptr.String(jtv)
24489			}
24490
24491		case "message":
24492			if value != nil {
24493				jtv, ok := value.(string)
24494				if !ok {
24495					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24496				}
24497				sv.Message = ptr.String(jtv)
24498			}
24499
24500		case "tip":
24501			if value != nil {
24502				jtv, ok := value.(string)
24503				if !ok {
24504					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24505				}
24506				sv.Tip = ptr.String(jtv)
24507			}
24508
24509		default:
24510			_, _ = key, value
24511
24512		}
24513	}
24514	*v = sv
24515	return nil
24516}
24517
24518func awsAwsjson11_deserializeDocumentIpv6AddressList(v *[]string, value interface{}) error {
24519	if v == nil {
24520		return fmt.Errorf("unexpected nil of type %T", v)
24521	}
24522	if value == nil {
24523		return nil
24524	}
24525
24526	shape, ok := value.([]interface{})
24527	if !ok {
24528		return fmt.Errorf("unexpected JSON type %v", value)
24529	}
24530
24531	var cv []string
24532	if *v == nil {
24533		cv = []string{}
24534	} else {
24535		cv = *v
24536	}
24537
24538	for _, value := range shape {
24539		var col string
24540		if value != nil {
24541			jtv, ok := value.(string)
24542			if !ok {
24543				return fmt.Errorf("expected Ipv6Address to be of type string, got %T instead", value)
24544			}
24545			col = jtv
24546		}
24547		cv = append(cv, col)
24548
24549	}
24550	*v = cv
24551	return nil
24552}
24553
24554func awsAwsjson11_deserializeDocumentKeyPair(v **types.KeyPair, value interface{}) error {
24555	if v == nil {
24556		return fmt.Errorf("unexpected nil of type %T", v)
24557	}
24558	if value == nil {
24559		return nil
24560	}
24561
24562	shape, ok := value.(map[string]interface{})
24563	if !ok {
24564		return fmt.Errorf("unexpected JSON type %v", value)
24565	}
24566
24567	var sv *types.KeyPair
24568	if *v == nil {
24569		sv = &types.KeyPair{}
24570	} else {
24571		sv = *v
24572	}
24573
24574	for key, value := range shape {
24575		switch key {
24576		case "arn":
24577			if value != nil {
24578				jtv, ok := value.(string)
24579				if !ok {
24580					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24581				}
24582				sv.Arn = ptr.String(jtv)
24583			}
24584
24585		case "createdAt":
24586			if value != nil {
24587				jtv, ok := value.(json.Number)
24588				if !ok {
24589					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
24590				}
24591				f64, err := jtv.Float64()
24592				if err != nil {
24593					return err
24594				}
24595				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24596			}
24597
24598		case "fingerprint":
24599			if value != nil {
24600				jtv, ok := value.(string)
24601				if !ok {
24602					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
24603				}
24604				sv.Fingerprint = ptr.String(jtv)
24605			}
24606
24607		case "location":
24608			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24609				return err
24610			}
24611
24612		case "name":
24613			if value != nil {
24614				jtv, ok := value.(string)
24615				if !ok {
24616					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24617				}
24618				sv.Name = ptr.String(jtv)
24619			}
24620
24621		case "resourceType":
24622			if value != nil {
24623				jtv, ok := value.(string)
24624				if !ok {
24625					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24626				}
24627				sv.ResourceType = types.ResourceType(jtv)
24628			}
24629
24630		case "supportCode":
24631			if value != nil {
24632				jtv, ok := value.(string)
24633				if !ok {
24634					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24635				}
24636				sv.SupportCode = ptr.String(jtv)
24637			}
24638
24639		case "tags":
24640			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24641				return err
24642			}
24643
24644		default:
24645			_, _ = key, value
24646
24647		}
24648	}
24649	*v = sv
24650	return nil
24651}
24652
24653func awsAwsjson11_deserializeDocumentKeyPairList(v *[]types.KeyPair, value interface{}) error {
24654	if v == nil {
24655		return fmt.Errorf("unexpected nil of type %T", v)
24656	}
24657	if value == nil {
24658		return nil
24659	}
24660
24661	shape, ok := value.([]interface{})
24662	if !ok {
24663		return fmt.Errorf("unexpected JSON type %v", value)
24664	}
24665
24666	var cv []types.KeyPair
24667	if *v == nil {
24668		cv = []types.KeyPair{}
24669	} else {
24670		cv = *v
24671	}
24672
24673	for _, value := range shape {
24674		var col types.KeyPair
24675		destAddr := &col
24676		if err := awsAwsjson11_deserializeDocumentKeyPair(&destAddr, value); err != nil {
24677			return err
24678		}
24679		col = *destAddr
24680		cv = append(cv, col)
24681
24682	}
24683	*v = cv
24684	return nil
24685}
24686
24687func awsAwsjson11_deserializeDocumentLightsailDistribution(v **types.LightsailDistribution, value interface{}) error {
24688	if v == nil {
24689		return fmt.Errorf("unexpected nil of type %T", v)
24690	}
24691	if value == nil {
24692		return nil
24693	}
24694
24695	shape, ok := value.(map[string]interface{})
24696	if !ok {
24697		return fmt.Errorf("unexpected JSON type %v", value)
24698	}
24699
24700	var sv *types.LightsailDistribution
24701	if *v == nil {
24702		sv = &types.LightsailDistribution{}
24703	} else {
24704		sv = *v
24705	}
24706
24707	for key, value := range shape {
24708		switch key {
24709		case "ableToUpdateBundle":
24710			if value != nil {
24711				jtv, ok := value.(bool)
24712				if !ok {
24713					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24714				}
24715				sv.AbleToUpdateBundle = ptr.Bool(jtv)
24716			}
24717
24718		case "alternativeDomainNames":
24719			if err := awsAwsjson11_deserializeDocumentStringList(&sv.AlternativeDomainNames, value); err != nil {
24720				return err
24721			}
24722
24723		case "arn":
24724			if value != nil {
24725				jtv, ok := value.(string)
24726				if !ok {
24727					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24728				}
24729				sv.Arn = ptr.String(jtv)
24730			}
24731
24732		case "bundleId":
24733			if value != nil {
24734				jtv, ok := value.(string)
24735				if !ok {
24736					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24737				}
24738				sv.BundleId = ptr.String(jtv)
24739			}
24740
24741		case "cacheBehaviors":
24742			if err := awsAwsjson11_deserializeDocumentCacheBehaviorList(&sv.CacheBehaviors, value); err != nil {
24743				return err
24744			}
24745
24746		case "cacheBehaviorSettings":
24747			if err := awsAwsjson11_deserializeDocumentCacheSettings(&sv.CacheBehaviorSettings, value); err != nil {
24748				return err
24749			}
24750
24751		case "certificateName":
24752			if value != nil {
24753				jtv, ok := value.(string)
24754				if !ok {
24755					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24756				}
24757				sv.CertificateName = ptr.String(jtv)
24758			}
24759
24760		case "createdAt":
24761			if value != nil {
24762				jtv, ok := value.(json.Number)
24763				if !ok {
24764					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
24765				}
24766				f64, err := jtv.Float64()
24767				if err != nil {
24768					return err
24769				}
24770				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24771			}
24772
24773		case "defaultCacheBehavior":
24774			if err := awsAwsjson11_deserializeDocumentCacheBehavior(&sv.DefaultCacheBehavior, value); err != nil {
24775				return err
24776			}
24777
24778		case "domainName":
24779			if value != nil {
24780				jtv, ok := value.(string)
24781				if !ok {
24782					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24783				}
24784				sv.DomainName = ptr.String(jtv)
24785			}
24786
24787		case "ipAddressType":
24788			if value != nil {
24789				jtv, ok := value.(string)
24790				if !ok {
24791					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
24792				}
24793				sv.IpAddressType = types.IpAddressType(jtv)
24794			}
24795
24796		case "isEnabled":
24797			if value != nil {
24798				jtv, ok := value.(bool)
24799				if !ok {
24800					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
24801				}
24802				sv.IsEnabled = ptr.Bool(jtv)
24803			}
24804
24805		case "location":
24806			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24807				return err
24808			}
24809
24810		case "name":
24811			if value != nil {
24812				jtv, ok := value.(string)
24813				if !ok {
24814					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24815				}
24816				sv.Name = ptr.String(jtv)
24817			}
24818
24819		case "origin":
24820			if err := awsAwsjson11_deserializeDocumentOrigin(&sv.Origin, value); err != nil {
24821				return err
24822			}
24823
24824		case "originPublicDNS":
24825			if value != nil {
24826				jtv, ok := value.(string)
24827				if !ok {
24828					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24829				}
24830				sv.OriginPublicDNS = ptr.String(jtv)
24831			}
24832
24833		case "resourceType":
24834			if value != nil {
24835				jtv, ok := value.(string)
24836				if !ok {
24837					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
24838				}
24839				sv.ResourceType = types.ResourceType(jtv)
24840			}
24841
24842		case "status":
24843			if value != nil {
24844				jtv, ok := value.(string)
24845				if !ok {
24846					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24847				}
24848				sv.Status = ptr.String(jtv)
24849			}
24850
24851		case "supportCode":
24852			if value != nil {
24853				jtv, ok := value.(string)
24854				if !ok {
24855					return fmt.Errorf("expected string to be of type string, got %T instead", value)
24856				}
24857				sv.SupportCode = ptr.String(jtv)
24858			}
24859
24860		case "tags":
24861			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
24862				return err
24863			}
24864
24865		default:
24866			_, _ = key, value
24867
24868		}
24869	}
24870	*v = sv
24871	return nil
24872}
24873
24874func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, value interface{}) error {
24875	if v == nil {
24876		return fmt.Errorf("unexpected nil of type %T", v)
24877	}
24878	if value == nil {
24879		return nil
24880	}
24881
24882	shape, ok := value.(map[string]interface{})
24883	if !ok {
24884		return fmt.Errorf("unexpected JSON type %v", value)
24885	}
24886
24887	var sv *types.LoadBalancer
24888	if *v == nil {
24889		sv = &types.LoadBalancer{}
24890	} else {
24891		sv = *v
24892	}
24893
24894	for key, value := range shape {
24895		switch key {
24896		case "arn":
24897			if value != nil {
24898				jtv, ok := value.(string)
24899				if !ok {
24900					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24901				}
24902				sv.Arn = ptr.String(jtv)
24903			}
24904
24905		case "configurationOptions":
24906			if err := awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(&sv.ConfigurationOptions, value); err != nil {
24907				return err
24908			}
24909
24910		case "createdAt":
24911			if value != nil {
24912				jtv, ok := value.(json.Number)
24913				if !ok {
24914					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
24915				}
24916				f64, err := jtv.Float64()
24917				if err != nil {
24918					return err
24919				}
24920				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
24921			}
24922
24923		case "dnsName":
24924			if value != nil {
24925				jtv, ok := value.(string)
24926				if !ok {
24927					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24928				}
24929				sv.DnsName = ptr.String(jtv)
24930			}
24931
24932		case "healthCheckPath":
24933			if value != nil {
24934				jtv, ok := value.(string)
24935				if !ok {
24936					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
24937				}
24938				sv.HealthCheckPath = ptr.String(jtv)
24939			}
24940
24941		case "instanceHealthSummary":
24942			if err := awsAwsjson11_deserializeDocumentInstanceHealthSummaryList(&sv.InstanceHealthSummary, value); err != nil {
24943				return err
24944			}
24945
24946		case "instancePort":
24947			if value != nil {
24948				jtv, ok := value.(json.Number)
24949				if !ok {
24950					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
24951				}
24952				i64, err := jtv.Int64()
24953				if err != nil {
24954					return err
24955				}
24956				sv.InstancePort = ptr.Int32(int32(i64))
24957			}
24958
24959		case "ipAddressType":
24960			if value != nil {
24961				jtv, ok := value.(string)
24962				if !ok {
24963					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
24964				}
24965				sv.IpAddressType = types.IpAddressType(jtv)
24966			}
24967
24968		case "location":
24969			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
24970				return err
24971			}
24972
24973		case "name":
24974			if value != nil {
24975				jtv, ok := value.(string)
24976				if !ok {
24977					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
24978				}
24979				sv.Name = ptr.String(jtv)
24980			}
24981
24982		case "protocol":
24983			if value != nil {
24984				jtv, ok := value.(string)
24985				if !ok {
24986					return fmt.Errorf("expected LoadBalancerProtocol to be of type string, got %T instead", value)
24987				}
24988				sv.Protocol = types.LoadBalancerProtocol(jtv)
24989			}
24990
24991		case "publicPorts":
24992			if err := awsAwsjson11_deserializeDocumentPortList(&sv.PublicPorts, value); err != nil {
24993				return err
24994			}
24995
24996		case "resourceType":
24997			if value != nil {
24998				jtv, ok := value.(string)
24999				if !ok {
25000					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
25001				}
25002				sv.ResourceType = types.ResourceType(jtv)
25003			}
25004
25005		case "state":
25006			if value != nil {
25007				jtv, ok := value.(string)
25008				if !ok {
25009					return fmt.Errorf("expected LoadBalancerState to be of type string, got %T instead", value)
25010				}
25011				sv.State = types.LoadBalancerState(jtv)
25012			}
25013
25014		case "supportCode":
25015			if value != nil {
25016				jtv, ok := value.(string)
25017				if !ok {
25018					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25019				}
25020				sv.SupportCode = ptr.String(jtv)
25021			}
25022
25023		case "tags":
25024			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
25025				return err
25026			}
25027
25028		case "tlsCertificateSummaries":
25029			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(&sv.TlsCertificateSummaries, value); err != nil {
25030				return err
25031			}
25032
25033		default:
25034			_, _ = key, value
25035
25036		}
25037	}
25038	*v = sv
25039	return nil
25040}
25041
25042func awsAwsjson11_deserializeDocumentLoadBalancerConfigurationOptions(v *map[string]string, value interface{}) error {
25043	if v == nil {
25044		return fmt.Errorf("unexpected nil of type %T", v)
25045	}
25046	if value == nil {
25047		return nil
25048	}
25049
25050	shape, ok := value.(map[string]interface{})
25051	if !ok {
25052		return fmt.Errorf("unexpected JSON type %v", value)
25053	}
25054
25055	var mv map[string]string
25056	if *v == nil {
25057		mv = map[string]string{}
25058	} else {
25059		mv = *v
25060	}
25061
25062	for key, value := range shape {
25063		var parsedVal string
25064		if value != nil {
25065			jtv, ok := value.(string)
25066			if !ok {
25067				return fmt.Errorf("expected string to be of type string, got %T instead", value)
25068			}
25069			parsedVal = jtv
25070		}
25071		mv[key] = parsedVal
25072
25073	}
25074	*v = mv
25075	return nil
25076}
25077
25078func awsAwsjson11_deserializeDocumentLoadBalancerList(v *[]types.LoadBalancer, value interface{}) error {
25079	if v == nil {
25080		return fmt.Errorf("unexpected nil of type %T", v)
25081	}
25082	if value == nil {
25083		return nil
25084	}
25085
25086	shape, ok := value.([]interface{})
25087	if !ok {
25088		return fmt.Errorf("unexpected JSON type %v", value)
25089	}
25090
25091	var cv []types.LoadBalancer
25092	if *v == nil {
25093		cv = []types.LoadBalancer{}
25094	} else {
25095		cv = *v
25096	}
25097
25098	for _, value := range shape {
25099		var col types.LoadBalancer
25100		destAddr := &col
25101		if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil {
25102			return err
25103		}
25104		col = *destAddr
25105		cv = append(cv, col)
25106
25107	}
25108	*v = cv
25109	return nil
25110}
25111
25112func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(v **types.LoadBalancerTlsCertificate, value interface{}) error {
25113	if v == nil {
25114		return fmt.Errorf("unexpected nil of type %T", v)
25115	}
25116	if value == nil {
25117		return nil
25118	}
25119
25120	shape, ok := value.(map[string]interface{})
25121	if !ok {
25122		return fmt.Errorf("unexpected JSON type %v", value)
25123	}
25124
25125	var sv *types.LoadBalancerTlsCertificate
25126	if *v == nil {
25127		sv = &types.LoadBalancerTlsCertificate{}
25128	} else {
25129		sv = *v
25130	}
25131
25132	for key, value := range shape {
25133		switch key {
25134		case "arn":
25135			if value != nil {
25136				jtv, ok := value.(string)
25137				if !ok {
25138					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25139				}
25140				sv.Arn = ptr.String(jtv)
25141			}
25142
25143		case "createdAt":
25144			if value != nil {
25145				jtv, ok := value.(json.Number)
25146				if !ok {
25147					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25148				}
25149				f64, err := jtv.Float64()
25150				if err != nil {
25151					return err
25152				}
25153				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25154			}
25155
25156		case "domainName":
25157			if value != nil {
25158				jtv, ok := value.(string)
25159				if !ok {
25160					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
25161				}
25162				sv.DomainName = ptr.String(jtv)
25163			}
25164
25165		case "domainValidationRecords":
25166			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
25167				return err
25168			}
25169
25170		case "failureReason":
25171			if value != nil {
25172				jtv, ok := value.(string)
25173				if !ok {
25174					return fmt.Errorf("expected LoadBalancerTlsCertificateFailureReason to be of type string, got %T instead", value)
25175				}
25176				sv.FailureReason = types.LoadBalancerTlsCertificateFailureReason(jtv)
25177			}
25178
25179		case "isAttached":
25180			if value != nil {
25181				jtv, ok := value.(bool)
25182				if !ok {
25183					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
25184				}
25185				sv.IsAttached = ptr.Bool(jtv)
25186			}
25187
25188		case "issuedAt":
25189			if value != nil {
25190				jtv, ok := value.(json.Number)
25191				if !ok {
25192					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25193				}
25194				f64, err := jtv.Float64()
25195				if err != nil {
25196					return err
25197				}
25198				sv.IssuedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25199			}
25200
25201		case "issuer":
25202			if value != nil {
25203				jtv, ok := value.(string)
25204				if !ok {
25205					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25206				}
25207				sv.Issuer = ptr.String(jtv)
25208			}
25209
25210		case "keyAlgorithm":
25211			if value != nil {
25212				jtv, ok := value.(string)
25213				if !ok {
25214					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25215				}
25216				sv.KeyAlgorithm = ptr.String(jtv)
25217			}
25218
25219		case "loadBalancerName":
25220			if value != nil {
25221				jtv, ok := value.(string)
25222				if !ok {
25223					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25224				}
25225				sv.LoadBalancerName = ptr.String(jtv)
25226			}
25227
25228		case "location":
25229			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
25230				return err
25231			}
25232
25233		case "name":
25234			if value != nil {
25235				jtv, ok := value.(string)
25236				if !ok {
25237					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25238				}
25239				sv.Name = ptr.String(jtv)
25240			}
25241
25242		case "notAfter":
25243			if value != nil {
25244				jtv, ok := value.(json.Number)
25245				if !ok {
25246					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25247				}
25248				f64, err := jtv.Float64()
25249				if err != nil {
25250					return err
25251				}
25252				sv.NotAfter = ptr.Time(smithytime.ParseEpochSeconds(f64))
25253			}
25254
25255		case "notBefore":
25256			if value != nil {
25257				jtv, ok := value.(json.Number)
25258				if !ok {
25259					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25260				}
25261				f64, err := jtv.Float64()
25262				if err != nil {
25263					return err
25264				}
25265				sv.NotBefore = ptr.Time(smithytime.ParseEpochSeconds(f64))
25266			}
25267
25268		case "renewalSummary":
25269			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(&sv.RenewalSummary, value); err != nil {
25270				return err
25271			}
25272
25273		case "resourceType":
25274			if value != nil {
25275				jtv, ok := value.(string)
25276				if !ok {
25277					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
25278				}
25279				sv.ResourceType = types.ResourceType(jtv)
25280			}
25281
25282		case "revocationReason":
25283			if value != nil {
25284				jtv, ok := value.(string)
25285				if !ok {
25286					return fmt.Errorf("expected LoadBalancerTlsCertificateRevocationReason to be of type string, got %T instead", value)
25287				}
25288				sv.RevocationReason = types.LoadBalancerTlsCertificateRevocationReason(jtv)
25289			}
25290
25291		case "revokedAt":
25292			if value != nil {
25293				jtv, ok := value.(json.Number)
25294				if !ok {
25295					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25296				}
25297				f64, err := jtv.Float64()
25298				if err != nil {
25299					return err
25300				}
25301				sv.RevokedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25302			}
25303
25304		case "serial":
25305			if value != nil {
25306				jtv, ok := value.(string)
25307				if !ok {
25308					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25309				}
25310				sv.Serial = ptr.String(jtv)
25311			}
25312
25313		case "signatureAlgorithm":
25314			if value != nil {
25315				jtv, ok := value.(string)
25316				if !ok {
25317					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25318				}
25319				sv.SignatureAlgorithm = ptr.String(jtv)
25320			}
25321
25322		case "status":
25323			if value != nil {
25324				jtv, ok := value.(string)
25325				if !ok {
25326					return fmt.Errorf("expected LoadBalancerTlsCertificateStatus to be of type string, got %T instead", value)
25327				}
25328				sv.Status = types.LoadBalancerTlsCertificateStatus(jtv)
25329			}
25330
25331		case "subject":
25332			if value != nil {
25333				jtv, ok := value.(string)
25334				if !ok {
25335					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25336				}
25337				sv.Subject = ptr.String(jtv)
25338			}
25339
25340		case "subjectAlternativeNames":
25341			if err := awsAwsjson11_deserializeDocumentStringList(&sv.SubjectAlternativeNames, value); err != nil {
25342				return err
25343			}
25344
25345		case "supportCode":
25346			if value != nil {
25347				jtv, ok := value.(string)
25348				if !ok {
25349					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25350				}
25351				sv.SupportCode = ptr.String(jtv)
25352			}
25353
25354		case "tags":
25355			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
25356				return err
25357			}
25358
25359		default:
25360			_, _ = key, value
25361
25362		}
25363	}
25364	*v = sv
25365	return nil
25366}
25367
25368func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(v **types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
25369	if v == nil {
25370		return fmt.Errorf("unexpected nil of type %T", v)
25371	}
25372	if value == nil {
25373		return nil
25374	}
25375
25376	shape, ok := value.(map[string]interface{})
25377	if !ok {
25378		return fmt.Errorf("unexpected JSON type %v", value)
25379	}
25380
25381	var sv *types.LoadBalancerTlsCertificateDomainValidationOption
25382	if *v == nil {
25383		sv = &types.LoadBalancerTlsCertificateDomainValidationOption{}
25384	} else {
25385		sv = *v
25386	}
25387
25388	for key, value := range shape {
25389		switch key {
25390		case "domainName":
25391			if value != nil {
25392				jtv, ok := value.(string)
25393				if !ok {
25394					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
25395				}
25396				sv.DomainName = ptr.String(jtv)
25397			}
25398
25399		case "validationStatus":
25400			if value != nil {
25401				jtv, ok := value.(string)
25402				if !ok {
25403					return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
25404				}
25405				sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
25406			}
25407
25408		default:
25409			_, _ = key, value
25410
25411		}
25412	}
25413	*v = sv
25414	return nil
25415}
25416
25417func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(v *[]types.LoadBalancerTlsCertificateDomainValidationOption, value interface{}) error {
25418	if v == nil {
25419		return fmt.Errorf("unexpected nil of type %T", v)
25420	}
25421	if value == nil {
25422		return nil
25423	}
25424
25425	shape, ok := value.([]interface{})
25426	if !ok {
25427		return fmt.Errorf("unexpected JSON type %v", value)
25428	}
25429
25430	var cv []types.LoadBalancerTlsCertificateDomainValidationOption
25431	if *v == nil {
25432		cv = []types.LoadBalancerTlsCertificateDomainValidationOption{}
25433	} else {
25434		cv = *v
25435	}
25436
25437	for _, value := range shape {
25438		var col types.LoadBalancerTlsCertificateDomainValidationOption
25439		destAddr := &col
25440		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOption(&destAddr, value); err != nil {
25441			return err
25442		}
25443		col = *destAddr
25444		cv = append(cv, col)
25445
25446	}
25447	*v = cv
25448	return nil
25449}
25450
25451func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(v **types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
25452	if v == nil {
25453		return fmt.Errorf("unexpected nil of type %T", v)
25454	}
25455	if value == nil {
25456		return nil
25457	}
25458
25459	shape, ok := value.(map[string]interface{})
25460	if !ok {
25461		return fmt.Errorf("unexpected JSON type %v", value)
25462	}
25463
25464	var sv *types.LoadBalancerTlsCertificateDomainValidationRecord
25465	if *v == nil {
25466		sv = &types.LoadBalancerTlsCertificateDomainValidationRecord{}
25467	} else {
25468		sv = *v
25469	}
25470
25471	for key, value := range shape {
25472		switch key {
25473		case "domainName":
25474			if value != nil {
25475				jtv, ok := value.(string)
25476				if !ok {
25477					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
25478				}
25479				sv.DomainName = ptr.String(jtv)
25480			}
25481
25482		case "name":
25483			if value != nil {
25484				jtv, ok := value.(string)
25485				if !ok {
25486					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25487				}
25488				sv.Name = ptr.String(jtv)
25489			}
25490
25491		case "type":
25492			if value != nil {
25493				jtv, ok := value.(string)
25494				if !ok {
25495					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25496				}
25497				sv.Type = ptr.String(jtv)
25498			}
25499
25500		case "validationStatus":
25501			if value != nil {
25502				jtv, ok := value.(string)
25503				if !ok {
25504					return fmt.Errorf("expected LoadBalancerTlsCertificateDomainStatus to be of type string, got %T instead", value)
25505				}
25506				sv.ValidationStatus = types.LoadBalancerTlsCertificateDomainStatus(jtv)
25507			}
25508
25509		case "value":
25510			if value != nil {
25511				jtv, ok := value.(string)
25512				if !ok {
25513					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
25514				}
25515				sv.Value = ptr.String(jtv)
25516			}
25517
25518		default:
25519			_, _ = key, value
25520
25521		}
25522	}
25523	*v = sv
25524	return nil
25525}
25526
25527func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecordList(v *[]types.LoadBalancerTlsCertificateDomainValidationRecord, value interface{}) error {
25528	if v == nil {
25529		return fmt.Errorf("unexpected nil of type %T", v)
25530	}
25531	if value == nil {
25532		return nil
25533	}
25534
25535	shape, ok := value.([]interface{})
25536	if !ok {
25537		return fmt.Errorf("unexpected JSON type %v", value)
25538	}
25539
25540	var cv []types.LoadBalancerTlsCertificateDomainValidationRecord
25541	if *v == nil {
25542		cv = []types.LoadBalancerTlsCertificateDomainValidationRecord{}
25543	} else {
25544		cv = *v
25545	}
25546
25547	for _, value := range shape {
25548		var col types.LoadBalancerTlsCertificateDomainValidationRecord
25549		destAddr := &col
25550		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationRecord(&destAddr, value); err != nil {
25551			return err
25552		}
25553		col = *destAddr
25554		cv = append(cv, col)
25555
25556	}
25557	*v = cv
25558	return nil
25559}
25560
25561func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(v *[]types.LoadBalancerTlsCertificate, value interface{}) error {
25562	if v == nil {
25563		return fmt.Errorf("unexpected nil of type %T", v)
25564	}
25565	if value == nil {
25566		return nil
25567	}
25568
25569	shape, ok := value.([]interface{})
25570	if !ok {
25571		return fmt.Errorf("unexpected JSON type %v", value)
25572	}
25573
25574	var cv []types.LoadBalancerTlsCertificate
25575	if *v == nil {
25576		cv = []types.LoadBalancerTlsCertificate{}
25577	} else {
25578		cv = *v
25579	}
25580
25581	for _, value := range shape {
25582		var col types.LoadBalancerTlsCertificate
25583		destAddr := &col
25584		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificate(&destAddr, value); err != nil {
25585			return err
25586		}
25587		col = *destAddr
25588		cv = append(cv, col)
25589
25590	}
25591	*v = cv
25592	return nil
25593}
25594
25595func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateRenewalSummary(v **types.LoadBalancerTlsCertificateRenewalSummary, value interface{}) error {
25596	if v == nil {
25597		return fmt.Errorf("unexpected nil of type %T", v)
25598	}
25599	if value == nil {
25600		return nil
25601	}
25602
25603	shape, ok := value.(map[string]interface{})
25604	if !ok {
25605		return fmt.Errorf("unexpected JSON type %v", value)
25606	}
25607
25608	var sv *types.LoadBalancerTlsCertificateRenewalSummary
25609	if *v == nil {
25610		sv = &types.LoadBalancerTlsCertificateRenewalSummary{}
25611	} else {
25612		sv = *v
25613	}
25614
25615	for key, value := range shape {
25616		switch key {
25617		case "domainValidationOptions":
25618			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateDomainValidationOptionList(&sv.DomainValidationOptions, value); err != nil {
25619				return err
25620			}
25621
25622		case "renewalStatus":
25623			if value != nil {
25624				jtv, ok := value.(string)
25625				if !ok {
25626					return fmt.Errorf("expected LoadBalancerTlsCertificateRenewalStatus to be of type string, got %T instead", value)
25627				}
25628				sv.RenewalStatus = types.LoadBalancerTlsCertificateRenewalStatus(jtv)
25629			}
25630
25631		default:
25632			_, _ = key, value
25633
25634		}
25635	}
25636	*v = sv
25637	return nil
25638}
25639
25640func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(v **types.LoadBalancerTlsCertificateSummary, value interface{}) error {
25641	if v == nil {
25642		return fmt.Errorf("unexpected nil of type %T", v)
25643	}
25644	if value == nil {
25645		return nil
25646	}
25647
25648	shape, ok := value.(map[string]interface{})
25649	if !ok {
25650		return fmt.Errorf("unexpected JSON type %v", value)
25651	}
25652
25653	var sv *types.LoadBalancerTlsCertificateSummary
25654	if *v == nil {
25655		sv = &types.LoadBalancerTlsCertificateSummary{}
25656	} else {
25657		sv = *v
25658	}
25659
25660	for key, value := range shape {
25661		switch key {
25662		case "isAttached":
25663			if value != nil {
25664				jtv, ok := value.(bool)
25665				if !ok {
25666					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
25667				}
25668				sv.IsAttached = ptr.Bool(jtv)
25669			}
25670
25671		case "name":
25672			if value != nil {
25673				jtv, ok := value.(string)
25674				if !ok {
25675					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25676				}
25677				sv.Name = ptr.String(jtv)
25678			}
25679
25680		default:
25681			_, _ = key, value
25682
25683		}
25684	}
25685	*v = sv
25686	return nil
25687}
25688
25689func awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummaryList(v *[]types.LoadBalancerTlsCertificateSummary, value interface{}) error {
25690	if v == nil {
25691		return fmt.Errorf("unexpected nil of type %T", v)
25692	}
25693	if value == nil {
25694		return nil
25695	}
25696
25697	shape, ok := value.([]interface{})
25698	if !ok {
25699		return fmt.Errorf("unexpected JSON type %v", value)
25700	}
25701
25702	var cv []types.LoadBalancerTlsCertificateSummary
25703	if *v == nil {
25704		cv = []types.LoadBalancerTlsCertificateSummary{}
25705	} else {
25706		cv = *v
25707	}
25708
25709	for _, value := range shape {
25710		var col types.LoadBalancerTlsCertificateSummary
25711		destAddr := &col
25712		if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateSummary(&destAddr, value); err != nil {
25713			return err
25714		}
25715		col = *destAddr
25716		cv = append(cv, col)
25717
25718	}
25719	*v = cv
25720	return nil
25721}
25722
25723func awsAwsjson11_deserializeDocumentLogEvent(v **types.LogEvent, value interface{}) error {
25724	if v == nil {
25725		return fmt.Errorf("unexpected nil of type %T", v)
25726	}
25727	if value == nil {
25728		return nil
25729	}
25730
25731	shape, ok := value.(map[string]interface{})
25732	if !ok {
25733		return fmt.Errorf("unexpected JSON type %v", value)
25734	}
25735
25736	var sv *types.LogEvent
25737	if *v == nil {
25738		sv = &types.LogEvent{}
25739	} else {
25740		sv = *v
25741	}
25742
25743	for key, value := range shape {
25744		switch key {
25745		case "createdAt":
25746			if value != nil {
25747				jtv, ok := value.(json.Number)
25748				if !ok {
25749					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
25750				}
25751				f64, err := jtv.Float64()
25752				if err != nil {
25753					return err
25754				}
25755				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
25756			}
25757
25758		case "message":
25759			if value != nil {
25760				jtv, ok := value.(string)
25761				if !ok {
25762					return fmt.Errorf("expected string to be of type string, got %T instead", value)
25763				}
25764				sv.Message = ptr.String(jtv)
25765			}
25766
25767		default:
25768			_, _ = key, value
25769
25770		}
25771	}
25772	*v = sv
25773	return nil
25774}
25775
25776func awsAwsjson11_deserializeDocumentLogEventList(v *[]types.LogEvent, value interface{}) error {
25777	if v == nil {
25778		return fmt.Errorf("unexpected nil of type %T", v)
25779	}
25780	if value == nil {
25781		return nil
25782	}
25783
25784	shape, ok := value.([]interface{})
25785	if !ok {
25786		return fmt.Errorf("unexpected JSON type %v", value)
25787	}
25788
25789	var cv []types.LogEvent
25790	if *v == nil {
25791		cv = []types.LogEvent{}
25792	} else {
25793		cv = *v
25794	}
25795
25796	for _, value := range shape {
25797		var col types.LogEvent
25798		destAddr := &col
25799		if err := awsAwsjson11_deserializeDocumentLogEvent(&destAddr, value); err != nil {
25800			return err
25801		}
25802		col = *destAddr
25803		cv = append(cv, col)
25804
25805	}
25806	*v = cv
25807	return nil
25808}
25809
25810func awsAwsjson11_deserializeDocumentMetricDatapoint(v **types.MetricDatapoint, value interface{}) error {
25811	if v == nil {
25812		return fmt.Errorf("unexpected nil of type %T", v)
25813	}
25814	if value == nil {
25815		return nil
25816	}
25817
25818	shape, ok := value.(map[string]interface{})
25819	if !ok {
25820		return fmt.Errorf("unexpected JSON type %v", value)
25821	}
25822
25823	var sv *types.MetricDatapoint
25824	if *v == nil {
25825		sv = &types.MetricDatapoint{}
25826	} else {
25827		sv = *v
25828	}
25829
25830	for key, value := range shape {
25831		switch key {
25832		case "average":
25833			if value != nil {
25834				jtv, ok := value.(json.Number)
25835				if !ok {
25836					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
25837				}
25838				f64, err := jtv.Float64()
25839				if err != nil {
25840					return err
25841				}
25842				sv.Average = ptr.Float64(f64)
25843			}
25844
25845		case "maximum":
25846			if value != nil {
25847				jtv, ok := value.(json.Number)
25848				if !ok {
25849					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
25850				}
25851				f64, err := jtv.Float64()
25852				if err != nil {
25853					return err
25854				}
25855				sv.Maximum = ptr.Float64(f64)
25856			}
25857
25858		case "minimum":
25859			if value != nil {
25860				jtv, ok := value.(json.Number)
25861				if !ok {
25862					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
25863				}
25864				f64, err := jtv.Float64()
25865				if err != nil {
25866					return err
25867				}
25868				sv.Minimum = ptr.Float64(f64)
25869			}
25870
25871		case "sampleCount":
25872			if value != nil {
25873				jtv, ok := value.(json.Number)
25874				if !ok {
25875					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
25876				}
25877				f64, err := jtv.Float64()
25878				if err != nil {
25879					return err
25880				}
25881				sv.SampleCount = ptr.Float64(f64)
25882			}
25883
25884		case "sum":
25885			if value != nil {
25886				jtv, ok := value.(json.Number)
25887				if !ok {
25888					return fmt.Errorf("expected double to be json.Number, got %T instead", value)
25889				}
25890				f64, err := jtv.Float64()
25891				if err != nil {
25892					return err
25893				}
25894				sv.Sum = ptr.Float64(f64)
25895			}
25896
25897		case "timestamp":
25898			if value != nil {
25899				jtv, ok := value.(json.Number)
25900				if !ok {
25901					return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value)
25902				}
25903				f64, err := jtv.Float64()
25904				if err != nil {
25905					return err
25906				}
25907				sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
25908			}
25909
25910		case "unit":
25911			if value != nil {
25912				jtv, ok := value.(string)
25913				if !ok {
25914					return fmt.Errorf("expected MetricUnit to be of type string, got %T instead", value)
25915				}
25916				sv.Unit = types.MetricUnit(jtv)
25917			}
25918
25919		default:
25920			_, _ = key, value
25921
25922		}
25923	}
25924	*v = sv
25925	return nil
25926}
25927
25928func awsAwsjson11_deserializeDocumentMetricDatapointList(v *[]types.MetricDatapoint, value interface{}) error {
25929	if v == nil {
25930		return fmt.Errorf("unexpected nil of type %T", v)
25931	}
25932	if value == nil {
25933		return nil
25934	}
25935
25936	shape, ok := value.([]interface{})
25937	if !ok {
25938		return fmt.Errorf("unexpected JSON type %v", value)
25939	}
25940
25941	var cv []types.MetricDatapoint
25942	if *v == nil {
25943		cv = []types.MetricDatapoint{}
25944	} else {
25945		cv = *v
25946	}
25947
25948	for _, value := range shape {
25949		var col types.MetricDatapoint
25950		destAddr := &col
25951		if err := awsAwsjson11_deserializeDocumentMetricDatapoint(&destAddr, value); err != nil {
25952			return err
25953		}
25954		col = *destAddr
25955		cv = append(cv, col)
25956
25957	}
25958	*v = cv
25959	return nil
25960}
25961
25962func awsAwsjson11_deserializeDocumentMonitoredResourceInfo(v **types.MonitoredResourceInfo, value interface{}) error {
25963	if v == nil {
25964		return fmt.Errorf("unexpected nil of type %T", v)
25965	}
25966	if value == nil {
25967		return nil
25968	}
25969
25970	shape, ok := value.(map[string]interface{})
25971	if !ok {
25972		return fmt.Errorf("unexpected JSON type %v", value)
25973	}
25974
25975	var sv *types.MonitoredResourceInfo
25976	if *v == nil {
25977		sv = &types.MonitoredResourceInfo{}
25978	} else {
25979		sv = *v
25980	}
25981
25982	for key, value := range shape {
25983		switch key {
25984		case "arn":
25985			if value != nil {
25986				jtv, ok := value.(string)
25987				if !ok {
25988					return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
25989				}
25990				sv.Arn = ptr.String(jtv)
25991			}
25992
25993		case "name":
25994			if value != nil {
25995				jtv, ok := value.(string)
25996				if !ok {
25997					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
25998				}
25999				sv.Name = ptr.String(jtv)
26000			}
26001
26002		case "resourceType":
26003			if value != nil {
26004				jtv, ok := value.(string)
26005				if !ok {
26006					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26007				}
26008				sv.ResourceType = types.ResourceType(jtv)
26009			}
26010
26011		default:
26012			_, _ = key, value
26013
26014		}
26015	}
26016	*v = sv
26017	return nil
26018}
26019
26020func awsAwsjson11_deserializeDocumentMonthlyTransfer(v **types.MonthlyTransfer, 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.MonthlyTransfer
26034	if *v == nil {
26035		sv = &types.MonthlyTransfer{}
26036	} else {
26037		sv = *v
26038	}
26039
26040	for key, value := range shape {
26041		switch key {
26042		case "gbPerMonthAllocated":
26043			if value != nil {
26044				jtv, ok := value.(json.Number)
26045				if !ok {
26046					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
26047				}
26048				i64, err := jtv.Int64()
26049				if err != nil {
26050					return err
26051				}
26052				sv.GbPerMonthAllocated = ptr.Int32(int32(i64))
26053			}
26054
26055		default:
26056			_, _ = key, value
26057
26058		}
26059	}
26060	*v = sv
26061	return nil
26062}
26063
26064func awsAwsjson11_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error {
26065	if v == nil {
26066		return fmt.Errorf("unexpected nil of type %T", v)
26067	}
26068	if value == nil {
26069		return nil
26070	}
26071
26072	shape, ok := value.(map[string]interface{})
26073	if !ok {
26074		return fmt.Errorf("unexpected JSON type %v", value)
26075	}
26076
26077	var sv *types.NotFoundException
26078	if *v == nil {
26079		sv = &types.NotFoundException{}
26080	} else {
26081		sv = *v
26082	}
26083
26084	for key, value := range shape {
26085		switch key {
26086		case "code":
26087			if value != nil {
26088				jtv, ok := value.(string)
26089				if !ok {
26090					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26091				}
26092				sv.Code = ptr.String(jtv)
26093			}
26094
26095		case "docs":
26096			if value != nil {
26097				jtv, ok := value.(string)
26098				if !ok {
26099					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26100				}
26101				sv.Docs = ptr.String(jtv)
26102			}
26103
26104		case "message":
26105			if value != nil {
26106				jtv, ok := value.(string)
26107				if !ok {
26108					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26109				}
26110				sv.Message = ptr.String(jtv)
26111			}
26112
26113		case "tip":
26114			if value != nil {
26115				jtv, ok := value.(string)
26116				if !ok {
26117					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26118				}
26119				sv.Tip = ptr.String(jtv)
26120			}
26121
26122		default:
26123			_, _ = key, value
26124
26125		}
26126	}
26127	*v = sv
26128	return nil
26129}
26130
26131func awsAwsjson11_deserializeDocumentNotificationTriggerList(v *[]types.AlarmState, value interface{}) error {
26132	if v == nil {
26133		return fmt.Errorf("unexpected nil of type %T", v)
26134	}
26135	if value == nil {
26136		return nil
26137	}
26138
26139	shape, ok := value.([]interface{})
26140	if !ok {
26141		return fmt.Errorf("unexpected JSON type %v", value)
26142	}
26143
26144	var cv []types.AlarmState
26145	if *v == nil {
26146		cv = []types.AlarmState{}
26147	} else {
26148		cv = *v
26149	}
26150
26151	for _, value := range shape {
26152		var col types.AlarmState
26153		if value != nil {
26154			jtv, ok := value.(string)
26155			if !ok {
26156				return fmt.Errorf("expected AlarmState to be of type string, got %T instead", value)
26157			}
26158			col = types.AlarmState(jtv)
26159		}
26160		cv = append(cv, col)
26161
26162	}
26163	*v = cv
26164	return nil
26165}
26166
26167func awsAwsjson11_deserializeDocumentOperation(v **types.Operation, value interface{}) error {
26168	if v == nil {
26169		return fmt.Errorf("unexpected nil of type %T", v)
26170	}
26171	if value == nil {
26172		return nil
26173	}
26174
26175	shape, ok := value.(map[string]interface{})
26176	if !ok {
26177		return fmt.Errorf("unexpected JSON type %v", value)
26178	}
26179
26180	var sv *types.Operation
26181	if *v == nil {
26182		sv = &types.Operation{}
26183	} else {
26184		sv = *v
26185	}
26186
26187	for key, value := range shape {
26188		switch key {
26189		case "createdAt":
26190			if value != nil {
26191				jtv, ok := value.(json.Number)
26192				if !ok {
26193					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
26194				}
26195				f64, err := jtv.Float64()
26196				if err != nil {
26197					return err
26198				}
26199				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26200			}
26201
26202		case "errorCode":
26203			if value != nil {
26204				jtv, ok := value.(string)
26205				if !ok {
26206					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26207				}
26208				sv.ErrorCode = ptr.String(jtv)
26209			}
26210
26211		case "errorDetails":
26212			if value != nil {
26213				jtv, ok := value.(string)
26214				if !ok {
26215					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26216				}
26217				sv.ErrorDetails = ptr.String(jtv)
26218			}
26219
26220		case "id":
26221			if value != nil {
26222				jtv, ok := value.(string)
26223				if !ok {
26224					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26225				}
26226				sv.Id = ptr.String(jtv)
26227			}
26228
26229		case "isTerminal":
26230			if value != nil {
26231				jtv, ok := value.(bool)
26232				if !ok {
26233					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26234				}
26235				sv.IsTerminal = ptr.Bool(jtv)
26236			}
26237
26238		case "location":
26239			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
26240				return err
26241			}
26242
26243		case "operationDetails":
26244			if value != nil {
26245				jtv, ok := value.(string)
26246				if !ok {
26247					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26248				}
26249				sv.OperationDetails = ptr.String(jtv)
26250			}
26251
26252		case "operationType":
26253			if value != nil {
26254				jtv, ok := value.(string)
26255				if !ok {
26256					return fmt.Errorf("expected OperationType to be of type string, got %T instead", value)
26257				}
26258				sv.OperationType = types.OperationType(jtv)
26259			}
26260
26261		case "resourceName":
26262			if value != nil {
26263				jtv, ok := value.(string)
26264				if !ok {
26265					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26266				}
26267				sv.ResourceName = ptr.String(jtv)
26268			}
26269
26270		case "resourceType":
26271			if value != nil {
26272				jtv, ok := value.(string)
26273				if !ok {
26274					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26275				}
26276				sv.ResourceType = types.ResourceType(jtv)
26277			}
26278
26279		case "status":
26280			if value != nil {
26281				jtv, ok := value.(string)
26282				if !ok {
26283					return fmt.Errorf("expected OperationStatus to be of type string, got %T instead", value)
26284				}
26285				sv.Status = types.OperationStatus(jtv)
26286			}
26287
26288		case "statusChangedAt":
26289			if value != nil {
26290				jtv, ok := value.(json.Number)
26291				if !ok {
26292					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
26293				}
26294				f64, err := jtv.Float64()
26295				if err != nil {
26296					return err
26297				}
26298				sv.StatusChangedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26299			}
26300
26301		default:
26302			_, _ = key, value
26303
26304		}
26305	}
26306	*v = sv
26307	return nil
26308}
26309
26310func awsAwsjson11_deserializeDocumentOperationFailureException(v **types.OperationFailureException, value interface{}) error {
26311	if v == nil {
26312		return fmt.Errorf("unexpected nil of type %T", v)
26313	}
26314	if value == nil {
26315		return nil
26316	}
26317
26318	shape, ok := value.(map[string]interface{})
26319	if !ok {
26320		return fmt.Errorf("unexpected JSON type %v", value)
26321	}
26322
26323	var sv *types.OperationFailureException
26324	if *v == nil {
26325		sv = &types.OperationFailureException{}
26326	} else {
26327		sv = *v
26328	}
26329
26330	for key, value := range shape {
26331		switch key {
26332		case "code":
26333			if value != nil {
26334				jtv, ok := value.(string)
26335				if !ok {
26336					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26337				}
26338				sv.Code = ptr.String(jtv)
26339			}
26340
26341		case "docs":
26342			if value != nil {
26343				jtv, ok := value.(string)
26344				if !ok {
26345					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26346				}
26347				sv.Docs = ptr.String(jtv)
26348			}
26349
26350		case "message":
26351			if value != nil {
26352				jtv, ok := value.(string)
26353				if !ok {
26354					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26355				}
26356				sv.Message = ptr.String(jtv)
26357			}
26358
26359		case "tip":
26360			if value != nil {
26361				jtv, ok := value.(string)
26362				if !ok {
26363					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26364				}
26365				sv.Tip = ptr.String(jtv)
26366			}
26367
26368		default:
26369			_, _ = key, value
26370
26371		}
26372	}
26373	*v = sv
26374	return nil
26375}
26376
26377func awsAwsjson11_deserializeDocumentOperationList(v *[]types.Operation, value interface{}) error {
26378	if v == nil {
26379		return fmt.Errorf("unexpected nil of type %T", v)
26380	}
26381	if value == nil {
26382		return nil
26383	}
26384
26385	shape, ok := value.([]interface{})
26386	if !ok {
26387		return fmt.Errorf("unexpected JSON type %v", value)
26388	}
26389
26390	var cv []types.Operation
26391	if *v == nil {
26392		cv = []types.Operation{}
26393	} else {
26394		cv = *v
26395	}
26396
26397	for _, value := range shape {
26398		var col types.Operation
26399		destAddr := &col
26400		if err := awsAwsjson11_deserializeDocumentOperation(&destAddr, value); err != nil {
26401			return err
26402		}
26403		col = *destAddr
26404		cv = append(cv, col)
26405
26406	}
26407	*v = cv
26408	return nil
26409}
26410
26411func awsAwsjson11_deserializeDocumentOrigin(v **types.Origin, value interface{}) error {
26412	if v == nil {
26413		return fmt.Errorf("unexpected nil of type %T", v)
26414	}
26415	if value == nil {
26416		return nil
26417	}
26418
26419	shape, ok := value.(map[string]interface{})
26420	if !ok {
26421		return fmt.Errorf("unexpected JSON type %v", value)
26422	}
26423
26424	var sv *types.Origin
26425	if *v == nil {
26426		sv = &types.Origin{}
26427	} else {
26428		sv = *v
26429	}
26430
26431	for key, value := range shape {
26432		switch key {
26433		case "name":
26434			if value != nil {
26435				jtv, ok := value.(string)
26436				if !ok {
26437					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26438				}
26439				sv.Name = ptr.String(jtv)
26440			}
26441
26442		case "protocolPolicy":
26443			if value != nil {
26444				jtv, ok := value.(string)
26445				if !ok {
26446					return fmt.Errorf("expected OriginProtocolPolicyEnum to be of type string, got %T instead", value)
26447				}
26448				sv.ProtocolPolicy = types.OriginProtocolPolicyEnum(jtv)
26449			}
26450
26451		case "regionName":
26452			if value != nil {
26453				jtv, ok := value.(string)
26454				if !ok {
26455					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
26456				}
26457				sv.RegionName = types.RegionName(jtv)
26458			}
26459
26460		case "resourceType":
26461			if value != nil {
26462				jtv, ok := value.(string)
26463				if !ok {
26464					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
26465				}
26466				sv.ResourceType = types.ResourceType(jtv)
26467			}
26468
26469		default:
26470			_, _ = key, value
26471
26472		}
26473	}
26474	*v = sv
26475	return nil
26476}
26477
26478func awsAwsjson11_deserializeDocumentPasswordData(v **types.PasswordData, value interface{}) error {
26479	if v == nil {
26480		return fmt.Errorf("unexpected nil of type %T", v)
26481	}
26482	if value == nil {
26483		return nil
26484	}
26485
26486	shape, ok := value.(map[string]interface{})
26487	if !ok {
26488		return fmt.Errorf("unexpected JSON type %v", value)
26489	}
26490
26491	var sv *types.PasswordData
26492	if *v == nil {
26493		sv = &types.PasswordData{}
26494	} else {
26495		sv = *v
26496	}
26497
26498	for key, value := range shape {
26499		switch key {
26500		case "ciphertext":
26501			if value != nil {
26502				jtv, ok := value.(string)
26503				if !ok {
26504					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26505				}
26506				sv.Ciphertext = ptr.String(jtv)
26507			}
26508
26509		case "keyPairName":
26510			if value != nil {
26511				jtv, ok := value.(string)
26512				if !ok {
26513					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
26514				}
26515				sv.KeyPairName = ptr.String(jtv)
26516			}
26517
26518		default:
26519			_, _ = key, value
26520
26521		}
26522	}
26523	*v = sv
26524	return nil
26525}
26526
26527func awsAwsjson11_deserializeDocumentPendingMaintenanceAction(v **types.PendingMaintenanceAction, value interface{}) error {
26528	if v == nil {
26529		return fmt.Errorf("unexpected nil of type %T", v)
26530	}
26531	if value == nil {
26532		return nil
26533	}
26534
26535	shape, ok := value.(map[string]interface{})
26536	if !ok {
26537		return fmt.Errorf("unexpected JSON type %v", value)
26538	}
26539
26540	var sv *types.PendingMaintenanceAction
26541	if *v == nil {
26542		sv = &types.PendingMaintenanceAction{}
26543	} else {
26544		sv = *v
26545	}
26546
26547	for key, value := range shape {
26548		switch key {
26549		case "action":
26550			if value != nil {
26551				jtv, ok := value.(string)
26552				if !ok {
26553					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26554				}
26555				sv.Action = ptr.String(jtv)
26556			}
26557
26558		case "currentApplyDate":
26559			if value != nil {
26560				jtv, ok := value.(json.Number)
26561				if !ok {
26562					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
26563				}
26564				f64, err := jtv.Float64()
26565				if err != nil {
26566					return err
26567				}
26568				sv.CurrentApplyDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
26569			}
26570
26571		case "description":
26572			if value != nil {
26573				jtv, ok := value.(string)
26574				if !ok {
26575					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26576				}
26577				sv.Description = ptr.String(jtv)
26578			}
26579
26580		default:
26581			_, _ = key, value
26582
26583		}
26584	}
26585	*v = sv
26586	return nil
26587}
26588
26589func awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(v *[]types.PendingMaintenanceAction, value interface{}) error {
26590	if v == nil {
26591		return fmt.Errorf("unexpected nil of type %T", v)
26592	}
26593	if value == nil {
26594		return nil
26595	}
26596
26597	shape, ok := value.([]interface{})
26598	if !ok {
26599		return fmt.Errorf("unexpected JSON type %v", value)
26600	}
26601
26602	var cv []types.PendingMaintenanceAction
26603	if *v == nil {
26604		cv = []types.PendingMaintenanceAction{}
26605	} else {
26606		cv = *v
26607	}
26608
26609	for _, value := range shape {
26610		var col types.PendingMaintenanceAction
26611		destAddr := &col
26612		if err := awsAwsjson11_deserializeDocumentPendingMaintenanceAction(&destAddr, value); err != nil {
26613			return err
26614		}
26615		col = *destAddr
26616		cv = append(cv, col)
26617
26618	}
26619	*v = cv
26620	return nil
26621}
26622
26623func awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(v **types.PendingModifiedRelationalDatabaseValues, value interface{}) error {
26624	if v == nil {
26625		return fmt.Errorf("unexpected nil of type %T", v)
26626	}
26627	if value == nil {
26628		return nil
26629	}
26630
26631	shape, ok := value.(map[string]interface{})
26632	if !ok {
26633		return fmt.Errorf("unexpected JSON type %v", value)
26634	}
26635
26636	var sv *types.PendingModifiedRelationalDatabaseValues
26637	if *v == nil {
26638		sv = &types.PendingModifiedRelationalDatabaseValues{}
26639	} else {
26640		sv = *v
26641	}
26642
26643	for key, value := range shape {
26644		switch key {
26645		case "backupRetentionEnabled":
26646			if value != nil {
26647				jtv, ok := value.(bool)
26648				if !ok {
26649					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26650				}
26651				sv.BackupRetentionEnabled = ptr.Bool(jtv)
26652			}
26653
26654		case "engineVersion":
26655			if value != nil {
26656				jtv, ok := value.(string)
26657				if !ok {
26658					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26659				}
26660				sv.EngineVersion = ptr.String(jtv)
26661			}
26662
26663		case "masterUserPassword":
26664			if value != nil {
26665				jtv, ok := value.(string)
26666				if !ok {
26667					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26668				}
26669				sv.MasterUserPassword = ptr.String(jtv)
26670			}
26671
26672		default:
26673			_, _ = key, value
26674
26675		}
26676	}
26677	*v = sv
26678	return nil
26679}
26680
26681func awsAwsjson11_deserializeDocumentPortList(v *[]int32, value interface{}) error {
26682	if v == nil {
26683		return fmt.Errorf("unexpected nil of type %T", v)
26684	}
26685	if value == nil {
26686		return nil
26687	}
26688
26689	shape, ok := value.([]interface{})
26690	if !ok {
26691		return fmt.Errorf("unexpected JSON type %v", value)
26692	}
26693
26694	var cv []int32
26695	if *v == nil {
26696		cv = []int32{}
26697	} else {
26698		cv = *v
26699	}
26700
26701	for _, value := range shape {
26702		var col int32
26703		if value != nil {
26704			jtv, ok := value.(json.Number)
26705			if !ok {
26706				return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
26707			}
26708			i64, err := jtv.Int64()
26709			if err != nil {
26710				return err
26711			}
26712			col = int32(i64)
26713		}
26714		cv = append(cv, col)
26715
26716	}
26717	*v = cv
26718	return nil
26719}
26720
26721func awsAwsjson11_deserializeDocumentPortMap(v *map[string]types.ContainerServiceProtocol, value interface{}) error {
26722	if v == nil {
26723		return fmt.Errorf("unexpected nil of type %T", v)
26724	}
26725	if value == nil {
26726		return nil
26727	}
26728
26729	shape, ok := value.(map[string]interface{})
26730	if !ok {
26731		return fmt.Errorf("unexpected JSON type %v", value)
26732	}
26733
26734	var mv map[string]types.ContainerServiceProtocol
26735	if *v == nil {
26736		mv = map[string]types.ContainerServiceProtocol{}
26737	} else {
26738		mv = *v
26739	}
26740
26741	for key, value := range shape {
26742		var parsedVal types.ContainerServiceProtocol
26743		if value != nil {
26744			jtv, ok := value.(string)
26745			if !ok {
26746				return fmt.Errorf("expected ContainerServiceProtocol to be of type string, got %T instead", value)
26747			}
26748			parsedVal = types.ContainerServiceProtocol(jtv)
26749		}
26750		mv[key] = parsedVal
26751
26752	}
26753	*v = mv
26754	return nil
26755}
26756
26757func awsAwsjson11_deserializeDocumentQueryStringObject(v **types.QueryStringObject, value interface{}) error {
26758	if v == nil {
26759		return fmt.Errorf("unexpected nil of type %T", v)
26760	}
26761	if value == nil {
26762		return nil
26763	}
26764
26765	shape, ok := value.(map[string]interface{})
26766	if !ok {
26767		return fmt.Errorf("unexpected JSON type %v", value)
26768	}
26769
26770	var sv *types.QueryStringObject
26771	if *v == nil {
26772		sv = &types.QueryStringObject{}
26773	} else {
26774		sv = *v
26775	}
26776
26777	for key, value := range shape {
26778		switch key {
26779		case "option":
26780			if value != nil {
26781				jtv, ok := value.(bool)
26782				if !ok {
26783					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26784				}
26785				sv.Option = ptr.Bool(jtv)
26786			}
26787
26788		case "queryStringsAllowList":
26789			if err := awsAwsjson11_deserializeDocumentStringList(&sv.QueryStringsAllowList, value); err != nil {
26790				return err
26791			}
26792
26793		default:
26794			_, _ = key, value
26795
26796		}
26797	}
26798	*v = sv
26799	return nil
26800}
26801
26802func awsAwsjson11_deserializeDocumentRegion(v **types.Region, value interface{}) error {
26803	if v == nil {
26804		return fmt.Errorf("unexpected nil of type %T", v)
26805	}
26806	if value == nil {
26807		return nil
26808	}
26809
26810	shape, ok := value.(map[string]interface{})
26811	if !ok {
26812		return fmt.Errorf("unexpected JSON type %v", value)
26813	}
26814
26815	var sv *types.Region
26816	if *v == nil {
26817		sv = &types.Region{}
26818	} else {
26819		sv = *v
26820	}
26821
26822	for key, value := range shape {
26823		switch key {
26824		case "availabilityZones":
26825			if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.AvailabilityZones, value); err != nil {
26826				return err
26827			}
26828
26829		case "continentCode":
26830			if value != nil {
26831				jtv, ok := value.(string)
26832				if !ok {
26833					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26834				}
26835				sv.ContinentCode = ptr.String(jtv)
26836			}
26837
26838		case "description":
26839			if value != nil {
26840				jtv, ok := value.(string)
26841				if !ok {
26842					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26843				}
26844				sv.Description = ptr.String(jtv)
26845			}
26846
26847		case "displayName":
26848			if value != nil {
26849				jtv, ok := value.(string)
26850				if !ok {
26851					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26852				}
26853				sv.DisplayName = ptr.String(jtv)
26854			}
26855
26856		case "name":
26857			if value != nil {
26858				jtv, ok := value.(string)
26859				if !ok {
26860					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
26861				}
26862				sv.Name = types.RegionName(jtv)
26863			}
26864
26865		case "relationalDatabaseAvailabilityZones":
26866			if err := awsAwsjson11_deserializeDocumentAvailabilityZoneList(&sv.RelationalDatabaseAvailabilityZones, value); err != nil {
26867				return err
26868			}
26869
26870		default:
26871			_, _ = key, value
26872
26873		}
26874	}
26875	*v = sv
26876	return nil
26877}
26878
26879func awsAwsjson11_deserializeDocumentRegionList(v *[]types.Region, value interface{}) error {
26880	if v == nil {
26881		return fmt.Errorf("unexpected nil of type %T", v)
26882	}
26883	if value == nil {
26884		return nil
26885	}
26886
26887	shape, ok := value.([]interface{})
26888	if !ok {
26889		return fmt.Errorf("unexpected JSON type %v", value)
26890	}
26891
26892	var cv []types.Region
26893	if *v == nil {
26894		cv = []types.Region{}
26895	} else {
26896		cv = *v
26897	}
26898
26899	for _, value := range shape {
26900		var col types.Region
26901		destAddr := &col
26902		if err := awsAwsjson11_deserializeDocumentRegion(&destAddr, value); err != nil {
26903			return err
26904		}
26905		col = *destAddr
26906		cv = append(cv, col)
26907
26908	}
26909	*v = cv
26910	return nil
26911}
26912
26913func awsAwsjson11_deserializeDocumentRelationalDatabase(v **types.RelationalDatabase, value interface{}) error {
26914	if v == nil {
26915		return fmt.Errorf("unexpected nil of type %T", v)
26916	}
26917	if value == nil {
26918		return nil
26919	}
26920
26921	shape, ok := value.(map[string]interface{})
26922	if !ok {
26923		return fmt.Errorf("unexpected JSON type %v", value)
26924	}
26925
26926	var sv *types.RelationalDatabase
26927	if *v == nil {
26928		sv = &types.RelationalDatabase{}
26929	} else {
26930		sv = *v
26931	}
26932
26933	for key, value := range shape {
26934		switch key {
26935		case "arn":
26936			if value != nil {
26937				jtv, ok := value.(string)
26938				if !ok {
26939					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26940				}
26941				sv.Arn = ptr.String(jtv)
26942			}
26943
26944		case "backupRetentionEnabled":
26945			if value != nil {
26946				jtv, ok := value.(bool)
26947				if !ok {
26948					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
26949				}
26950				sv.BackupRetentionEnabled = ptr.Bool(jtv)
26951			}
26952
26953		case "caCertificateIdentifier":
26954			if value != nil {
26955				jtv, ok := value.(string)
26956				if !ok {
26957					return fmt.Errorf("expected string to be of type string, got %T instead", value)
26958				}
26959				sv.CaCertificateIdentifier = ptr.String(jtv)
26960			}
26961
26962		case "createdAt":
26963			if value != nil {
26964				jtv, ok := value.(json.Number)
26965				if !ok {
26966					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
26967				}
26968				f64, err := jtv.Float64()
26969				if err != nil {
26970					return err
26971				}
26972				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
26973			}
26974
26975		case "engine":
26976			if value != nil {
26977				jtv, ok := value.(string)
26978				if !ok {
26979					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26980				}
26981				sv.Engine = ptr.String(jtv)
26982			}
26983
26984		case "engineVersion":
26985			if value != nil {
26986				jtv, ok := value.(string)
26987				if !ok {
26988					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
26989				}
26990				sv.EngineVersion = ptr.String(jtv)
26991			}
26992
26993		case "hardware":
26994			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(&sv.Hardware, value); err != nil {
26995				return err
26996			}
26997
26998		case "latestRestorableTime":
26999			if value != nil {
27000				jtv, ok := value.(json.Number)
27001				if !ok {
27002					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
27003				}
27004				f64, err := jtv.Float64()
27005				if err != nil {
27006					return err
27007				}
27008				sv.LatestRestorableTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
27009			}
27010
27011		case "location":
27012			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27013				return err
27014			}
27015
27016		case "masterDatabaseName":
27017			if value != nil {
27018				jtv, ok := value.(string)
27019				if !ok {
27020					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27021				}
27022				sv.MasterDatabaseName = ptr.String(jtv)
27023			}
27024
27025		case "masterEndpoint":
27026			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(&sv.MasterEndpoint, value); err != nil {
27027				return err
27028			}
27029
27030		case "masterUsername":
27031			if value != nil {
27032				jtv, ok := value.(string)
27033				if !ok {
27034					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27035				}
27036				sv.MasterUsername = ptr.String(jtv)
27037			}
27038
27039		case "name":
27040			if value != nil {
27041				jtv, ok := value.(string)
27042				if !ok {
27043					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27044				}
27045				sv.Name = ptr.String(jtv)
27046			}
27047
27048		case "parameterApplyStatus":
27049			if value != nil {
27050				jtv, ok := value.(string)
27051				if !ok {
27052					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27053				}
27054				sv.ParameterApplyStatus = ptr.String(jtv)
27055			}
27056
27057		case "pendingMaintenanceActions":
27058			if err := awsAwsjson11_deserializeDocumentPendingMaintenanceActionList(&sv.PendingMaintenanceActions, value); err != nil {
27059				return err
27060			}
27061
27062		case "pendingModifiedValues":
27063			if err := awsAwsjson11_deserializeDocumentPendingModifiedRelationalDatabaseValues(&sv.PendingModifiedValues, value); err != nil {
27064				return err
27065			}
27066
27067		case "preferredBackupWindow":
27068			if value != nil {
27069				jtv, ok := value.(string)
27070				if !ok {
27071					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27072				}
27073				sv.PreferredBackupWindow = ptr.String(jtv)
27074			}
27075
27076		case "preferredMaintenanceWindow":
27077			if value != nil {
27078				jtv, ok := value.(string)
27079				if !ok {
27080					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27081				}
27082				sv.PreferredMaintenanceWindow = ptr.String(jtv)
27083			}
27084
27085		case "publiclyAccessible":
27086			if value != nil {
27087				jtv, ok := value.(bool)
27088				if !ok {
27089					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27090				}
27091				sv.PubliclyAccessible = ptr.Bool(jtv)
27092			}
27093
27094		case "relationalDatabaseBlueprintId":
27095			if value != nil {
27096				jtv, ok := value.(string)
27097				if !ok {
27098					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27099				}
27100				sv.RelationalDatabaseBlueprintId = ptr.String(jtv)
27101			}
27102
27103		case "relationalDatabaseBundleId":
27104			if value != nil {
27105				jtv, ok := value.(string)
27106				if !ok {
27107					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27108				}
27109				sv.RelationalDatabaseBundleId = ptr.String(jtv)
27110			}
27111
27112		case "resourceType":
27113			if value != nil {
27114				jtv, ok := value.(string)
27115				if !ok {
27116					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27117				}
27118				sv.ResourceType = types.ResourceType(jtv)
27119			}
27120
27121		case "secondaryAvailabilityZone":
27122			if value != nil {
27123				jtv, ok := value.(string)
27124				if !ok {
27125					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27126				}
27127				sv.SecondaryAvailabilityZone = ptr.String(jtv)
27128			}
27129
27130		case "state":
27131			if value != nil {
27132				jtv, ok := value.(string)
27133				if !ok {
27134					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27135				}
27136				sv.State = ptr.String(jtv)
27137			}
27138
27139		case "supportCode":
27140			if value != nil {
27141				jtv, ok := value.(string)
27142				if !ok {
27143					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27144				}
27145				sv.SupportCode = ptr.String(jtv)
27146			}
27147
27148		case "tags":
27149			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
27150				return err
27151			}
27152
27153		default:
27154			_, _ = key, value
27155
27156		}
27157	}
27158	*v = sv
27159	return nil
27160}
27161
27162func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(v **types.RelationalDatabaseBlueprint, value interface{}) error {
27163	if v == nil {
27164		return fmt.Errorf("unexpected nil of type %T", v)
27165	}
27166	if value == nil {
27167		return nil
27168	}
27169
27170	shape, ok := value.(map[string]interface{})
27171	if !ok {
27172		return fmt.Errorf("unexpected JSON type %v", value)
27173	}
27174
27175	var sv *types.RelationalDatabaseBlueprint
27176	if *v == nil {
27177		sv = &types.RelationalDatabaseBlueprint{}
27178	} else {
27179		sv = *v
27180	}
27181
27182	for key, value := range shape {
27183		switch key {
27184		case "blueprintId":
27185			if value != nil {
27186				jtv, ok := value.(string)
27187				if !ok {
27188					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27189				}
27190				sv.BlueprintId = ptr.String(jtv)
27191			}
27192
27193		case "engine":
27194			if value != nil {
27195				jtv, ok := value.(string)
27196				if !ok {
27197					return fmt.Errorf("expected RelationalDatabaseEngine to be of type string, got %T instead", value)
27198				}
27199				sv.Engine = types.RelationalDatabaseEngine(jtv)
27200			}
27201
27202		case "engineDescription":
27203			if value != nil {
27204				jtv, ok := value.(string)
27205				if !ok {
27206					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27207				}
27208				sv.EngineDescription = ptr.String(jtv)
27209			}
27210
27211		case "engineVersion":
27212			if value != nil {
27213				jtv, ok := value.(string)
27214				if !ok {
27215					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27216				}
27217				sv.EngineVersion = ptr.String(jtv)
27218			}
27219
27220		case "engineVersionDescription":
27221			if value != nil {
27222				jtv, ok := value.(string)
27223				if !ok {
27224					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27225				}
27226				sv.EngineVersionDescription = ptr.String(jtv)
27227			}
27228
27229		case "isEngineDefault":
27230			if value != nil {
27231				jtv, ok := value.(bool)
27232				if !ok {
27233					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27234				}
27235				sv.IsEngineDefault = ptr.Bool(jtv)
27236			}
27237
27238		default:
27239			_, _ = key, value
27240
27241		}
27242	}
27243	*v = sv
27244	return nil
27245}
27246
27247func awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(v *[]types.RelationalDatabaseBlueprint, value interface{}) error {
27248	if v == nil {
27249		return fmt.Errorf("unexpected nil of type %T", v)
27250	}
27251	if value == nil {
27252		return nil
27253	}
27254
27255	shape, ok := value.([]interface{})
27256	if !ok {
27257		return fmt.Errorf("unexpected JSON type %v", value)
27258	}
27259
27260	var cv []types.RelationalDatabaseBlueprint
27261	if *v == nil {
27262		cv = []types.RelationalDatabaseBlueprint{}
27263	} else {
27264		cv = *v
27265	}
27266
27267	for _, value := range shape {
27268		var col types.RelationalDatabaseBlueprint
27269		destAddr := &col
27270		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprint(&destAddr, value); err != nil {
27271			return err
27272		}
27273		col = *destAddr
27274		cv = append(cv, col)
27275
27276	}
27277	*v = cv
27278	return nil
27279}
27280
27281func awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(v **types.RelationalDatabaseBundle, value interface{}) error {
27282	if v == nil {
27283		return fmt.Errorf("unexpected nil of type %T", v)
27284	}
27285	if value == nil {
27286		return nil
27287	}
27288
27289	shape, ok := value.(map[string]interface{})
27290	if !ok {
27291		return fmt.Errorf("unexpected JSON type %v", value)
27292	}
27293
27294	var sv *types.RelationalDatabaseBundle
27295	if *v == nil {
27296		sv = &types.RelationalDatabaseBundle{}
27297	} else {
27298		sv = *v
27299	}
27300
27301	for key, value := range shape {
27302		switch key {
27303		case "bundleId":
27304			if value != nil {
27305				jtv, ok := value.(string)
27306				if !ok {
27307					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27308				}
27309				sv.BundleId = ptr.String(jtv)
27310			}
27311
27312		case "cpuCount":
27313			if value != nil {
27314				jtv, ok := value.(json.Number)
27315				if !ok {
27316					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27317				}
27318				i64, err := jtv.Int64()
27319				if err != nil {
27320					return err
27321				}
27322				sv.CpuCount = ptr.Int32(int32(i64))
27323			}
27324
27325		case "diskSizeInGb":
27326			if value != nil {
27327				jtv, ok := value.(json.Number)
27328				if !ok {
27329					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27330				}
27331				i64, err := jtv.Int64()
27332				if err != nil {
27333					return err
27334				}
27335				sv.DiskSizeInGb = ptr.Int32(int32(i64))
27336			}
27337
27338		case "isActive":
27339			if value != nil {
27340				jtv, ok := value.(bool)
27341				if !ok {
27342					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27343				}
27344				sv.IsActive = ptr.Bool(jtv)
27345			}
27346
27347		case "isEncrypted":
27348			if value != nil {
27349				jtv, ok := value.(bool)
27350				if !ok {
27351					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27352				}
27353				sv.IsEncrypted = ptr.Bool(jtv)
27354			}
27355
27356		case "name":
27357			if value != nil {
27358				jtv, ok := value.(string)
27359				if !ok {
27360					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27361				}
27362				sv.Name = ptr.String(jtv)
27363			}
27364
27365		case "price":
27366			if value != nil {
27367				jtv, ok := value.(json.Number)
27368				if !ok {
27369					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
27370				}
27371				f64, err := jtv.Float64()
27372				if err != nil {
27373					return err
27374				}
27375				sv.Price = ptr.Float32(float32(f64))
27376			}
27377
27378		case "ramSizeInGb":
27379			if value != nil {
27380				jtv, ok := value.(json.Number)
27381				if !ok {
27382					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
27383				}
27384				f64, err := jtv.Float64()
27385				if err != nil {
27386					return err
27387				}
27388				sv.RamSizeInGb = ptr.Float32(float32(f64))
27389			}
27390
27391		case "transferPerMonthInGb":
27392			if value != nil {
27393				jtv, ok := value.(json.Number)
27394				if !ok {
27395					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27396				}
27397				i64, err := jtv.Int64()
27398				if err != nil {
27399					return err
27400				}
27401				sv.TransferPerMonthInGb = ptr.Int32(int32(i64))
27402			}
27403
27404		default:
27405			_, _ = key, value
27406
27407		}
27408	}
27409	*v = sv
27410	return nil
27411}
27412
27413func awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(v *[]types.RelationalDatabaseBundle, value interface{}) error {
27414	if v == nil {
27415		return fmt.Errorf("unexpected nil of type %T", v)
27416	}
27417	if value == nil {
27418		return nil
27419	}
27420
27421	shape, ok := value.([]interface{})
27422	if !ok {
27423		return fmt.Errorf("unexpected JSON type %v", value)
27424	}
27425
27426	var cv []types.RelationalDatabaseBundle
27427	if *v == nil {
27428		cv = []types.RelationalDatabaseBundle{}
27429	} else {
27430		cv = *v
27431	}
27432
27433	for _, value := range shape {
27434		var col types.RelationalDatabaseBundle
27435		destAddr := &col
27436		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundle(&destAddr, value); err != nil {
27437			return err
27438		}
27439		col = *destAddr
27440		cv = append(cv, col)
27441
27442	}
27443	*v = cv
27444	return nil
27445}
27446
27447func awsAwsjson11_deserializeDocumentRelationalDatabaseEndpoint(v **types.RelationalDatabaseEndpoint, value interface{}) error {
27448	if v == nil {
27449		return fmt.Errorf("unexpected nil of type %T", v)
27450	}
27451	if value == nil {
27452		return nil
27453	}
27454
27455	shape, ok := value.(map[string]interface{})
27456	if !ok {
27457		return fmt.Errorf("unexpected JSON type %v", value)
27458	}
27459
27460	var sv *types.RelationalDatabaseEndpoint
27461	if *v == nil {
27462		sv = &types.RelationalDatabaseEndpoint{}
27463	} else {
27464		sv = *v
27465	}
27466
27467	for key, value := range shape {
27468		switch key {
27469		case "address":
27470			if value != nil {
27471				jtv, ok := value.(string)
27472				if !ok {
27473					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27474				}
27475				sv.Address = ptr.String(jtv)
27476			}
27477
27478		case "port":
27479			if value != nil {
27480				jtv, ok := value.(json.Number)
27481				if !ok {
27482					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27483				}
27484				i64, err := jtv.Int64()
27485				if err != nil {
27486					return err
27487				}
27488				sv.Port = ptr.Int32(int32(i64))
27489			}
27490
27491		default:
27492			_, _ = key, value
27493
27494		}
27495	}
27496	*v = sv
27497	return nil
27498}
27499
27500func awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(v **types.RelationalDatabaseEvent, value interface{}) error {
27501	if v == nil {
27502		return fmt.Errorf("unexpected nil of type %T", v)
27503	}
27504	if value == nil {
27505		return nil
27506	}
27507
27508	shape, ok := value.(map[string]interface{})
27509	if !ok {
27510		return fmt.Errorf("unexpected JSON type %v", value)
27511	}
27512
27513	var sv *types.RelationalDatabaseEvent
27514	if *v == nil {
27515		sv = &types.RelationalDatabaseEvent{}
27516	} else {
27517		sv = *v
27518	}
27519
27520	for key, value := range shape {
27521		switch key {
27522		case "createdAt":
27523			if value != nil {
27524				jtv, ok := value.(json.Number)
27525				if !ok {
27526					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
27527				}
27528				f64, err := jtv.Float64()
27529				if err != nil {
27530					return err
27531				}
27532				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27533			}
27534
27535		case "eventCategories":
27536			if err := awsAwsjson11_deserializeDocumentStringList(&sv.EventCategories, value); err != nil {
27537				return err
27538			}
27539
27540		case "message":
27541			if value != nil {
27542				jtv, ok := value.(string)
27543				if !ok {
27544					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27545				}
27546				sv.Message = ptr.String(jtv)
27547			}
27548
27549		case "resource":
27550			if value != nil {
27551				jtv, ok := value.(string)
27552				if !ok {
27553					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27554				}
27555				sv.Resource = ptr.String(jtv)
27556			}
27557
27558		default:
27559			_, _ = key, value
27560
27561		}
27562	}
27563	*v = sv
27564	return nil
27565}
27566
27567func awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(v *[]types.RelationalDatabaseEvent, value interface{}) error {
27568	if v == nil {
27569		return fmt.Errorf("unexpected nil of type %T", v)
27570	}
27571	if value == nil {
27572		return nil
27573	}
27574
27575	shape, ok := value.([]interface{})
27576	if !ok {
27577		return fmt.Errorf("unexpected JSON type %v", value)
27578	}
27579
27580	var cv []types.RelationalDatabaseEvent
27581	if *v == nil {
27582		cv = []types.RelationalDatabaseEvent{}
27583	} else {
27584		cv = *v
27585	}
27586
27587	for _, value := range shape {
27588		var col types.RelationalDatabaseEvent
27589		destAddr := &col
27590		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEvent(&destAddr, value); err != nil {
27591			return err
27592		}
27593		col = *destAddr
27594		cv = append(cv, col)
27595
27596	}
27597	*v = cv
27598	return nil
27599}
27600
27601func awsAwsjson11_deserializeDocumentRelationalDatabaseHardware(v **types.RelationalDatabaseHardware, value interface{}) error {
27602	if v == nil {
27603		return fmt.Errorf("unexpected nil of type %T", v)
27604	}
27605	if value == nil {
27606		return nil
27607	}
27608
27609	shape, ok := value.(map[string]interface{})
27610	if !ok {
27611		return fmt.Errorf("unexpected JSON type %v", value)
27612	}
27613
27614	var sv *types.RelationalDatabaseHardware
27615	if *v == nil {
27616		sv = &types.RelationalDatabaseHardware{}
27617	} else {
27618		sv = *v
27619	}
27620
27621	for key, value := range shape {
27622		switch key {
27623		case "cpuCount":
27624			if value != nil {
27625				jtv, ok := value.(json.Number)
27626				if !ok {
27627					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27628				}
27629				i64, err := jtv.Int64()
27630				if err != nil {
27631					return err
27632				}
27633				sv.CpuCount = ptr.Int32(int32(i64))
27634			}
27635
27636		case "diskSizeInGb":
27637			if value != nil {
27638				jtv, ok := value.(json.Number)
27639				if !ok {
27640					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27641				}
27642				i64, err := jtv.Int64()
27643				if err != nil {
27644					return err
27645				}
27646				sv.DiskSizeInGb = ptr.Int32(int32(i64))
27647			}
27648
27649		case "ramSizeInGb":
27650			if value != nil {
27651				jtv, ok := value.(json.Number)
27652				if !ok {
27653					return fmt.Errorf("expected float to be json.Number, got %T instead", value)
27654				}
27655				f64, err := jtv.Float64()
27656				if err != nil {
27657					return err
27658				}
27659				sv.RamSizeInGb = ptr.Float32(float32(f64))
27660			}
27661
27662		default:
27663			_, _ = key, value
27664
27665		}
27666	}
27667	*v = sv
27668	return nil
27669}
27670
27671func awsAwsjson11_deserializeDocumentRelationalDatabaseList(v *[]types.RelationalDatabase, value interface{}) error {
27672	if v == nil {
27673		return fmt.Errorf("unexpected nil of type %T", v)
27674	}
27675	if value == nil {
27676		return nil
27677	}
27678
27679	shape, ok := value.([]interface{})
27680	if !ok {
27681		return fmt.Errorf("unexpected JSON type %v", value)
27682	}
27683
27684	var cv []types.RelationalDatabase
27685	if *v == nil {
27686		cv = []types.RelationalDatabase{}
27687	} else {
27688		cv = *v
27689	}
27690
27691	for _, value := range shape {
27692		var col types.RelationalDatabase
27693		destAddr := &col
27694		if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&destAddr, value); err != nil {
27695			return err
27696		}
27697		col = *destAddr
27698		cv = append(cv, col)
27699
27700	}
27701	*v = cv
27702	return nil
27703}
27704
27705func awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(v **types.RelationalDatabaseParameter, value interface{}) error {
27706	if v == nil {
27707		return fmt.Errorf("unexpected nil of type %T", v)
27708	}
27709	if value == nil {
27710		return nil
27711	}
27712
27713	shape, ok := value.(map[string]interface{})
27714	if !ok {
27715		return fmt.Errorf("unexpected JSON type %v", value)
27716	}
27717
27718	var sv *types.RelationalDatabaseParameter
27719	if *v == nil {
27720		sv = &types.RelationalDatabaseParameter{}
27721	} else {
27722		sv = *v
27723	}
27724
27725	for key, value := range shape {
27726		switch key {
27727		case "allowedValues":
27728			if value != nil {
27729				jtv, ok := value.(string)
27730				if !ok {
27731					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27732				}
27733				sv.AllowedValues = ptr.String(jtv)
27734			}
27735
27736		case "applyMethod":
27737			if value != nil {
27738				jtv, ok := value.(string)
27739				if !ok {
27740					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27741				}
27742				sv.ApplyMethod = ptr.String(jtv)
27743			}
27744
27745		case "applyType":
27746			if value != nil {
27747				jtv, ok := value.(string)
27748				if !ok {
27749					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27750				}
27751				sv.ApplyType = ptr.String(jtv)
27752			}
27753
27754		case "dataType":
27755			if value != nil {
27756				jtv, ok := value.(string)
27757				if !ok {
27758					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27759				}
27760				sv.DataType = ptr.String(jtv)
27761			}
27762
27763		case "description":
27764			if value != nil {
27765				jtv, ok := value.(string)
27766				if !ok {
27767					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27768				}
27769				sv.Description = ptr.String(jtv)
27770			}
27771
27772		case "isModifiable":
27773			if value != nil {
27774				jtv, ok := value.(bool)
27775				if !ok {
27776					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
27777				}
27778				sv.IsModifiable = ptr.Bool(jtv)
27779			}
27780
27781		case "parameterName":
27782			if value != nil {
27783				jtv, ok := value.(string)
27784				if !ok {
27785					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27786				}
27787				sv.ParameterName = ptr.String(jtv)
27788			}
27789
27790		case "parameterValue":
27791			if value != nil {
27792				jtv, ok := value.(string)
27793				if !ok {
27794					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27795				}
27796				sv.ParameterValue = ptr.String(jtv)
27797			}
27798
27799		default:
27800			_, _ = key, value
27801
27802		}
27803	}
27804	*v = sv
27805	return nil
27806}
27807
27808func awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(v *[]types.RelationalDatabaseParameter, value interface{}) error {
27809	if v == nil {
27810		return fmt.Errorf("unexpected nil of type %T", v)
27811	}
27812	if value == nil {
27813		return nil
27814	}
27815
27816	shape, ok := value.([]interface{})
27817	if !ok {
27818		return fmt.Errorf("unexpected JSON type %v", value)
27819	}
27820
27821	var cv []types.RelationalDatabaseParameter
27822	if *v == nil {
27823		cv = []types.RelationalDatabaseParameter{}
27824	} else {
27825		cv = *v
27826	}
27827
27828	for _, value := range shape {
27829		var col types.RelationalDatabaseParameter
27830		destAddr := &col
27831		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameter(&destAddr, value); err != nil {
27832			return err
27833		}
27834		col = *destAddr
27835		cv = append(cv, col)
27836
27837	}
27838	*v = cv
27839	return nil
27840}
27841
27842func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(v **types.RelationalDatabaseSnapshot, value interface{}) error {
27843	if v == nil {
27844		return fmt.Errorf("unexpected nil of type %T", v)
27845	}
27846	if value == nil {
27847		return nil
27848	}
27849
27850	shape, ok := value.(map[string]interface{})
27851	if !ok {
27852		return fmt.Errorf("unexpected JSON type %v", value)
27853	}
27854
27855	var sv *types.RelationalDatabaseSnapshot
27856	if *v == nil {
27857		sv = &types.RelationalDatabaseSnapshot{}
27858	} else {
27859		sv = *v
27860	}
27861
27862	for key, value := range shape {
27863		switch key {
27864		case "arn":
27865			if value != nil {
27866				jtv, ok := value.(string)
27867				if !ok {
27868					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27869				}
27870				sv.Arn = ptr.String(jtv)
27871			}
27872
27873		case "createdAt":
27874			if value != nil {
27875				jtv, ok := value.(json.Number)
27876				if !ok {
27877					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
27878				}
27879				f64, err := jtv.Float64()
27880				if err != nil {
27881					return err
27882				}
27883				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
27884			}
27885
27886		case "engine":
27887			if value != nil {
27888				jtv, ok := value.(string)
27889				if !ok {
27890					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27891				}
27892				sv.Engine = ptr.String(jtv)
27893			}
27894
27895		case "engineVersion":
27896			if value != nil {
27897				jtv, ok := value.(string)
27898				if !ok {
27899					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27900				}
27901				sv.EngineVersion = ptr.String(jtv)
27902			}
27903
27904		case "fromRelationalDatabaseArn":
27905			if value != nil {
27906				jtv, ok := value.(string)
27907				if !ok {
27908					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27909				}
27910				sv.FromRelationalDatabaseArn = ptr.String(jtv)
27911			}
27912
27913		case "fromRelationalDatabaseBlueprintId":
27914			if value != nil {
27915				jtv, ok := value.(string)
27916				if !ok {
27917					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27918				}
27919				sv.FromRelationalDatabaseBlueprintId = ptr.String(jtv)
27920			}
27921
27922		case "fromRelationalDatabaseBundleId":
27923			if value != nil {
27924				jtv, ok := value.(string)
27925				if !ok {
27926					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27927				}
27928				sv.FromRelationalDatabaseBundleId = ptr.String(jtv)
27929			}
27930
27931		case "fromRelationalDatabaseName":
27932			if value != nil {
27933				jtv, ok := value.(string)
27934				if !ok {
27935					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27936				}
27937				sv.FromRelationalDatabaseName = ptr.String(jtv)
27938			}
27939
27940		case "location":
27941			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
27942				return err
27943			}
27944
27945		case "name":
27946			if value != nil {
27947				jtv, ok := value.(string)
27948				if !ok {
27949					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
27950				}
27951				sv.Name = ptr.String(jtv)
27952			}
27953
27954		case "resourceType":
27955			if value != nil {
27956				jtv, ok := value.(string)
27957				if !ok {
27958					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
27959				}
27960				sv.ResourceType = types.ResourceType(jtv)
27961			}
27962
27963		case "sizeInGb":
27964			if value != nil {
27965				jtv, ok := value.(json.Number)
27966				if !ok {
27967					return fmt.Errorf("expected integer to be json.Number, got %T instead", value)
27968				}
27969				i64, err := jtv.Int64()
27970				if err != nil {
27971					return err
27972				}
27973				sv.SizeInGb = ptr.Int32(int32(i64))
27974			}
27975
27976		case "state":
27977			if value != nil {
27978				jtv, ok := value.(string)
27979				if !ok {
27980					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
27981				}
27982				sv.State = ptr.String(jtv)
27983			}
27984
27985		case "supportCode":
27986			if value != nil {
27987				jtv, ok := value.(string)
27988				if !ok {
27989					return fmt.Errorf("expected string to be of type string, got %T instead", value)
27990				}
27991				sv.SupportCode = ptr.String(jtv)
27992			}
27993
27994		case "tags":
27995			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
27996				return err
27997			}
27998
27999		default:
28000			_, _ = key, value
28001
28002		}
28003	}
28004	*v = sv
28005	return nil
28006}
28007
28008func awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(v *[]types.RelationalDatabaseSnapshot, value interface{}) error {
28009	if v == nil {
28010		return fmt.Errorf("unexpected nil of type %T", v)
28011	}
28012	if value == nil {
28013		return nil
28014	}
28015
28016	shape, ok := value.([]interface{})
28017	if !ok {
28018		return fmt.Errorf("unexpected JSON type %v", value)
28019	}
28020
28021	var cv []types.RelationalDatabaseSnapshot
28022	if *v == nil {
28023		cv = []types.RelationalDatabaseSnapshot{}
28024	} else {
28025		cv = *v
28026	}
28027
28028	for _, value := range shape {
28029		var col types.RelationalDatabaseSnapshot
28030		destAddr := &col
28031		if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&destAddr, value); err != nil {
28032			return err
28033		}
28034		col = *destAddr
28035		cv = append(cv, col)
28036
28037	}
28038	*v = cv
28039	return nil
28040}
28041
28042func awsAwsjson11_deserializeDocumentRenewalSummary(v **types.RenewalSummary, value interface{}) error {
28043	if v == nil {
28044		return fmt.Errorf("unexpected nil of type %T", v)
28045	}
28046	if value == nil {
28047		return nil
28048	}
28049
28050	shape, ok := value.(map[string]interface{})
28051	if !ok {
28052		return fmt.Errorf("unexpected JSON type %v", value)
28053	}
28054
28055	var sv *types.RenewalSummary
28056	if *v == nil {
28057		sv = &types.RenewalSummary{}
28058	} else {
28059		sv = *v
28060	}
28061
28062	for key, value := range shape {
28063		switch key {
28064		case "domainValidationRecords":
28065			if err := awsAwsjson11_deserializeDocumentDomainValidationRecordList(&sv.DomainValidationRecords, value); err != nil {
28066				return err
28067			}
28068
28069		case "renewalStatus":
28070			if value != nil {
28071				jtv, ok := value.(string)
28072				if !ok {
28073					return fmt.Errorf("expected RenewalStatus to be of type string, got %T instead", value)
28074				}
28075				sv.RenewalStatus = types.RenewalStatus(jtv)
28076			}
28077
28078		case "renewalStatusReason":
28079			if value != nil {
28080				jtv, ok := value.(string)
28081				if !ok {
28082					return fmt.Errorf("expected RenewalStatusReason to be of type string, got %T instead", value)
28083				}
28084				sv.RenewalStatusReason = ptr.String(jtv)
28085			}
28086
28087		case "updatedAt":
28088			if value != nil {
28089				jtv, ok := value.(json.Number)
28090				if !ok {
28091					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
28092				}
28093				f64, err := jtv.Float64()
28094				if err != nil {
28095					return err
28096				}
28097				sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28098			}
28099
28100		default:
28101			_, _ = key, value
28102
28103		}
28104	}
28105	*v = sv
28106	return nil
28107}
28108
28109func awsAwsjson11_deserializeDocumentResourceLocation(v **types.ResourceLocation, value interface{}) error {
28110	if v == nil {
28111		return fmt.Errorf("unexpected nil of type %T", v)
28112	}
28113	if value == nil {
28114		return nil
28115	}
28116
28117	shape, ok := value.(map[string]interface{})
28118	if !ok {
28119		return fmt.Errorf("unexpected JSON type %v", value)
28120	}
28121
28122	var sv *types.ResourceLocation
28123	if *v == nil {
28124		sv = &types.ResourceLocation{}
28125	} else {
28126		sv = *v
28127	}
28128
28129	for key, value := range shape {
28130		switch key {
28131		case "availabilityZone":
28132			if value != nil {
28133				jtv, ok := value.(string)
28134				if !ok {
28135					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28136				}
28137				sv.AvailabilityZone = ptr.String(jtv)
28138			}
28139
28140		case "regionName":
28141			if value != nil {
28142				jtv, ok := value.(string)
28143				if !ok {
28144					return fmt.Errorf("expected RegionName to be of type string, got %T instead", value)
28145				}
28146				sv.RegionName = types.RegionName(jtv)
28147			}
28148
28149		default:
28150			_, _ = key, value
28151
28152		}
28153	}
28154	*v = sv
28155	return nil
28156}
28157
28158func awsAwsjson11_deserializeDocumentResourceRecord(v **types.ResourceRecord, value interface{}) error {
28159	if v == nil {
28160		return fmt.Errorf("unexpected nil of type %T", v)
28161	}
28162	if value == nil {
28163		return nil
28164	}
28165
28166	shape, ok := value.(map[string]interface{})
28167	if !ok {
28168		return fmt.Errorf("unexpected JSON type %v", value)
28169	}
28170
28171	var sv *types.ResourceRecord
28172	if *v == nil {
28173		sv = &types.ResourceRecord{}
28174	} else {
28175		sv = *v
28176	}
28177
28178	for key, value := range shape {
28179		switch key {
28180		case "name":
28181			if value != nil {
28182				jtv, ok := value.(string)
28183				if !ok {
28184					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28185				}
28186				sv.Name = ptr.String(jtv)
28187			}
28188
28189		case "type":
28190			if value != nil {
28191				jtv, ok := value.(string)
28192				if !ok {
28193					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28194				}
28195				sv.Type = ptr.String(jtv)
28196			}
28197
28198		case "value":
28199			if value != nil {
28200				jtv, ok := value.(string)
28201				if !ok {
28202					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28203				}
28204				sv.Value = ptr.String(jtv)
28205			}
28206
28207		default:
28208			_, _ = key, value
28209
28210		}
28211	}
28212	*v = sv
28213	return nil
28214}
28215
28216func awsAwsjson11_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error {
28217	if v == nil {
28218		return fmt.Errorf("unexpected nil of type %T", v)
28219	}
28220	if value == nil {
28221		return nil
28222	}
28223
28224	shape, ok := value.(map[string]interface{})
28225	if !ok {
28226		return fmt.Errorf("unexpected JSON type %v", value)
28227	}
28228
28229	var sv *types.ServiceException
28230	if *v == nil {
28231		sv = &types.ServiceException{}
28232	} else {
28233		sv = *v
28234	}
28235
28236	for key, value := range shape {
28237		switch key {
28238		case "code":
28239			if value != nil {
28240				jtv, ok := value.(string)
28241				if !ok {
28242					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28243				}
28244				sv.Code = ptr.String(jtv)
28245			}
28246
28247		case "docs":
28248			if value != nil {
28249				jtv, ok := value.(string)
28250				if !ok {
28251					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28252				}
28253				sv.Docs = ptr.String(jtv)
28254			}
28255
28256		case "message":
28257			if value != nil {
28258				jtv, ok := value.(string)
28259				if !ok {
28260					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28261				}
28262				sv.Message = ptr.String(jtv)
28263			}
28264
28265		case "tip":
28266			if value != nil {
28267				jtv, ok := value.(string)
28268				if !ok {
28269					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28270				}
28271				sv.Tip = ptr.String(jtv)
28272			}
28273
28274		default:
28275			_, _ = key, value
28276
28277		}
28278	}
28279	*v = sv
28280	return nil
28281}
28282
28283func awsAwsjson11_deserializeDocumentStaticIp(v **types.StaticIp, value interface{}) error {
28284	if v == nil {
28285		return fmt.Errorf("unexpected nil of type %T", v)
28286	}
28287	if value == nil {
28288		return nil
28289	}
28290
28291	shape, ok := value.(map[string]interface{})
28292	if !ok {
28293		return fmt.Errorf("unexpected JSON type %v", value)
28294	}
28295
28296	var sv *types.StaticIp
28297	if *v == nil {
28298		sv = &types.StaticIp{}
28299	} else {
28300		sv = *v
28301	}
28302
28303	for key, value := range shape {
28304		switch key {
28305		case "arn":
28306			if value != nil {
28307				jtv, ok := value.(string)
28308				if !ok {
28309					return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
28310				}
28311				sv.Arn = ptr.String(jtv)
28312			}
28313
28314		case "attachedTo":
28315			if value != nil {
28316				jtv, ok := value.(string)
28317				if !ok {
28318					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28319				}
28320				sv.AttachedTo = ptr.String(jtv)
28321			}
28322
28323		case "createdAt":
28324			if value != nil {
28325				jtv, ok := value.(json.Number)
28326				if !ok {
28327					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
28328				}
28329				f64, err := jtv.Float64()
28330				if err != nil {
28331					return err
28332				}
28333				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
28334			}
28335
28336		case "ipAddress":
28337			if value != nil {
28338				jtv, ok := value.(string)
28339				if !ok {
28340					return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
28341				}
28342				sv.IpAddress = ptr.String(jtv)
28343			}
28344
28345		case "isAttached":
28346			if value != nil {
28347				jtv, ok := value.(bool)
28348				if !ok {
28349					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
28350				}
28351				sv.IsAttached = ptr.Bool(jtv)
28352			}
28353
28354		case "location":
28355			if err := awsAwsjson11_deserializeDocumentResourceLocation(&sv.Location, value); err != nil {
28356				return err
28357			}
28358
28359		case "name":
28360			if value != nil {
28361				jtv, ok := value.(string)
28362				if !ok {
28363					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
28364				}
28365				sv.Name = ptr.String(jtv)
28366			}
28367
28368		case "resourceType":
28369			if value != nil {
28370				jtv, ok := value.(string)
28371				if !ok {
28372					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
28373				}
28374				sv.ResourceType = types.ResourceType(jtv)
28375			}
28376
28377		case "supportCode":
28378			if value != nil {
28379				jtv, ok := value.(string)
28380				if !ok {
28381					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28382				}
28383				sv.SupportCode = ptr.String(jtv)
28384			}
28385
28386		default:
28387			_, _ = key, value
28388
28389		}
28390	}
28391	*v = sv
28392	return nil
28393}
28394
28395func awsAwsjson11_deserializeDocumentStaticIpList(v *[]types.StaticIp, value interface{}) error {
28396	if v == nil {
28397		return fmt.Errorf("unexpected nil of type %T", v)
28398	}
28399	if value == nil {
28400		return nil
28401	}
28402
28403	shape, ok := value.([]interface{})
28404	if !ok {
28405		return fmt.Errorf("unexpected JSON type %v", value)
28406	}
28407
28408	var cv []types.StaticIp
28409	if *v == nil {
28410		cv = []types.StaticIp{}
28411	} else {
28412		cv = *v
28413	}
28414
28415	for _, value := range shape {
28416		var col types.StaticIp
28417		destAddr := &col
28418		if err := awsAwsjson11_deserializeDocumentStaticIp(&destAddr, value); err != nil {
28419			return err
28420		}
28421		col = *destAddr
28422		cv = append(cv, col)
28423
28424	}
28425	*v = cv
28426	return nil
28427}
28428
28429func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error {
28430	if v == nil {
28431		return fmt.Errorf("unexpected nil of type %T", v)
28432	}
28433	if value == nil {
28434		return nil
28435	}
28436
28437	shape, ok := value.([]interface{})
28438	if !ok {
28439		return fmt.Errorf("unexpected JSON type %v", value)
28440	}
28441
28442	var cv []string
28443	if *v == nil {
28444		cv = []string{}
28445	} else {
28446		cv = *v
28447	}
28448
28449	for _, value := range shape {
28450		var col string
28451		if value != nil {
28452			jtv, ok := value.(string)
28453			if !ok {
28454				return fmt.Errorf("expected string to be of type string, got %T instead", value)
28455			}
28456			col = jtv
28457		}
28458		cv = append(cv, col)
28459
28460	}
28461	*v = cv
28462	return nil
28463}
28464
28465func awsAwsjson11_deserializeDocumentSubjectAlternativeNameList(v *[]string, value interface{}) error {
28466	if v == nil {
28467		return fmt.Errorf("unexpected nil of type %T", v)
28468	}
28469	if value == nil {
28470		return nil
28471	}
28472
28473	shape, ok := value.([]interface{})
28474	if !ok {
28475		return fmt.Errorf("unexpected JSON type %v", value)
28476	}
28477
28478	var cv []string
28479	if *v == nil {
28480		cv = []string{}
28481	} else {
28482		cv = *v
28483	}
28484
28485	for _, value := range shape {
28486		var col string
28487		if value != nil {
28488			jtv, ok := value.(string)
28489			if !ok {
28490				return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
28491			}
28492			col = jtv
28493		}
28494		cv = append(cv, col)
28495
28496	}
28497	*v = cv
28498	return nil
28499}
28500
28501func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
28502	if v == nil {
28503		return fmt.Errorf("unexpected nil of type %T", v)
28504	}
28505	if value == nil {
28506		return nil
28507	}
28508
28509	shape, ok := value.(map[string]interface{})
28510	if !ok {
28511		return fmt.Errorf("unexpected JSON type %v", value)
28512	}
28513
28514	var sv *types.Tag
28515	if *v == nil {
28516		sv = &types.Tag{}
28517	} else {
28518		sv = *v
28519	}
28520
28521	for key, value := range shape {
28522		switch key {
28523		case "key":
28524			if value != nil {
28525				jtv, ok := value.(string)
28526				if !ok {
28527					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
28528				}
28529				sv.Key = ptr.String(jtv)
28530			}
28531
28532		case "value":
28533			if value != nil {
28534				jtv, ok := value.(string)
28535				if !ok {
28536					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
28537				}
28538				sv.Value = ptr.String(jtv)
28539			}
28540
28541		default:
28542			_, _ = key, value
28543
28544		}
28545	}
28546	*v = sv
28547	return nil
28548}
28549
28550func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
28551	if v == nil {
28552		return fmt.Errorf("unexpected nil of type %T", v)
28553	}
28554	if value == nil {
28555		return nil
28556	}
28557
28558	shape, ok := value.([]interface{})
28559	if !ok {
28560		return fmt.Errorf("unexpected JSON type %v", value)
28561	}
28562
28563	var cv []types.Tag
28564	if *v == nil {
28565		cv = []types.Tag{}
28566	} else {
28567		cv = *v
28568	}
28569
28570	for _, value := range shape {
28571		var col types.Tag
28572		destAddr := &col
28573		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
28574			return err
28575		}
28576		col = *destAddr
28577		cv = append(cv, col)
28578
28579	}
28580	*v = cv
28581	return nil
28582}
28583
28584func awsAwsjson11_deserializeDocumentUnauthenticatedException(v **types.UnauthenticatedException, value interface{}) error {
28585	if v == nil {
28586		return fmt.Errorf("unexpected nil of type %T", v)
28587	}
28588	if value == nil {
28589		return nil
28590	}
28591
28592	shape, ok := value.(map[string]interface{})
28593	if !ok {
28594		return fmt.Errorf("unexpected JSON type %v", value)
28595	}
28596
28597	var sv *types.UnauthenticatedException
28598	if *v == nil {
28599		sv = &types.UnauthenticatedException{}
28600	} else {
28601		sv = *v
28602	}
28603
28604	for key, value := range shape {
28605		switch key {
28606		case "code":
28607			if value != nil {
28608				jtv, ok := value.(string)
28609				if !ok {
28610					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28611				}
28612				sv.Code = ptr.String(jtv)
28613			}
28614
28615		case "docs":
28616			if value != nil {
28617				jtv, ok := value.(string)
28618				if !ok {
28619					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28620				}
28621				sv.Docs = ptr.String(jtv)
28622			}
28623
28624		case "message":
28625			if value != nil {
28626				jtv, ok := value.(string)
28627				if !ok {
28628					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28629				}
28630				sv.Message = ptr.String(jtv)
28631			}
28632
28633		case "tip":
28634			if value != nil {
28635				jtv, ok := value.(string)
28636				if !ok {
28637					return fmt.Errorf("expected string to be of type string, got %T instead", value)
28638				}
28639				sv.Tip = ptr.String(jtv)
28640			}
28641
28642		default:
28643			_, _ = key, value
28644
28645		}
28646	}
28647	*v = sv
28648	return nil
28649}
28650
28651func awsAwsjson11_deserializeOpDocumentAllocateStaticIpOutput(v **AllocateStaticIpOutput, value interface{}) error {
28652	if v == nil {
28653		return fmt.Errorf("unexpected nil of type %T", v)
28654	}
28655	if value == nil {
28656		return nil
28657	}
28658
28659	shape, ok := value.(map[string]interface{})
28660	if !ok {
28661		return fmt.Errorf("unexpected JSON type %v", value)
28662	}
28663
28664	var sv *AllocateStaticIpOutput
28665	if *v == nil {
28666		sv = &AllocateStaticIpOutput{}
28667	} else {
28668		sv = *v
28669	}
28670
28671	for key, value := range shape {
28672		switch key {
28673		case "operations":
28674			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28675				return err
28676			}
28677
28678		default:
28679			_, _ = key, value
28680
28681		}
28682	}
28683	*v = sv
28684	return nil
28685}
28686
28687func awsAwsjson11_deserializeOpDocumentAttachCertificateToDistributionOutput(v **AttachCertificateToDistributionOutput, 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 *AttachCertificateToDistributionOutput
28701	if *v == nil {
28702		sv = &AttachCertificateToDistributionOutput{}
28703	} else {
28704		sv = *v
28705	}
28706
28707	for key, value := range shape {
28708		switch key {
28709		case "operation":
28710			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
28711				return err
28712			}
28713
28714		default:
28715			_, _ = key, value
28716
28717		}
28718	}
28719	*v = sv
28720	return nil
28721}
28722
28723func awsAwsjson11_deserializeOpDocumentAttachDiskOutput(v **AttachDiskOutput, value interface{}) error {
28724	if v == nil {
28725		return fmt.Errorf("unexpected nil of type %T", v)
28726	}
28727	if value == nil {
28728		return nil
28729	}
28730
28731	shape, ok := value.(map[string]interface{})
28732	if !ok {
28733		return fmt.Errorf("unexpected JSON type %v", value)
28734	}
28735
28736	var sv *AttachDiskOutput
28737	if *v == nil {
28738		sv = &AttachDiskOutput{}
28739	} else {
28740		sv = *v
28741	}
28742
28743	for key, value := range shape {
28744		switch key {
28745		case "operations":
28746			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28747				return err
28748			}
28749
28750		default:
28751			_, _ = key, value
28752
28753		}
28754	}
28755	*v = sv
28756	return nil
28757}
28758
28759func awsAwsjson11_deserializeOpDocumentAttachInstancesToLoadBalancerOutput(v **AttachInstancesToLoadBalancerOutput, value interface{}) error {
28760	if v == nil {
28761		return fmt.Errorf("unexpected nil of type %T", v)
28762	}
28763	if value == nil {
28764		return nil
28765	}
28766
28767	shape, ok := value.(map[string]interface{})
28768	if !ok {
28769		return fmt.Errorf("unexpected JSON type %v", value)
28770	}
28771
28772	var sv *AttachInstancesToLoadBalancerOutput
28773	if *v == nil {
28774		sv = &AttachInstancesToLoadBalancerOutput{}
28775	} else {
28776		sv = *v
28777	}
28778
28779	for key, value := range shape {
28780		switch key {
28781		case "operations":
28782			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28783				return err
28784			}
28785
28786		default:
28787			_, _ = key, value
28788
28789		}
28790	}
28791	*v = sv
28792	return nil
28793}
28794
28795func awsAwsjson11_deserializeOpDocumentAttachLoadBalancerTlsCertificateOutput(v **AttachLoadBalancerTlsCertificateOutput, value interface{}) error {
28796	if v == nil {
28797		return fmt.Errorf("unexpected nil of type %T", v)
28798	}
28799	if value == nil {
28800		return nil
28801	}
28802
28803	shape, ok := value.(map[string]interface{})
28804	if !ok {
28805		return fmt.Errorf("unexpected JSON type %v", value)
28806	}
28807
28808	var sv *AttachLoadBalancerTlsCertificateOutput
28809	if *v == nil {
28810		sv = &AttachLoadBalancerTlsCertificateOutput{}
28811	} else {
28812		sv = *v
28813	}
28814
28815	for key, value := range shape {
28816		switch key {
28817		case "operations":
28818			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28819				return err
28820			}
28821
28822		default:
28823			_, _ = key, value
28824
28825		}
28826	}
28827	*v = sv
28828	return nil
28829}
28830
28831func awsAwsjson11_deserializeOpDocumentAttachStaticIpOutput(v **AttachStaticIpOutput, value interface{}) error {
28832	if v == nil {
28833		return fmt.Errorf("unexpected nil of type %T", v)
28834	}
28835	if value == nil {
28836		return nil
28837	}
28838
28839	shape, ok := value.(map[string]interface{})
28840	if !ok {
28841		return fmt.Errorf("unexpected JSON type %v", value)
28842	}
28843
28844	var sv *AttachStaticIpOutput
28845	if *v == nil {
28846		sv = &AttachStaticIpOutput{}
28847	} else {
28848		sv = *v
28849	}
28850
28851	for key, value := range shape {
28852		switch key {
28853		case "operations":
28854			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28855				return err
28856			}
28857
28858		default:
28859			_, _ = key, value
28860
28861		}
28862	}
28863	*v = sv
28864	return nil
28865}
28866
28867func awsAwsjson11_deserializeOpDocumentCloseInstancePublicPortsOutput(v **CloseInstancePublicPortsOutput, value interface{}) error {
28868	if v == nil {
28869		return fmt.Errorf("unexpected nil of type %T", v)
28870	}
28871	if value == nil {
28872		return nil
28873	}
28874
28875	shape, ok := value.(map[string]interface{})
28876	if !ok {
28877		return fmt.Errorf("unexpected JSON type %v", value)
28878	}
28879
28880	var sv *CloseInstancePublicPortsOutput
28881	if *v == nil {
28882		sv = &CloseInstancePublicPortsOutput{}
28883	} else {
28884		sv = *v
28885	}
28886
28887	for key, value := range shape {
28888		switch key {
28889		case "operation":
28890			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
28891				return err
28892			}
28893
28894		default:
28895			_, _ = key, value
28896
28897		}
28898	}
28899	*v = sv
28900	return nil
28901}
28902
28903func awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(v **CopySnapshotOutput, value interface{}) error {
28904	if v == nil {
28905		return fmt.Errorf("unexpected nil of type %T", v)
28906	}
28907	if value == nil {
28908		return nil
28909	}
28910
28911	shape, ok := value.(map[string]interface{})
28912	if !ok {
28913		return fmt.Errorf("unexpected JSON type %v", value)
28914	}
28915
28916	var sv *CopySnapshotOutput
28917	if *v == nil {
28918		sv = &CopySnapshotOutput{}
28919	} else {
28920		sv = *v
28921	}
28922
28923	for key, value := range shape {
28924		switch key {
28925		case "operations":
28926			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28927				return err
28928			}
28929
28930		default:
28931			_, _ = key, value
28932
28933		}
28934	}
28935	*v = sv
28936	return nil
28937}
28938
28939func awsAwsjson11_deserializeOpDocumentCreateCertificateOutput(v **CreateCertificateOutput, value interface{}) error {
28940	if v == nil {
28941		return fmt.Errorf("unexpected nil of type %T", v)
28942	}
28943	if value == nil {
28944		return nil
28945	}
28946
28947	shape, ok := value.(map[string]interface{})
28948	if !ok {
28949		return fmt.Errorf("unexpected JSON type %v", value)
28950	}
28951
28952	var sv *CreateCertificateOutput
28953	if *v == nil {
28954		sv = &CreateCertificateOutput{}
28955	} else {
28956		sv = *v
28957	}
28958
28959	for key, value := range shape {
28960		switch key {
28961		case "certificate":
28962			if err := awsAwsjson11_deserializeDocumentCertificateSummary(&sv.Certificate, value); err != nil {
28963				return err
28964			}
28965
28966		case "operations":
28967			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
28968				return err
28969			}
28970
28971		default:
28972			_, _ = key, value
28973
28974		}
28975	}
28976	*v = sv
28977	return nil
28978}
28979
28980func awsAwsjson11_deserializeOpDocumentCreateCloudFormationStackOutput(v **CreateCloudFormationStackOutput, value interface{}) error {
28981	if v == nil {
28982		return fmt.Errorf("unexpected nil of type %T", v)
28983	}
28984	if value == nil {
28985		return nil
28986	}
28987
28988	shape, ok := value.(map[string]interface{})
28989	if !ok {
28990		return fmt.Errorf("unexpected JSON type %v", value)
28991	}
28992
28993	var sv *CreateCloudFormationStackOutput
28994	if *v == nil {
28995		sv = &CreateCloudFormationStackOutput{}
28996	} else {
28997		sv = *v
28998	}
28999
29000	for key, value := range shape {
29001		switch key {
29002		case "operations":
29003			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29004				return err
29005			}
29006
29007		default:
29008			_, _ = key, value
29009
29010		}
29011	}
29012	*v = sv
29013	return nil
29014}
29015
29016func awsAwsjson11_deserializeOpDocumentCreateContactMethodOutput(v **CreateContactMethodOutput, value interface{}) error {
29017	if v == nil {
29018		return fmt.Errorf("unexpected nil of type %T", v)
29019	}
29020	if value == nil {
29021		return nil
29022	}
29023
29024	shape, ok := value.(map[string]interface{})
29025	if !ok {
29026		return fmt.Errorf("unexpected JSON type %v", value)
29027	}
29028
29029	var sv *CreateContactMethodOutput
29030	if *v == nil {
29031		sv = &CreateContactMethodOutput{}
29032	} else {
29033		sv = *v
29034	}
29035
29036	for key, value := range shape {
29037		switch key {
29038		case "operations":
29039			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29040				return err
29041			}
29042
29043		default:
29044			_, _ = key, value
29045
29046		}
29047	}
29048	*v = sv
29049	return nil
29050}
29051
29052func awsAwsjson11_deserializeOpDocumentCreateContainerServiceDeploymentOutput(v **CreateContainerServiceDeploymentOutput, value interface{}) error {
29053	if v == nil {
29054		return fmt.Errorf("unexpected nil of type %T", v)
29055	}
29056	if value == nil {
29057		return nil
29058	}
29059
29060	shape, ok := value.(map[string]interface{})
29061	if !ok {
29062		return fmt.Errorf("unexpected JSON type %v", value)
29063	}
29064
29065	var sv *CreateContainerServiceDeploymentOutput
29066	if *v == nil {
29067		sv = &CreateContainerServiceDeploymentOutput{}
29068	} else {
29069		sv = *v
29070	}
29071
29072	for key, value := range shape {
29073		switch key {
29074		case "containerService":
29075			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
29076				return err
29077			}
29078
29079		default:
29080			_, _ = key, value
29081
29082		}
29083	}
29084	*v = sv
29085	return nil
29086}
29087
29088func awsAwsjson11_deserializeOpDocumentCreateContainerServiceOutput(v **CreateContainerServiceOutput, value interface{}) error {
29089	if v == nil {
29090		return fmt.Errorf("unexpected nil of type %T", v)
29091	}
29092	if value == nil {
29093		return nil
29094	}
29095
29096	shape, ok := value.(map[string]interface{})
29097	if !ok {
29098		return fmt.Errorf("unexpected JSON type %v", value)
29099	}
29100
29101	var sv *CreateContainerServiceOutput
29102	if *v == nil {
29103		sv = &CreateContainerServiceOutput{}
29104	} else {
29105		sv = *v
29106	}
29107
29108	for key, value := range shape {
29109		switch key {
29110		case "containerService":
29111			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
29112				return err
29113			}
29114
29115		default:
29116			_, _ = key, value
29117
29118		}
29119	}
29120	*v = sv
29121	return nil
29122}
29123
29124func awsAwsjson11_deserializeOpDocumentCreateContainerServiceRegistryLoginOutput(v **CreateContainerServiceRegistryLoginOutput, value interface{}) error {
29125	if v == nil {
29126		return fmt.Errorf("unexpected nil of type %T", v)
29127	}
29128	if value == nil {
29129		return nil
29130	}
29131
29132	shape, ok := value.(map[string]interface{})
29133	if !ok {
29134		return fmt.Errorf("unexpected JSON type %v", value)
29135	}
29136
29137	var sv *CreateContainerServiceRegistryLoginOutput
29138	if *v == nil {
29139		sv = &CreateContainerServiceRegistryLoginOutput{}
29140	} else {
29141		sv = *v
29142	}
29143
29144	for key, value := range shape {
29145		switch key {
29146		case "registryLogin":
29147			if err := awsAwsjson11_deserializeDocumentContainerServiceRegistryLogin(&sv.RegistryLogin, value); err != nil {
29148				return err
29149			}
29150
29151		default:
29152			_, _ = key, value
29153
29154		}
29155	}
29156	*v = sv
29157	return nil
29158}
29159
29160func awsAwsjson11_deserializeOpDocumentCreateDiskFromSnapshotOutput(v **CreateDiskFromSnapshotOutput, value interface{}) error {
29161	if v == nil {
29162		return fmt.Errorf("unexpected nil of type %T", v)
29163	}
29164	if value == nil {
29165		return nil
29166	}
29167
29168	shape, ok := value.(map[string]interface{})
29169	if !ok {
29170		return fmt.Errorf("unexpected JSON type %v", value)
29171	}
29172
29173	var sv *CreateDiskFromSnapshotOutput
29174	if *v == nil {
29175		sv = &CreateDiskFromSnapshotOutput{}
29176	} else {
29177		sv = *v
29178	}
29179
29180	for key, value := range shape {
29181		switch key {
29182		case "operations":
29183			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29184				return err
29185			}
29186
29187		default:
29188			_, _ = key, value
29189
29190		}
29191	}
29192	*v = sv
29193	return nil
29194}
29195
29196func awsAwsjson11_deserializeOpDocumentCreateDiskOutput(v **CreateDiskOutput, value interface{}) error {
29197	if v == nil {
29198		return fmt.Errorf("unexpected nil of type %T", v)
29199	}
29200	if value == nil {
29201		return nil
29202	}
29203
29204	shape, ok := value.(map[string]interface{})
29205	if !ok {
29206		return fmt.Errorf("unexpected JSON type %v", value)
29207	}
29208
29209	var sv *CreateDiskOutput
29210	if *v == nil {
29211		sv = &CreateDiskOutput{}
29212	} else {
29213		sv = *v
29214	}
29215
29216	for key, value := range shape {
29217		switch key {
29218		case "operations":
29219			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29220				return err
29221			}
29222
29223		default:
29224			_, _ = key, value
29225
29226		}
29227	}
29228	*v = sv
29229	return nil
29230}
29231
29232func awsAwsjson11_deserializeOpDocumentCreateDiskSnapshotOutput(v **CreateDiskSnapshotOutput, value interface{}) error {
29233	if v == nil {
29234		return fmt.Errorf("unexpected nil of type %T", v)
29235	}
29236	if value == nil {
29237		return nil
29238	}
29239
29240	shape, ok := value.(map[string]interface{})
29241	if !ok {
29242		return fmt.Errorf("unexpected JSON type %v", value)
29243	}
29244
29245	var sv *CreateDiskSnapshotOutput
29246	if *v == nil {
29247		sv = &CreateDiskSnapshotOutput{}
29248	} else {
29249		sv = *v
29250	}
29251
29252	for key, value := range shape {
29253		switch key {
29254		case "operations":
29255			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29256				return err
29257			}
29258
29259		default:
29260			_, _ = key, value
29261
29262		}
29263	}
29264	*v = sv
29265	return nil
29266}
29267
29268func awsAwsjson11_deserializeOpDocumentCreateDistributionOutput(v **CreateDistributionOutput, value interface{}) error {
29269	if v == nil {
29270		return fmt.Errorf("unexpected nil of type %T", v)
29271	}
29272	if value == nil {
29273		return nil
29274	}
29275
29276	shape, ok := value.(map[string]interface{})
29277	if !ok {
29278		return fmt.Errorf("unexpected JSON type %v", value)
29279	}
29280
29281	var sv *CreateDistributionOutput
29282	if *v == nil {
29283		sv = &CreateDistributionOutput{}
29284	} else {
29285		sv = *v
29286	}
29287
29288	for key, value := range shape {
29289		switch key {
29290		case "distribution":
29291			if err := awsAwsjson11_deserializeDocumentLightsailDistribution(&sv.Distribution, value); err != nil {
29292				return err
29293			}
29294
29295		case "operation":
29296			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
29297				return err
29298			}
29299
29300		default:
29301			_, _ = key, value
29302
29303		}
29304	}
29305	*v = sv
29306	return nil
29307}
29308
29309func awsAwsjson11_deserializeOpDocumentCreateDomainEntryOutput(v **CreateDomainEntryOutput, value interface{}) error {
29310	if v == nil {
29311		return fmt.Errorf("unexpected nil of type %T", v)
29312	}
29313	if value == nil {
29314		return nil
29315	}
29316
29317	shape, ok := value.(map[string]interface{})
29318	if !ok {
29319		return fmt.Errorf("unexpected JSON type %v", value)
29320	}
29321
29322	var sv *CreateDomainEntryOutput
29323	if *v == nil {
29324		sv = &CreateDomainEntryOutput{}
29325	} else {
29326		sv = *v
29327	}
29328
29329	for key, value := range shape {
29330		switch key {
29331		case "operation":
29332			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
29333				return err
29334			}
29335
29336		default:
29337			_, _ = key, value
29338
29339		}
29340	}
29341	*v = sv
29342	return nil
29343}
29344
29345func awsAwsjson11_deserializeOpDocumentCreateDomainOutput(v **CreateDomainOutput, value interface{}) error {
29346	if v == nil {
29347		return fmt.Errorf("unexpected nil of type %T", v)
29348	}
29349	if value == nil {
29350		return nil
29351	}
29352
29353	shape, ok := value.(map[string]interface{})
29354	if !ok {
29355		return fmt.Errorf("unexpected JSON type %v", value)
29356	}
29357
29358	var sv *CreateDomainOutput
29359	if *v == nil {
29360		sv = &CreateDomainOutput{}
29361	} else {
29362		sv = *v
29363	}
29364
29365	for key, value := range shape {
29366		switch key {
29367		case "operation":
29368			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
29369				return err
29370			}
29371
29372		default:
29373			_, _ = key, value
29374
29375		}
29376	}
29377	*v = sv
29378	return nil
29379}
29380
29381func awsAwsjson11_deserializeOpDocumentCreateInstancesFromSnapshotOutput(v **CreateInstancesFromSnapshotOutput, value interface{}) error {
29382	if v == nil {
29383		return fmt.Errorf("unexpected nil of type %T", v)
29384	}
29385	if value == nil {
29386		return nil
29387	}
29388
29389	shape, ok := value.(map[string]interface{})
29390	if !ok {
29391		return fmt.Errorf("unexpected JSON type %v", value)
29392	}
29393
29394	var sv *CreateInstancesFromSnapshotOutput
29395	if *v == nil {
29396		sv = &CreateInstancesFromSnapshotOutput{}
29397	} else {
29398		sv = *v
29399	}
29400
29401	for key, value := range shape {
29402		switch key {
29403		case "operations":
29404			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29405				return err
29406			}
29407
29408		default:
29409			_, _ = key, value
29410
29411		}
29412	}
29413	*v = sv
29414	return nil
29415}
29416
29417func awsAwsjson11_deserializeOpDocumentCreateInstanceSnapshotOutput(v **CreateInstanceSnapshotOutput, value interface{}) error {
29418	if v == nil {
29419		return fmt.Errorf("unexpected nil of type %T", v)
29420	}
29421	if value == nil {
29422		return nil
29423	}
29424
29425	shape, ok := value.(map[string]interface{})
29426	if !ok {
29427		return fmt.Errorf("unexpected JSON type %v", value)
29428	}
29429
29430	var sv *CreateInstanceSnapshotOutput
29431	if *v == nil {
29432		sv = &CreateInstanceSnapshotOutput{}
29433	} else {
29434		sv = *v
29435	}
29436
29437	for key, value := range shape {
29438		switch key {
29439		case "operations":
29440			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29441				return err
29442			}
29443
29444		default:
29445			_, _ = key, value
29446
29447		}
29448	}
29449	*v = sv
29450	return nil
29451}
29452
29453func awsAwsjson11_deserializeOpDocumentCreateInstancesOutput(v **CreateInstancesOutput, value interface{}) error {
29454	if v == nil {
29455		return fmt.Errorf("unexpected nil of type %T", v)
29456	}
29457	if value == nil {
29458		return nil
29459	}
29460
29461	shape, ok := value.(map[string]interface{})
29462	if !ok {
29463		return fmt.Errorf("unexpected JSON type %v", value)
29464	}
29465
29466	var sv *CreateInstancesOutput
29467	if *v == nil {
29468		sv = &CreateInstancesOutput{}
29469	} else {
29470		sv = *v
29471	}
29472
29473	for key, value := range shape {
29474		switch key {
29475		case "operations":
29476			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29477				return err
29478			}
29479
29480		default:
29481			_, _ = key, value
29482
29483		}
29484	}
29485	*v = sv
29486	return nil
29487}
29488
29489func awsAwsjson11_deserializeOpDocumentCreateKeyPairOutput(v **CreateKeyPairOutput, value interface{}) error {
29490	if v == nil {
29491		return fmt.Errorf("unexpected nil of type %T", v)
29492	}
29493	if value == nil {
29494		return nil
29495	}
29496
29497	shape, ok := value.(map[string]interface{})
29498	if !ok {
29499		return fmt.Errorf("unexpected JSON type %v", value)
29500	}
29501
29502	var sv *CreateKeyPairOutput
29503	if *v == nil {
29504		sv = &CreateKeyPairOutput{}
29505	} else {
29506		sv = *v
29507	}
29508
29509	for key, value := range shape {
29510		switch key {
29511		case "keyPair":
29512			if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
29513				return err
29514			}
29515
29516		case "operation":
29517			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
29518				return err
29519			}
29520
29521		case "privateKeyBase64":
29522			if value != nil {
29523				jtv, ok := value.(string)
29524				if !ok {
29525					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
29526				}
29527				sv.PrivateKeyBase64 = ptr.String(jtv)
29528			}
29529
29530		case "publicKeyBase64":
29531			if value != nil {
29532				jtv, ok := value.(string)
29533				if !ok {
29534					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
29535				}
29536				sv.PublicKeyBase64 = ptr.String(jtv)
29537			}
29538
29539		default:
29540			_, _ = key, value
29541
29542		}
29543	}
29544	*v = sv
29545	return nil
29546}
29547
29548func awsAwsjson11_deserializeOpDocumentCreateLoadBalancerOutput(v **CreateLoadBalancerOutput, value interface{}) error {
29549	if v == nil {
29550		return fmt.Errorf("unexpected nil of type %T", v)
29551	}
29552	if value == nil {
29553		return nil
29554	}
29555
29556	shape, ok := value.(map[string]interface{})
29557	if !ok {
29558		return fmt.Errorf("unexpected JSON type %v", value)
29559	}
29560
29561	var sv *CreateLoadBalancerOutput
29562	if *v == nil {
29563		sv = &CreateLoadBalancerOutput{}
29564	} else {
29565		sv = *v
29566	}
29567
29568	for key, value := range shape {
29569		switch key {
29570		case "operations":
29571			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, 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_deserializeOpDocumentCreateLoadBalancerTlsCertificateOutput(v **CreateLoadBalancerTlsCertificateOutput, 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 *CreateLoadBalancerTlsCertificateOutput
29598	if *v == nil {
29599		sv = &CreateLoadBalancerTlsCertificateOutput{}
29600	} else {
29601		sv = *v
29602	}
29603
29604	for key, value := range shape {
29605		switch key {
29606		case "operations":
29607			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29608				return err
29609			}
29610
29611		default:
29612			_, _ = key, value
29613
29614		}
29615	}
29616	*v = sv
29617	return nil
29618}
29619
29620func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseFromSnapshotOutput(v **CreateRelationalDatabaseFromSnapshotOutput, value interface{}) error {
29621	if v == nil {
29622		return fmt.Errorf("unexpected nil of type %T", v)
29623	}
29624	if value == nil {
29625		return nil
29626	}
29627
29628	shape, ok := value.(map[string]interface{})
29629	if !ok {
29630		return fmt.Errorf("unexpected JSON type %v", value)
29631	}
29632
29633	var sv *CreateRelationalDatabaseFromSnapshotOutput
29634	if *v == nil {
29635		sv = &CreateRelationalDatabaseFromSnapshotOutput{}
29636	} else {
29637		sv = *v
29638	}
29639
29640	for key, value := range shape {
29641		switch key {
29642		case "operations":
29643			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29644				return err
29645			}
29646
29647		default:
29648			_, _ = key, value
29649
29650		}
29651	}
29652	*v = sv
29653	return nil
29654}
29655
29656func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseOutput(v **CreateRelationalDatabaseOutput, value interface{}) error {
29657	if v == nil {
29658		return fmt.Errorf("unexpected nil of type %T", v)
29659	}
29660	if value == nil {
29661		return nil
29662	}
29663
29664	shape, ok := value.(map[string]interface{})
29665	if !ok {
29666		return fmt.Errorf("unexpected JSON type %v", value)
29667	}
29668
29669	var sv *CreateRelationalDatabaseOutput
29670	if *v == nil {
29671		sv = &CreateRelationalDatabaseOutput{}
29672	} else {
29673		sv = *v
29674	}
29675
29676	for key, value := range shape {
29677		switch key {
29678		case "operations":
29679			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29680				return err
29681			}
29682
29683		default:
29684			_, _ = key, value
29685
29686		}
29687	}
29688	*v = sv
29689	return nil
29690}
29691
29692func awsAwsjson11_deserializeOpDocumentCreateRelationalDatabaseSnapshotOutput(v **CreateRelationalDatabaseSnapshotOutput, value interface{}) error {
29693	if v == nil {
29694		return fmt.Errorf("unexpected nil of type %T", v)
29695	}
29696	if value == nil {
29697		return nil
29698	}
29699
29700	shape, ok := value.(map[string]interface{})
29701	if !ok {
29702		return fmt.Errorf("unexpected JSON type %v", value)
29703	}
29704
29705	var sv *CreateRelationalDatabaseSnapshotOutput
29706	if *v == nil {
29707		sv = &CreateRelationalDatabaseSnapshotOutput{}
29708	} else {
29709		sv = *v
29710	}
29711
29712	for key, value := range shape {
29713		switch key {
29714		case "operations":
29715			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29716				return err
29717			}
29718
29719		default:
29720			_, _ = key, value
29721
29722		}
29723	}
29724	*v = sv
29725	return nil
29726}
29727
29728func awsAwsjson11_deserializeOpDocumentDeleteAlarmOutput(v **DeleteAlarmOutput, value interface{}) error {
29729	if v == nil {
29730		return fmt.Errorf("unexpected nil of type %T", v)
29731	}
29732	if value == nil {
29733		return nil
29734	}
29735
29736	shape, ok := value.(map[string]interface{})
29737	if !ok {
29738		return fmt.Errorf("unexpected JSON type %v", value)
29739	}
29740
29741	var sv *DeleteAlarmOutput
29742	if *v == nil {
29743		sv = &DeleteAlarmOutput{}
29744	} else {
29745		sv = *v
29746	}
29747
29748	for key, value := range shape {
29749		switch key {
29750		case "operations":
29751			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29752				return err
29753			}
29754
29755		default:
29756			_, _ = key, value
29757
29758		}
29759	}
29760	*v = sv
29761	return nil
29762}
29763
29764func awsAwsjson11_deserializeOpDocumentDeleteAutoSnapshotOutput(v **DeleteAutoSnapshotOutput, value interface{}) error {
29765	if v == nil {
29766		return fmt.Errorf("unexpected nil of type %T", v)
29767	}
29768	if value == nil {
29769		return nil
29770	}
29771
29772	shape, ok := value.(map[string]interface{})
29773	if !ok {
29774		return fmt.Errorf("unexpected JSON type %v", value)
29775	}
29776
29777	var sv *DeleteAutoSnapshotOutput
29778	if *v == nil {
29779		sv = &DeleteAutoSnapshotOutput{}
29780	} else {
29781		sv = *v
29782	}
29783
29784	for key, value := range shape {
29785		switch key {
29786		case "operations":
29787			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29788				return err
29789			}
29790
29791		default:
29792			_, _ = key, value
29793
29794		}
29795	}
29796	*v = sv
29797	return nil
29798}
29799
29800func awsAwsjson11_deserializeOpDocumentDeleteCertificateOutput(v **DeleteCertificateOutput, value interface{}) error {
29801	if v == nil {
29802		return fmt.Errorf("unexpected nil of type %T", v)
29803	}
29804	if value == nil {
29805		return nil
29806	}
29807
29808	shape, ok := value.(map[string]interface{})
29809	if !ok {
29810		return fmt.Errorf("unexpected JSON type %v", value)
29811	}
29812
29813	var sv *DeleteCertificateOutput
29814	if *v == nil {
29815		sv = &DeleteCertificateOutput{}
29816	} else {
29817		sv = *v
29818	}
29819
29820	for key, value := range shape {
29821		switch key {
29822		case "operations":
29823			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29824				return err
29825			}
29826
29827		default:
29828			_, _ = key, value
29829
29830		}
29831	}
29832	*v = sv
29833	return nil
29834}
29835
29836func awsAwsjson11_deserializeOpDocumentDeleteContactMethodOutput(v **DeleteContactMethodOutput, value interface{}) error {
29837	if v == nil {
29838		return fmt.Errorf("unexpected nil of type %T", v)
29839	}
29840	if value == nil {
29841		return nil
29842	}
29843
29844	shape, ok := value.(map[string]interface{})
29845	if !ok {
29846		return fmt.Errorf("unexpected JSON type %v", value)
29847	}
29848
29849	var sv *DeleteContactMethodOutput
29850	if *v == nil {
29851		sv = &DeleteContactMethodOutput{}
29852	} else {
29853		sv = *v
29854	}
29855
29856	for key, value := range shape {
29857		switch key {
29858		case "operations":
29859			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29860				return err
29861			}
29862
29863		default:
29864			_, _ = key, value
29865
29866		}
29867	}
29868	*v = sv
29869	return nil
29870}
29871
29872func awsAwsjson11_deserializeOpDocumentDeleteContainerImageOutput(v **DeleteContainerImageOutput, value interface{}) error {
29873	if v == nil {
29874		return fmt.Errorf("unexpected nil of type %T", v)
29875	}
29876	if value == nil {
29877		return nil
29878	}
29879
29880	shape, ok := value.(map[string]interface{})
29881	if !ok {
29882		return fmt.Errorf("unexpected JSON type %v", value)
29883	}
29884
29885	var sv *DeleteContainerImageOutput
29886	if *v == nil {
29887		sv = &DeleteContainerImageOutput{}
29888	} else {
29889		sv = *v
29890	}
29891
29892	for key, value := range shape {
29893		switch key {
29894		default:
29895			_, _ = key, value
29896
29897		}
29898	}
29899	*v = sv
29900	return nil
29901}
29902
29903func awsAwsjson11_deserializeOpDocumentDeleteContainerServiceOutput(v **DeleteContainerServiceOutput, value interface{}) error {
29904	if v == nil {
29905		return fmt.Errorf("unexpected nil of type %T", v)
29906	}
29907	if value == nil {
29908		return nil
29909	}
29910
29911	shape, ok := value.(map[string]interface{})
29912	if !ok {
29913		return fmt.Errorf("unexpected JSON type %v", value)
29914	}
29915
29916	var sv *DeleteContainerServiceOutput
29917	if *v == nil {
29918		sv = &DeleteContainerServiceOutput{}
29919	} else {
29920		sv = *v
29921	}
29922
29923	for key, value := range shape {
29924		switch key {
29925		default:
29926			_, _ = key, value
29927
29928		}
29929	}
29930	*v = sv
29931	return nil
29932}
29933
29934func awsAwsjson11_deserializeOpDocumentDeleteDiskOutput(v **DeleteDiskOutput, value interface{}) error {
29935	if v == nil {
29936		return fmt.Errorf("unexpected nil of type %T", v)
29937	}
29938	if value == nil {
29939		return nil
29940	}
29941
29942	shape, ok := value.(map[string]interface{})
29943	if !ok {
29944		return fmt.Errorf("unexpected JSON type %v", value)
29945	}
29946
29947	var sv *DeleteDiskOutput
29948	if *v == nil {
29949		sv = &DeleteDiskOutput{}
29950	} else {
29951		sv = *v
29952	}
29953
29954	for key, value := range shape {
29955		switch key {
29956		case "operations":
29957			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29958				return err
29959			}
29960
29961		default:
29962			_, _ = key, value
29963
29964		}
29965	}
29966	*v = sv
29967	return nil
29968}
29969
29970func awsAwsjson11_deserializeOpDocumentDeleteDiskSnapshotOutput(v **DeleteDiskSnapshotOutput, value interface{}) error {
29971	if v == nil {
29972		return fmt.Errorf("unexpected nil of type %T", v)
29973	}
29974	if value == nil {
29975		return nil
29976	}
29977
29978	shape, ok := value.(map[string]interface{})
29979	if !ok {
29980		return fmt.Errorf("unexpected JSON type %v", value)
29981	}
29982
29983	var sv *DeleteDiskSnapshotOutput
29984	if *v == nil {
29985		sv = &DeleteDiskSnapshotOutput{}
29986	} else {
29987		sv = *v
29988	}
29989
29990	for key, value := range shape {
29991		switch key {
29992		case "operations":
29993			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
29994				return err
29995			}
29996
29997		default:
29998			_, _ = key, value
29999
30000		}
30001	}
30002	*v = sv
30003	return nil
30004}
30005
30006func awsAwsjson11_deserializeOpDocumentDeleteDistributionOutput(v **DeleteDistributionOutput, value interface{}) error {
30007	if v == nil {
30008		return fmt.Errorf("unexpected nil of type %T", v)
30009	}
30010	if value == nil {
30011		return nil
30012	}
30013
30014	shape, ok := value.(map[string]interface{})
30015	if !ok {
30016		return fmt.Errorf("unexpected JSON type %v", value)
30017	}
30018
30019	var sv *DeleteDistributionOutput
30020	if *v == nil {
30021		sv = &DeleteDistributionOutput{}
30022	} else {
30023		sv = *v
30024	}
30025
30026	for key, value := range shape {
30027		switch key {
30028		case "operation":
30029			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
30030				return err
30031			}
30032
30033		default:
30034			_, _ = key, value
30035
30036		}
30037	}
30038	*v = sv
30039	return nil
30040}
30041
30042func awsAwsjson11_deserializeOpDocumentDeleteDomainEntryOutput(v **DeleteDomainEntryOutput, value interface{}) error {
30043	if v == nil {
30044		return fmt.Errorf("unexpected nil of type %T", v)
30045	}
30046	if value == nil {
30047		return nil
30048	}
30049
30050	shape, ok := value.(map[string]interface{})
30051	if !ok {
30052		return fmt.Errorf("unexpected JSON type %v", value)
30053	}
30054
30055	var sv *DeleteDomainEntryOutput
30056	if *v == nil {
30057		sv = &DeleteDomainEntryOutput{}
30058	} else {
30059		sv = *v
30060	}
30061
30062	for key, value := range shape {
30063		switch key {
30064		case "operation":
30065			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
30066				return err
30067			}
30068
30069		default:
30070			_, _ = key, value
30071
30072		}
30073	}
30074	*v = sv
30075	return nil
30076}
30077
30078func awsAwsjson11_deserializeOpDocumentDeleteDomainOutput(v **DeleteDomainOutput, value interface{}) error {
30079	if v == nil {
30080		return fmt.Errorf("unexpected nil of type %T", v)
30081	}
30082	if value == nil {
30083		return nil
30084	}
30085
30086	shape, ok := value.(map[string]interface{})
30087	if !ok {
30088		return fmt.Errorf("unexpected JSON type %v", value)
30089	}
30090
30091	var sv *DeleteDomainOutput
30092	if *v == nil {
30093		sv = &DeleteDomainOutput{}
30094	} else {
30095		sv = *v
30096	}
30097
30098	for key, value := range shape {
30099		switch key {
30100		case "operation":
30101			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
30102				return err
30103			}
30104
30105		default:
30106			_, _ = key, value
30107
30108		}
30109	}
30110	*v = sv
30111	return nil
30112}
30113
30114func awsAwsjson11_deserializeOpDocumentDeleteInstanceOutput(v **DeleteInstanceOutput, value interface{}) error {
30115	if v == nil {
30116		return fmt.Errorf("unexpected nil of type %T", v)
30117	}
30118	if value == nil {
30119		return nil
30120	}
30121
30122	shape, ok := value.(map[string]interface{})
30123	if !ok {
30124		return fmt.Errorf("unexpected JSON type %v", value)
30125	}
30126
30127	var sv *DeleteInstanceOutput
30128	if *v == nil {
30129		sv = &DeleteInstanceOutput{}
30130	} else {
30131		sv = *v
30132	}
30133
30134	for key, value := range shape {
30135		switch key {
30136		case "operations":
30137			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30138				return err
30139			}
30140
30141		default:
30142			_, _ = key, value
30143
30144		}
30145	}
30146	*v = sv
30147	return nil
30148}
30149
30150func awsAwsjson11_deserializeOpDocumentDeleteInstanceSnapshotOutput(v **DeleteInstanceSnapshotOutput, value interface{}) error {
30151	if v == nil {
30152		return fmt.Errorf("unexpected nil of type %T", v)
30153	}
30154	if value == nil {
30155		return nil
30156	}
30157
30158	shape, ok := value.(map[string]interface{})
30159	if !ok {
30160		return fmt.Errorf("unexpected JSON type %v", value)
30161	}
30162
30163	var sv *DeleteInstanceSnapshotOutput
30164	if *v == nil {
30165		sv = &DeleteInstanceSnapshotOutput{}
30166	} else {
30167		sv = *v
30168	}
30169
30170	for key, value := range shape {
30171		switch key {
30172		case "operations":
30173			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30174				return err
30175			}
30176
30177		default:
30178			_, _ = key, value
30179
30180		}
30181	}
30182	*v = sv
30183	return nil
30184}
30185
30186func awsAwsjson11_deserializeOpDocumentDeleteKeyPairOutput(v **DeleteKeyPairOutput, value interface{}) error {
30187	if v == nil {
30188		return fmt.Errorf("unexpected nil of type %T", v)
30189	}
30190	if value == nil {
30191		return nil
30192	}
30193
30194	shape, ok := value.(map[string]interface{})
30195	if !ok {
30196		return fmt.Errorf("unexpected JSON type %v", value)
30197	}
30198
30199	var sv *DeleteKeyPairOutput
30200	if *v == nil {
30201		sv = &DeleteKeyPairOutput{}
30202	} else {
30203		sv = *v
30204	}
30205
30206	for key, value := range shape {
30207		switch key {
30208		case "operation":
30209			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
30210				return err
30211			}
30212
30213		default:
30214			_, _ = key, value
30215
30216		}
30217	}
30218	*v = sv
30219	return nil
30220}
30221
30222func awsAwsjson11_deserializeOpDocumentDeleteKnownHostKeysOutput(v **DeleteKnownHostKeysOutput, value interface{}) error {
30223	if v == nil {
30224		return fmt.Errorf("unexpected nil of type %T", v)
30225	}
30226	if value == nil {
30227		return nil
30228	}
30229
30230	shape, ok := value.(map[string]interface{})
30231	if !ok {
30232		return fmt.Errorf("unexpected JSON type %v", value)
30233	}
30234
30235	var sv *DeleteKnownHostKeysOutput
30236	if *v == nil {
30237		sv = &DeleteKnownHostKeysOutput{}
30238	} else {
30239		sv = *v
30240	}
30241
30242	for key, value := range shape {
30243		switch key {
30244		case "operations":
30245			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30246				return err
30247			}
30248
30249		default:
30250			_, _ = key, value
30251
30252		}
30253	}
30254	*v = sv
30255	return nil
30256}
30257
30258func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerOutput(v **DeleteLoadBalancerOutput, value interface{}) error {
30259	if v == nil {
30260		return fmt.Errorf("unexpected nil of type %T", v)
30261	}
30262	if value == nil {
30263		return nil
30264	}
30265
30266	shape, ok := value.(map[string]interface{})
30267	if !ok {
30268		return fmt.Errorf("unexpected JSON type %v", value)
30269	}
30270
30271	var sv *DeleteLoadBalancerOutput
30272	if *v == nil {
30273		sv = &DeleteLoadBalancerOutput{}
30274	} else {
30275		sv = *v
30276	}
30277
30278	for key, value := range shape {
30279		switch key {
30280		case "operations":
30281			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30282				return err
30283			}
30284
30285		default:
30286			_, _ = key, value
30287
30288		}
30289	}
30290	*v = sv
30291	return nil
30292}
30293
30294func awsAwsjson11_deserializeOpDocumentDeleteLoadBalancerTlsCertificateOutput(v **DeleteLoadBalancerTlsCertificateOutput, value interface{}) error {
30295	if v == nil {
30296		return fmt.Errorf("unexpected nil of type %T", v)
30297	}
30298	if value == nil {
30299		return nil
30300	}
30301
30302	shape, ok := value.(map[string]interface{})
30303	if !ok {
30304		return fmt.Errorf("unexpected JSON type %v", value)
30305	}
30306
30307	var sv *DeleteLoadBalancerTlsCertificateOutput
30308	if *v == nil {
30309		sv = &DeleteLoadBalancerTlsCertificateOutput{}
30310	} else {
30311		sv = *v
30312	}
30313
30314	for key, value := range shape {
30315		switch key {
30316		case "operations":
30317			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30318				return err
30319			}
30320
30321		default:
30322			_, _ = key, value
30323
30324		}
30325	}
30326	*v = sv
30327	return nil
30328}
30329
30330func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseOutput(v **DeleteRelationalDatabaseOutput, 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 *DeleteRelationalDatabaseOutput
30344	if *v == nil {
30345		sv = &DeleteRelationalDatabaseOutput{}
30346	} else {
30347		sv = *v
30348	}
30349
30350	for key, value := range shape {
30351		switch key {
30352		case "operations":
30353			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30354				return err
30355			}
30356
30357		default:
30358			_, _ = key, value
30359
30360		}
30361	}
30362	*v = sv
30363	return nil
30364}
30365
30366func awsAwsjson11_deserializeOpDocumentDeleteRelationalDatabaseSnapshotOutput(v **DeleteRelationalDatabaseSnapshotOutput, value interface{}) error {
30367	if v == nil {
30368		return fmt.Errorf("unexpected nil of type %T", v)
30369	}
30370	if value == nil {
30371		return nil
30372	}
30373
30374	shape, ok := value.(map[string]interface{})
30375	if !ok {
30376		return fmt.Errorf("unexpected JSON type %v", value)
30377	}
30378
30379	var sv *DeleteRelationalDatabaseSnapshotOutput
30380	if *v == nil {
30381		sv = &DeleteRelationalDatabaseSnapshotOutput{}
30382	} else {
30383		sv = *v
30384	}
30385
30386	for key, value := range shape {
30387		switch key {
30388		case "operations":
30389			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30390				return err
30391			}
30392
30393		default:
30394			_, _ = key, value
30395
30396		}
30397	}
30398	*v = sv
30399	return nil
30400}
30401
30402func awsAwsjson11_deserializeOpDocumentDetachCertificateFromDistributionOutput(v **DetachCertificateFromDistributionOutput, value interface{}) error {
30403	if v == nil {
30404		return fmt.Errorf("unexpected nil of type %T", v)
30405	}
30406	if value == nil {
30407		return nil
30408	}
30409
30410	shape, ok := value.(map[string]interface{})
30411	if !ok {
30412		return fmt.Errorf("unexpected JSON type %v", value)
30413	}
30414
30415	var sv *DetachCertificateFromDistributionOutput
30416	if *v == nil {
30417		sv = &DetachCertificateFromDistributionOutput{}
30418	} else {
30419		sv = *v
30420	}
30421
30422	for key, value := range shape {
30423		switch key {
30424		case "operation":
30425			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
30426				return err
30427			}
30428
30429		default:
30430			_, _ = key, value
30431
30432		}
30433	}
30434	*v = sv
30435	return nil
30436}
30437
30438func awsAwsjson11_deserializeOpDocumentDetachDiskOutput(v **DetachDiskOutput, value interface{}) error {
30439	if v == nil {
30440		return fmt.Errorf("unexpected nil of type %T", v)
30441	}
30442	if value == nil {
30443		return nil
30444	}
30445
30446	shape, ok := value.(map[string]interface{})
30447	if !ok {
30448		return fmt.Errorf("unexpected JSON type %v", value)
30449	}
30450
30451	var sv *DetachDiskOutput
30452	if *v == nil {
30453		sv = &DetachDiskOutput{}
30454	} else {
30455		sv = *v
30456	}
30457
30458	for key, value := range shape {
30459		switch key {
30460		case "operations":
30461			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30462				return err
30463			}
30464
30465		default:
30466			_, _ = key, value
30467
30468		}
30469	}
30470	*v = sv
30471	return nil
30472}
30473
30474func awsAwsjson11_deserializeOpDocumentDetachInstancesFromLoadBalancerOutput(v **DetachInstancesFromLoadBalancerOutput, value interface{}) error {
30475	if v == nil {
30476		return fmt.Errorf("unexpected nil of type %T", v)
30477	}
30478	if value == nil {
30479		return nil
30480	}
30481
30482	shape, ok := value.(map[string]interface{})
30483	if !ok {
30484		return fmt.Errorf("unexpected JSON type %v", value)
30485	}
30486
30487	var sv *DetachInstancesFromLoadBalancerOutput
30488	if *v == nil {
30489		sv = &DetachInstancesFromLoadBalancerOutput{}
30490	} else {
30491		sv = *v
30492	}
30493
30494	for key, value := range shape {
30495		switch key {
30496		case "operations":
30497			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30498				return err
30499			}
30500
30501		default:
30502			_, _ = key, value
30503
30504		}
30505	}
30506	*v = sv
30507	return nil
30508}
30509
30510func awsAwsjson11_deserializeOpDocumentDetachStaticIpOutput(v **DetachStaticIpOutput, value interface{}) error {
30511	if v == nil {
30512		return fmt.Errorf("unexpected nil of type %T", v)
30513	}
30514	if value == nil {
30515		return nil
30516	}
30517
30518	shape, ok := value.(map[string]interface{})
30519	if !ok {
30520		return fmt.Errorf("unexpected JSON type %v", value)
30521	}
30522
30523	var sv *DetachStaticIpOutput
30524	if *v == nil {
30525		sv = &DetachStaticIpOutput{}
30526	} else {
30527		sv = *v
30528	}
30529
30530	for key, value := range shape {
30531		switch key {
30532		case "operations":
30533			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30534				return err
30535			}
30536
30537		default:
30538			_, _ = key, value
30539
30540		}
30541	}
30542	*v = sv
30543	return nil
30544}
30545
30546func awsAwsjson11_deserializeOpDocumentDisableAddOnOutput(v **DisableAddOnOutput, value interface{}) error {
30547	if v == nil {
30548		return fmt.Errorf("unexpected nil of type %T", v)
30549	}
30550	if value == nil {
30551		return nil
30552	}
30553
30554	shape, ok := value.(map[string]interface{})
30555	if !ok {
30556		return fmt.Errorf("unexpected JSON type %v", value)
30557	}
30558
30559	var sv *DisableAddOnOutput
30560	if *v == nil {
30561		sv = &DisableAddOnOutput{}
30562	} else {
30563		sv = *v
30564	}
30565
30566	for key, value := range shape {
30567		switch key {
30568		case "operations":
30569			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30570				return err
30571			}
30572
30573		default:
30574			_, _ = key, value
30575
30576		}
30577	}
30578	*v = sv
30579	return nil
30580}
30581
30582func awsAwsjson11_deserializeOpDocumentDownloadDefaultKeyPairOutput(v **DownloadDefaultKeyPairOutput, value interface{}) error {
30583	if v == nil {
30584		return fmt.Errorf("unexpected nil of type %T", v)
30585	}
30586	if value == nil {
30587		return nil
30588	}
30589
30590	shape, ok := value.(map[string]interface{})
30591	if !ok {
30592		return fmt.Errorf("unexpected JSON type %v", value)
30593	}
30594
30595	var sv *DownloadDefaultKeyPairOutput
30596	if *v == nil {
30597		sv = &DownloadDefaultKeyPairOutput{}
30598	} else {
30599		sv = *v
30600	}
30601
30602	for key, value := range shape {
30603		switch key {
30604		case "privateKeyBase64":
30605			if value != nil {
30606				jtv, ok := value.(string)
30607				if !ok {
30608					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
30609				}
30610				sv.PrivateKeyBase64 = ptr.String(jtv)
30611			}
30612
30613		case "publicKeyBase64":
30614			if value != nil {
30615				jtv, ok := value.(string)
30616				if !ok {
30617					return fmt.Errorf("expected Base64 to be of type string, got %T instead", value)
30618				}
30619				sv.PublicKeyBase64 = ptr.String(jtv)
30620			}
30621
30622		default:
30623			_, _ = key, value
30624
30625		}
30626	}
30627	*v = sv
30628	return nil
30629}
30630
30631func awsAwsjson11_deserializeOpDocumentEnableAddOnOutput(v **EnableAddOnOutput, value interface{}) error {
30632	if v == nil {
30633		return fmt.Errorf("unexpected nil of type %T", v)
30634	}
30635	if value == nil {
30636		return nil
30637	}
30638
30639	shape, ok := value.(map[string]interface{})
30640	if !ok {
30641		return fmt.Errorf("unexpected JSON type %v", value)
30642	}
30643
30644	var sv *EnableAddOnOutput
30645	if *v == nil {
30646		sv = &EnableAddOnOutput{}
30647	} else {
30648		sv = *v
30649	}
30650
30651	for key, value := range shape {
30652		switch key {
30653		case "operations":
30654			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30655				return err
30656			}
30657
30658		default:
30659			_, _ = key, value
30660
30661		}
30662	}
30663	*v = sv
30664	return nil
30665}
30666
30667func awsAwsjson11_deserializeOpDocumentExportSnapshotOutput(v **ExportSnapshotOutput, value interface{}) error {
30668	if v == nil {
30669		return fmt.Errorf("unexpected nil of type %T", v)
30670	}
30671	if value == nil {
30672		return nil
30673	}
30674
30675	shape, ok := value.(map[string]interface{})
30676	if !ok {
30677		return fmt.Errorf("unexpected JSON type %v", value)
30678	}
30679
30680	var sv *ExportSnapshotOutput
30681	if *v == nil {
30682		sv = &ExportSnapshotOutput{}
30683	} else {
30684		sv = *v
30685	}
30686
30687	for key, value := range shape {
30688		switch key {
30689		case "operations":
30690			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
30691				return err
30692			}
30693
30694		default:
30695			_, _ = key, value
30696
30697		}
30698	}
30699	*v = sv
30700	return nil
30701}
30702
30703func awsAwsjson11_deserializeOpDocumentGetActiveNamesOutput(v **GetActiveNamesOutput, value interface{}) error {
30704	if v == nil {
30705		return fmt.Errorf("unexpected nil of type %T", v)
30706	}
30707	if value == nil {
30708		return nil
30709	}
30710
30711	shape, ok := value.(map[string]interface{})
30712	if !ok {
30713		return fmt.Errorf("unexpected JSON type %v", value)
30714	}
30715
30716	var sv *GetActiveNamesOutput
30717	if *v == nil {
30718		sv = &GetActiveNamesOutput{}
30719	} else {
30720		sv = *v
30721	}
30722
30723	for key, value := range shape {
30724		switch key {
30725		case "activeNames":
30726			if err := awsAwsjson11_deserializeDocumentStringList(&sv.ActiveNames, value); err != nil {
30727				return err
30728			}
30729
30730		case "nextPageToken":
30731			if value != nil {
30732				jtv, ok := value.(string)
30733				if !ok {
30734					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30735				}
30736				sv.NextPageToken = ptr.String(jtv)
30737			}
30738
30739		default:
30740			_, _ = key, value
30741
30742		}
30743	}
30744	*v = sv
30745	return nil
30746}
30747
30748func awsAwsjson11_deserializeOpDocumentGetAlarmsOutput(v **GetAlarmsOutput, value interface{}) error {
30749	if v == nil {
30750		return fmt.Errorf("unexpected nil of type %T", v)
30751	}
30752	if value == nil {
30753		return nil
30754	}
30755
30756	shape, ok := value.(map[string]interface{})
30757	if !ok {
30758		return fmt.Errorf("unexpected JSON type %v", value)
30759	}
30760
30761	var sv *GetAlarmsOutput
30762	if *v == nil {
30763		sv = &GetAlarmsOutput{}
30764	} else {
30765		sv = *v
30766	}
30767
30768	for key, value := range shape {
30769		switch key {
30770		case "alarms":
30771			if err := awsAwsjson11_deserializeDocumentAlarmsList(&sv.Alarms, value); err != nil {
30772				return err
30773			}
30774
30775		case "nextPageToken":
30776			if value != nil {
30777				jtv, ok := value.(string)
30778				if !ok {
30779					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30780				}
30781				sv.NextPageToken = ptr.String(jtv)
30782			}
30783
30784		default:
30785			_, _ = key, value
30786
30787		}
30788	}
30789	*v = sv
30790	return nil
30791}
30792
30793func awsAwsjson11_deserializeOpDocumentGetAutoSnapshotsOutput(v **GetAutoSnapshotsOutput, value interface{}) error {
30794	if v == nil {
30795		return fmt.Errorf("unexpected nil of type %T", v)
30796	}
30797	if value == nil {
30798		return nil
30799	}
30800
30801	shape, ok := value.(map[string]interface{})
30802	if !ok {
30803		return fmt.Errorf("unexpected JSON type %v", value)
30804	}
30805
30806	var sv *GetAutoSnapshotsOutput
30807	if *v == nil {
30808		sv = &GetAutoSnapshotsOutput{}
30809	} else {
30810		sv = *v
30811	}
30812
30813	for key, value := range shape {
30814		switch key {
30815		case "autoSnapshots":
30816			if err := awsAwsjson11_deserializeDocumentAutoSnapshotDetailsList(&sv.AutoSnapshots, value); err != nil {
30817				return err
30818			}
30819
30820		case "resourceName":
30821			if value != nil {
30822				jtv, ok := value.(string)
30823				if !ok {
30824					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
30825				}
30826				sv.ResourceName = ptr.String(jtv)
30827			}
30828
30829		case "resourceType":
30830			if value != nil {
30831				jtv, ok := value.(string)
30832				if !ok {
30833					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
30834				}
30835				sv.ResourceType = types.ResourceType(jtv)
30836			}
30837
30838		default:
30839			_, _ = key, value
30840
30841		}
30842	}
30843	*v = sv
30844	return nil
30845}
30846
30847func awsAwsjson11_deserializeOpDocumentGetBlueprintsOutput(v **GetBlueprintsOutput, value interface{}) error {
30848	if v == nil {
30849		return fmt.Errorf("unexpected nil of type %T", v)
30850	}
30851	if value == nil {
30852		return nil
30853	}
30854
30855	shape, ok := value.(map[string]interface{})
30856	if !ok {
30857		return fmt.Errorf("unexpected JSON type %v", value)
30858	}
30859
30860	var sv *GetBlueprintsOutput
30861	if *v == nil {
30862		sv = &GetBlueprintsOutput{}
30863	} else {
30864		sv = *v
30865	}
30866
30867	for key, value := range shape {
30868		switch key {
30869		case "blueprints":
30870			if err := awsAwsjson11_deserializeDocumentBlueprintList(&sv.Blueprints, value); err != nil {
30871				return err
30872			}
30873
30874		case "nextPageToken":
30875			if value != nil {
30876				jtv, ok := value.(string)
30877				if !ok {
30878					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30879				}
30880				sv.NextPageToken = ptr.String(jtv)
30881			}
30882
30883		default:
30884			_, _ = key, value
30885
30886		}
30887	}
30888	*v = sv
30889	return nil
30890}
30891
30892func awsAwsjson11_deserializeOpDocumentGetBundlesOutput(v **GetBundlesOutput, value interface{}) error {
30893	if v == nil {
30894		return fmt.Errorf("unexpected nil of type %T", v)
30895	}
30896	if value == nil {
30897		return nil
30898	}
30899
30900	shape, ok := value.(map[string]interface{})
30901	if !ok {
30902		return fmt.Errorf("unexpected JSON type %v", value)
30903	}
30904
30905	var sv *GetBundlesOutput
30906	if *v == nil {
30907		sv = &GetBundlesOutput{}
30908	} else {
30909		sv = *v
30910	}
30911
30912	for key, value := range shape {
30913		switch key {
30914		case "bundles":
30915			if err := awsAwsjson11_deserializeDocumentBundleList(&sv.Bundles, value); err != nil {
30916				return err
30917			}
30918
30919		case "nextPageToken":
30920			if value != nil {
30921				jtv, ok := value.(string)
30922				if !ok {
30923					return fmt.Errorf("expected string to be of type string, got %T instead", value)
30924				}
30925				sv.NextPageToken = ptr.String(jtv)
30926			}
30927
30928		default:
30929			_, _ = key, value
30930
30931		}
30932	}
30933	*v = sv
30934	return nil
30935}
30936
30937func awsAwsjson11_deserializeOpDocumentGetCertificatesOutput(v **GetCertificatesOutput, value interface{}) error {
30938	if v == nil {
30939		return fmt.Errorf("unexpected nil of type %T", v)
30940	}
30941	if value == nil {
30942		return nil
30943	}
30944
30945	shape, ok := value.(map[string]interface{})
30946	if !ok {
30947		return fmt.Errorf("unexpected JSON type %v", value)
30948	}
30949
30950	var sv *GetCertificatesOutput
30951	if *v == nil {
30952		sv = &GetCertificatesOutput{}
30953	} else {
30954		sv = *v
30955	}
30956
30957	for key, value := range shape {
30958		switch key {
30959		case "certificates":
30960			if err := awsAwsjson11_deserializeDocumentCertificateSummaryList(&sv.Certificates, value); err != nil {
30961				return err
30962			}
30963
30964		default:
30965			_, _ = key, value
30966
30967		}
30968	}
30969	*v = sv
30970	return nil
30971}
30972
30973func awsAwsjson11_deserializeOpDocumentGetCloudFormationStackRecordsOutput(v **GetCloudFormationStackRecordsOutput, value interface{}) error {
30974	if v == nil {
30975		return fmt.Errorf("unexpected nil of type %T", v)
30976	}
30977	if value == nil {
30978		return nil
30979	}
30980
30981	shape, ok := value.(map[string]interface{})
30982	if !ok {
30983		return fmt.Errorf("unexpected JSON type %v", value)
30984	}
30985
30986	var sv *GetCloudFormationStackRecordsOutput
30987	if *v == nil {
30988		sv = &GetCloudFormationStackRecordsOutput{}
30989	} else {
30990		sv = *v
30991	}
30992
30993	for key, value := range shape {
30994		switch key {
30995		case "cloudFormationStackRecords":
30996			if err := awsAwsjson11_deserializeDocumentCloudFormationStackRecordList(&sv.CloudFormationStackRecords, value); err != nil {
30997				return err
30998			}
30999
31000		case "nextPageToken":
31001			if value != nil {
31002				jtv, ok := value.(string)
31003				if !ok {
31004					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31005				}
31006				sv.NextPageToken = ptr.String(jtv)
31007			}
31008
31009		default:
31010			_, _ = key, value
31011
31012		}
31013	}
31014	*v = sv
31015	return nil
31016}
31017
31018func awsAwsjson11_deserializeOpDocumentGetContactMethodsOutput(v **GetContactMethodsOutput, value interface{}) error {
31019	if v == nil {
31020		return fmt.Errorf("unexpected nil of type %T", v)
31021	}
31022	if value == nil {
31023		return nil
31024	}
31025
31026	shape, ok := value.(map[string]interface{})
31027	if !ok {
31028		return fmt.Errorf("unexpected JSON type %v", value)
31029	}
31030
31031	var sv *GetContactMethodsOutput
31032	if *v == nil {
31033		sv = &GetContactMethodsOutput{}
31034	} else {
31035		sv = *v
31036	}
31037
31038	for key, value := range shape {
31039		switch key {
31040		case "contactMethods":
31041			if err := awsAwsjson11_deserializeDocumentContactMethodsList(&sv.ContactMethods, value); err != nil {
31042				return err
31043			}
31044
31045		default:
31046			_, _ = key, value
31047
31048		}
31049	}
31050	*v = sv
31051	return nil
31052}
31053
31054func awsAwsjson11_deserializeOpDocumentGetContainerAPIMetadataOutput(v **GetContainerAPIMetadataOutput, value interface{}) error {
31055	if v == nil {
31056		return fmt.Errorf("unexpected nil of type %T", v)
31057	}
31058	if value == nil {
31059		return nil
31060	}
31061
31062	shape, ok := value.(map[string]interface{})
31063	if !ok {
31064		return fmt.Errorf("unexpected JSON type %v", value)
31065	}
31066
31067	var sv *GetContainerAPIMetadataOutput
31068	if *v == nil {
31069		sv = &GetContainerAPIMetadataOutput{}
31070	} else {
31071		sv = *v
31072	}
31073
31074	for key, value := range shape {
31075		switch key {
31076		case "metadata":
31077			if err := awsAwsjson11_deserializeDocumentContainerServiceMetadataEntryList(&sv.Metadata, value); err != nil {
31078				return err
31079			}
31080
31081		default:
31082			_, _ = key, value
31083
31084		}
31085	}
31086	*v = sv
31087	return nil
31088}
31089
31090func awsAwsjson11_deserializeOpDocumentGetContainerImagesOutput(v **GetContainerImagesOutput, value interface{}) error {
31091	if v == nil {
31092		return fmt.Errorf("unexpected nil of type %T", v)
31093	}
31094	if value == nil {
31095		return nil
31096	}
31097
31098	shape, ok := value.(map[string]interface{})
31099	if !ok {
31100		return fmt.Errorf("unexpected JSON type %v", value)
31101	}
31102
31103	var sv *GetContainerImagesOutput
31104	if *v == nil {
31105		sv = &GetContainerImagesOutput{}
31106	} else {
31107		sv = *v
31108	}
31109
31110	for key, value := range shape {
31111		switch key {
31112		case "containerImages":
31113			if err := awsAwsjson11_deserializeDocumentContainerImageList(&sv.ContainerImages, value); err != nil {
31114				return err
31115			}
31116
31117		default:
31118			_, _ = key, value
31119
31120		}
31121	}
31122	*v = sv
31123	return nil
31124}
31125
31126func awsAwsjson11_deserializeOpDocumentGetContainerLogOutput(v **GetContainerLogOutput, value interface{}) error {
31127	if v == nil {
31128		return fmt.Errorf("unexpected nil of type %T", v)
31129	}
31130	if value == nil {
31131		return nil
31132	}
31133
31134	shape, ok := value.(map[string]interface{})
31135	if !ok {
31136		return fmt.Errorf("unexpected JSON type %v", value)
31137	}
31138
31139	var sv *GetContainerLogOutput
31140	if *v == nil {
31141		sv = &GetContainerLogOutput{}
31142	} else {
31143		sv = *v
31144	}
31145
31146	for key, value := range shape {
31147		switch key {
31148		case "logEvents":
31149			if err := awsAwsjson11_deserializeDocumentContainerServiceLogEventList(&sv.LogEvents, value); err != nil {
31150				return err
31151			}
31152
31153		case "nextPageToken":
31154			if value != nil {
31155				jtv, ok := value.(string)
31156				if !ok {
31157					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31158				}
31159				sv.NextPageToken = ptr.String(jtv)
31160			}
31161
31162		default:
31163			_, _ = key, value
31164
31165		}
31166	}
31167	*v = sv
31168	return nil
31169}
31170
31171func awsAwsjson11_deserializeOpDocumentGetContainerServiceDeploymentsOutput(v **GetContainerServiceDeploymentsOutput, value interface{}) error {
31172	if v == nil {
31173		return fmt.Errorf("unexpected nil of type %T", v)
31174	}
31175	if value == nil {
31176		return nil
31177	}
31178
31179	shape, ok := value.(map[string]interface{})
31180	if !ok {
31181		return fmt.Errorf("unexpected JSON type %v", value)
31182	}
31183
31184	var sv *GetContainerServiceDeploymentsOutput
31185	if *v == nil {
31186		sv = &GetContainerServiceDeploymentsOutput{}
31187	} else {
31188		sv = *v
31189	}
31190
31191	for key, value := range shape {
31192		switch key {
31193		case "deployments":
31194			if err := awsAwsjson11_deserializeDocumentContainerServiceDeploymentList(&sv.Deployments, value); err != nil {
31195				return err
31196			}
31197
31198		default:
31199			_, _ = key, value
31200
31201		}
31202	}
31203	*v = sv
31204	return nil
31205}
31206
31207func awsAwsjson11_deserializeOpDocumentGetContainerServiceMetricDataOutput(v **GetContainerServiceMetricDataOutput, value interface{}) error {
31208	if v == nil {
31209		return fmt.Errorf("unexpected nil of type %T", v)
31210	}
31211	if value == nil {
31212		return nil
31213	}
31214
31215	shape, ok := value.(map[string]interface{})
31216	if !ok {
31217		return fmt.Errorf("unexpected JSON type %v", value)
31218	}
31219
31220	var sv *GetContainerServiceMetricDataOutput
31221	if *v == nil {
31222		sv = &GetContainerServiceMetricDataOutput{}
31223	} else {
31224		sv = *v
31225	}
31226
31227	for key, value := range shape {
31228		switch key {
31229		case "metricData":
31230			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
31231				return err
31232			}
31233
31234		case "metricName":
31235			if value != nil {
31236				jtv, ok := value.(string)
31237				if !ok {
31238					return fmt.Errorf("expected ContainerServiceMetricName to be of type string, got %T instead", value)
31239				}
31240				sv.MetricName = types.ContainerServiceMetricName(jtv)
31241			}
31242
31243		default:
31244			_, _ = key, value
31245
31246		}
31247	}
31248	*v = sv
31249	return nil
31250}
31251
31252func awsAwsjson11_deserializeOpDocumentGetContainerServicePowersOutput(v **GetContainerServicePowersOutput, value interface{}) error {
31253	if v == nil {
31254		return fmt.Errorf("unexpected nil of type %T", v)
31255	}
31256	if value == nil {
31257		return nil
31258	}
31259
31260	shape, ok := value.(map[string]interface{})
31261	if !ok {
31262		return fmt.Errorf("unexpected JSON type %v", value)
31263	}
31264
31265	var sv *GetContainerServicePowersOutput
31266	if *v == nil {
31267		sv = &GetContainerServicePowersOutput{}
31268	} else {
31269		sv = *v
31270	}
31271
31272	for key, value := range shape {
31273		switch key {
31274		case "powers":
31275			if err := awsAwsjson11_deserializeDocumentContainerServicePowerList(&sv.Powers, value); err != nil {
31276				return err
31277			}
31278
31279		default:
31280			_, _ = key, value
31281
31282		}
31283	}
31284	*v = sv
31285	return nil
31286}
31287
31288func awsAwsjson11_deserializeOpDocumentGetContainerServicesOutput(v **GetContainerServicesOutput, value interface{}) error {
31289	if v == nil {
31290		return fmt.Errorf("unexpected nil of type %T", v)
31291	}
31292	if value == nil {
31293		return nil
31294	}
31295
31296	shape, ok := value.(map[string]interface{})
31297	if !ok {
31298		return fmt.Errorf("unexpected JSON type %v", value)
31299	}
31300
31301	var sv *GetContainerServicesOutput
31302	if *v == nil {
31303		sv = &GetContainerServicesOutput{}
31304	} else {
31305		sv = *v
31306	}
31307
31308	for key, value := range shape {
31309		switch key {
31310		case "containerServices":
31311			if err := awsAwsjson11_deserializeDocumentContainerServiceList(&sv.ContainerServices, value); err != nil {
31312				return err
31313			}
31314
31315		default:
31316			_, _ = key, value
31317
31318		}
31319	}
31320	*v = sv
31321	return nil
31322}
31323
31324func awsAwsjson11_deserializeOpDocumentGetDiskOutput(v **GetDiskOutput, value interface{}) error {
31325	if v == nil {
31326		return fmt.Errorf("unexpected nil of type %T", v)
31327	}
31328	if value == nil {
31329		return nil
31330	}
31331
31332	shape, ok := value.(map[string]interface{})
31333	if !ok {
31334		return fmt.Errorf("unexpected JSON type %v", value)
31335	}
31336
31337	var sv *GetDiskOutput
31338	if *v == nil {
31339		sv = &GetDiskOutput{}
31340	} else {
31341		sv = *v
31342	}
31343
31344	for key, value := range shape {
31345		switch key {
31346		case "disk":
31347			if err := awsAwsjson11_deserializeDocumentDisk(&sv.Disk, value); err != nil {
31348				return err
31349			}
31350
31351		default:
31352			_, _ = key, value
31353
31354		}
31355	}
31356	*v = sv
31357	return nil
31358}
31359
31360func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotOutput(v **GetDiskSnapshotOutput, value interface{}) error {
31361	if v == nil {
31362		return fmt.Errorf("unexpected nil of type %T", v)
31363	}
31364	if value == nil {
31365		return nil
31366	}
31367
31368	shape, ok := value.(map[string]interface{})
31369	if !ok {
31370		return fmt.Errorf("unexpected JSON type %v", value)
31371	}
31372
31373	var sv *GetDiskSnapshotOutput
31374	if *v == nil {
31375		sv = &GetDiskSnapshotOutput{}
31376	} else {
31377		sv = *v
31378	}
31379
31380	for key, value := range shape {
31381		switch key {
31382		case "diskSnapshot":
31383			if err := awsAwsjson11_deserializeDocumentDiskSnapshot(&sv.DiskSnapshot, value); err != nil {
31384				return err
31385			}
31386
31387		default:
31388			_, _ = key, value
31389
31390		}
31391	}
31392	*v = sv
31393	return nil
31394}
31395
31396func awsAwsjson11_deserializeOpDocumentGetDiskSnapshotsOutput(v **GetDiskSnapshotsOutput, value interface{}) error {
31397	if v == nil {
31398		return fmt.Errorf("unexpected nil of type %T", v)
31399	}
31400	if value == nil {
31401		return nil
31402	}
31403
31404	shape, ok := value.(map[string]interface{})
31405	if !ok {
31406		return fmt.Errorf("unexpected JSON type %v", value)
31407	}
31408
31409	var sv *GetDiskSnapshotsOutput
31410	if *v == nil {
31411		sv = &GetDiskSnapshotsOutput{}
31412	} else {
31413		sv = *v
31414	}
31415
31416	for key, value := range shape {
31417		switch key {
31418		case "diskSnapshots":
31419			if err := awsAwsjson11_deserializeDocumentDiskSnapshotList(&sv.DiskSnapshots, value); err != nil {
31420				return err
31421			}
31422
31423		case "nextPageToken":
31424			if value != nil {
31425				jtv, ok := value.(string)
31426				if !ok {
31427					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31428				}
31429				sv.NextPageToken = ptr.String(jtv)
31430			}
31431
31432		default:
31433			_, _ = key, value
31434
31435		}
31436	}
31437	*v = sv
31438	return nil
31439}
31440
31441func awsAwsjson11_deserializeOpDocumentGetDisksOutput(v **GetDisksOutput, value interface{}) error {
31442	if v == nil {
31443		return fmt.Errorf("unexpected nil of type %T", v)
31444	}
31445	if value == nil {
31446		return nil
31447	}
31448
31449	shape, ok := value.(map[string]interface{})
31450	if !ok {
31451		return fmt.Errorf("unexpected JSON type %v", value)
31452	}
31453
31454	var sv *GetDisksOutput
31455	if *v == nil {
31456		sv = &GetDisksOutput{}
31457	} else {
31458		sv = *v
31459	}
31460
31461	for key, value := range shape {
31462		switch key {
31463		case "disks":
31464			if err := awsAwsjson11_deserializeDocumentDiskList(&sv.Disks, value); err != nil {
31465				return err
31466			}
31467
31468		case "nextPageToken":
31469			if value != nil {
31470				jtv, ok := value.(string)
31471				if !ok {
31472					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31473				}
31474				sv.NextPageToken = ptr.String(jtv)
31475			}
31476
31477		default:
31478			_, _ = key, value
31479
31480		}
31481	}
31482	*v = sv
31483	return nil
31484}
31485
31486func awsAwsjson11_deserializeOpDocumentGetDistributionBundlesOutput(v **GetDistributionBundlesOutput, value interface{}) error {
31487	if v == nil {
31488		return fmt.Errorf("unexpected nil of type %T", v)
31489	}
31490	if value == nil {
31491		return nil
31492	}
31493
31494	shape, ok := value.(map[string]interface{})
31495	if !ok {
31496		return fmt.Errorf("unexpected JSON type %v", value)
31497	}
31498
31499	var sv *GetDistributionBundlesOutput
31500	if *v == nil {
31501		sv = &GetDistributionBundlesOutput{}
31502	} else {
31503		sv = *v
31504	}
31505
31506	for key, value := range shape {
31507		switch key {
31508		case "bundles":
31509			if err := awsAwsjson11_deserializeDocumentDistributionBundleList(&sv.Bundles, value); err != nil {
31510				return err
31511			}
31512
31513		default:
31514			_, _ = key, value
31515
31516		}
31517	}
31518	*v = sv
31519	return nil
31520}
31521
31522func awsAwsjson11_deserializeOpDocumentGetDistributionLatestCacheResetOutput(v **GetDistributionLatestCacheResetOutput, value interface{}) error {
31523	if v == nil {
31524		return fmt.Errorf("unexpected nil of type %T", v)
31525	}
31526	if value == nil {
31527		return nil
31528	}
31529
31530	shape, ok := value.(map[string]interface{})
31531	if !ok {
31532		return fmt.Errorf("unexpected JSON type %v", value)
31533	}
31534
31535	var sv *GetDistributionLatestCacheResetOutput
31536	if *v == nil {
31537		sv = &GetDistributionLatestCacheResetOutput{}
31538	} else {
31539		sv = *v
31540	}
31541
31542	for key, value := range shape {
31543		switch key {
31544		case "createTime":
31545			if value != nil {
31546				jtv, ok := value.(json.Number)
31547				if !ok {
31548					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
31549				}
31550				f64, err := jtv.Float64()
31551				if err != nil {
31552					return err
31553				}
31554				sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
31555			}
31556
31557		case "status":
31558			if value != nil {
31559				jtv, ok := value.(string)
31560				if !ok {
31561					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31562				}
31563				sv.Status = ptr.String(jtv)
31564			}
31565
31566		default:
31567			_, _ = key, value
31568
31569		}
31570	}
31571	*v = sv
31572	return nil
31573}
31574
31575func awsAwsjson11_deserializeOpDocumentGetDistributionMetricDataOutput(v **GetDistributionMetricDataOutput, value interface{}) error {
31576	if v == nil {
31577		return fmt.Errorf("unexpected nil of type %T", v)
31578	}
31579	if value == nil {
31580		return nil
31581	}
31582
31583	shape, ok := value.(map[string]interface{})
31584	if !ok {
31585		return fmt.Errorf("unexpected JSON type %v", value)
31586	}
31587
31588	var sv *GetDistributionMetricDataOutput
31589	if *v == nil {
31590		sv = &GetDistributionMetricDataOutput{}
31591	} else {
31592		sv = *v
31593	}
31594
31595	for key, value := range shape {
31596		switch key {
31597		case "metricData":
31598			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
31599				return err
31600			}
31601
31602		case "metricName":
31603			if value != nil {
31604				jtv, ok := value.(string)
31605				if !ok {
31606					return fmt.Errorf("expected DistributionMetricName to be of type string, got %T instead", value)
31607				}
31608				sv.MetricName = types.DistributionMetricName(jtv)
31609			}
31610
31611		default:
31612			_, _ = key, value
31613
31614		}
31615	}
31616	*v = sv
31617	return nil
31618}
31619
31620func awsAwsjson11_deserializeOpDocumentGetDistributionsOutput(v **GetDistributionsOutput, value interface{}) error {
31621	if v == nil {
31622		return fmt.Errorf("unexpected nil of type %T", v)
31623	}
31624	if value == nil {
31625		return nil
31626	}
31627
31628	shape, ok := value.(map[string]interface{})
31629	if !ok {
31630		return fmt.Errorf("unexpected JSON type %v", value)
31631	}
31632
31633	var sv *GetDistributionsOutput
31634	if *v == nil {
31635		sv = &GetDistributionsOutput{}
31636	} else {
31637		sv = *v
31638	}
31639
31640	for key, value := range shape {
31641		switch key {
31642		case "distributions":
31643			if err := awsAwsjson11_deserializeDocumentDistributionList(&sv.Distributions, value); err != nil {
31644				return err
31645			}
31646
31647		case "nextPageToken":
31648			if value != nil {
31649				jtv, ok := value.(string)
31650				if !ok {
31651					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31652				}
31653				sv.NextPageToken = ptr.String(jtv)
31654			}
31655
31656		default:
31657			_, _ = key, value
31658
31659		}
31660	}
31661	*v = sv
31662	return nil
31663}
31664
31665func awsAwsjson11_deserializeOpDocumentGetDomainOutput(v **GetDomainOutput, value interface{}) error {
31666	if v == nil {
31667		return fmt.Errorf("unexpected nil of type %T", v)
31668	}
31669	if value == nil {
31670		return nil
31671	}
31672
31673	shape, ok := value.(map[string]interface{})
31674	if !ok {
31675		return fmt.Errorf("unexpected JSON type %v", value)
31676	}
31677
31678	var sv *GetDomainOutput
31679	if *v == nil {
31680		sv = &GetDomainOutput{}
31681	} else {
31682		sv = *v
31683	}
31684
31685	for key, value := range shape {
31686		switch key {
31687		case "domain":
31688			if err := awsAwsjson11_deserializeDocumentDomain(&sv.Domain, value); err != nil {
31689				return err
31690			}
31691
31692		default:
31693			_, _ = key, value
31694
31695		}
31696	}
31697	*v = sv
31698	return nil
31699}
31700
31701func awsAwsjson11_deserializeOpDocumentGetDomainsOutput(v **GetDomainsOutput, value interface{}) error {
31702	if v == nil {
31703		return fmt.Errorf("unexpected nil of type %T", v)
31704	}
31705	if value == nil {
31706		return nil
31707	}
31708
31709	shape, ok := value.(map[string]interface{})
31710	if !ok {
31711		return fmt.Errorf("unexpected JSON type %v", value)
31712	}
31713
31714	var sv *GetDomainsOutput
31715	if *v == nil {
31716		sv = &GetDomainsOutput{}
31717	} else {
31718		sv = *v
31719	}
31720
31721	for key, value := range shape {
31722		switch key {
31723		case "domains":
31724			if err := awsAwsjson11_deserializeDocumentDomainList(&sv.Domains, value); err != nil {
31725				return err
31726			}
31727
31728		case "nextPageToken":
31729			if value != nil {
31730				jtv, ok := value.(string)
31731				if !ok {
31732					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31733				}
31734				sv.NextPageToken = ptr.String(jtv)
31735			}
31736
31737		default:
31738			_, _ = key, value
31739
31740		}
31741	}
31742	*v = sv
31743	return nil
31744}
31745
31746func awsAwsjson11_deserializeOpDocumentGetExportSnapshotRecordsOutput(v **GetExportSnapshotRecordsOutput, value interface{}) error {
31747	if v == nil {
31748		return fmt.Errorf("unexpected nil of type %T", v)
31749	}
31750	if value == nil {
31751		return nil
31752	}
31753
31754	shape, ok := value.(map[string]interface{})
31755	if !ok {
31756		return fmt.Errorf("unexpected JSON type %v", value)
31757	}
31758
31759	var sv *GetExportSnapshotRecordsOutput
31760	if *v == nil {
31761		sv = &GetExportSnapshotRecordsOutput{}
31762	} else {
31763		sv = *v
31764	}
31765
31766	for key, value := range shape {
31767		switch key {
31768		case "exportSnapshotRecords":
31769			if err := awsAwsjson11_deserializeDocumentExportSnapshotRecordList(&sv.ExportSnapshotRecords, value); err != nil {
31770				return err
31771			}
31772
31773		case "nextPageToken":
31774			if value != nil {
31775				jtv, ok := value.(string)
31776				if !ok {
31777					return fmt.Errorf("expected string to be of type string, got %T instead", value)
31778				}
31779				sv.NextPageToken = ptr.String(jtv)
31780			}
31781
31782		default:
31783			_, _ = key, value
31784
31785		}
31786	}
31787	*v = sv
31788	return nil
31789}
31790
31791func awsAwsjson11_deserializeOpDocumentGetInstanceAccessDetailsOutput(v **GetInstanceAccessDetailsOutput, value interface{}) error {
31792	if v == nil {
31793		return fmt.Errorf("unexpected nil of type %T", v)
31794	}
31795	if value == nil {
31796		return nil
31797	}
31798
31799	shape, ok := value.(map[string]interface{})
31800	if !ok {
31801		return fmt.Errorf("unexpected JSON type %v", value)
31802	}
31803
31804	var sv *GetInstanceAccessDetailsOutput
31805	if *v == nil {
31806		sv = &GetInstanceAccessDetailsOutput{}
31807	} else {
31808		sv = *v
31809	}
31810
31811	for key, value := range shape {
31812		switch key {
31813		case "accessDetails":
31814			if err := awsAwsjson11_deserializeDocumentInstanceAccessDetails(&sv.AccessDetails, value); err != nil {
31815				return err
31816			}
31817
31818		default:
31819			_, _ = key, value
31820
31821		}
31822	}
31823	*v = sv
31824	return nil
31825}
31826
31827func awsAwsjson11_deserializeOpDocumentGetInstanceMetricDataOutput(v **GetInstanceMetricDataOutput, value interface{}) error {
31828	if v == nil {
31829		return fmt.Errorf("unexpected nil of type %T", v)
31830	}
31831	if value == nil {
31832		return nil
31833	}
31834
31835	shape, ok := value.(map[string]interface{})
31836	if !ok {
31837		return fmt.Errorf("unexpected JSON type %v", value)
31838	}
31839
31840	var sv *GetInstanceMetricDataOutput
31841	if *v == nil {
31842		sv = &GetInstanceMetricDataOutput{}
31843	} else {
31844		sv = *v
31845	}
31846
31847	for key, value := range shape {
31848		switch key {
31849		case "metricData":
31850			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
31851				return err
31852			}
31853
31854		case "metricName":
31855			if value != nil {
31856				jtv, ok := value.(string)
31857				if !ok {
31858					return fmt.Errorf("expected InstanceMetricName to be of type string, got %T instead", value)
31859				}
31860				sv.MetricName = types.InstanceMetricName(jtv)
31861			}
31862
31863		default:
31864			_, _ = key, value
31865
31866		}
31867	}
31868	*v = sv
31869	return nil
31870}
31871
31872func awsAwsjson11_deserializeOpDocumentGetInstanceOutput(v **GetInstanceOutput, value interface{}) error {
31873	if v == nil {
31874		return fmt.Errorf("unexpected nil of type %T", v)
31875	}
31876	if value == nil {
31877		return nil
31878	}
31879
31880	shape, ok := value.(map[string]interface{})
31881	if !ok {
31882		return fmt.Errorf("unexpected JSON type %v", value)
31883	}
31884
31885	var sv *GetInstanceOutput
31886	if *v == nil {
31887		sv = &GetInstanceOutput{}
31888	} else {
31889		sv = *v
31890	}
31891
31892	for key, value := range shape {
31893		switch key {
31894		case "instance":
31895			if err := awsAwsjson11_deserializeDocumentInstance(&sv.Instance, value); err != nil {
31896				return err
31897			}
31898
31899		default:
31900			_, _ = key, value
31901
31902		}
31903	}
31904	*v = sv
31905	return nil
31906}
31907
31908func awsAwsjson11_deserializeOpDocumentGetInstancePortStatesOutput(v **GetInstancePortStatesOutput, value interface{}) error {
31909	if v == nil {
31910		return fmt.Errorf("unexpected nil of type %T", v)
31911	}
31912	if value == nil {
31913		return nil
31914	}
31915
31916	shape, ok := value.(map[string]interface{})
31917	if !ok {
31918		return fmt.Errorf("unexpected JSON type %v", value)
31919	}
31920
31921	var sv *GetInstancePortStatesOutput
31922	if *v == nil {
31923		sv = &GetInstancePortStatesOutput{}
31924	} else {
31925		sv = *v
31926	}
31927
31928	for key, value := range shape {
31929		switch key {
31930		case "portStates":
31931			if err := awsAwsjson11_deserializeDocumentInstancePortStateList(&sv.PortStates, value); err != nil {
31932				return err
31933			}
31934
31935		default:
31936			_, _ = key, value
31937
31938		}
31939	}
31940	*v = sv
31941	return nil
31942}
31943
31944func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotOutput(v **GetInstanceSnapshotOutput, value interface{}) error {
31945	if v == nil {
31946		return fmt.Errorf("unexpected nil of type %T", v)
31947	}
31948	if value == nil {
31949		return nil
31950	}
31951
31952	shape, ok := value.(map[string]interface{})
31953	if !ok {
31954		return fmt.Errorf("unexpected JSON type %v", value)
31955	}
31956
31957	var sv *GetInstanceSnapshotOutput
31958	if *v == nil {
31959		sv = &GetInstanceSnapshotOutput{}
31960	} else {
31961		sv = *v
31962	}
31963
31964	for key, value := range shape {
31965		switch key {
31966		case "instanceSnapshot":
31967			if err := awsAwsjson11_deserializeDocumentInstanceSnapshot(&sv.InstanceSnapshot, value); err != nil {
31968				return err
31969			}
31970
31971		default:
31972			_, _ = key, value
31973
31974		}
31975	}
31976	*v = sv
31977	return nil
31978}
31979
31980func awsAwsjson11_deserializeOpDocumentGetInstanceSnapshotsOutput(v **GetInstanceSnapshotsOutput, value interface{}) error {
31981	if v == nil {
31982		return fmt.Errorf("unexpected nil of type %T", v)
31983	}
31984	if value == nil {
31985		return nil
31986	}
31987
31988	shape, ok := value.(map[string]interface{})
31989	if !ok {
31990		return fmt.Errorf("unexpected JSON type %v", value)
31991	}
31992
31993	var sv *GetInstanceSnapshotsOutput
31994	if *v == nil {
31995		sv = &GetInstanceSnapshotsOutput{}
31996	} else {
31997		sv = *v
31998	}
31999
32000	for key, value := range shape {
32001		switch key {
32002		case "instanceSnapshots":
32003			if err := awsAwsjson11_deserializeDocumentInstanceSnapshotList(&sv.InstanceSnapshots, value); err != nil {
32004				return err
32005			}
32006
32007		case "nextPageToken":
32008			if value != nil {
32009				jtv, ok := value.(string)
32010				if !ok {
32011					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32012				}
32013				sv.NextPageToken = ptr.String(jtv)
32014			}
32015
32016		default:
32017			_, _ = key, value
32018
32019		}
32020	}
32021	*v = sv
32022	return nil
32023}
32024
32025func awsAwsjson11_deserializeOpDocumentGetInstancesOutput(v **GetInstancesOutput, value interface{}) error {
32026	if v == nil {
32027		return fmt.Errorf("unexpected nil of type %T", v)
32028	}
32029	if value == nil {
32030		return nil
32031	}
32032
32033	shape, ok := value.(map[string]interface{})
32034	if !ok {
32035		return fmt.Errorf("unexpected JSON type %v", value)
32036	}
32037
32038	var sv *GetInstancesOutput
32039	if *v == nil {
32040		sv = &GetInstancesOutput{}
32041	} else {
32042		sv = *v
32043	}
32044
32045	for key, value := range shape {
32046		switch key {
32047		case "instances":
32048			if err := awsAwsjson11_deserializeDocumentInstanceList(&sv.Instances, value); err != nil {
32049				return err
32050			}
32051
32052		case "nextPageToken":
32053			if value != nil {
32054				jtv, ok := value.(string)
32055				if !ok {
32056					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32057				}
32058				sv.NextPageToken = ptr.String(jtv)
32059			}
32060
32061		default:
32062			_, _ = key, value
32063
32064		}
32065	}
32066	*v = sv
32067	return nil
32068}
32069
32070func awsAwsjson11_deserializeOpDocumentGetInstanceStateOutput(v **GetInstanceStateOutput, value interface{}) error {
32071	if v == nil {
32072		return fmt.Errorf("unexpected nil of type %T", v)
32073	}
32074	if value == nil {
32075		return nil
32076	}
32077
32078	shape, ok := value.(map[string]interface{})
32079	if !ok {
32080		return fmt.Errorf("unexpected JSON type %v", value)
32081	}
32082
32083	var sv *GetInstanceStateOutput
32084	if *v == nil {
32085		sv = &GetInstanceStateOutput{}
32086	} else {
32087		sv = *v
32088	}
32089
32090	for key, value := range shape {
32091		switch key {
32092		case "state":
32093			if err := awsAwsjson11_deserializeDocumentInstanceState(&sv.State, value); err != nil {
32094				return err
32095			}
32096
32097		default:
32098			_, _ = key, value
32099
32100		}
32101	}
32102	*v = sv
32103	return nil
32104}
32105
32106func awsAwsjson11_deserializeOpDocumentGetKeyPairOutput(v **GetKeyPairOutput, value interface{}) error {
32107	if v == nil {
32108		return fmt.Errorf("unexpected nil of type %T", v)
32109	}
32110	if value == nil {
32111		return nil
32112	}
32113
32114	shape, ok := value.(map[string]interface{})
32115	if !ok {
32116		return fmt.Errorf("unexpected JSON type %v", value)
32117	}
32118
32119	var sv *GetKeyPairOutput
32120	if *v == nil {
32121		sv = &GetKeyPairOutput{}
32122	} else {
32123		sv = *v
32124	}
32125
32126	for key, value := range shape {
32127		switch key {
32128		case "keyPair":
32129			if err := awsAwsjson11_deserializeDocumentKeyPair(&sv.KeyPair, value); err != nil {
32130				return err
32131			}
32132
32133		default:
32134			_, _ = key, value
32135
32136		}
32137	}
32138	*v = sv
32139	return nil
32140}
32141
32142func awsAwsjson11_deserializeOpDocumentGetKeyPairsOutput(v **GetKeyPairsOutput, value interface{}) error {
32143	if v == nil {
32144		return fmt.Errorf("unexpected nil of type %T", v)
32145	}
32146	if value == nil {
32147		return nil
32148	}
32149
32150	shape, ok := value.(map[string]interface{})
32151	if !ok {
32152		return fmt.Errorf("unexpected JSON type %v", value)
32153	}
32154
32155	var sv *GetKeyPairsOutput
32156	if *v == nil {
32157		sv = &GetKeyPairsOutput{}
32158	} else {
32159		sv = *v
32160	}
32161
32162	for key, value := range shape {
32163		switch key {
32164		case "keyPairs":
32165			if err := awsAwsjson11_deserializeDocumentKeyPairList(&sv.KeyPairs, value); err != nil {
32166				return err
32167			}
32168
32169		case "nextPageToken":
32170			if value != nil {
32171				jtv, ok := value.(string)
32172				if !ok {
32173					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32174				}
32175				sv.NextPageToken = ptr.String(jtv)
32176			}
32177
32178		default:
32179			_, _ = key, value
32180
32181		}
32182	}
32183	*v = sv
32184	return nil
32185}
32186
32187func awsAwsjson11_deserializeOpDocumentGetLoadBalancerMetricDataOutput(v **GetLoadBalancerMetricDataOutput, value interface{}) error {
32188	if v == nil {
32189		return fmt.Errorf("unexpected nil of type %T", v)
32190	}
32191	if value == nil {
32192		return nil
32193	}
32194
32195	shape, ok := value.(map[string]interface{})
32196	if !ok {
32197		return fmt.Errorf("unexpected JSON type %v", value)
32198	}
32199
32200	var sv *GetLoadBalancerMetricDataOutput
32201	if *v == nil {
32202		sv = &GetLoadBalancerMetricDataOutput{}
32203	} else {
32204		sv = *v
32205	}
32206
32207	for key, value := range shape {
32208		switch key {
32209		case "metricData":
32210			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
32211				return err
32212			}
32213
32214		case "metricName":
32215			if value != nil {
32216				jtv, ok := value.(string)
32217				if !ok {
32218					return fmt.Errorf("expected LoadBalancerMetricName to be of type string, got %T instead", value)
32219				}
32220				sv.MetricName = types.LoadBalancerMetricName(jtv)
32221			}
32222
32223		default:
32224			_, _ = key, value
32225
32226		}
32227	}
32228	*v = sv
32229	return nil
32230}
32231
32232func awsAwsjson11_deserializeOpDocumentGetLoadBalancerOutput(v **GetLoadBalancerOutput, value interface{}) error {
32233	if v == nil {
32234		return fmt.Errorf("unexpected nil of type %T", v)
32235	}
32236	if value == nil {
32237		return nil
32238	}
32239
32240	shape, ok := value.(map[string]interface{})
32241	if !ok {
32242		return fmt.Errorf("unexpected JSON type %v", value)
32243	}
32244
32245	var sv *GetLoadBalancerOutput
32246	if *v == nil {
32247		sv = &GetLoadBalancerOutput{}
32248	} else {
32249		sv = *v
32250	}
32251
32252	for key, value := range shape {
32253		switch key {
32254		case "loadBalancer":
32255			if err := awsAwsjson11_deserializeDocumentLoadBalancer(&sv.LoadBalancer, value); err != nil {
32256				return err
32257			}
32258
32259		default:
32260			_, _ = key, value
32261
32262		}
32263	}
32264	*v = sv
32265	return nil
32266}
32267
32268func awsAwsjson11_deserializeOpDocumentGetLoadBalancersOutput(v **GetLoadBalancersOutput, value interface{}) error {
32269	if v == nil {
32270		return fmt.Errorf("unexpected nil of type %T", v)
32271	}
32272	if value == nil {
32273		return nil
32274	}
32275
32276	shape, ok := value.(map[string]interface{})
32277	if !ok {
32278		return fmt.Errorf("unexpected JSON type %v", value)
32279	}
32280
32281	var sv *GetLoadBalancersOutput
32282	if *v == nil {
32283		sv = &GetLoadBalancersOutput{}
32284	} else {
32285		sv = *v
32286	}
32287
32288	for key, value := range shape {
32289		switch key {
32290		case "loadBalancers":
32291			if err := awsAwsjson11_deserializeDocumentLoadBalancerList(&sv.LoadBalancers, value); err != nil {
32292				return err
32293			}
32294
32295		case "nextPageToken":
32296			if value != nil {
32297				jtv, ok := value.(string)
32298				if !ok {
32299					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32300				}
32301				sv.NextPageToken = ptr.String(jtv)
32302			}
32303
32304		default:
32305			_, _ = key, value
32306
32307		}
32308	}
32309	*v = sv
32310	return nil
32311}
32312
32313func awsAwsjson11_deserializeOpDocumentGetLoadBalancerTlsCertificatesOutput(v **GetLoadBalancerTlsCertificatesOutput, value interface{}) error {
32314	if v == nil {
32315		return fmt.Errorf("unexpected nil of type %T", v)
32316	}
32317	if value == nil {
32318		return nil
32319	}
32320
32321	shape, ok := value.(map[string]interface{})
32322	if !ok {
32323		return fmt.Errorf("unexpected JSON type %v", value)
32324	}
32325
32326	var sv *GetLoadBalancerTlsCertificatesOutput
32327	if *v == nil {
32328		sv = &GetLoadBalancerTlsCertificatesOutput{}
32329	} else {
32330		sv = *v
32331	}
32332
32333	for key, value := range shape {
32334		switch key {
32335		case "tlsCertificates":
32336			if err := awsAwsjson11_deserializeDocumentLoadBalancerTlsCertificateList(&sv.TlsCertificates, value); err != nil {
32337				return err
32338			}
32339
32340		default:
32341			_, _ = key, value
32342
32343		}
32344	}
32345	*v = sv
32346	return nil
32347}
32348
32349func awsAwsjson11_deserializeOpDocumentGetOperationOutput(v **GetOperationOutput, value interface{}) error {
32350	if v == nil {
32351		return fmt.Errorf("unexpected nil of type %T", v)
32352	}
32353	if value == nil {
32354		return nil
32355	}
32356
32357	shape, ok := value.(map[string]interface{})
32358	if !ok {
32359		return fmt.Errorf("unexpected JSON type %v", value)
32360	}
32361
32362	var sv *GetOperationOutput
32363	if *v == nil {
32364		sv = &GetOperationOutput{}
32365	} else {
32366		sv = *v
32367	}
32368
32369	for key, value := range shape {
32370		switch key {
32371		case "operation":
32372			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
32373				return err
32374			}
32375
32376		default:
32377			_, _ = key, value
32378
32379		}
32380	}
32381	*v = sv
32382	return nil
32383}
32384
32385func awsAwsjson11_deserializeOpDocumentGetOperationsForResourceOutput(v **GetOperationsForResourceOutput, value interface{}) error {
32386	if v == nil {
32387		return fmt.Errorf("unexpected nil of type %T", v)
32388	}
32389	if value == nil {
32390		return nil
32391	}
32392
32393	shape, ok := value.(map[string]interface{})
32394	if !ok {
32395		return fmt.Errorf("unexpected JSON type %v", value)
32396	}
32397
32398	var sv *GetOperationsForResourceOutput
32399	if *v == nil {
32400		sv = &GetOperationsForResourceOutput{}
32401	} else {
32402		sv = *v
32403	}
32404
32405	for key, value := range shape {
32406		switch key {
32407		case "nextPageCount":
32408			if value != nil {
32409				jtv, ok := value.(string)
32410				if !ok {
32411					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32412				}
32413				sv.NextPageCount = ptr.String(jtv)
32414			}
32415
32416		case "nextPageToken":
32417			if value != nil {
32418				jtv, ok := value.(string)
32419				if !ok {
32420					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32421				}
32422				sv.NextPageToken = ptr.String(jtv)
32423			}
32424
32425		case "operations":
32426			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32427				return err
32428			}
32429
32430		default:
32431			_, _ = key, value
32432
32433		}
32434	}
32435	*v = sv
32436	return nil
32437}
32438
32439func awsAwsjson11_deserializeOpDocumentGetOperationsOutput(v **GetOperationsOutput, value interface{}) error {
32440	if v == nil {
32441		return fmt.Errorf("unexpected nil of type %T", v)
32442	}
32443	if value == nil {
32444		return nil
32445	}
32446
32447	shape, ok := value.(map[string]interface{})
32448	if !ok {
32449		return fmt.Errorf("unexpected JSON type %v", value)
32450	}
32451
32452	var sv *GetOperationsOutput
32453	if *v == nil {
32454		sv = &GetOperationsOutput{}
32455	} else {
32456		sv = *v
32457	}
32458
32459	for key, value := range shape {
32460		switch key {
32461		case "nextPageToken":
32462			if value != nil {
32463				jtv, ok := value.(string)
32464				if !ok {
32465					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32466				}
32467				sv.NextPageToken = ptr.String(jtv)
32468			}
32469
32470		case "operations":
32471			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
32472				return err
32473			}
32474
32475		default:
32476			_, _ = key, value
32477
32478		}
32479	}
32480	*v = sv
32481	return nil
32482}
32483
32484func awsAwsjson11_deserializeOpDocumentGetRegionsOutput(v **GetRegionsOutput, value interface{}) error {
32485	if v == nil {
32486		return fmt.Errorf("unexpected nil of type %T", v)
32487	}
32488	if value == nil {
32489		return nil
32490	}
32491
32492	shape, ok := value.(map[string]interface{})
32493	if !ok {
32494		return fmt.Errorf("unexpected JSON type %v", value)
32495	}
32496
32497	var sv *GetRegionsOutput
32498	if *v == nil {
32499		sv = &GetRegionsOutput{}
32500	} else {
32501		sv = *v
32502	}
32503
32504	for key, value := range shape {
32505		switch key {
32506		case "regions":
32507			if err := awsAwsjson11_deserializeDocumentRegionList(&sv.Regions, value); err != nil {
32508				return err
32509			}
32510
32511		default:
32512			_, _ = key, value
32513
32514		}
32515	}
32516	*v = sv
32517	return nil
32518}
32519
32520func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBlueprintsOutput(v **GetRelationalDatabaseBlueprintsOutput, value interface{}) error {
32521	if v == nil {
32522		return fmt.Errorf("unexpected nil of type %T", v)
32523	}
32524	if value == nil {
32525		return nil
32526	}
32527
32528	shape, ok := value.(map[string]interface{})
32529	if !ok {
32530		return fmt.Errorf("unexpected JSON type %v", value)
32531	}
32532
32533	var sv *GetRelationalDatabaseBlueprintsOutput
32534	if *v == nil {
32535		sv = &GetRelationalDatabaseBlueprintsOutput{}
32536	} else {
32537		sv = *v
32538	}
32539
32540	for key, value := range shape {
32541		switch key {
32542		case "blueprints":
32543			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBlueprintList(&sv.Blueprints, value); err != nil {
32544				return err
32545			}
32546
32547		case "nextPageToken":
32548			if value != nil {
32549				jtv, ok := value.(string)
32550				if !ok {
32551					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32552				}
32553				sv.NextPageToken = ptr.String(jtv)
32554			}
32555
32556		default:
32557			_, _ = key, value
32558
32559		}
32560	}
32561	*v = sv
32562	return nil
32563}
32564
32565func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseBundlesOutput(v **GetRelationalDatabaseBundlesOutput, value interface{}) error {
32566	if v == nil {
32567		return fmt.Errorf("unexpected nil of type %T", v)
32568	}
32569	if value == nil {
32570		return nil
32571	}
32572
32573	shape, ok := value.(map[string]interface{})
32574	if !ok {
32575		return fmt.Errorf("unexpected JSON type %v", value)
32576	}
32577
32578	var sv *GetRelationalDatabaseBundlesOutput
32579	if *v == nil {
32580		sv = &GetRelationalDatabaseBundlesOutput{}
32581	} else {
32582		sv = *v
32583	}
32584
32585	for key, value := range shape {
32586		switch key {
32587		case "bundles":
32588			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseBundleList(&sv.Bundles, value); err != nil {
32589				return err
32590			}
32591
32592		case "nextPageToken":
32593			if value != nil {
32594				jtv, ok := value.(string)
32595				if !ok {
32596					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32597				}
32598				sv.NextPageToken = ptr.String(jtv)
32599			}
32600
32601		default:
32602			_, _ = key, value
32603
32604		}
32605	}
32606	*v = sv
32607	return nil
32608}
32609
32610func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseEventsOutput(v **GetRelationalDatabaseEventsOutput, value interface{}) error {
32611	if v == nil {
32612		return fmt.Errorf("unexpected nil of type %T", v)
32613	}
32614	if value == nil {
32615		return nil
32616	}
32617
32618	shape, ok := value.(map[string]interface{})
32619	if !ok {
32620		return fmt.Errorf("unexpected JSON type %v", value)
32621	}
32622
32623	var sv *GetRelationalDatabaseEventsOutput
32624	if *v == nil {
32625		sv = &GetRelationalDatabaseEventsOutput{}
32626	} else {
32627		sv = *v
32628	}
32629
32630	for key, value := range shape {
32631		switch key {
32632		case "nextPageToken":
32633			if value != nil {
32634				jtv, ok := value.(string)
32635				if !ok {
32636					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32637				}
32638				sv.NextPageToken = ptr.String(jtv)
32639			}
32640
32641		case "relationalDatabaseEvents":
32642			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseEventList(&sv.RelationalDatabaseEvents, value); err != nil {
32643				return err
32644			}
32645
32646		default:
32647			_, _ = key, value
32648
32649		}
32650	}
32651	*v = sv
32652	return nil
32653}
32654
32655func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogEventsOutput(v **GetRelationalDatabaseLogEventsOutput, value interface{}) error {
32656	if v == nil {
32657		return fmt.Errorf("unexpected nil of type %T", v)
32658	}
32659	if value == nil {
32660		return nil
32661	}
32662
32663	shape, ok := value.(map[string]interface{})
32664	if !ok {
32665		return fmt.Errorf("unexpected JSON type %v", value)
32666	}
32667
32668	var sv *GetRelationalDatabaseLogEventsOutput
32669	if *v == nil {
32670		sv = &GetRelationalDatabaseLogEventsOutput{}
32671	} else {
32672		sv = *v
32673	}
32674
32675	for key, value := range shape {
32676		switch key {
32677		case "nextBackwardToken":
32678			if value != nil {
32679				jtv, ok := value.(string)
32680				if !ok {
32681					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32682				}
32683				sv.NextBackwardToken = ptr.String(jtv)
32684			}
32685
32686		case "nextForwardToken":
32687			if value != nil {
32688				jtv, ok := value.(string)
32689				if !ok {
32690					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32691				}
32692				sv.NextForwardToken = ptr.String(jtv)
32693			}
32694
32695		case "resourceLogEvents":
32696			if err := awsAwsjson11_deserializeDocumentLogEventList(&sv.ResourceLogEvents, value); err != nil {
32697				return err
32698			}
32699
32700		default:
32701			_, _ = key, value
32702
32703		}
32704	}
32705	*v = sv
32706	return nil
32707}
32708
32709func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseLogStreamsOutput(v **GetRelationalDatabaseLogStreamsOutput, value interface{}) error {
32710	if v == nil {
32711		return fmt.Errorf("unexpected nil of type %T", v)
32712	}
32713	if value == nil {
32714		return nil
32715	}
32716
32717	shape, ok := value.(map[string]interface{})
32718	if !ok {
32719		return fmt.Errorf("unexpected JSON type %v", value)
32720	}
32721
32722	var sv *GetRelationalDatabaseLogStreamsOutput
32723	if *v == nil {
32724		sv = &GetRelationalDatabaseLogStreamsOutput{}
32725	} else {
32726		sv = *v
32727	}
32728
32729	for key, value := range shape {
32730		switch key {
32731		case "logStreams":
32732			if err := awsAwsjson11_deserializeDocumentStringList(&sv.LogStreams, value); err != nil {
32733				return err
32734			}
32735
32736		default:
32737			_, _ = key, value
32738
32739		}
32740	}
32741	*v = sv
32742	return nil
32743}
32744
32745func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMasterUserPasswordOutput(v **GetRelationalDatabaseMasterUserPasswordOutput, value interface{}) error {
32746	if v == nil {
32747		return fmt.Errorf("unexpected nil of type %T", v)
32748	}
32749	if value == nil {
32750		return nil
32751	}
32752
32753	shape, ok := value.(map[string]interface{})
32754	if !ok {
32755		return fmt.Errorf("unexpected JSON type %v", value)
32756	}
32757
32758	var sv *GetRelationalDatabaseMasterUserPasswordOutput
32759	if *v == nil {
32760		sv = &GetRelationalDatabaseMasterUserPasswordOutput{}
32761	} else {
32762		sv = *v
32763	}
32764
32765	for key, value := range shape {
32766		switch key {
32767		case "createdAt":
32768			if value != nil {
32769				jtv, ok := value.(json.Number)
32770				if !ok {
32771					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
32772				}
32773				f64, err := jtv.Float64()
32774				if err != nil {
32775					return err
32776				}
32777				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
32778			}
32779
32780		case "masterUserPassword":
32781			if value != nil {
32782				jtv, ok := value.(string)
32783				if !ok {
32784					return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
32785				}
32786				sv.MasterUserPassword = ptr.String(jtv)
32787			}
32788
32789		default:
32790			_, _ = key, value
32791
32792		}
32793	}
32794	*v = sv
32795	return nil
32796}
32797
32798func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseMetricDataOutput(v **GetRelationalDatabaseMetricDataOutput, value interface{}) error {
32799	if v == nil {
32800		return fmt.Errorf("unexpected nil of type %T", v)
32801	}
32802	if value == nil {
32803		return nil
32804	}
32805
32806	shape, ok := value.(map[string]interface{})
32807	if !ok {
32808		return fmt.Errorf("unexpected JSON type %v", value)
32809	}
32810
32811	var sv *GetRelationalDatabaseMetricDataOutput
32812	if *v == nil {
32813		sv = &GetRelationalDatabaseMetricDataOutput{}
32814	} else {
32815		sv = *v
32816	}
32817
32818	for key, value := range shape {
32819		switch key {
32820		case "metricData":
32821			if err := awsAwsjson11_deserializeDocumentMetricDatapointList(&sv.MetricData, value); err != nil {
32822				return err
32823			}
32824
32825		case "metricName":
32826			if value != nil {
32827				jtv, ok := value.(string)
32828				if !ok {
32829					return fmt.Errorf("expected RelationalDatabaseMetricName to be of type string, got %T instead", value)
32830				}
32831				sv.MetricName = types.RelationalDatabaseMetricName(jtv)
32832			}
32833
32834		default:
32835			_, _ = key, value
32836
32837		}
32838	}
32839	*v = sv
32840	return nil
32841}
32842
32843func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseOutput(v **GetRelationalDatabaseOutput, value interface{}) error {
32844	if v == nil {
32845		return fmt.Errorf("unexpected nil of type %T", v)
32846	}
32847	if value == nil {
32848		return nil
32849	}
32850
32851	shape, ok := value.(map[string]interface{})
32852	if !ok {
32853		return fmt.Errorf("unexpected JSON type %v", value)
32854	}
32855
32856	var sv *GetRelationalDatabaseOutput
32857	if *v == nil {
32858		sv = &GetRelationalDatabaseOutput{}
32859	} else {
32860		sv = *v
32861	}
32862
32863	for key, value := range shape {
32864		switch key {
32865		case "relationalDatabase":
32866			if err := awsAwsjson11_deserializeDocumentRelationalDatabase(&sv.RelationalDatabase, value); err != nil {
32867				return err
32868			}
32869
32870		default:
32871			_, _ = key, value
32872
32873		}
32874	}
32875	*v = sv
32876	return nil
32877}
32878
32879func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseParametersOutput(v **GetRelationalDatabaseParametersOutput, value interface{}) error {
32880	if v == nil {
32881		return fmt.Errorf("unexpected nil of type %T", v)
32882	}
32883	if value == nil {
32884		return nil
32885	}
32886
32887	shape, ok := value.(map[string]interface{})
32888	if !ok {
32889		return fmt.Errorf("unexpected JSON type %v", value)
32890	}
32891
32892	var sv *GetRelationalDatabaseParametersOutput
32893	if *v == nil {
32894		sv = &GetRelationalDatabaseParametersOutput{}
32895	} else {
32896		sv = *v
32897	}
32898
32899	for key, value := range shape {
32900		switch key {
32901		case "nextPageToken":
32902			if value != nil {
32903				jtv, ok := value.(string)
32904				if !ok {
32905					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32906				}
32907				sv.NextPageToken = ptr.String(jtv)
32908			}
32909
32910		case "parameters":
32911			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseParameterList(&sv.Parameters, value); err != nil {
32912				return err
32913			}
32914
32915		default:
32916			_, _ = key, value
32917
32918		}
32919	}
32920	*v = sv
32921	return nil
32922}
32923
32924func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotOutput(v **GetRelationalDatabaseSnapshotOutput, value interface{}) error {
32925	if v == nil {
32926		return fmt.Errorf("unexpected nil of type %T", v)
32927	}
32928	if value == nil {
32929		return nil
32930	}
32931
32932	shape, ok := value.(map[string]interface{})
32933	if !ok {
32934		return fmt.Errorf("unexpected JSON type %v", value)
32935	}
32936
32937	var sv *GetRelationalDatabaseSnapshotOutput
32938	if *v == nil {
32939		sv = &GetRelationalDatabaseSnapshotOutput{}
32940	} else {
32941		sv = *v
32942	}
32943
32944	for key, value := range shape {
32945		switch key {
32946		case "relationalDatabaseSnapshot":
32947			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshot(&sv.RelationalDatabaseSnapshot, value); err != nil {
32948				return err
32949			}
32950
32951		default:
32952			_, _ = key, value
32953
32954		}
32955	}
32956	*v = sv
32957	return nil
32958}
32959
32960func awsAwsjson11_deserializeOpDocumentGetRelationalDatabaseSnapshotsOutput(v **GetRelationalDatabaseSnapshotsOutput, value interface{}) error {
32961	if v == nil {
32962		return fmt.Errorf("unexpected nil of type %T", v)
32963	}
32964	if value == nil {
32965		return nil
32966	}
32967
32968	shape, ok := value.(map[string]interface{})
32969	if !ok {
32970		return fmt.Errorf("unexpected JSON type %v", value)
32971	}
32972
32973	var sv *GetRelationalDatabaseSnapshotsOutput
32974	if *v == nil {
32975		sv = &GetRelationalDatabaseSnapshotsOutput{}
32976	} else {
32977		sv = *v
32978	}
32979
32980	for key, value := range shape {
32981		switch key {
32982		case "nextPageToken":
32983			if value != nil {
32984				jtv, ok := value.(string)
32985				if !ok {
32986					return fmt.Errorf("expected string to be of type string, got %T instead", value)
32987				}
32988				sv.NextPageToken = ptr.String(jtv)
32989			}
32990
32991		case "relationalDatabaseSnapshots":
32992			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseSnapshotList(&sv.RelationalDatabaseSnapshots, value); err != nil {
32993				return err
32994			}
32995
32996		default:
32997			_, _ = key, value
32998
32999		}
33000	}
33001	*v = sv
33002	return nil
33003}
33004
33005func awsAwsjson11_deserializeOpDocumentGetRelationalDatabasesOutput(v **GetRelationalDatabasesOutput, value interface{}) error {
33006	if v == nil {
33007		return fmt.Errorf("unexpected nil of type %T", v)
33008	}
33009	if value == nil {
33010		return nil
33011	}
33012
33013	shape, ok := value.(map[string]interface{})
33014	if !ok {
33015		return fmt.Errorf("unexpected JSON type %v", value)
33016	}
33017
33018	var sv *GetRelationalDatabasesOutput
33019	if *v == nil {
33020		sv = &GetRelationalDatabasesOutput{}
33021	} else {
33022		sv = *v
33023	}
33024
33025	for key, value := range shape {
33026		switch key {
33027		case "nextPageToken":
33028			if value != nil {
33029				jtv, ok := value.(string)
33030				if !ok {
33031					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33032				}
33033				sv.NextPageToken = ptr.String(jtv)
33034			}
33035
33036		case "relationalDatabases":
33037			if err := awsAwsjson11_deserializeDocumentRelationalDatabaseList(&sv.RelationalDatabases, value); err != nil {
33038				return err
33039			}
33040
33041		default:
33042			_, _ = key, value
33043
33044		}
33045	}
33046	*v = sv
33047	return nil
33048}
33049
33050func awsAwsjson11_deserializeOpDocumentGetStaticIpOutput(v **GetStaticIpOutput, value interface{}) error {
33051	if v == nil {
33052		return fmt.Errorf("unexpected nil of type %T", v)
33053	}
33054	if value == nil {
33055		return nil
33056	}
33057
33058	shape, ok := value.(map[string]interface{})
33059	if !ok {
33060		return fmt.Errorf("unexpected JSON type %v", value)
33061	}
33062
33063	var sv *GetStaticIpOutput
33064	if *v == nil {
33065		sv = &GetStaticIpOutput{}
33066	} else {
33067		sv = *v
33068	}
33069
33070	for key, value := range shape {
33071		switch key {
33072		case "staticIp":
33073			if err := awsAwsjson11_deserializeDocumentStaticIp(&sv.StaticIp, value); err != nil {
33074				return err
33075			}
33076
33077		default:
33078			_, _ = key, value
33079
33080		}
33081	}
33082	*v = sv
33083	return nil
33084}
33085
33086func awsAwsjson11_deserializeOpDocumentGetStaticIpsOutput(v **GetStaticIpsOutput, value interface{}) error {
33087	if v == nil {
33088		return fmt.Errorf("unexpected nil of type %T", v)
33089	}
33090	if value == nil {
33091		return nil
33092	}
33093
33094	shape, ok := value.(map[string]interface{})
33095	if !ok {
33096		return fmt.Errorf("unexpected JSON type %v", value)
33097	}
33098
33099	var sv *GetStaticIpsOutput
33100	if *v == nil {
33101		sv = &GetStaticIpsOutput{}
33102	} else {
33103		sv = *v
33104	}
33105
33106	for key, value := range shape {
33107		switch key {
33108		case "nextPageToken":
33109			if value != nil {
33110				jtv, ok := value.(string)
33111				if !ok {
33112					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33113				}
33114				sv.NextPageToken = ptr.String(jtv)
33115			}
33116
33117		case "staticIps":
33118			if err := awsAwsjson11_deserializeDocumentStaticIpList(&sv.StaticIps, value); err != nil {
33119				return err
33120			}
33121
33122		default:
33123			_, _ = key, value
33124
33125		}
33126	}
33127	*v = sv
33128	return nil
33129}
33130
33131func awsAwsjson11_deserializeOpDocumentImportKeyPairOutput(v **ImportKeyPairOutput, value interface{}) error {
33132	if v == nil {
33133		return fmt.Errorf("unexpected nil of type %T", v)
33134	}
33135	if value == nil {
33136		return nil
33137	}
33138
33139	shape, ok := value.(map[string]interface{})
33140	if !ok {
33141		return fmt.Errorf("unexpected JSON type %v", value)
33142	}
33143
33144	var sv *ImportKeyPairOutput
33145	if *v == nil {
33146		sv = &ImportKeyPairOutput{}
33147	} else {
33148		sv = *v
33149	}
33150
33151	for key, value := range shape {
33152		switch key {
33153		case "operation":
33154			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33155				return err
33156			}
33157
33158		default:
33159			_, _ = key, value
33160
33161		}
33162	}
33163	*v = sv
33164	return nil
33165}
33166
33167func awsAwsjson11_deserializeOpDocumentIsVpcPeeredOutput(v **IsVpcPeeredOutput, value interface{}) error {
33168	if v == nil {
33169		return fmt.Errorf("unexpected nil of type %T", v)
33170	}
33171	if value == nil {
33172		return nil
33173	}
33174
33175	shape, ok := value.(map[string]interface{})
33176	if !ok {
33177		return fmt.Errorf("unexpected JSON type %v", value)
33178	}
33179
33180	var sv *IsVpcPeeredOutput
33181	if *v == nil {
33182		sv = &IsVpcPeeredOutput{}
33183	} else {
33184		sv = *v
33185	}
33186
33187	for key, value := range shape {
33188		switch key {
33189		case "isPeered":
33190			if value != nil {
33191				jtv, ok := value.(bool)
33192				if !ok {
33193					return fmt.Errorf("expected boolean to be of type *bool, got %T instead", value)
33194				}
33195				sv.IsPeered = ptr.Bool(jtv)
33196			}
33197
33198		default:
33199			_, _ = key, value
33200
33201		}
33202	}
33203	*v = sv
33204	return nil
33205}
33206
33207func awsAwsjson11_deserializeOpDocumentOpenInstancePublicPortsOutput(v **OpenInstancePublicPortsOutput, value interface{}) error {
33208	if v == nil {
33209		return fmt.Errorf("unexpected nil of type %T", v)
33210	}
33211	if value == nil {
33212		return nil
33213	}
33214
33215	shape, ok := value.(map[string]interface{})
33216	if !ok {
33217		return fmt.Errorf("unexpected JSON type %v", value)
33218	}
33219
33220	var sv *OpenInstancePublicPortsOutput
33221	if *v == nil {
33222		sv = &OpenInstancePublicPortsOutput{}
33223	} else {
33224		sv = *v
33225	}
33226
33227	for key, value := range shape {
33228		switch key {
33229		case "operation":
33230			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33231				return err
33232			}
33233
33234		default:
33235			_, _ = key, value
33236
33237		}
33238	}
33239	*v = sv
33240	return nil
33241}
33242
33243func awsAwsjson11_deserializeOpDocumentPeerVpcOutput(v **PeerVpcOutput, value interface{}) error {
33244	if v == nil {
33245		return fmt.Errorf("unexpected nil of type %T", v)
33246	}
33247	if value == nil {
33248		return nil
33249	}
33250
33251	shape, ok := value.(map[string]interface{})
33252	if !ok {
33253		return fmt.Errorf("unexpected JSON type %v", value)
33254	}
33255
33256	var sv *PeerVpcOutput
33257	if *v == nil {
33258		sv = &PeerVpcOutput{}
33259	} else {
33260		sv = *v
33261	}
33262
33263	for key, value := range shape {
33264		switch key {
33265		case "operation":
33266			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33267				return err
33268			}
33269
33270		default:
33271			_, _ = key, value
33272
33273		}
33274	}
33275	*v = sv
33276	return nil
33277}
33278
33279func awsAwsjson11_deserializeOpDocumentPutAlarmOutput(v **PutAlarmOutput, value interface{}) error {
33280	if v == nil {
33281		return fmt.Errorf("unexpected nil of type %T", v)
33282	}
33283	if value == nil {
33284		return nil
33285	}
33286
33287	shape, ok := value.(map[string]interface{})
33288	if !ok {
33289		return fmt.Errorf("unexpected JSON type %v", value)
33290	}
33291
33292	var sv *PutAlarmOutput
33293	if *v == nil {
33294		sv = &PutAlarmOutput{}
33295	} else {
33296		sv = *v
33297	}
33298
33299	for key, value := range shape {
33300		switch key {
33301		case "operations":
33302			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33303				return err
33304			}
33305
33306		default:
33307			_, _ = key, value
33308
33309		}
33310	}
33311	*v = sv
33312	return nil
33313}
33314
33315func awsAwsjson11_deserializeOpDocumentPutInstancePublicPortsOutput(v **PutInstancePublicPortsOutput, value interface{}) error {
33316	if v == nil {
33317		return fmt.Errorf("unexpected nil of type %T", v)
33318	}
33319	if value == nil {
33320		return nil
33321	}
33322
33323	shape, ok := value.(map[string]interface{})
33324	if !ok {
33325		return fmt.Errorf("unexpected JSON type %v", value)
33326	}
33327
33328	var sv *PutInstancePublicPortsOutput
33329	if *v == nil {
33330		sv = &PutInstancePublicPortsOutput{}
33331	} else {
33332		sv = *v
33333	}
33334
33335	for key, value := range shape {
33336		switch key {
33337		case "operation":
33338			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33339				return err
33340			}
33341
33342		default:
33343			_, _ = key, value
33344
33345		}
33346	}
33347	*v = sv
33348	return nil
33349}
33350
33351func awsAwsjson11_deserializeOpDocumentRebootInstanceOutput(v **RebootInstanceOutput, value interface{}) error {
33352	if v == nil {
33353		return fmt.Errorf("unexpected nil of type %T", v)
33354	}
33355	if value == nil {
33356		return nil
33357	}
33358
33359	shape, ok := value.(map[string]interface{})
33360	if !ok {
33361		return fmt.Errorf("unexpected JSON type %v", value)
33362	}
33363
33364	var sv *RebootInstanceOutput
33365	if *v == nil {
33366		sv = &RebootInstanceOutput{}
33367	} else {
33368		sv = *v
33369	}
33370
33371	for key, value := range shape {
33372		switch key {
33373		case "operations":
33374			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33375				return err
33376			}
33377
33378		default:
33379			_, _ = key, value
33380
33381		}
33382	}
33383	*v = sv
33384	return nil
33385}
33386
33387func awsAwsjson11_deserializeOpDocumentRebootRelationalDatabaseOutput(v **RebootRelationalDatabaseOutput, value interface{}) error {
33388	if v == nil {
33389		return fmt.Errorf("unexpected nil of type %T", v)
33390	}
33391	if value == nil {
33392		return nil
33393	}
33394
33395	shape, ok := value.(map[string]interface{})
33396	if !ok {
33397		return fmt.Errorf("unexpected JSON type %v", value)
33398	}
33399
33400	var sv *RebootRelationalDatabaseOutput
33401	if *v == nil {
33402		sv = &RebootRelationalDatabaseOutput{}
33403	} else {
33404		sv = *v
33405	}
33406
33407	for key, value := range shape {
33408		switch key {
33409		case "operations":
33410			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33411				return err
33412			}
33413
33414		default:
33415			_, _ = key, value
33416
33417		}
33418	}
33419	*v = sv
33420	return nil
33421}
33422
33423func awsAwsjson11_deserializeOpDocumentRegisterContainerImageOutput(v **RegisterContainerImageOutput, value interface{}) error {
33424	if v == nil {
33425		return fmt.Errorf("unexpected nil of type %T", v)
33426	}
33427	if value == nil {
33428		return nil
33429	}
33430
33431	shape, ok := value.(map[string]interface{})
33432	if !ok {
33433		return fmt.Errorf("unexpected JSON type %v", value)
33434	}
33435
33436	var sv *RegisterContainerImageOutput
33437	if *v == nil {
33438		sv = &RegisterContainerImageOutput{}
33439	} else {
33440		sv = *v
33441	}
33442
33443	for key, value := range shape {
33444		switch key {
33445		case "containerImage":
33446			if err := awsAwsjson11_deserializeDocumentContainerImage(&sv.ContainerImage, value); err != nil {
33447				return err
33448			}
33449
33450		default:
33451			_, _ = key, value
33452
33453		}
33454	}
33455	*v = sv
33456	return nil
33457}
33458
33459func awsAwsjson11_deserializeOpDocumentReleaseStaticIpOutput(v **ReleaseStaticIpOutput, value interface{}) error {
33460	if v == nil {
33461		return fmt.Errorf("unexpected nil of type %T", v)
33462	}
33463	if value == nil {
33464		return nil
33465	}
33466
33467	shape, ok := value.(map[string]interface{})
33468	if !ok {
33469		return fmt.Errorf("unexpected JSON type %v", value)
33470	}
33471
33472	var sv *ReleaseStaticIpOutput
33473	if *v == nil {
33474		sv = &ReleaseStaticIpOutput{}
33475	} else {
33476		sv = *v
33477	}
33478
33479	for key, value := range shape {
33480		switch key {
33481		case "operations":
33482			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33483				return err
33484			}
33485
33486		default:
33487			_, _ = key, value
33488
33489		}
33490	}
33491	*v = sv
33492	return nil
33493}
33494
33495func awsAwsjson11_deserializeOpDocumentResetDistributionCacheOutput(v **ResetDistributionCacheOutput, value interface{}) error {
33496	if v == nil {
33497		return fmt.Errorf("unexpected nil of type %T", v)
33498	}
33499	if value == nil {
33500		return nil
33501	}
33502
33503	shape, ok := value.(map[string]interface{})
33504	if !ok {
33505		return fmt.Errorf("unexpected JSON type %v", value)
33506	}
33507
33508	var sv *ResetDistributionCacheOutput
33509	if *v == nil {
33510		sv = &ResetDistributionCacheOutput{}
33511	} else {
33512		sv = *v
33513	}
33514
33515	for key, value := range shape {
33516		switch key {
33517		case "createTime":
33518			if value != nil {
33519				jtv, ok := value.(json.Number)
33520				if !ok {
33521					return fmt.Errorf("expected IsoDate to be json.Number, got %T instead", value)
33522				}
33523				f64, err := jtv.Float64()
33524				if err != nil {
33525					return err
33526				}
33527				sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
33528			}
33529
33530		case "operation":
33531			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33532				return err
33533			}
33534
33535		case "status":
33536			if value != nil {
33537				jtv, ok := value.(string)
33538				if !ok {
33539					return fmt.Errorf("expected string to be of type string, got %T instead", value)
33540				}
33541				sv.Status = ptr.String(jtv)
33542			}
33543
33544		default:
33545			_, _ = key, value
33546
33547		}
33548	}
33549	*v = sv
33550	return nil
33551}
33552
33553func awsAwsjson11_deserializeOpDocumentSendContactMethodVerificationOutput(v **SendContactMethodVerificationOutput, value interface{}) error {
33554	if v == nil {
33555		return fmt.Errorf("unexpected nil of type %T", v)
33556	}
33557	if value == nil {
33558		return nil
33559	}
33560
33561	shape, ok := value.(map[string]interface{})
33562	if !ok {
33563		return fmt.Errorf("unexpected JSON type %v", value)
33564	}
33565
33566	var sv *SendContactMethodVerificationOutput
33567	if *v == nil {
33568		sv = &SendContactMethodVerificationOutput{}
33569	} else {
33570		sv = *v
33571	}
33572
33573	for key, value := range shape {
33574		switch key {
33575		case "operations":
33576			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33577				return err
33578			}
33579
33580		default:
33581			_, _ = key, value
33582
33583		}
33584	}
33585	*v = sv
33586	return nil
33587}
33588
33589func awsAwsjson11_deserializeOpDocumentSetIpAddressTypeOutput(v **SetIpAddressTypeOutput, value interface{}) error {
33590	if v == nil {
33591		return fmt.Errorf("unexpected nil of type %T", v)
33592	}
33593	if value == nil {
33594		return nil
33595	}
33596
33597	shape, ok := value.(map[string]interface{})
33598	if !ok {
33599		return fmt.Errorf("unexpected JSON type %v", value)
33600	}
33601
33602	var sv *SetIpAddressTypeOutput
33603	if *v == nil {
33604		sv = &SetIpAddressTypeOutput{}
33605	} else {
33606		sv = *v
33607	}
33608
33609	for key, value := range shape {
33610		switch key {
33611		case "operations":
33612			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33613				return err
33614			}
33615
33616		default:
33617			_, _ = key, value
33618
33619		}
33620	}
33621	*v = sv
33622	return nil
33623}
33624
33625func awsAwsjson11_deserializeOpDocumentStartInstanceOutput(v **StartInstanceOutput, value interface{}) error {
33626	if v == nil {
33627		return fmt.Errorf("unexpected nil of type %T", v)
33628	}
33629	if value == nil {
33630		return nil
33631	}
33632
33633	shape, ok := value.(map[string]interface{})
33634	if !ok {
33635		return fmt.Errorf("unexpected JSON type %v", value)
33636	}
33637
33638	var sv *StartInstanceOutput
33639	if *v == nil {
33640		sv = &StartInstanceOutput{}
33641	} else {
33642		sv = *v
33643	}
33644
33645	for key, value := range shape {
33646		switch key {
33647		case "operations":
33648			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33649				return err
33650			}
33651
33652		default:
33653			_, _ = key, value
33654
33655		}
33656	}
33657	*v = sv
33658	return nil
33659}
33660
33661func awsAwsjson11_deserializeOpDocumentStartRelationalDatabaseOutput(v **StartRelationalDatabaseOutput, value interface{}) error {
33662	if v == nil {
33663		return fmt.Errorf("unexpected nil of type %T", v)
33664	}
33665	if value == nil {
33666		return nil
33667	}
33668
33669	shape, ok := value.(map[string]interface{})
33670	if !ok {
33671		return fmt.Errorf("unexpected JSON type %v", value)
33672	}
33673
33674	var sv *StartRelationalDatabaseOutput
33675	if *v == nil {
33676		sv = &StartRelationalDatabaseOutput{}
33677	} else {
33678		sv = *v
33679	}
33680
33681	for key, value := range shape {
33682		switch key {
33683		case "operations":
33684			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33685				return err
33686			}
33687
33688		default:
33689			_, _ = key, value
33690
33691		}
33692	}
33693	*v = sv
33694	return nil
33695}
33696
33697func awsAwsjson11_deserializeOpDocumentStopInstanceOutput(v **StopInstanceOutput, value interface{}) error {
33698	if v == nil {
33699		return fmt.Errorf("unexpected nil of type %T", v)
33700	}
33701	if value == nil {
33702		return nil
33703	}
33704
33705	shape, ok := value.(map[string]interface{})
33706	if !ok {
33707		return fmt.Errorf("unexpected JSON type %v", value)
33708	}
33709
33710	var sv *StopInstanceOutput
33711	if *v == nil {
33712		sv = &StopInstanceOutput{}
33713	} else {
33714		sv = *v
33715	}
33716
33717	for key, value := range shape {
33718		switch key {
33719		case "operations":
33720			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33721				return err
33722			}
33723
33724		default:
33725			_, _ = key, value
33726
33727		}
33728	}
33729	*v = sv
33730	return nil
33731}
33732
33733func awsAwsjson11_deserializeOpDocumentStopRelationalDatabaseOutput(v **StopRelationalDatabaseOutput, value interface{}) error {
33734	if v == nil {
33735		return fmt.Errorf("unexpected nil of type %T", v)
33736	}
33737	if value == nil {
33738		return nil
33739	}
33740
33741	shape, ok := value.(map[string]interface{})
33742	if !ok {
33743		return fmt.Errorf("unexpected JSON type %v", value)
33744	}
33745
33746	var sv *StopRelationalDatabaseOutput
33747	if *v == nil {
33748		sv = &StopRelationalDatabaseOutput{}
33749	} else {
33750		sv = *v
33751	}
33752
33753	for key, value := range shape {
33754		switch key {
33755		case "operations":
33756			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33757				return err
33758			}
33759
33760		default:
33761			_, _ = key, value
33762
33763		}
33764	}
33765	*v = sv
33766	return nil
33767}
33768
33769func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
33770	if v == nil {
33771		return fmt.Errorf("unexpected nil of type %T", v)
33772	}
33773	if value == nil {
33774		return nil
33775	}
33776
33777	shape, ok := value.(map[string]interface{})
33778	if !ok {
33779		return fmt.Errorf("unexpected JSON type %v", value)
33780	}
33781
33782	var sv *TagResourceOutput
33783	if *v == nil {
33784		sv = &TagResourceOutput{}
33785	} else {
33786		sv = *v
33787	}
33788
33789	for key, value := range shape {
33790		switch key {
33791		case "operations":
33792			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33793				return err
33794			}
33795
33796		default:
33797			_, _ = key, value
33798
33799		}
33800	}
33801	*v = sv
33802	return nil
33803}
33804
33805func awsAwsjson11_deserializeOpDocumentTestAlarmOutput(v **TestAlarmOutput, value interface{}) error {
33806	if v == nil {
33807		return fmt.Errorf("unexpected nil of type %T", v)
33808	}
33809	if value == nil {
33810		return nil
33811	}
33812
33813	shape, ok := value.(map[string]interface{})
33814	if !ok {
33815		return fmt.Errorf("unexpected JSON type %v", value)
33816	}
33817
33818	var sv *TestAlarmOutput
33819	if *v == nil {
33820		sv = &TestAlarmOutput{}
33821	} else {
33822		sv = *v
33823	}
33824
33825	for key, value := range shape {
33826		switch key {
33827		case "operations":
33828			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33829				return err
33830			}
33831
33832		default:
33833			_, _ = key, value
33834
33835		}
33836	}
33837	*v = sv
33838	return nil
33839}
33840
33841func awsAwsjson11_deserializeOpDocumentUnpeerVpcOutput(v **UnpeerVpcOutput, value interface{}) error {
33842	if v == nil {
33843		return fmt.Errorf("unexpected nil of type %T", v)
33844	}
33845	if value == nil {
33846		return nil
33847	}
33848
33849	shape, ok := value.(map[string]interface{})
33850	if !ok {
33851		return fmt.Errorf("unexpected JSON type %v", value)
33852	}
33853
33854	var sv *UnpeerVpcOutput
33855	if *v == nil {
33856		sv = &UnpeerVpcOutput{}
33857	} else {
33858		sv = *v
33859	}
33860
33861	for key, value := range shape {
33862		switch key {
33863		case "operation":
33864			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33865				return err
33866			}
33867
33868		default:
33869			_, _ = key, value
33870
33871		}
33872	}
33873	*v = sv
33874	return nil
33875}
33876
33877func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
33878	if v == nil {
33879		return fmt.Errorf("unexpected nil of type %T", v)
33880	}
33881	if value == nil {
33882		return nil
33883	}
33884
33885	shape, ok := value.(map[string]interface{})
33886	if !ok {
33887		return fmt.Errorf("unexpected JSON type %v", value)
33888	}
33889
33890	var sv *UntagResourceOutput
33891	if *v == nil {
33892		sv = &UntagResourceOutput{}
33893	} else {
33894		sv = *v
33895	}
33896
33897	for key, value := range shape {
33898		switch key {
33899		case "operations":
33900			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
33901				return err
33902			}
33903
33904		default:
33905			_, _ = key, value
33906
33907		}
33908	}
33909	*v = sv
33910	return nil
33911}
33912
33913func awsAwsjson11_deserializeOpDocumentUpdateContainerServiceOutput(v **UpdateContainerServiceOutput, value interface{}) error {
33914	if v == nil {
33915		return fmt.Errorf("unexpected nil of type %T", v)
33916	}
33917	if value == nil {
33918		return nil
33919	}
33920
33921	shape, ok := value.(map[string]interface{})
33922	if !ok {
33923		return fmt.Errorf("unexpected JSON type %v", value)
33924	}
33925
33926	var sv *UpdateContainerServiceOutput
33927	if *v == nil {
33928		sv = &UpdateContainerServiceOutput{}
33929	} else {
33930		sv = *v
33931	}
33932
33933	for key, value := range shape {
33934		switch key {
33935		case "containerService":
33936			if err := awsAwsjson11_deserializeDocumentContainerService(&sv.ContainerService, value); err != nil {
33937				return err
33938			}
33939
33940		default:
33941			_, _ = key, value
33942
33943		}
33944	}
33945	*v = sv
33946	return nil
33947}
33948
33949func awsAwsjson11_deserializeOpDocumentUpdateDistributionBundleOutput(v **UpdateDistributionBundleOutput, value interface{}) error {
33950	if v == nil {
33951		return fmt.Errorf("unexpected nil of type %T", v)
33952	}
33953	if value == nil {
33954		return nil
33955	}
33956
33957	shape, ok := value.(map[string]interface{})
33958	if !ok {
33959		return fmt.Errorf("unexpected JSON type %v", value)
33960	}
33961
33962	var sv *UpdateDistributionBundleOutput
33963	if *v == nil {
33964		sv = &UpdateDistributionBundleOutput{}
33965	} else {
33966		sv = *v
33967	}
33968
33969	for key, value := range shape {
33970		switch key {
33971		case "operation":
33972			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
33973				return err
33974			}
33975
33976		default:
33977			_, _ = key, value
33978
33979		}
33980	}
33981	*v = sv
33982	return nil
33983}
33984
33985func awsAwsjson11_deserializeOpDocumentUpdateDistributionOutput(v **UpdateDistributionOutput, value interface{}) error {
33986	if v == nil {
33987		return fmt.Errorf("unexpected nil of type %T", v)
33988	}
33989	if value == nil {
33990		return nil
33991	}
33992
33993	shape, ok := value.(map[string]interface{})
33994	if !ok {
33995		return fmt.Errorf("unexpected JSON type %v", value)
33996	}
33997
33998	var sv *UpdateDistributionOutput
33999	if *v == nil {
34000		sv = &UpdateDistributionOutput{}
34001	} else {
34002		sv = *v
34003	}
34004
34005	for key, value := range shape {
34006		switch key {
34007		case "operation":
34008			if err := awsAwsjson11_deserializeDocumentOperation(&sv.Operation, value); err != nil {
34009				return err
34010			}
34011
34012		default:
34013			_, _ = key, value
34014
34015		}
34016	}
34017	*v = sv
34018	return nil
34019}
34020
34021func awsAwsjson11_deserializeOpDocumentUpdateDomainEntryOutput(v **UpdateDomainEntryOutput, value interface{}) error {
34022	if v == nil {
34023		return fmt.Errorf("unexpected nil of type %T", v)
34024	}
34025	if value == nil {
34026		return nil
34027	}
34028
34029	shape, ok := value.(map[string]interface{})
34030	if !ok {
34031		return fmt.Errorf("unexpected JSON type %v", value)
34032	}
34033
34034	var sv *UpdateDomainEntryOutput
34035	if *v == nil {
34036		sv = &UpdateDomainEntryOutput{}
34037	} else {
34038		sv = *v
34039	}
34040
34041	for key, value := range shape {
34042		switch key {
34043		case "operations":
34044			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34045				return err
34046			}
34047
34048		default:
34049			_, _ = key, value
34050
34051		}
34052	}
34053	*v = sv
34054	return nil
34055}
34056
34057func awsAwsjson11_deserializeOpDocumentUpdateLoadBalancerAttributeOutput(v **UpdateLoadBalancerAttributeOutput, value interface{}) error {
34058	if v == nil {
34059		return fmt.Errorf("unexpected nil of type %T", v)
34060	}
34061	if value == nil {
34062		return nil
34063	}
34064
34065	shape, ok := value.(map[string]interface{})
34066	if !ok {
34067		return fmt.Errorf("unexpected JSON type %v", value)
34068	}
34069
34070	var sv *UpdateLoadBalancerAttributeOutput
34071	if *v == nil {
34072		sv = &UpdateLoadBalancerAttributeOutput{}
34073	} else {
34074		sv = *v
34075	}
34076
34077	for key, value := range shape {
34078		switch key {
34079		case "operations":
34080			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34081				return err
34082			}
34083
34084		default:
34085			_, _ = key, value
34086
34087		}
34088	}
34089	*v = sv
34090	return nil
34091}
34092
34093func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseOutput(v **UpdateRelationalDatabaseOutput, value interface{}) error {
34094	if v == nil {
34095		return fmt.Errorf("unexpected nil of type %T", v)
34096	}
34097	if value == nil {
34098		return nil
34099	}
34100
34101	shape, ok := value.(map[string]interface{})
34102	if !ok {
34103		return fmt.Errorf("unexpected JSON type %v", value)
34104	}
34105
34106	var sv *UpdateRelationalDatabaseOutput
34107	if *v == nil {
34108		sv = &UpdateRelationalDatabaseOutput{}
34109	} else {
34110		sv = *v
34111	}
34112
34113	for key, value := range shape {
34114		switch key {
34115		case "operations":
34116			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34117				return err
34118			}
34119
34120		default:
34121			_, _ = key, value
34122
34123		}
34124	}
34125	*v = sv
34126	return nil
34127}
34128
34129func awsAwsjson11_deserializeOpDocumentUpdateRelationalDatabaseParametersOutput(v **UpdateRelationalDatabaseParametersOutput, value interface{}) error {
34130	if v == nil {
34131		return fmt.Errorf("unexpected nil of type %T", v)
34132	}
34133	if value == nil {
34134		return nil
34135	}
34136
34137	shape, ok := value.(map[string]interface{})
34138	if !ok {
34139		return fmt.Errorf("unexpected JSON type %v", value)
34140	}
34141
34142	var sv *UpdateRelationalDatabaseParametersOutput
34143	if *v == nil {
34144		sv = &UpdateRelationalDatabaseParametersOutput{}
34145	} else {
34146		sv = *v
34147	}
34148
34149	for key, value := range shape {
34150		switch key {
34151		case "operations":
34152			if err := awsAwsjson11_deserializeDocumentOperationList(&sv.Operations, value); err != nil {
34153				return err
34154			}
34155
34156		default:
34157			_, _ = key, value
34158
34159		}
34160	}
34161	*v = sv
34162	return nil
34163}
34164