1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package ecs
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/ecs/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_deserializeOpCreateCapacityProvider struct {
23}
24
25func (*awsAwsjson11_deserializeOpCreateCapacityProvider) ID() string {
26	return "OperationDeserializer"
27}
28
29func (m *awsAwsjson11_deserializeOpCreateCapacityProvider) 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_deserializeOpErrorCreateCapacityProvider(response, &metadata)
44	}
45	output := &CreateCapacityProviderOutput{}
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_deserializeOpDocumentCreateCapacityProviderOutput(&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_deserializeOpErrorCreateCapacityProvider(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("ClientException", errorCode):
121		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
122
123	case strings.EqualFold("InvalidParameterException", errorCode):
124		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
125
126	case strings.EqualFold("LimitExceededException", errorCode):
127		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
128
129	case strings.EqualFold("ServerException", errorCode):
130		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
131
132	case strings.EqualFold("UpdateInProgressException", errorCode):
133		return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
134
135	default:
136		genericError := &smithy.GenericAPIError{
137			Code:    errorCode,
138			Message: errorMessage,
139		}
140		return genericError
141
142	}
143}
144
145type awsAwsjson11_deserializeOpCreateCluster struct {
146}
147
148func (*awsAwsjson11_deserializeOpCreateCluster) ID() string {
149	return "OperationDeserializer"
150}
151
152func (m *awsAwsjson11_deserializeOpCreateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
153	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
154) {
155	out, metadata, err = next.HandleDeserialize(ctx, in)
156	if err != nil {
157		return out, metadata, err
158	}
159
160	response, ok := out.RawResponse.(*smithyhttp.Response)
161	if !ok {
162		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
163	}
164
165	if response.StatusCode < 200 || response.StatusCode >= 300 {
166		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata)
167	}
168	output := &CreateClusterOutput{}
169	out.Result = output
170
171	var buff [1024]byte
172	ringBuffer := smithyio.NewRingBuffer(buff[:])
173
174	body := io.TeeReader(response.Body, ringBuffer)
175	decoder := json.NewDecoder(body)
176	decoder.UseNumber()
177	var shape interface{}
178	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
179		var snapshot bytes.Buffer
180		io.Copy(&snapshot, ringBuffer)
181		err = &smithy.DeserializationError{
182			Err:      fmt.Errorf("failed to decode response body, %w", err),
183			Snapshot: snapshot.Bytes(),
184		}
185		return out, metadata, err
186	}
187
188	err = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&output, shape)
189	if err != nil {
190		var snapshot bytes.Buffer
191		io.Copy(&snapshot, ringBuffer)
192		err = &smithy.DeserializationError{
193			Err:      fmt.Errorf("failed to decode response body, %w", err),
194			Snapshot: snapshot.Bytes(),
195		}
196		return out, metadata, err
197	}
198
199	return out, metadata, err
200}
201
202func awsAwsjson11_deserializeOpErrorCreateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
203	var errorBuffer bytes.Buffer
204	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
205		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
206	}
207	errorBody := bytes.NewReader(errorBuffer.Bytes())
208
209	errorCode := "UnknownError"
210	errorMessage := errorCode
211
212	code := response.Header.Get("X-Amzn-ErrorType")
213	if len(code) != 0 {
214		errorCode = restjson.SanitizeErrorCode(code)
215	}
216
217	var buff [1024]byte
218	ringBuffer := smithyio.NewRingBuffer(buff[:])
219
220	body := io.TeeReader(errorBody, ringBuffer)
221	decoder := json.NewDecoder(body)
222	decoder.UseNumber()
223	code, message, err := restjson.GetErrorInfo(decoder)
224	if err != nil {
225		var snapshot bytes.Buffer
226		io.Copy(&snapshot, ringBuffer)
227		err = &smithy.DeserializationError{
228			Err:      fmt.Errorf("failed to decode response body, %w", err),
229			Snapshot: snapshot.Bytes(),
230		}
231		return err
232	}
233
234	errorBody.Seek(0, io.SeekStart)
235	if len(code) != 0 {
236		errorCode = restjson.SanitizeErrorCode(code)
237	}
238	if len(message) != 0 {
239		errorMessage = message
240	}
241
242	switch {
243	case strings.EqualFold("ClientException", errorCode):
244		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
245
246	case strings.EqualFold("InvalidParameterException", errorCode):
247		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
248
249	case strings.EqualFold("ServerException", errorCode):
250		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
251
252	default:
253		genericError := &smithy.GenericAPIError{
254			Code:    errorCode,
255			Message: errorMessage,
256		}
257		return genericError
258
259	}
260}
261
262type awsAwsjson11_deserializeOpCreateService struct {
263}
264
265func (*awsAwsjson11_deserializeOpCreateService) ID() string {
266	return "OperationDeserializer"
267}
268
269func (m *awsAwsjson11_deserializeOpCreateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
270	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
271) {
272	out, metadata, err = next.HandleDeserialize(ctx, in)
273	if err != nil {
274		return out, metadata, err
275	}
276
277	response, ok := out.RawResponse.(*smithyhttp.Response)
278	if !ok {
279		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
280	}
281
282	if response.StatusCode < 200 || response.StatusCode >= 300 {
283		return out, metadata, awsAwsjson11_deserializeOpErrorCreateService(response, &metadata)
284	}
285	output := &CreateServiceOutput{}
286	out.Result = output
287
288	var buff [1024]byte
289	ringBuffer := smithyio.NewRingBuffer(buff[:])
290
291	body := io.TeeReader(response.Body, ringBuffer)
292	decoder := json.NewDecoder(body)
293	decoder.UseNumber()
294	var shape interface{}
295	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
296		var snapshot bytes.Buffer
297		io.Copy(&snapshot, ringBuffer)
298		err = &smithy.DeserializationError{
299			Err:      fmt.Errorf("failed to decode response body, %w", err),
300			Snapshot: snapshot.Bytes(),
301		}
302		return out, metadata, err
303	}
304
305	err = awsAwsjson11_deserializeOpDocumentCreateServiceOutput(&output, shape)
306	if err != nil {
307		var snapshot bytes.Buffer
308		io.Copy(&snapshot, ringBuffer)
309		err = &smithy.DeserializationError{
310			Err:      fmt.Errorf("failed to decode response body, %w", err),
311			Snapshot: snapshot.Bytes(),
312		}
313		return out, metadata, err
314	}
315
316	return out, metadata, err
317}
318
319func awsAwsjson11_deserializeOpErrorCreateService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
320	var errorBuffer bytes.Buffer
321	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
322		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
323	}
324	errorBody := bytes.NewReader(errorBuffer.Bytes())
325
326	errorCode := "UnknownError"
327	errorMessage := errorCode
328
329	code := response.Header.Get("X-Amzn-ErrorType")
330	if len(code) != 0 {
331		errorCode = restjson.SanitizeErrorCode(code)
332	}
333
334	var buff [1024]byte
335	ringBuffer := smithyio.NewRingBuffer(buff[:])
336
337	body := io.TeeReader(errorBody, ringBuffer)
338	decoder := json.NewDecoder(body)
339	decoder.UseNumber()
340	code, message, err := restjson.GetErrorInfo(decoder)
341	if err != nil {
342		var snapshot bytes.Buffer
343		io.Copy(&snapshot, ringBuffer)
344		err = &smithy.DeserializationError{
345			Err:      fmt.Errorf("failed to decode response body, %w", err),
346			Snapshot: snapshot.Bytes(),
347		}
348		return err
349	}
350
351	errorBody.Seek(0, io.SeekStart)
352	if len(code) != 0 {
353		errorCode = restjson.SanitizeErrorCode(code)
354	}
355	if len(message) != 0 {
356		errorMessage = message
357	}
358
359	switch {
360	case strings.EqualFold("AccessDeniedException", errorCode):
361		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
362
363	case strings.EqualFold("ClientException", errorCode):
364		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
365
366	case strings.EqualFold("ClusterNotFoundException", errorCode):
367		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
368
369	case strings.EqualFold("InvalidParameterException", errorCode):
370		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
371
372	case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
373		return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
374
375	case strings.EqualFold("PlatformUnknownException", errorCode):
376		return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
377
378	case strings.EqualFold("ServerException", errorCode):
379		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
380
381	case strings.EqualFold("UnsupportedFeatureException", errorCode):
382		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
383
384	default:
385		genericError := &smithy.GenericAPIError{
386			Code:    errorCode,
387			Message: errorMessage,
388		}
389		return genericError
390
391	}
392}
393
394type awsAwsjson11_deserializeOpCreateTaskSet struct {
395}
396
397func (*awsAwsjson11_deserializeOpCreateTaskSet) ID() string {
398	return "OperationDeserializer"
399}
400
401func (m *awsAwsjson11_deserializeOpCreateTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
402	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
403) {
404	out, metadata, err = next.HandleDeserialize(ctx, in)
405	if err != nil {
406		return out, metadata, err
407	}
408
409	response, ok := out.RawResponse.(*smithyhttp.Response)
410	if !ok {
411		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
412	}
413
414	if response.StatusCode < 200 || response.StatusCode >= 300 {
415		return out, metadata, awsAwsjson11_deserializeOpErrorCreateTaskSet(response, &metadata)
416	}
417	output := &CreateTaskSetOutput{}
418	out.Result = output
419
420	var buff [1024]byte
421	ringBuffer := smithyio.NewRingBuffer(buff[:])
422
423	body := io.TeeReader(response.Body, ringBuffer)
424	decoder := json.NewDecoder(body)
425	decoder.UseNumber()
426	var shape interface{}
427	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
428		var snapshot bytes.Buffer
429		io.Copy(&snapshot, ringBuffer)
430		err = &smithy.DeserializationError{
431			Err:      fmt.Errorf("failed to decode response body, %w", err),
432			Snapshot: snapshot.Bytes(),
433		}
434		return out, metadata, err
435	}
436
437	err = awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(&output, shape)
438	if err != nil {
439		var snapshot bytes.Buffer
440		io.Copy(&snapshot, ringBuffer)
441		err = &smithy.DeserializationError{
442			Err:      fmt.Errorf("failed to decode response body, %w", err),
443			Snapshot: snapshot.Bytes(),
444		}
445		return out, metadata, err
446	}
447
448	return out, metadata, err
449}
450
451func awsAwsjson11_deserializeOpErrorCreateTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
452	var errorBuffer bytes.Buffer
453	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
454		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
455	}
456	errorBody := bytes.NewReader(errorBuffer.Bytes())
457
458	errorCode := "UnknownError"
459	errorMessage := errorCode
460
461	code := response.Header.Get("X-Amzn-ErrorType")
462	if len(code) != 0 {
463		errorCode = restjson.SanitizeErrorCode(code)
464	}
465
466	var buff [1024]byte
467	ringBuffer := smithyio.NewRingBuffer(buff[:])
468
469	body := io.TeeReader(errorBody, ringBuffer)
470	decoder := json.NewDecoder(body)
471	decoder.UseNumber()
472	code, message, err := restjson.GetErrorInfo(decoder)
473	if err != nil {
474		var snapshot bytes.Buffer
475		io.Copy(&snapshot, ringBuffer)
476		err = &smithy.DeserializationError{
477			Err:      fmt.Errorf("failed to decode response body, %w", err),
478			Snapshot: snapshot.Bytes(),
479		}
480		return err
481	}
482
483	errorBody.Seek(0, io.SeekStart)
484	if len(code) != 0 {
485		errorCode = restjson.SanitizeErrorCode(code)
486	}
487	if len(message) != 0 {
488		errorMessage = message
489	}
490
491	switch {
492	case strings.EqualFold("AccessDeniedException", errorCode):
493		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
494
495	case strings.EqualFold("ClientException", errorCode):
496		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
497
498	case strings.EqualFold("ClusterNotFoundException", errorCode):
499		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
500
501	case strings.EqualFold("InvalidParameterException", errorCode):
502		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
503
504	case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
505		return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
506
507	case strings.EqualFold("PlatformUnknownException", errorCode):
508		return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
509
510	case strings.EqualFold("ServerException", errorCode):
511		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
512
513	case strings.EqualFold("ServiceNotActiveException", errorCode):
514		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
515
516	case strings.EqualFold("ServiceNotFoundException", errorCode):
517		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
518
519	case strings.EqualFold("UnsupportedFeatureException", errorCode):
520		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
521
522	default:
523		genericError := &smithy.GenericAPIError{
524			Code:    errorCode,
525			Message: errorMessage,
526		}
527		return genericError
528
529	}
530}
531
532type awsAwsjson11_deserializeOpDeleteAccountSetting struct {
533}
534
535func (*awsAwsjson11_deserializeOpDeleteAccountSetting) ID() string {
536	return "OperationDeserializer"
537}
538
539func (m *awsAwsjson11_deserializeOpDeleteAccountSetting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
540	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
541) {
542	out, metadata, err = next.HandleDeserialize(ctx, in)
543	if err != nil {
544		return out, metadata, err
545	}
546
547	response, ok := out.RawResponse.(*smithyhttp.Response)
548	if !ok {
549		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
550	}
551
552	if response.StatusCode < 200 || response.StatusCode >= 300 {
553		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccountSetting(response, &metadata)
554	}
555	output := &DeleteAccountSettingOutput{}
556	out.Result = output
557
558	var buff [1024]byte
559	ringBuffer := smithyio.NewRingBuffer(buff[:])
560
561	body := io.TeeReader(response.Body, ringBuffer)
562	decoder := json.NewDecoder(body)
563	decoder.UseNumber()
564	var shape interface{}
565	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
566		var snapshot bytes.Buffer
567		io.Copy(&snapshot, ringBuffer)
568		err = &smithy.DeserializationError{
569			Err:      fmt.Errorf("failed to decode response body, %w", err),
570			Snapshot: snapshot.Bytes(),
571		}
572		return out, metadata, err
573	}
574
575	err = awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(&output, shape)
576	if err != nil {
577		var snapshot bytes.Buffer
578		io.Copy(&snapshot, ringBuffer)
579		err = &smithy.DeserializationError{
580			Err:      fmt.Errorf("failed to decode response body, %w", err),
581			Snapshot: snapshot.Bytes(),
582		}
583		return out, metadata, err
584	}
585
586	return out, metadata, err
587}
588
589func awsAwsjson11_deserializeOpErrorDeleteAccountSetting(response *smithyhttp.Response, metadata *middleware.Metadata) error {
590	var errorBuffer bytes.Buffer
591	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
592		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
593	}
594	errorBody := bytes.NewReader(errorBuffer.Bytes())
595
596	errorCode := "UnknownError"
597	errorMessage := errorCode
598
599	code := response.Header.Get("X-Amzn-ErrorType")
600	if len(code) != 0 {
601		errorCode = restjson.SanitizeErrorCode(code)
602	}
603
604	var buff [1024]byte
605	ringBuffer := smithyio.NewRingBuffer(buff[:])
606
607	body := io.TeeReader(errorBody, ringBuffer)
608	decoder := json.NewDecoder(body)
609	decoder.UseNumber()
610	code, message, err := restjson.GetErrorInfo(decoder)
611	if err != nil {
612		var snapshot bytes.Buffer
613		io.Copy(&snapshot, ringBuffer)
614		err = &smithy.DeserializationError{
615			Err:      fmt.Errorf("failed to decode response body, %w", err),
616			Snapshot: snapshot.Bytes(),
617		}
618		return err
619	}
620
621	errorBody.Seek(0, io.SeekStart)
622	if len(code) != 0 {
623		errorCode = restjson.SanitizeErrorCode(code)
624	}
625	if len(message) != 0 {
626		errorMessage = message
627	}
628
629	switch {
630	case strings.EqualFold("ClientException", errorCode):
631		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
632
633	case strings.EqualFold("InvalidParameterException", errorCode):
634		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
635
636	case strings.EqualFold("ServerException", errorCode):
637		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
638
639	default:
640		genericError := &smithy.GenericAPIError{
641			Code:    errorCode,
642			Message: errorMessage,
643		}
644		return genericError
645
646	}
647}
648
649type awsAwsjson11_deserializeOpDeleteAttributes struct {
650}
651
652func (*awsAwsjson11_deserializeOpDeleteAttributes) ID() string {
653	return "OperationDeserializer"
654}
655
656func (m *awsAwsjson11_deserializeOpDeleteAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
657	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
658) {
659	out, metadata, err = next.HandleDeserialize(ctx, in)
660	if err != nil {
661		return out, metadata, err
662	}
663
664	response, ok := out.RawResponse.(*smithyhttp.Response)
665	if !ok {
666		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
667	}
668
669	if response.StatusCode < 200 || response.StatusCode >= 300 {
670		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAttributes(response, &metadata)
671	}
672	output := &DeleteAttributesOutput{}
673	out.Result = output
674
675	var buff [1024]byte
676	ringBuffer := smithyio.NewRingBuffer(buff[:])
677
678	body := io.TeeReader(response.Body, ringBuffer)
679	decoder := json.NewDecoder(body)
680	decoder.UseNumber()
681	var shape interface{}
682	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
683		var snapshot bytes.Buffer
684		io.Copy(&snapshot, ringBuffer)
685		err = &smithy.DeserializationError{
686			Err:      fmt.Errorf("failed to decode response body, %w", err),
687			Snapshot: snapshot.Bytes(),
688		}
689		return out, metadata, err
690	}
691
692	err = awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(&output, shape)
693	if err != nil {
694		var snapshot bytes.Buffer
695		io.Copy(&snapshot, ringBuffer)
696		err = &smithy.DeserializationError{
697			Err:      fmt.Errorf("failed to decode response body, %w", err),
698			Snapshot: snapshot.Bytes(),
699		}
700		return out, metadata, err
701	}
702
703	return out, metadata, err
704}
705
706func awsAwsjson11_deserializeOpErrorDeleteAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
707	var errorBuffer bytes.Buffer
708	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
709		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
710	}
711	errorBody := bytes.NewReader(errorBuffer.Bytes())
712
713	errorCode := "UnknownError"
714	errorMessage := errorCode
715
716	code := response.Header.Get("X-Amzn-ErrorType")
717	if len(code) != 0 {
718		errorCode = restjson.SanitizeErrorCode(code)
719	}
720
721	var buff [1024]byte
722	ringBuffer := smithyio.NewRingBuffer(buff[:])
723
724	body := io.TeeReader(errorBody, ringBuffer)
725	decoder := json.NewDecoder(body)
726	decoder.UseNumber()
727	code, message, err := restjson.GetErrorInfo(decoder)
728	if err != nil {
729		var snapshot bytes.Buffer
730		io.Copy(&snapshot, ringBuffer)
731		err = &smithy.DeserializationError{
732			Err:      fmt.Errorf("failed to decode response body, %w", err),
733			Snapshot: snapshot.Bytes(),
734		}
735		return err
736	}
737
738	errorBody.Seek(0, io.SeekStart)
739	if len(code) != 0 {
740		errorCode = restjson.SanitizeErrorCode(code)
741	}
742	if len(message) != 0 {
743		errorMessage = message
744	}
745
746	switch {
747	case strings.EqualFold("ClusterNotFoundException", errorCode):
748		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
749
750	case strings.EqualFold("InvalidParameterException", errorCode):
751		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
752
753	case strings.EqualFold("TargetNotFoundException", errorCode):
754		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
755
756	default:
757		genericError := &smithy.GenericAPIError{
758			Code:    errorCode,
759			Message: errorMessage,
760		}
761		return genericError
762
763	}
764}
765
766type awsAwsjson11_deserializeOpDeleteCapacityProvider struct {
767}
768
769func (*awsAwsjson11_deserializeOpDeleteCapacityProvider) ID() string {
770	return "OperationDeserializer"
771}
772
773func (m *awsAwsjson11_deserializeOpDeleteCapacityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
774	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
775) {
776	out, metadata, err = next.HandleDeserialize(ctx, in)
777	if err != nil {
778		return out, metadata, err
779	}
780
781	response, ok := out.RawResponse.(*smithyhttp.Response)
782	if !ok {
783		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
784	}
785
786	if response.StatusCode < 200 || response.StatusCode >= 300 {
787		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(response, &metadata)
788	}
789	output := &DeleteCapacityProviderOutput{}
790	out.Result = output
791
792	var buff [1024]byte
793	ringBuffer := smithyio.NewRingBuffer(buff[:])
794
795	body := io.TeeReader(response.Body, ringBuffer)
796	decoder := json.NewDecoder(body)
797	decoder.UseNumber()
798	var shape interface{}
799	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
800		var snapshot bytes.Buffer
801		io.Copy(&snapshot, ringBuffer)
802		err = &smithy.DeserializationError{
803			Err:      fmt.Errorf("failed to decode response body, %w", err),
804			Snapshot: snapshot.Bytes(),
805		}
806		return out, metadata, err
807	}
808
809	err = awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(&output, shape)
810	if err != nil {
811		var snapshot bytes.Buffer
812		io.Copy(&snapshot, ringBuffer)
813		err = &smithy.DeserializationError{
814			Err:      fmt.Errorf("failed to decode response body, %w", err),
815			Snapshot: snapshot.Bytes(),
816		}
817		return out, metadata, err
818	}
819
820	return out, metadata, err
821}
822
823func awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
824	var errorBuffer bytes.Buffer
825	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
826		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
827	}
828	errorBody := bytes.NewReader(errorBuffer.Bytes())
829
830	errorCode := "UnknownError"
831	errorMessage := errorCode
832
833	code := response.Header.Get("X-Amzn-ErrorType")
834	if len(code) != 0 {
835		errorCode = restjson.SanitizeErrorCode(code)
836	}
837
838	var buff [1024]byte
839	ringBuffer := smithyio.NewRingBuffer(buff[:])
840
841	body := io.TeeReader(errorBody, ringBuffer)
842	decoder := json.NewDecoder(body)
843	decoder.UseNumber()
844	code, message, err := restjson.GetErrorInfo(decoder)
845	if err != nil {
846		var snapshot bytes.Buffer
847		io.Copy(&snapshot, ringBuffer)
848		err = &smithy.DeserializationError{
849			Err:      fmt.Errorf("failed to decode response body, %w", err),
850			Snapshot: snapshot.Bytes(),
851		}
852		return err
853	}
854
855	errorBody.Seek(0, io.SeekStart)
856	if len(code) != 0 {
857		errorCode = restjson.SanitizeErrorCode(code)
858	}
859	if len(message) != 0 {
860		errorMessage = message
861	}
862
863	switch {
864	case strings.EqualFold("ClientException", errorCode):
865		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
866
867	case strings.EqualFold("InvalidParameterException", errorCode):
868		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
869
870	case strings.EqualFold("ServerException", errorCode):
871		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
872
873	default:
874		genericError := &smithy.GenericAPIError{
875			Code:    errorCode,
876			Message: errorMessage,
877		}
878		return genericError
879
880	}
881}
882
883type awsAwsjson11_deserializeOpDeleteCluster struct {
884}
885
886func (*awsAwsjson11_deserializeOpDeleteCluster) ID() string {
887	return "OperationDeserializer"
888}
889
890func (m *awsAwsjson11_deserializeOpDeleteCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
891	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
892) {
893	out, metadata, err = next.HandleDeserialize(ctx, in)
894	if err != nil {
895		return out, metadata, err
896	}
897
898	response, ok := out.RawResponse.(*smithyhttp.Response)
899	if !ok {
900		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
901	}
902
903	if response.StatusCode < 200 || response.StatusCode >= 300 {
904		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCluster(response, &metadata)
905	}
906	output := &DeleteClusterOutput{}
907	out.Result = output
908
909	var buff [1024]byte
910	ringBuffer := smithyio.NewRingBuffer(buff[:])
911
912	body := io.TeeReader(response.Body, ringBuffer)
913	decoder := json.NewDecoder(body)
914	decoder.UseNumber()
915	var shape interface{}
916	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
917		var snapshot bytes.Buffer
918		io.Copy(&snapshot, ringBuffer)
919		err = &smithy.DeserializationError{
920			Err:      fmt.Errorf("failed to decode response body, %w", err),
921			Snapshot: snapshot.Bytes(),
922		}
923		return out, metadata, err
924	}
925
926	err = awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(&output, shape)
927	if err != nil {
928		var snapshot bytes.Buffer
929		io.Copy(&snapshot, ringBuffer)
930		err = &smithy.DeserializationError{
931			Err:      fmt.Errorf("failed to decode response body, %w", err),
932			Snapshot: snapshot.Bytes(),
933		}
934		return out, metadata, err
935	}
936
937	return out, metadata, err
938}
939
940func awsAwsjson11_deserializeOpErrorDeleteCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
941	var errorBuffer bytes.Buffer
942	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
943		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
944	}
945	errorBody := bytes.NewReader(errorBuffer.Bytes())
946
947	errorCode := "UnknownError"
948	errorMessage := errorCode
949
950	code := response.Header.Get("X-Amzn-ErrorType")
951	if len(code) != 0 {
952		errorCode = restjson.SanitizeErrorCode(code)
953	}
954
955	var buff [1024]byte
956	ringBuffer := smithyio.NewRingBuffer(buff[:])
957
958	body := io.TeeReader(errorBody, ringBuffer)
959	decoder := json.NewDecoder(body)
960	decoder.UseNumber()
961	code, message, err := restjson.GetErrorInfo(decoder)
962	if err != nil {
963		var snapshot bytes.Buffer
964		io.Copy(&snapshot, ringBuffer)
965		err = &smithy.DeserializationError{
966			Err:      fmt.Errorf("failed to decode response body, %w", err),
967			Snapshot: snapshot.Bytes(),
968		}
969		return err
970	}
971
972	errorBody.Seek(0, io.SeekStart)
973	if len(code) != 0 {
974		errorCode = restjson.SanitizeErrorCode(code)
975	}
976	if len(message) != 0 {
977		errorMessage = message
978	}
979
980	switch {
981	case strings.EqualFold("ClientException", errorCode):
982		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
983
984	case strings.EqualFold("ClusterContainsContainerInstancesException", errorCode):
985		return awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(response, errorBody)
986
987	case strings.EqualFold("ClusterContainsServicesException", errorCode):
988		return awsAwsjson11_deserializeErrorClusterContainsServicesException(response, errorBody)
989
990	case strings.EqualFold("ClusterContainsTasksException", errorCode):
991		return awsAwsjson11_deserializeErrorClusterContainsTasksException(response, errorBody)
992
993	case strings.EqualFold("ClusterNotFoundException", errorCode):
994		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
995
996	case strings.EqualFold("InvalidParameterException", errorCode):
997		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
998
999	case strings.EqualFold("ServerException", errorCode):
1000		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1001
1002	case strings.EqualFold("UpdateInProgressException", errorCode):
1003		return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
1004
1005	default:
1006		genericError := &smithy.GenericAPIError{
1007			Code:    errorCode,
1008			Message: errorMessage,
1009		}
1010		return genericError
1011
1012	}
1013}
1014
1015type awsAwsjson11_deserializeOpDeleteService struct {
1016}
1017
1018func (*awsAwsjson11_deserializeOpDeleteService) ID() string {
1019	return "OperationDeserializer"
1020}
1021
1022func (m *awsAwsjson11_deserializeOpDeleteService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1023	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1024) {
1025	out, metadata, err = next.HandleDeserialize(ctx, in)
1026	if err != nil {
1027		return out, metadata, err
1028	}
1029
1030	response, ok := out.RawResponse.(*smithyhttp.Response)
1031	if !ok {
1032		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1033	}
1034
1035	if response.StatusCode < 200 || response.StatusCode >= 300 {
1036		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteService(response, &metadata)
1037	}
1038	output := &DeleteServiceOutput{}
1039	out.Result = output
1040
1041	var buff [1024]byte
1042	ringBuffer := smithyio.NewRingBuffer(buff[:])
1043
1044	body := io.TeeReader(response.Body, ringBuffer)
1045	decoder := json.NewDecoder(body)
1046	decoder.UseNumber()
1047	var shape interface{}
1048	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1049		var snapshot bytes.Buffer
1050		io.Copy(&snapshot, ringBuffer)
1051		err = &smithy.DeserializationError{
1052			Err:      fmt.Errorf("failed to decode response body, %w", err),
1053			Snapshot: snapshot.Bytes(),
1054		}
1055		return out, metadata, err
1056	}
1057
1058	err = awsAwsjson11_deserializeOpDocumentDeleteServiceOutput(&output, shape)
1059	if err != nil {
1060		var snapshot bytes.Buffer
1061		io.Copy(&snapshot, ringBuffer)
1062		err = &smithy.DeserializationError{
1063			Err:      fmt.Errorf("failed to decode response body, %w", err),
1064			Snapshot: snapshot.Bytes(),
1065		}
1066		return out, metadata, err
1067	}
1068
1069	return out, metadata, err
1070}
1071
1072func awsAwsjson11_deserializeOpErrorDeleteService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1073	var errorBuffer bytes.Buffer
1074	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1075		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1076	}
1077	errorBody := bytes.NewReader(errorBuffer.Bytes())
1078
1079	errorCode := "UnknownError"
1080	errorMessage := errorCode
1081
1082	code := response.Header.Get("X-Amzn-ErrorType")
1083	if len(code) != 0 {
1084		errorCode = restjson.SanitizeErrorCode(code)
1085	}
1086
1087	var buff [1024]byte
1088	ringBuffer := smithyio.NewRingBuffer(buff[:])
1089
1090	body := io.TeeReader(errorBody, ringBuffer)
1091	decoder := json.NewDecoder(body)
1092	decoder.UseNumber()
1093	code, message, err := restjson.GetErrorInfo(decoder)
1094	if err != nil {
1095		var snapshot bytes.Buffer
1096		io.Copy(&snapshot, ringBuffer)
1097		err = &smithy.DeserializationError{
1098			Err:      fmt.Errorf("failed to decode response body, %w", err),
1099			Snapshot: snapshot.Bytes(),
1100		}
1101		return err
1102	}
1103
1104	errorBody.Seek(0, io.SeekStart)
1105	if len(code) != 0 {
1106		errorCode = restjson.SanitizeErrorCode(code)
1107	}
1108	if len(message) != 0 {
1109		errorMessage = message
1110	}
1111
1112	switch {
1113	case strings.EqualFold("ClientException", errorCode):
1114		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1115
1116	case strings.EqualFold("ClusterNotFoundException", errorCode):
1117		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
1118
1119	case strings.EqualFold("InvalidParameterException", errorCode):
1120		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1121
1122	case strings.EqualFold("ServerException", errorCode):
1123		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1124
1125	case strings.EqualFold("ServiceNotFoundException", errorCode):
1126		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
1127
1128	default:
1129		genericError := &smithy.GenericAPIError{
1130			Code:    errorCode,
1131			Message: errorMessage,
1132		}
1133		return genericError
1134
1135	}
1136}
1137
1138type awsAwsjson11_deserializeOpDeleteTaskSet struct {
1139}
1140
1141func (*awsAwsjson11_deserializeOpDeleteTaskSet) ID() string {
1142	return "OperationDeserializer"
1143}
1144
1145func (m *awsAwsjson11_deserializeOpDeleteTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1146	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1147) {
1148	out, metadata, err = next.HandleDeserialize(ctx, in)
1149	if err != nil {
1150		return out, metadata, err
1151	}
1152
1153	response, ok := out.RawResponse.(*smithyhttp.Response)
1154	if !ok {
1155		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1156	}
1157
1158	if response.StatusCode < 200 || response.StatusCode >= 300 {
1159		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTaskSet(response, &metadata)
1160	}
1161	output := &DeleteTaskSetOutput{}
1162	out.Result = output
1163
1164	var buff [1024]byte
1165	ringBuffer := smithyio.NewRingBuffer(buff[:])
1166
1167	body := io.TeeReader(response.Body, ringBuffer)
1168	decoder := json.NewDecoder(body)
1169	decoder.UseNumber()
1170	var shape interface{}
1171	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1172		var snapshot bytes.Buffer
1173		io.Copy(&snapshot, ringBuffer)
1174		err = &smithy.DeserializationError{
1175			Err:      fmt.Errorf("failed to decode response body, %w", err),
1176			Snapshot: snapshot.Bytes(),
1177		}
1178		return out, metadata, err
1179	}
1180
1181	err = awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(&output, shape)
1182	if err != nil {
1183		var snapshot bytes.Buffer
1184		io.Copy(&snapshot, ringBuffer)
1185		err = &smithy.DeserializationError{
1186			Err:      fmt.Errorf("failed to decode response body, %w", err),
1187			Snapshot: snapshot.Bytes(),
1188		}
1189		return out, metadata, err
1190	}
1191
1192	return out, metadata, err
1193}
1194
1195func awsAwsjson11_deserializeOpErrorDeleteTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1196	var errorBuffer bytes.Buffer
1197	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1198		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1199	}
1200	errorBody := bytes.NewReader(errorBuffer.Bytes())
1201
1202	errorCode := "UnknownError"
1203	errorMessage := errorCode
1204
1205	code := response.Header.Get("X-Amzn-ErrorType")
1206	if len(code) != 0 {
1207		errorCode = restjson.SanitizeErrorCode(code)
1208	}
1209
1210	var buff [1024]byte
1211	ringBuffer := smithyio.NewRingBuffer(buff[:])
1212
1213	body := io.TeeReader(errorBody, ringBuffer)
1214	decoder := json.NewDecoder(body)
1215	decoder.UseNumber()
1216	code, message, err := restjson.GetErrorInfo(decoder)
1217	if err != nil {
1218		var snapshot bytes.Buffer
1219		io.Copy(&snapshot, ringBuffer)
1220		err = &smithy.DeserializationError{
1221			Err:      fmt.Errorf("failed to decode response body, %w", err),
1222			Snapshot: snapshot.Bytes(),
1223		}
1224		return err
1225	}
1226
1227	errorBody.Seek(0, io.SeekStart)
1228	if len(code) != 0 {
1229		errorCode = restjson.SanitizeErrorCode(code)
1230	}
1231	if len(message) != 0 {
1232		errorMessage = message
1233	}
1234
1235	switch {
1236	case strings.EqualFold("AccessDeniedException", errorCode):
1237		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1238
1239	case strings.EqualFold("ClientException", errorCode):
1240		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1241
1242	case strings.EqualFold("ClusterNotFoundException", errorCode):
1243		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
1244
1245	case strings.EqualFold("InvalidParameterException", errorCode):
1246		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1247
1248	case strings.EqualFold("ServerException", errorCode):
1249		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1250
1251	case strings.EqualFold("ServiceNotActiveException", errorCode):
1252		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
1253
1254	case strings.EqualFold("ServiceNotFoundException", errorCode):
1255		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
1256
1257	case strings.EqualFold("TaskSetNotFoundException", errorCode):
1258		return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
1259
1260	case strings.EqualFold("UnsupportedFeatureException", errorCode):
1261		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
1262
1263	default:
1264		genericError := &smithy.GenericAPIError{
1265			Code:    errorCode,
1266			Message: errorMessage,
1267		}
1268		return genericError
1269
1270	}
1271}
1272
1273type awsAwsjson11_deserializeOpDeregisterContainerInstance struct {
1274}
1275
1276func (*awsAwsjson11_deserializeOpDeregisterContainerInstance) ID() string {
1277	return "OperationDeserializer"
1278}
1279
1280func (m *awsAwsjson11_deserializeOpDeregisterContainerInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1281	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	out, metadata, err = next.HandleDeserialize(ctx, in)
1284	if err != nil {
1285		return out, metadata, err
1286	}
1287
1288	response, ok := out.RawResponse.(*smithyhttp.Response)
1289	if !ok {
1290		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1291	}
1292
1293	if response.StatusCode < 200 || response.StatusCode >= 300 {
1294		return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(response, &metadata)
1295	}
1296	output := &DeregisterContainerInstanceOutput{}
1297	out.Result = output
1298
1299	var buff [1024]byte
1300	ringBuffer := smithyio.NewRingBuffer(buff[:])
1301
1302	body := io.TeeReader(response.Body, ringBuffer)
1303	decoder := json.NewDecoder(body)
1304	decoder.UseNumber()
1305	var shape interface{}
1306	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1307		var snapshot bytes.Buffer
1308		io.Copy(&snapshot, ringBuffer)
1309		err = &smithy.DeserializationError{
1310			Err:      fmt.Errorf("failed to decode response body, %w", err),
1311			Snapshot: snapshot.Bytes(),
1312		}
1313		return out, metadata, err
1314	}
1315
1316	err = awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(&output, shape)
1317	if err != nil {
1318		var snapshot bytes.Buffer
1319		io.Copy(&snapshot, ringBuffer)
1320		err = &smithy.DeserializationError{
1321			Err:      fmt.Errorf("failed to decode response body, %w", err),
1322			Snapshot: snapshot.Bytes(),
1323		}
1324		return out, metadata, err
1325	}
1326
1327	return out, metadata, err
1328}
1329
1330func awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1331	var errorBuffer bytes.Buffer
1332	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1333		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1334	}
1335	errorBody := bytes.NewReader(errorBuffer.Bytes())
1336
1337	errorCode := "UnknownError"
1338	errorMessage := errorCode
1339
1340	code := response.Header.Get("X-Amzn-ErrorType")
1341	if len(code) != 0 {
1342		errorCode = restjson.SanitizeErrorCode(code)
1343	}
1344
1345	var buff [1024]byte
1346	ringBuffer := smithyio.NewRingBuffer(buff[:])
1347
1348	body := io.TeeReader(errorBody, ringBuffer)
1349	decoder := json.NewDecoder(body)
1350	decoder.UseNumber()
1351	code, message, err := restjson.GetErrorInfo(decoder)
1352	if err != nil {
1353		var snapshot bytes.Buffer
1354		io.Copy(&snapshot, ringBuffer)
1355		err = &smithy.DeserializationError{
1356			Err:      fmt.Errorf("failed to decode response body, %w", err),
1357			Snapshot: snapshot.Bytes(),
1358		}
1359		return err
1360	}
1361
1362	errorBody.Seek(0, io.SeekStart)
1363	if len(code) != 0 {
1364		errorCode = restjson.SanitizeErrorCode(code)
1365	}
1366	if len(message) != 0 {
1367		errorMessage = message
1368	}
1369
1370	switch {
1371	case strings.EqualFold("ClientException", errorCode):
1372		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1373
1374	case strings.EqualFold("ClusterNotFoundException", errorCode):
1375		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
1376
1377	case strings.EqualFold("InvalidParameterException", errorCode):
1378		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1379
1380	case strings.EqualFold("ServerException", errorCode):
1381		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1382
1383	default:
1384		genericError := &smithy.GenericAPIError{
1385			Code:    errorCode,
1386			Message: errorMessage,
1387		}
1388		return genericError
1389
1390	}
1391}
1392
1393type awsAwsjson11_deserializeOpDeregisterTaskDefinition struct {
1394}
1395
1396func (*awsAwsjson11_deserializeOpDeregisterTaskDefinition) ID() string {
1397	return "OperationDeserializer"
1398}
1399
1400func (m *awsAwsjson11_deserializeOpDeregisterTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1401	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	out, metadata, err = next.HandleDeserialize(ctx, in)
1404	if err != nil {
1405		return out, metadata, err
1406	}
1407
1408	response, ok := out.RawResponse.(*smithyhttp.Response)
1409	if !ok {
1410		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1411	}
1412
1413	if response.StatusCode < 200 || response.StatusCode >= 300 {
1414		return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(response, &metadata)
1415	}
1416	output := &DeregisterTaskDefinitionOutput{}
1417	out.Result = output
1418
1419	var buff [1024]byte
1420	ringBuffer := smithyio.NewRingBuffer(buff[:])
1421
1422	body := io.TeeReader(response.Body, ringBuffer)
1423	decoder := json.NewDecoder(body)
1424	decoder.UseNumber()
1425	var shape interface{}
1426	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1427		var snapshot bytes.Buffer
1428		io.Copy(&snapshot, ringBuffer)
1429		err = &smithy.DeserializationError{
1430			Err:      fmt.Errorf("failed to decode response body, %w", err),
1431			Snapshot: snapshot.Bytes(),
1432		}
1433		return out, metadata, err
1434	}
1435
1436	err = awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(&output, shape)
1437	if err != nil {
1438		var snapshot bytes.Buffer
1439		io.Copy(&snapshot, ringBuffer)
1440		err = &smithy.DeserializationError{
1441			Err:      fmt.Errorf("failed to decode response body, %w", err),
1442			Snapshot: snapshot.Bytes(),
1443		}
1444		return out, metadata, err
1445	}
1446
1447	return out, metadata, err
1448}
1449
1450func awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1451	var errorBuffer bytes.Buffer
1452	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1453		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1454	}
1455	errorBody := bytes.NewReader(errorBuffer.Bytes())
1456
1457	errorCode := "UnknownError"
1458	errorMessage := errorCode
1459
1460	code := response.Header.Get("X-Amzn-ErrorType")
1461	if len(code) != 0 {
1462		errorCode = restjson.SanitizeErrorCode(code)
1463	}
1464
1465	var buff [1024]byte
1466	ringBuffer := smithyio.NewRingBuffer(buff[:])
1467
1468	body := io.TeeReader(errorBody, ringBuffer)
1469	decoder := json.NewDecoder(body)
1470	decoder.UseNumber()
1471	code, message, err := restjson.GetErrorInfo(decoder)
1472	if err != nil {
1473		var snapshot bytes.Buffer
1474		io.Copy(&snapshot, ringBuffer)
1475		err = &smithy.DeserializationError{
1476			Err:      fmt.Errorf("failed to decode response body, %w", err),
1477			Snapshot: snapshot.Bytes(),
1478		}
1479		return err
1480	}
1481
1482	errorBody.Seek(0, io.SeekStart)
1483	if len(code) != 0 {
1484		errorCode = restjson.SanitizeErrorCode(code)
1485	}
1486	if len(message) != 0 {
1487		errorMessage = message
1488	}
1489
1490	switch {
1491	case strings.EqualFold("ClientException", errorCode):
1492		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1493
1494	case strings.EqualFold("InvalidParameterException", errorCode):
1495		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1496
1497	case strings.EqualFold("ServerException", errorCode):
1498		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1499
1500	default:
1501		genericError := &smithy.GenericAPIError{
1502			Code:    errorCode,
1503			Message: errorMessage,
1504		}
1505		return genericError
1506
1507	}
1508}
1509
1510type awsAwsjson11_deserializeOpDescribeCapacityProviders struct {
1511}
1512
1513func (*awsAwsjson11_deserializeOpDescribeCapacityProviders) ID() string {
1514	return "OperationDeserializer"
1515}
1516
1517func (m *awsAwsjson11_deserializeOpDescribeCapacityProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1518	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1519) {
1520	out, metadata, err = next.HandleDeserialize(ctx, in)
1521	if err != nil {
1522		return out, metadata, err
1523	}
1524
1525	response, ok := out.RawResponse.(*smithyhttp.Response)
1526	if !ok {
1527		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1528	}
1529
1530	if response.StatusCode < 200 || response.StatusCode >= 300 {
1531		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(response, &metadata)
1532	}
1533	output := &DescribeCapacityProvidersOutput{}
1534	out.Result = output
1535
1536	var buff [1024]byte
1537	ringBuffer := smithyio.NewRingBuffer(buff[:])
1538
1539	body := io.TeeReader(response.Body, ringBuffer)
1540	decoder := json.NewDecoder(body)
1541	decoder.UseNumber()
1542	var shape interface{}
1543	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1544		var snapshot bytes.Buffer
1545		io.Copy(&snapshot, ringBuffer)
1546		err = &smithy.DeserializationError{
1547			Err:      fmt.Errorf("failed to decode response body, %w", err),
1548			Snapshot: snapshot.Bytes(),
1549		}
1550		return out, metadata, err
1551	}
1552
1553	err = awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(&output, shape)
1554	if err != nil {
1555		var snapshot bytes.Buffer
1556		io.Copy(&snapshot, ringBuffer)
1557		err = &smithy.DeserializationError{
1558			Err:      fmt.Errorf("failed to decode response body, %w", err),
1559			Snapshot: snapshot.Bytes(),
1560		}
1561		return out, metadata, err
1562	}
1563
1564	return out, metadata, err
1565}
1566
1567func awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1568	var errorBuffer bytes.Buffer
1569	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1570		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1571	}
1572	errorBody := bytes.NewReader(errorBuffer.Bytes())
1573
1574	errorCode := "UnknownError"
1575	errorMessage := errorCode
1576
1577	code := response.Header.Get("X-Amzn-ErrorType")
1578	if len(code) != 0 {
1579		errorCode = restjson.SanitizeErrorCode(code)
1580	}
1581
1582	var buff [1024]byte
1583	ringBuffer := smithyio.NewRingBuffer(buff[:])
1584
1585	body := io.TeeReader(errorBody, ringBuffer)
1586	decoder := json.NewDecoder(body)
1587	decoder.UseNumber()
1588	code, message, err := restjson.GetErrorInfo(decoder)
1589	if err != nil {
1590		var snapshot bytes.Buffer
1591		io.Copy(&snapshot, ringBuffer)
1592		err = &smithy.DeserializationError{
1593			Err:      fmt.Errorf("failed to decode response body, %w", err),
1594			Snapshot: snapshot.Bytes(),
1595		}
1596		return err
1597	}
1598
1599	errorBody.Seek(0, io.SeekStart)
1600	if len(code) != 0 {
1601		errorCode = restjson.SanitizeErrorCode(code)
1602	}
1603	if len(message) != 0 {
1604		errorMessage = message
1605	}
1606
1607	switch {
1608	case strings.EqualFold("ClientException", errorCode):
1609		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1610
1611	case strings.EqualFold("InvalidParameterException", errorCode):
1612		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1613
1614	case strings.EqualFold("ServerException", errorCode):
1615		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1616
1617	default:
1618		genericError := &smithy.GenericAPIError{
1619			Code:    errorCode,
1620			Message: errorMessage,
1621		}
1622		return genericError
1623
1624	}
1625}
1626
1627type awsAwsjson11_deserializeOpDescribeClusters struct {
1628}
1629
1630func (*awsAwsjson11_deserializeOpDescribeClusters) ID() string {
1631	return "OperationDeserializer"
1632}
1633
1634func (m *awsAwsjson11_deserializeOpDescribeClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1635	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1636) {
1637	out, metadata, err = next.HandleDeserialize(ctx, in)
1638	if err != nil {
1639		return out, metadata, err
1640	}
1641
1642	response, ok := out.RawResponse.(*smithyhttp.Response)
1643	if !ok {
1644		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1645	}
1646
1647	if response.StatusCode < 200 || response.StatusCode >= 300 {
1648		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeClusters(response, &metadata)
1649	}
1650	output := &DescribeClustersOutput{}
1651	out.Result = output
1652
1653	var buff [1024]byte
1654	ringBuffer := smithyio.NewRingBuffer(buff[:])
1655
1656	body := io.TeeReader(response.Body, ringBuffer)
1657	decoder := json.NewDecoder(body)
1658	decoder.UseNumber()
1659	var shape interface{}
1660	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1661		var snapshot bytes.Buffer
1662		io.Copy(&snapshot, ringBuffer)
1663		err = &smithy.DeserializationError{
1664			Err:      fmt.Errorf("failed to decode response body, %w", err),
1665			Snapshot: snapshot.Bytes(),
1666		}
1667		return out, metadata, err
1668	}
1669
1670	err = awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(&output, shape)
1671	if err != nil {
1672		var snapshot bytes.Buffer
1673		io.Copy(&snapshot, ringBuffer)
1674		err = &smithy.DeserializationError{
1675			Err:      fmt.Errorf("failed to decode response body, %w", err),
1676			Snapshot: snapshot.Bytes(),
1677		}
1678		return out, metadata, err
1679	}
1680
1681	return out, metadata, err
1682}
1683
1684func awsAwsjson11_deserializeOpErrorDescribeClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1685	var errorBuffer bytes.Buffer
1686	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1687		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1688	}
1689	errorBody := bytes.NewReader(errorBuffer.Bytes())
1690
1691	errorCode := "UnknownError"
1692	errorMessage := errorCode
1693
1694	code := response.Header.Get("X-Amzn-ErrorType")
1695	if len(code) != 0 {
1696		errorCode = restjson.SanitizeErrorCode(code)
1697	}
1698
1699	var buff [1024]byte
1700	ringBuffer := smithyio.NewRingBuffer(buff[:])
1701
1702	body := io.TeeReader(errorBody, ringBuffer)
1703	decoder := json.NewDecoder(body)
1704	decoder.UseNumber()
1705	code, message, err := restjson.GetErrorInfo(decoder)
1706	if err != nil {
1707		var snapshot bytes.Buffer
1708		io.Copy(&snapshot, ringBuffer)
1709		err = &smithy.DeserializationError{
1710			Err:      fmt.Errorf("failed to decode response body, %w", err),
1711			Snapshot: snapshot.Bytes(),
1712		}
1713		return err
1714	}
1715
1716	errorBody.Seek(0, io.SeekStart)
1717	if len(code) != 0 {
1718		errorCode = restjson.SanitizeErrorCode(code)
1719	}
1720	if len(message) != 0 {
1721		errorMessage = message
1722	}
1723
1724	switch {
1725	case strings.EqualFold("ClientException", errorCode):
1726		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1727
1728	case strings.EqualFold("InvalidParameterException", errorCode):
1729		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1730
1731	case strings.EqualFold("ServerException", errorCode):
1732		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1733
1734	default:
1735		genericError := &smithy.GenericAPIError{
1736			Code:    errorCode,
1737			Message: errorMessage,
1738		}
1739		return genericError
1740
1741	}
1742}
1743
1744type awsAwsjson11_deserializeOpDescribeContainerInstances struct {
1745}
1746
1747func (*awsAwsjson11_deserializeOpDescribeContainerInstances) ID() string {
1748	return "OperationDeserializer"
1749}
1750
1751func (m *awsAwsjson11_deserializeOpDescribeContainerInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1752	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1753) {
1754	out, metadata, err = next.HandleDeserialize(ctx, in)
1755	if err != nil {
1756		return out, metadata, err
1757	}
1758
1759	response, ok := out.RawResponse.(*smithyhttp.Response)
1760	if !ok {
1761		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1762	}
1763
1764	if response.StatusCode < 200 || response.StatusCode >= 300 {
1765		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeContainerInstances(response, &metadata)
1766	}
1767	output := &DescribeContainerInstancesOutput{}
1768	out.Result = output
1769
1770	var buff [1024]byte
1771	ringBuffer := smithyio.NewRingBuffer(buff[:])
1772
1773	body := io.TeeReader(response.Body, ringBuffer)
1774	decoder := json.NewDecoder(body)
1775	decoder.UseNumber()
1776	var shape interface{}
1777	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1778		var snapshot bytes.Buffer
1779		io.Copy(&snapshot, ringBuffer)
1780		err = &smithy.DeserializationError{
1781			Err:      fmt.Errorf("failed to decode response body, %w", err),
1782			Snapshot: snapshot.Bytes(),
1783		}
1784		return out, metadata, err
1785	}
1786
1787	err = awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(&output, shape)
1788	if err != nil {
1789		var snapshot bytes.Buffer
1790		io.Copy(&snapshot, ringBuffer)
1791		err = &smithy.DeserializationError{
1792			Err:      fmt.Errorf("failed to decode response body, %w", err),
1793			Snapshot: snapshot.Bytes(),
1794		}
1795		return out, metadata, err
1796	}
1797
1798	return out, metadata, err
1799}
1800
1801func awsAwsjson11_deserializeOpErrorDescribeContainerInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1802	var errorBuffer bytes.Buffer
1803	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1804		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1805	}
1806	errorBody := bytes.NewReader(errorBuffer.Bytes())
1807
1808	errorCode := "UnknownError"
1809	errorMessage := errorCode
1810
1811	code := response.Header.Get("X-Amzn-ErrorType")
1812	if len(code) != 0 {
1813		errorCode = restjson.SanitizeErrorCode(code)
1814	}
1815
1816	var buff [1024]byte
1817	ringBuffer := smithyio.NewRingBuffer(buff[:])
1818
1819	body := io.TeeReader(errorBody, ringBuffer)
1820	decoder := json.NewDecoder(body)
1821	decoder.UseNumber()
1822	code, message, err := restjson.GetErrorInfo(decoder)
1823	if err != nil {
1824		var snapshot bytes.Buffer
1825		io.Copy(&snapshot, ringBuffer)
1826		err = &smithy.DeserializationError{
1827			Err:      fmt.Errorf("failed to decode response body, %w", err),
1828			Snapshot: snapshot.Bytes(),
1829		}
1830		return err
1831	}
1832
1833	errorBody.Seek(0, io.SeekStart)
1834	if len(code) != 0 {
1835		errorCode = restjson.SanitizeErrorCode(code)
1836	}
1837	if len(message) != 0 {
1838		errorMessage = message
1839	}
1840
1841	switch {
1842	case strings.EqualFold("ClientException", errorCode):
1843		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1844
1845	case strings.EqualFold("ClusterNotFoundException", errorCode):
1846		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
1847
1848	case strings.EqualFold("InvalidParameterException", errorCode):
1849		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1850
1851	case strings.EqualFold("ServerException", errorCode):
1852		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1853
1854	default:
1855		genericError := &smithy.GenericAPIError{
1856			Code:    errorCode,
1857			Message: errorMessage,
1858		}
1859		return genericError
1860
1861	}
1862}
1863
1864type awsAwsjson11_deserializeOpDescribeServices struct {
1865}
1866
1867func (*awsAwsjson11_deserializeOpDescribeServices) ID() string {
1868	return "OperationDeserializer"
1869}
1870
1871func (m *awsAwsjson11_deserializeOpDescribeServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1872	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1873) {
1874	out, metadata, err = next.HandleDeserialize(ctx, in)
1875	if err != nil {
1876		return out, metadata, err
1877	}
1878
1879	response, ok := out.RawResponse.(*smithyhttp.Response)
1880	if !ok {
1881		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1882	}
1883
1884	if response.StatusCode < 200 || response.StatusCode >= 300 {
1885		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServices(response, &metadata)
1886	}
1887	output := &DescribeServicesOutput{}
1888	out.Result = output
1889
1890	var buff [1024]byte
1891	ringBuffer := smithyio.NewRingBuffer(buff[:])
1892
1893	body := io.TeeReader(response.Body, ringBuffer)
1894	decoder := json.NewDecoder(body)
1895	decoder.UseNumber()
1896	var shape interface{}
1897	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1898		var snapshot bytes.Buffer
1899		io.Copy(&snapshot, ringBuffer)
1900		err = &smithy.DeserializationError{
1901			Err:      fmt.Errorf("failed to decode response body, %w", err),
1902			Snapshot: snapshot.Bytes(),
1903		}
1904		return out, metadata, err
1905	}
1906
1907	err = awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(&output, shape)
1908	if err != nil {
1909		var snapshot bytes.Buffer
1910		io.Copy(&snapshot, ringBuffer)
1911		err = &smithy.DeserializationError{
1912			Err:      fmt.Errorf("failed to decode response body, %w", err),
1913			Snapshot: snapshot.Bytes(),
1914		}
1915		return out, metadata, err
1916	}
1917
1918	return out, metadata, err
1919}
1920
1921func awsAwsjson11_deserializeOpErrorDescribeServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1922	var errorBuffer bytes.Buffer
1923	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1924		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1925	}
1926	errorBody := bytes.NewReader(errorBuffer.Bytes())
1927
1928	errorCode := "UnknownError"
1929	errorMessage := errorCode
1930
1931	code := response.Header.Get("X-Amzn-ErrorType")
1932	if len(code) != 0 {
1933		errorCode = restjson.SanitizeErrorCode(code)
1934	}
1935
1936	var buff [1024]byte
1937	ringBuffer := smithyio.NewRingBuffer(buff[:])
1938
1939	body := io.TeeReader(errorBody, ringBuffer)
1940	decoder := json.NewDecoder(body)
1941	decoder.UseNumber()
1942	code, message, err := restjson.GetErrorInfo(decoder)
1943	if err != nil {
1944		var snapshot bytes.Buffer
1945		io.Copy(&snapshot, ringBuffer)
1946		err = &smithy.DeserializationError{
1947			Err:      fmt.Errorf("failed to decode response body, %w", err),
1948			Snapshot: snapshot.Bytes(),
1949		}
1950		return err
1951	}
1952
1953	errorBody.Seek(0, io.SeekStart)
1954	if len(code) != 0 {
1955		errorCode = restjson.SanitizeErrorCode(code)
1956	}
1957	if len(message) != 0 {
1958		errorMessage = message
1959	}
1960
1961	switch {
1962	case strings.EqualFold("ClientException", errorCode):
1963		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
1964
1965	case strings.EqualFold("ClusterNotFoundException", errorCode):
1966		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
1967
1968	case strings.EqualFold("InvalidParameterException", errorCode):
1969		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1970
1971	case strings.EqualFold("ServerException", errorCode):
1972		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
1973
1974	default:
1975		genericError := &smithy.GenericAPIError{
1976			Code:    errorCode,
1977			Message: errorMessage,
1978		}
1979		return genericError
1980
1981	}
1982}
1983
1984type awsAwsjson11_deserializeOpDescribeTaskDefinition struct {
1985}
1986
1987func (*awsAwsjson11_deserializeOpDescribeTaskDefinition) ID() string {
1988	return "OperationDeserializer"
1989}
1990
1991func (m *awsAwsjson11_deserializeOpDescribeTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1992	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1993) {
1994	out, metadata, err = next.HandleDeserialize(ctx, in)
1995	if err != nil {
1996		return out, metadata, err
1997	}
1998
1999	response, ok := out.RawResponse.(*smithyhttp.Response)
2000	if !ok {
2001		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2002	}
2003
2004	if response.StatusCode < 200 || response.StatusCode >= 300 {
2005		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(response, &metadata)
2006	}
2007	output := &DescribeTaskDefinitionOutput{}
2008	out.Result = output
2009
2010	var buff [1024]byte
2011	ringBuffer := smithyio.NewRingBuffer(buff[:])
2012
2013	body := io.TeeReader(response.Body, ringBuffer)
2014	decoder := json.NewDecoder(body)
2015	decoder.UseNumber()
2016	var shape interface{}
2017	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2018		var snapshot bytes.Buffer
2019		io.Copy(&snapshot, ringBuffer)
2020		err = &smithy.DeserializationError{
2021			Err:      fmt.Errorf("failed to decode response body, %w", err),
2022			Snapshot: snapshot.Bytes(),
2023		}
2024		return out, metadata, err
2025	}
2026
2027	err = awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(&output, shape)
2028	if err != nil {
2029		var snapshot bytes.Buffer
2030		io.Copy(&snapshot, ringBuffer)
2031		err = &smithy.DeserializationError{
2032			Err:      fmt.Errorf("failed to decode response body, %w", err),
2033			Snapshot: snapshot.Bytes(),
2034		}
2035		return out, metadata, err
2036	}
2037
2038	return out, metadata, err
2039}
2040
2041func awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2042	var errorBuffer bytes.Buffer
2043	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2044		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2045	}
2046	errorBody := bytes.NewReader(errorBuffer.Bytes())
2047
2048	errorCode := "UnknownError"
2049	errorMessage := errorCode
2050
2051	code := response.Header.Get("X-Amzn-ErrorType")
2052	if len(code) != 0 {
2053		errorCode = restjson.SanitizeErrorCode(code)
2054	}
2055
2056	var buff [1024]byte
2057	ringBuffer := smithyio.NewRingBuffer(buff[:])
2058
2059	body := io.TeeReader(errorBody, ringBuffer)
2060	decoder := json.NewDecoder(body)
2061	decoder.UseNumber()
2062	code, message, err := restjson.GetErrorInfo(decoder)
2063	if err != nil {
2064		var snapshot bytes.Buffer
2065		io.Copy(&snapshot, ringBuffer)
2066		err = &smithy.DeserializationError{
2067			Err:      fmt.Errorf("failed to decode response body, %w", err),
2068			Snapshot: snapshot.Bytes(),
2069		}
2070		return err
2071	}
2072
2073	errorBody.Seek(0, io.SeekStart)
2074	if len(code) != 0 {
2075		errorCode = restjson.SanitizeErrorCode(code)
2076	}
2077	if len(message) != 0 {
2078		errorMessage = message
2079	}
2080
2081	switch {
2082	case strings.EqualFold("ClientException", errorCode):
2083		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2084
2085	case strings.EqualFold("InvalidParameterException", errorCode):
2086		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2087
2088	case strings.EqualFold("ServerException", errorCode):
2089		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2090
2091	default:
2092		genericError := &smithy.GenericAPIError{
2093			Code:    errorCode,
2094			Message: errorMessage,
2095		}
2096		return genericError
2097
2098	}
2099}
2100
2101type awsAwsjson11_deserializeOpDescribeTasks struct {
2102}
2103
2104func (*awsAwsjson11_deserializeOpDescribeTasks) ID() string {
2105	return "OperationDeserializer"
2106}
2107
2108func (m *awsAwsjson11_deserializeOpDescribeTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2109	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2110) {
2111	out, metadata, err = next.HandleDeserialize(ctx, in)
2112	if err != nil {
2113		return out, metadata, err
2114	}
2115
2116	response, ok := out.RawResponse.(*smithyhttp.Response)
2117	if !ok {
2118		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2119	}
2120
2121	if response.StatusCode < 200 || response.StatusCode >= 300 {
2122		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTasks(response, &metadata)
2123	}
2124	output := &DescribeTasksOutput{}
2125	out.Result = output
2126
2127	var buff [1024]byte
2128	ringBuffer := smithyio.NewRingBuffer(buff[:])
2129
2130	body := io.TeeReader(response.Body, ringBuffer)
2131	decoder := json.NewDecoder(body)
2132	decoder.UseNumber()
2133	var shape interface{}
2134	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2135		var snapshot bytes.Buffer
2136		io.Copy(&snapshot, ringBuffer)
2137		err = &smithy.DeserializationError{
2138			Err:      fmt.Errorf("failed to decode response body, %w", err),
2139			Snapshot: snapshot.Bytes(),
2140		}
2141		return out, metadata, err
2142	}
2143
2144	err = awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(&output, shape)
2145	if err != nil {
2146		var snapshot bytes.Buffer
2147		io.Copy(&snapshot, ringBuffer)
2148		err = &smithy.DeserializationError{
2149			Err:      fmt.Errorf("failed to decode response body, %w", err),
2150			Snapshot: snapshot.Bytes(),
2151		}
2152		return out, metadata, err
2153	}
2154
2155	return out, metadata, err
2156}
2157
2158func awsAwsjson11_deserializeOpErrorDescribeTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2159	var errorBuffer bytes.Buffer
2160	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2161		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2162	}
2163	errorBody := bytes.NewReader(errorBuffer.Bytes())
2164
2165	errorCode := "UnknownError"
2166	errorMessage := errorCode
2167
2168	code := response.Header.Get("X-Amzn-ErrorType")
2169	if len(code) != 0 {
2170		errorCode = restjson.SanitizeErrorCode(code)
2171	}
2172
2173	var buff [1024]byte
2174	ringBuffer := smithyio.NewRingBuffer(buff[:])
2175
2176	body := io.TeeReader(errorBody, ringBuffer)
2177	decoder := json.NewDecoder(body)
2178	decoder.UseNumber()
2179	code, message, err := restjson.GetErrorInfo(decoder)
2180	if err != nil {
2181		var snapshot bytes.Buffer
2182		io.Copy(&snapshot, ringBuffer)
2183		err = &smithy.DeserializationError{
2184			Err:      fmt.Errorf("failed to decode response body, %w", err),
2185			Snapshot: snapshot.Bytes(),
2186		}
2187		return err
2188	}
2189
2190	errorBody.Seek(0, io.SeekStart)
2191	if len(code) != 0 {
2192		errorCode = restjson.SanitizeErrorCode(code)
2193	}
2194	if len(message) != 0 {
2195		errorMessage = message
2196	}
2197
2198	switch {
2199	case strings.EqualFold("ClientException", errorCode):
2200		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2201
2202	case strings.EqualFold("ClusterNotFoundException", errorCode):
2203		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
2204
2205	case strings.EqualFold("InvalidParameterException", errorCode):
2206		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2207
2208	case strings.EqualFold("ServerException", errorCode):
2209		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2210
2211	default:
2212		genericError := &smithy.GenericAPIError{
2213			Code:    errorCode,
2214			Message: errorMessage,
2215		}
2216		return genericError
2217
2218	}
2219}
2220
2221type awsAwsjson11_deserializeOpDescribeTaskSets struct {
2222}
2223
2224func (*awsAwsjson11_deserializeOpDescribeTaskSets) ID() string {
2225	return "OperationDeserializer"
2226}
2227
2228func (m *awsAwsjson11_deserializeOpDescribeTaskSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2229	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2230) {
2231	out, metadata, err = next.HandleDeserialize(ctx, in)
2232	if err != nil {
2233		return out, metadata, err
2234	}
2235
2236	response, ok := out.RawResponse.(*smithyhttp.Response)
2237	if !ok {
2238		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2239	}
2240
2241	if response.StatusCode < 200 || response.StatusCode >= 300 {
2242		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTaskSets(response, &metadata)
2243	}
2244	output := &DescribeTaskSetsOutput{}
2245	out.Result = output
2246
2247	var buff [1024]byte
2248	ringBuffer := smithyio.NewRingBuffer(buff[:])
2249
2250	body := io.TeeReader(response.Body, ringBuffer)
2251	decoder := json.NewDecoder(body)
2252	decoder.UseNumber()
2253	var shape interface{}
2254	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2255		var snapshot bytes.Buffer
2256		io.Copy(&snapshot, ringBuffer)
2257		err = &smithy.DeserializationError{
2258			Err:      fmt.Errorf("failed to decode response body, %w", err),
2259			Snapshot: snapshot.Bytes(),
2260		}
2261		return out, metadata, err
2262	}
2263
2264	err = awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(&output, shape)
2265	if err != nil {
2266		var snapshot bytes.Buffer
2267		io.Copy(&snapshot, ringBuffer)
2268		err = &smithy.DeserializationError{
2269			Err:      fmt.Errorf("failed to decode response body, %w", err),
2270			Snapshot: snapshot.Bytes(),
2271		}
2272		return out, metadata, err
2273	}
2274
2275	return out, metadata, err
2276}
2277
2278func awsAwsjson11_deserializeOpErrorDescribeTaskSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2279	var errorBuffer bytes.Buffer
2280	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2281		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2282	}
2283	errorBody := bytes.NewReader(errorBuffer.Bytes())
2284
2285	errorCode := "UnknownError"
2286	errorMessage := errorCode
2287
2288	code := response.Header.Get("X-Amzn-ErrorType")
2289	if len(code) != 0 {
2290		errorCode = restjson.SanitizeErrorCode(code)
2291	}
2292
2293	var buff [1024]byte
2294	ringBuffer := smithyio.NewRingBuffer(buff[:])
2295
2296	body := io.TeeReader(errorBody, ringBuffer)
2297	decoder := json.NewDecoder(body)
2298	decoder.UseNumber()
2299	code, message, err := restjson.GetErrorInfo(decoder)
2300	if err != nil {
2301		var snapshot bytes.Buffer
2302		io.Copy(&snapshot, ringBuffer)
2303		err = &smithy.DeserializationError{
2304			Err:      fmt.Errorf("failed to decode response body, %w", err),
2305			Snapshot: snapshot.Bytes(),
2306		}
2307		return err
2308	}
2309
2310	errorBody.Seek(0, io.SeekStart)
2311	if len(code) != 0 {
2312		errorCode = restjson.SanitizeErrorCode(code)
2313	}
2314	if len(message) != 0 {
2315		errorMessage = message
2316	}
2317
2318	switch {
2319	case strings.EqualFold("AccessDeniedException", errorCode):
2320		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2321
2322	case strings.EqualFold("ClientException", errorCode):
2323		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2324
2325	case strings.EqualFold("ClusterNotFoundException", errorCode):
2326		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
2327
2328	case strings.EqualFold("InvalidParameterException", errorCode):
2329		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2330
2331	case strings.EqualFold("ServerException", errorCode):
2332		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2333
2334	case strings.EqualFold("ServiceNotActiveException", errorCode):
2335		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
2336
2337	case strings.EqualFold("ServiceNotFoundException", errorCode):
2338		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
2339
2340	case strings.EqualFold("UnsupportedFeatureException", errorCode):
2341		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
2342
2343	default:
2344		genericError := &smithy.GenericAPIError{
2345			Code:    errorCode,
2346			Message: errorMessage,
2347		}
2348		return genericError
2349
2350	}
2351}
2352
2353type awsAwsjson11_deserializeOpDiscoverPollEndpoint struct {
2354}
2355
2356func (*awsAwsjson11_deserializeOpDiscoverPollEndpoint) ID() string {
2357	return "OperationDeserializer"
2358}
2359
2360func (m *awsAwsjson11_deserializeOpDiscoverPollEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2361	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2362) {
2363	out, metadata, err = next.HandleDeserialize(ctx, in)
2364	if err != nil {
2365		return out, metadata, err
2366	}
2367
2368	response, ok := out.RawResponse.(*smithyhttp.Response)
2369	if !ok {
2370		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2371	}
2372
2373	if response.StatusCode < 200 || response.StatusCode >= 300 {
2374		return out, metadata, awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(response, &metadata)
2375	}
2376	output := &DiscoverPollEndpointOutput{}
2377	out.Result = output
2378
2379	var buff [1024]byte
2380	ringBuffer := smithyio.NewRingBuffer(buff[:])
2381
2382	body := io.TeeReader(response.Body, ringBuffer)
2383	decoder := json.NewDecoder(body)
2384	decoder.UseNumber()
2385	var shape interface{}
2386	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2387		var snapshot bytes.Buffer
2388		io.Copy(&snapshot, ringBuffer)
2389		err = &smithy.DeserializationError{
2390			Err:      fmt.Errorf("failed to decode response body, %w", err),
2391			Snapshot: snapshot.Bytes(),
2392		}
2393		return out, metadata, err
2394	}
2395
2396	err = awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(&output, shape)
2397	if err != nil {
2398		var snapshot bytes.Buffer
2399		io.Copy(&snapshot, ringBuffer)
2400		err = &smithy.DeserializationError{
2401			Err:      fmt.Errorf("failed to decode response body, %w", err),
2402			Snapshot: snapshot.Bytes(),
2403		}
2404		return out, metadata, err
2405	}
2406
2407	return out, metadata, err
2408}
2409
2410func awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2411	var errorBuffer bytes.Buffer
2412	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2413		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2414	}
2415	errorBody := bytes.NewReader(errorBuffer.Bytes())
2416
2417	errorCode := "UnknownError"
2418	errorMessage := errorCode
2419
2420	code := response.Header.Get("X-Amzn-ErrorType")
2421	if len(code) != 0 {
2422		errorCode = restjson.SanitizeErrorCode(code)
2423	}
2424
2425	var buff [1024]byte
2426	ringBuffer := smithyio.NewRingBuffer(buff[:])
2427
2428	body := io.TeeReader(errorBody, ringBuffer)
2429	decoder := json.NewDecoder(body)
2430	decoder.UseNumber()
2431	code, message, err := restjson.GetErrorInfo(decoder)
2432	if err != nil {
2433		var snapshot bytes.Buffer
2434		io.Copy(&snapshot, ringBuffer)
2435		err = &smithy.DeserializationError{
2436			Err:      fmt.Errorf("failed to decode response body, %w", err),
2437			Snapshot: snapshot.Bytes(),
2438		}
2439		return err
2440	}
2441
2442	errorBody.Seek(0, io.SeekStart)
2443	if len(code) != 0 {
2444		errorCode = restjson.SanitizeErrorCode(code)
2445	}
2446	if len(message) != 0 {
2447		errorMessage = message
2448	}
2449
2450	switch {
2451	case strings.EqualFold("ClientException", errorCode):
2452		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2453
2454	case strings.EqualFold("ServerException", errorCode):
2455		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2456
2457	default:
2458		genericError := &smithy.GenericAPIError{
2459			Code:    errorCode,
2460			Message: errorMessage,
2461		}
2462		return genericError
2463
2464	}
2465}
2466
2467type awsAwsjson11_deserializeOpExecuteCommand struct {
2468}
2469
2470func (*awsAwsjson11_deserializeOpExecuteCommand) ID() string {
2471	return "OperationDeserializer"
2472}
2473
2474func (m *awsAwsjson11_deserializeOpExecuteCommand) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2475	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2476) {
2477	out, metadata, err = next.HandleDeserialize(ctx, in)
2478	if err != nil {
2479		return out, metadata, err
2480	}
2481
2482	response, ok := out.RawResponse.(*smithyhttp.Response)
2483	if !ok {
2484		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2485	}
2486
2487	if response.StatusCode < 200 || response.StatusCode >= 300 {
2488		return out, metadata, awsAwsjson11_deserializeOpErrorExecuteCommand(response, &metadata)
2489	}
2490	output := &ExecuteCommandOutput{}
2491	out.Result = output
2492
2493	var buff [1024]byte
2494	ringBuffer := smithyio.NewRingBuffer(buff[:])
2495
2496	body := io.TeeReader(response.Body, ringBuffer)
2497	decoder := json.NewDecoder(body)
2498	decoder.UseNumber()
2499	var shape interface{}
2500	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2501		var snapshot bytes.Buffer
2502		io.Copy(&snapshot, ringBuffer)
2503		err = &smithy.DeserializationError{
2504			Err:      fmt.Errorf("failed to decode response body, %w", err),
2505			Snapshot: snapshot.Bytes(),
2506		}
2507		return out, metadata, err
2508	}
2509
2510	err = awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(&output, shape)
2511	if err != nil {
2512		var snapshot bytes.Buffer
2513		io.Copy(&snapshot, ringBuffer)
2514		err = &smithy.DeserializationError{
2515			Err:      fmt.Errorf("failed to decode response body, %w", err),
2516			Snapshot: snapshot.Bytes(),
2517		}
2518		return out, metadata, err
2519	}
2520
2521	return out, metadata, err
2522}
2523
2524func awsAwsjson11_deserializeOpErrorExecuteCommand(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2525	var errorBuffer bytes.Buffer
2526	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2527		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2528	}
2529	errorBody := bytes.NewReader(errorBuffer.Bytes())
2530
2531	errorCode := "UnknownError"
2532	errorMessage := errorCode
2533
2534	code := response.Header.Get("X-Amzn-ErrorType")
2535	if len(code) != 0 {
2536		errorCode = restjson.SanitizeErrorCode(code)
2537	}
2538
2539	var buff [1024]byte
2540	ringBuffer := smithyio.NewRingBuffer(buff[:])
2541
2542	body := io.TeeReader(errorBody, ringBuffer)
2543	decoder := json.NewDecoder(body)
2544	decoder.UseNumber()
2545	code, message, err := restjson.GetErrorInfo(decoder)
2546	if err != nil {
2547		var snapshot bytes.Buffer
2548		io.Copy(&snapshot, ringBuffer)
2549		err = &smithy.DeserializationError{
2550			Err:      fmt.Errorf("failed to decode response body, %w", err),
2551			Snapshot: snapshot.Bytes(),
2552		}
2553		return err
2554	}
2555
2556	errorBody.Seek(0, io.SeekStart)
2557	if len(code) != 0 {
2558		errorCode = restjson.SanitizeErrorCode(code)
2559	}
2560	if len(message) != 0 {
2561		errorMessage = message
2562	}
2563
2564	switch {
2565	case strings.EqualFold("AccessDeniedException", errorCode):
2566		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2567
2568	case strings.EqualFold("ClientException", errorCode):
2569		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2570
2571	case strings.EqualFold("ClusterNotFoundException", errorCode):
2572		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
2573
2574	case strings.EqualFold("InvalidParameterException", errorCode):
2575		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2576
2577	case strings.EqualFold("ServerException", errorCode):
2578		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2579
2580	case strings.EqualFold("TargetNotConnectedException", errorCode):
2581		return awsAwsjson11_deserializeErrorTargetNotConnectedException(response, errorBody)
2582
2583	default:
2584		genericError := &smithy.GenericAPIError{
2585			Code:    errorCode,
2586			Message: errorMessage,
2587		}
2588		return genericError
2589
2590	}
2591}
2592
2593type awsAwsjson11_deserializeOpListAccountSettings struct {
2594}
2595
2596func (*awsAwsjson11_deserializeOpListAccountSettings) ID() string {
2597	return "OperationDeserializer"
2598}
2599
2600func (m *awsAwsjson11_deserializeOpListAccountSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2601	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2602) {
2603	out, metadata, err = next.HandleDeserialize(ctx, in)
2604	if err != nil {
2605		return out, metadata, err
2606	}
2607
2608	response, ok := out.RawResponse.(*smithyhttp.Response)
2609	if !ok {
2610		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2611	}
2612
2613	if response.StatusCode < 200 || response.StatusCode >= 300 {
2614		return out, metadata, awsAwsjson11_deserializeOpErrorListAccountSettings(response, &metadata)
2615	}
2616	output := &ListAccountSettingsOutput{}
2617	out.Result = output
2618
2619	var buff [1024]byte
2620	ringBuffer := smithyio.NewRingBuffer(buff[:])
2621
2622	body := io.TeeReader(response.Body, ringBuffer)
2623	decoder := json.NewDecoder(body)
2624	decoder.UseNumber()
2625	var shape interface{}
2626	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2627		var snapshot bytes.Buffer
2628		io.Copy(&snapshot, ringBuffer)
2629		err = &smithy.DeserializationError{
2630			Err:      fmt.Errorf("failed to decode response body, %w", err),
2631			Snapshot: snapshot.Bytes(),
2632		}
2633		return out, metadata, err
2634	}
2635
2636	err = awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(&output, shape)
2637	if err != nil {
2638		var snapshot bytes.Buffer
2639		io.Copy(&snapshot, ringBuffer)
2640		err = &smithy.DeserializationError{
2641			Err:      fmt.Errorf("failed to decode response body, %w", err),
2642			Snapshot: snapshot.Bytes(),
2643		}
2644		return out, metadata, err
2645	}
2646
2647	return out, metadata, err
2648}
2649
2650func awsAwsjson11_deserializeOpErrorListAccountSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2651	var errorBuffer bytes.Buffer
2652	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2653		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2654	}
2655	errorBody := bytes.NewReader(errorBuffer.Bytes())
2656
2657	errorCode := "UnknownError"
2658	errorMessage := errorCode
2659
2660	code := response.Header.Get("X-Amzn-ErrorType")
2661	if len(code) != 0 {
2662		errorCode = restjson.SanitizeErrorCode(code)
2663	}
2664
2665	var buff [1024]byte
2666	ringBuffer := smithyio.NewRingBuffer(buff[:])
2667
2668	body := io.TeeReader(errorBody, ringBuffer)
2669	decoder := json.NewDecoder(body)
2670	decoder.UseNumber()
2671	code, message, err := restjson.GetErrorInfo(decoder)
2672	if err != nil {
2673		var snapshot bytes.Buffer
2674		io.Copy(&snapshot, ringBuffer)
2675		err = &smithy.DeserializationError{
2676			Err:      fmt.Errorf("failed to decode response body, %w", err),
2677			Snapshot: snapshot.Bytes(),
2678		}
2679		return err
2680	}
2681
2682	errorBody.Seek(0, io.SeekStart)
2683	if len(code) != 0 {
2684		errorCode = restjson.SanitizeErrorCode(code)
2685	}
2686	if len(message) != 0 {
2687		errorMessage = message
2688	}
2689
2690	switch {
2691	case strings.EqualFold("ClientException", errorCode):
2692		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2693
2694	case strings.EqualFold("InvalidParameterException", errorCode):
2695		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2696
2697	case strings.EqualFold("ServerException", errorCode):
2698		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2699
2700	default:
2701		genericError := &smithy.GenericAPIError{
2702			Code:    errorCode,
2703			Message: errorMessage,
2704		}
2705		return genericError
2706
2707	}
2708}
2709
2710type awsAwsjson11_deserializeOpListAttributes struct {
2711}
2712
2713func (*awsAwsjson11_deserializeOpListAttributes) ID() string {
2714	return "OperationDeserializer"
2715}
2716
2717func (m *awsAwsjson11_deserializeOpListAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2718	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2719) {
2720	out, metadata, err = next.HandleDeserialize(ctx, in)
2721	if err != nil {
2722		return out, metadata, err
2723	}
2724
2725	response, ok := out.RawResponse.(*smithyhttp.Response)
2726	if !ok {
2727		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2728	}
2729
2730	if response.StatusCode < 200 || response.StatusCode >= 300 {
2731		return out, metadata, awsAwsjson11_deserializeOpErrorListAttributes(response, &metadata)
2732	}
2733	output := &ListAttributesOutput{}
2734	out.Result = output
2735
2736	var buff [1024]byte
2737	ringBuffer := smithyio.NewRingBuffer(buff[:])
2738
2739	body := io.TeeReader(response.Body, ringBuffer)
2740	decoder := json.NewDecoder(body)
2741	decoder.UseNumber()
2742	var shape interface{}
2743	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2744		var snapshot bytes.Buffer
2745		io.Copy(&snapshot, ringBuffer)
2746		err = &smithy.DeserializationError{
2747			Err:      fmt.Errorf("failed to decode response body, %w", err),
2748			Snapshot: snapshot.Bytes(),
2749		}
2750		return out, metadata, err
2751	}
2752
2753	err = awsAwsjson11_deserializeOpDocumentListAttributesOutput(&output, shape)
2754	if err != nil {
2755		var snapshot bytes.Buffer
2756		io.Copy(&snapshot, ringBuffer)
2757		err = &smithy.DeserializationError{
2758			Err:      fmt.Errorf("failed to decode response body, %w", err),
2759			Snapshot: snapshot.Bytes(),
2760		}
2761		return out, metadata, err
2762	}
2763
2764	return out, metadata, err
2765}
2766
2767func awsAwsjson11_deserializeOpErrorListAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2768	var errorBuffer bytes.Buffer
2769	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2770		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2771	}
2772	errorBody := bytes.NewReader(errorBuffer.Bytes())
2773
2774	errorCode := "UnknownError"
2775	errorMessage := errorCode
2776
2777	code := response.Header.Get("X-Amzn-ErrorType")
2778	if len(code) != 0 {
2779		errorCode = restjson.SanitizeErrorCode(code)
2780	}
2781
2782	var buff [1024]byte
2783	ringBuffer := smithyio.NewRingBuffer(buff[:])
2784
2785	body := io.TeeReader(errorBody, ringBuffer)
2786	decoder := json.NewDecoder(body)
2787	decoder.UseNumber()
2788	code, message, err := restjson.GetErrorInfo(decoder)
2789	if err != nil {
2790		var snapshot bytes.Buffer
2791		io.Copy(&snapshot, ringBuffer)
2792		err = &smithy.DeserializationError{
2793			Err:      fmt.Errorf("failed to decode response body, %w", err),
2794			Snapshot: snapshot.Bytes(),
2795		}
2796		return err
2797	}
2798
2799	errorBody.Seek(0, io.SeekStart)
2800	if len(code) != 0 {
2801		errorCode = restjson.SanitizeErrorCode(code)
2802	}
2803	if len(message) != 0 {
2804		errorMessage = message
2805	}
2806
2807	switch {
2808	case strings.EqualFold("ClusterNotFoundException", errorCode):
2809		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
2810
2811	case strings.EqualFold("InvalidParameterException", errorCode):
2812		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2813
2814	default:
2815		genericError := &smithy.GenericAPIError{
2816			Code:    errorCode,
2817			Message: errorMessage,
2818		}
2819		return genericError
2820
2821	}
2822}
2823
2824type awsAwsjson11_deserializeOpListClusters struct {
2825}
2826
2827func (*awsAwsjson11_deserializeOpListClusters) ID() string {
2828	return "OperationDeserializer"
2829}
2830
2831func (m *awsAwsjson11_deserializeOpListClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2832	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2833) {
2834	out, metadata, err = next.HandleDeserialize(ctx, in)
2835	if err != nil {
2836		return out, metadata, err
2837	}
2838
2839	response, ok := out.RawResponse.(*smithyhttp.Response)
2840	if !ok {
2841		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2842	}
2843
2844	if response.StatusCode < 200 || response.StatusCode >= 300 {
2845		return out, metadata, awsAwsjson11_deserializeOpErrorListClusters(response, &metadata)
2846	}
2847	output := &ListClustersOutput{}
2848	out.Result = output
2849
2850	var buff [1024]byte
2851	ringBuffer := smithyio.NewRingBuffer(buff[:])
2852
2853	body := io.TeeReader(response.Body, ringBuffer)
2854	decoder := json.NewDecoder(body)
2855	decoder.UseNumber()
2856	var shape interface{}
2857	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2858		var snapshot bytes.Buffer
2859		io.Copy(&snapshot, ringBuffer)
2860		err = &smithy.DeserializationError{
2861			Err:      fmt.Errorf("failed to decode response body, %w", err),
2862			Snapshot: snapshot.Bytes(),
2863		}
2864		return out, metadata, err
2865	}
2866
2867	err = awsAwsjson11_deserializeOpDocumentListClustersOutput(&output, shape)
2868	if err != nil {
2869		var snapshot bytes.Buffer
2870		io.Copy(&snapshot, ringBuffer)
2871		err = &smithy.DeserializationError{
2872			Err:      fmt.Errorf("failed to decode response body, %w", err),
2873			Snapshot: snapshot.Bytes(),
2874		}
2875		return out, metadata, err
2876	}
2877
2878	return out, metadata, err
2879}
2880
2881func awsAwsjson11_deserializeOpErrorListClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2882	var errorBuffer bytes.Buffer
2883	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2884		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2885	}
2886	errorBody := bytes.NewReader(errorBuffer.Bytes())
2887
2888	errorCode := "UnknownError"
2889	errorMessage := errorCode
2890
2891	code := response.Header.Get("X-Amzn-ErrorType")
2892	if len(code) != 0 {
2893		errorCode = restjson.SanitizeErrorCode(code)
2894	}
2895
2896	var buff [1024]byte
2897	ringBuffer := smithyio.NewRingBuffer(buff[:])
2898
2899	body := io.TeeReader(errorBody, ringBuffer)
2900	decoder := json.NewDecoder(body)
2901	decoder.UseNumber()
2902	code, message, err := restjson.GetErrorInfo(decoder)
2903	if err != nil {
2904		var snapshot bytes.Buffer
2905		io.Copy(&snapshot, ringBuffer)
2906		err = &smithy.DeserializationError{
2907			Err:      fmt.Errorf("failed to decode response body, %w", err),
2908			Snapshot: snapshot.Bytes(),
2909		}
2910		return err
2911	}
2912
2913	errorBody.Seek(0, io.SeekStart)
2914	if len(code) != 0 {
2915		errorCode = restjson.SanitizeErrorCode(code)
2916	}
2917	if len(message) != 0 {
2918		errorMessage = message
2919	}
2920
2921	switch {
2922	case strings.EqualFold("ClientException", errorCode):
2923		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
2924
2925	case strings.EqualFold("InvalidParameterException", errorCode):
2926		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2927
2928	case strings.EqualFold("ServerException", errorCode):
2929		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
2930
2931	default:
2932		genericError := &smithy.GenericAPIError{
2933			Code:    errorCode,
2934			Message: errorMessage,
2935		}
2936		return genericError
2937
2938	}
2939}
2940
2941type awsAwsjson11_deserializeOpListContainerInstances struct {
2942}
2943
2944func (*awsAwsjson11_deserializeOpListContainerInstances) ID() string {
2945	return "OperationDeserializer"
2946}
2947
2948func (m *awsAwsjson11_deserializeOpListContainerInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2949	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2950) {
2951	out, metadata, err = next.HandleDeserialize(ctx, in)
2952	if err != nil {
2953		return out, metadata, err
2954	}
2955
2956	response, ok := out.RawResponse.(*smithyhttp.Response)
2957	if !ok {
2958		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2959	}
2960
2961	if response.StatusCode < 200 || response.StatusCode >= 300 {
2962		return out, metadata, awsAwsjson11_deserializeOpErrorListContainerInstances(response, &metadata)
2963	}
2964	output := &ListContainerInstancesOutput{}
2965	out.Result = output
2966
2967	var buff [1024]byte
2968	ringBuffer := smithyio.NewRingBuffer(buff[:])
2969
2970	body := io.TeeReader(response.Body, ringBuffer)
2971	decoder := json.NewDecoder(body)
2972	decoder.UseNumber()
2973	var shape interface{}
2974	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2975		var snapshot bytes.Buffer
2976		io.Copy(&snapshot, ringBuffer)
2977		err = &smithy.DeserializationError{
2978			Err:      fmt.Errorf("failed to decode response body, %w", err),
2979			Snapshot: snapshot.Bytes(),
2980		}
2981		return out, metadata, err
2982	}
2983
2984	err = awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(&output, shape)
2985	if err != nil {
2986		var snapshot bytes.Buffer
2987		io.Copy(&snapshot, ringBuffer)
2988		err = &smithy.DeserializationError{
2989			Err:      fmt.Errorf("failed to decode response body, %w", err),
2990			Snapshot: snapshot.Bytes(),
2991		}
2992		return out, metadata, err
2993	}
2994
2995	return out, metadata, err
2996}
2997
2998func awsAwsjson11_deserializeOpErrorListContainerInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2999	var errorBuffer bytes.Buffer
3000	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3001		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3002	}
3003	errorBody := bytes.NewReader(errorBuffer.Bytes())
3004
3005	errorCode := "UnknownError"
3006	errorMessage := errorCode
3007
3008	code := response.Header.Get("X-Amzn-ErrorType")
3009	if len(code) != 0 {
3010		errorCode = restjson.SanitizeErrorCode(code)
3011	}
3012
3013	var buff [1024]byte
3014	ringBuffer := smithyio.NewRingBuffer(buff[:])
3015
3016	body := io.TeeReader(errorBody, ringBuffer)
3017	decoder := json.NewDecoder(body)
3018	decoder.UseNumber()
3019	code, message, err := restjson.GetErrorInfo(decoder)
3020	if err != nil {
3021		var snapshot bytes.Buffer
3022		io.Copy(&snapshot, ringBuffer)
3023		err = &smithy.DeserializationError{
3024			Err:      fmt.Errorf("failed to decode response body, %w", err),
3025			Snapshot: snapshot.Bytes(),
3026		}
3027		return err
3028	}
3029
3030	errorBody.Seek(0, io.SeekStart)
3031	if len(code) != 0 {
3032		errorCode = restjson.SanitizeErrorCode(code)
3033	}
3034	if len(message) != 0 {
3035		errorMessage = message
3036	}
3037
3038	switch {
3039	case strings.EqualFold("ClientException", errorCode):
3040		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3041
3042	case strings.EqualFold("ClusterNotFoundException", errorCode):
3043		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
3044
3045	case strings.EqualFold("InvalidParameterException", errorCode):
3046		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3047
3048	case strings.EqualFold("ServerException", errorCode):
3049		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3050
3051	default:
3052		genericError := &smithy.GenericAPIError{
3053			Code:    errorCode,
3054			Message: errorMessage,
3055		}
3056		return genericError
3057
3058	}
3059}
3060
3061type awsAwsjson11_deserializeOpListServices struct {
3062}
3063
3064func (*awsAwsjson11_deserializeOpListServices) ID() string {
3065	return "OperationDeserializer"
3066}
3067
3068func (m *awsAwsjson11_deserializeOpListServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3069	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3070) {
3071	out, metadata, err = next.HandleDeserialize(ctx, in)
3072	if err != nil {
3073		return out, metadata, err
3074	}
3075
3076	response, ok := out.RawResponse.(*smithyhttp.Response)
3077	if !ok {
3078		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3079	}
3080
3081	if response.StatusCode < 200 || response.StatusCode >= 300 {
3082		return out, metadata, awsAwsjson11_deserializeOpErrorListServices(response, &metadata)
3083	}
3084	output := &ListServicesOutput{}
3085	out.Result = output
3086
3087	var buff [1024]byte
3088	ringBuffer := smithyio.NewRingBuffer(buff[:])
3089
3090	body := io.TeeReader(response.Body, ringBuffer)
3091	decoder := json.NewDecoder(body)
3092	decoder.UseNumber()
3093	var shape interface{}
3094	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3095		var snapshot bytes.Buffer
3096		io.Copy(&snapshot, ringBuffer)
3097		err = &smithy.DeserializationError{
3098			Err:      fmt.Errorf("failed to decode response body, %w", err),
3099			Snapshot: snapshot.Bytes(),
3100		}
3101		return out, metadata, err
3102	}
3103
3104	err = awsAwsjson11_deserializeOpDocumentListServicesOutput(&output, shape)
3105	if err != nil {
3106		var snapshot bytes.Buffer
3107		io.Copy(&snapshot, ringBuffer)
3108		err = &smithy.DeserializationError{
3109			Err:      fmt.Errorf("failed to decode response body, %w", err),
3110			Snapshot: snapshot.Bytes(),
3111		}
3112		return out, metadata, err
3113	}
3114
3115	return out, metadata, err
3116}
3117
3118func awsAwsjson11_deserializeOpErrorListServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3119	var errorBuffer bytes.Buffer
3120	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3121		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3122	}
3123	errorBody := bytes.NewReader(errorBuffer.Bytes())
3124
3125	errorCode := "UnknownError"
3126	errorMessage := errorCode
3127
3128	code := response.Header.Get("X-Amzn-ErrorType")
3129	if len(code) != 0 {
3130		errorCode = restjson.SanitizeErrorCode(code)
3131	}
3132
3133	var buff [1024]byte
3134	ringBuffer := smithyio.NewRingBuffer(buff[:])
3135
3136	body := io.TeeReader(errorBody, ringBuffer)
3137	decoder := json.NewDecoder(body)
3138	decoder.UseNumber()
3139	code, message, err := restjson.GetErrorInfo(decoder)
3140	if err != nil {
3141		var snapshot bytes.Buffer
3142		io.Copy(&snapshot, ringBuffer)
3143		err = &smithy.DeserializationError{
3144			Err:      fmt.Errorf("failed to decode response body, %w", err),
3145			Snapshot: snapshot.Bytes(),
3146		}
3147		return err
3148	}
3149
3150	errorBody.Seek(0, io.SeekStart)
3151	if len(code) != 0 {
3152		errorCode = restjson.SanitizeErrorCode(code)
3153	}
3154	if len(message) != 0 {
3155		errorMessage = message
3156	}
3157
3158	switch {
3159	case strings.EqualFold("ClientException", errorCode):
3160		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3161
3162	case strings.EqualFold("ClusterNotFoundException", errorCode):
3163		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
3164
3165	case strings.EqualFold("InvalidParameterException", errorCode):
3166		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3167
3168	case strings.EqualFold("ServerException", errorCode):
3169		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3170
3171	default:
3172		genericError := &smithy.GenericAPIError{
3173			Code:    errorCode,
3174			Message: errorMessage,
3175		}
3176		return genericError
3177
3178	}
3179}
3180
3181type awsAwsjson11_deserializeOpListTagsForResource struct {
3182}
3183
3184func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
3185	return "OperationDeserializer"
3186}
3187
3188func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3189	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3190) {
3191	out, metadata, err = next.HandleDeserialize(ctx, in)
3192	if err != nil {
3193		return out, metadata, err
3194	}
3195
3196	response, ok := out.RawResponse.(*smithyhttp.Response)
3197	if !ok {
3198		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3199	}
3200
3201	if response.StatusCode < 200 || response.StatusCode >= 300 {
3202		return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
3203	}
3204	output := &ListTagsForResourceOutput{}
3205	out.Result = output
3206
3207	var buff [1024]byte
3208	ringBuffer := smithyio.NewRingBuffer(buff[:])
3209
3210	body := io.TeeReader(response.Body, ringBuffer)
3211	decoder := json.NewDecoder(body)
3212	decoder.UseNumber()
3213	var shape interface{}
3214	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3215		var snapshot bytes.Buffer
3216		io.Copy(&snapshot, ringBuffer)
3217		err = &smithy.DeserializationError{
3218			Err:      fmt.Errorf("failed to decode response body, %w", err),
3219			Snapshot: snapshot.Bytes(),
3220		}
3221		return out, metadata, err
3222	}
3223
3224	err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
3225	if err != nil {
3226		var snapshot bytes.Buffer
3227		io.Copy(&snapshot, ringBuffer)
3228		err = &smithy.DeserializationError{
3229			Err:      fmt.Errorf("failed to decode response body, %w", err),
3230			Snapshot: snapshot.Bytes(),
3231		}
3232		return out, metadata, err
3233	}
3234
3235	return out, metadata, err
3236}
3237
3238func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3239	var errorBuffer bytes.Buffer
3240	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3241		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3242	}
3243	errorBody := bytes.NewReader(errorBuffer.Bytes())
3244
3245	errorCode := "UnknownError"
3246	errorMessage := errorCode
3247
3248	code := response.Header.Get("X-Amzn-ErrorType")
3249	if len(code) != 0 {
3250		errorCode = restjson.SanitizeErrorCode(code)
3251	}
3252
3253	var buff [1024]byte
3254	ringBuffer := smithyio.NewRingBuffer(buff[:])
3255
3256	body := io.TeeReader(errorBody, ringBuffer)
3257	decoder := json.NewDecoder(body)
3258	decoder.UseNumber()
3259	code, message, err := restjson.GetErrorInfo(decoder)
3260	if err != nil {
3261		var snapshot bytes.Buffer
3262		io.Copy(&snapshot, ringBuffer)
3263		err = &smithy.DeserializationError{
3264			Err:      fmt.Errorf("failed to decode response body, %w", err),
3265			Snapshot: snapshot.Bytes(),
3266		}
3267		return err
3268	}
3269
3270	errorBody.Seek(0, io.SeekStart)
3271	if len(code) != 0 {
3272		errorCode = restjson.SanitizeErrorCode(code)
3273	}
3274	if len(message) != 0 {
3275		errorMessage = message
3276	}
3277
3278	switch {
3279	case strings.EqualFold("ClientException", errorCode):
3280		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3281
3282	case strings.EqualFold("ClusterNotFoundException", errorCode):
3283		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
3284
3285	case strings.EqualFold("InvalidParameterException", errorCode):
3286		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3287
3288	case strings.EqualFold("ServerException", errorCode):
3289		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3290
3291	default:
3292		genericError := &smithy.GenericAPIError{
3293			Code:    errorCode,
3294			Message: errorMessage,
3295		}
3296		return genericError
3297
3298	}
3299}
3300
3301type awsAwsjson11_deserializeOpListTaskDefinitionFamilies struct {
3302}
3303
3304func (*awsAwsjson11_deserializeOpListTaskDefinitionFamilies) ID() string {
3305	return "OperationDeserializer"
3306}
3307
3308func (m *awsAwsjson11_deserializeOpListTaskDefinitionFamilies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3309	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3310) {
3311	out, metadata, err = next.HandleDeserialize(ctx, in)
3312	if err != nil {
3313		return out, metadata, err
3314	}
3315
3316	response, ok := out.RawResponse.(*smithyhttp.Response)
3317	if !ok {
3318		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3319	}
3320
3321	if response.StatusCode < 200 || response.StatusCode >= 300 {
3322		return out, metadata, awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(response, &metadata)
3323	}
3324	output := &ListTaskDefinitionFamiliesOutput{}
3325	out.Result = output
3326
3327	var buff [1024]byte
3328	ringBuffer := smithyio.NewRingBuffer(buff[:])
3329
3330	body := io.TeeReader(response.Body, ringBuffer)
3331	decoder := json.NewDecoder(body)
3332	decoder.UseNumber()
3333	var shape interface{}
3334	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3335		var snapshot bytes.Buffer
3336		io.Copy(&snapshot, ringBuffer)
3337		err = &smithy.DeserializationError{
3338			Err:      fmt.Errorf("failed to decode response body, %w", err),
3339			Snapshot: snapshot.Bytes(),
3340		}
3341		return out, metadata, err
3342	}
3343
3344	err = awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(&output, shape)
3345	if err != nil {
3346		var snapshot bytes.Buffer
3347		io.Copy(&snapshot, ringBuffer)
3348		err = &smithy.DeserializationError{
3349			Err:      fmt.Errorf("failed to decode response body, %w", err),
3350			Snapshot: snapshot.Bytes(),
3351		}
3352		return out, metadata, err
3353	}
3354
3355	return out, metadata, err
3356}
3357
3358func awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3359	var errorBuffer bytes.Buffer
3360	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3361		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3362	}
3363	errorBody := bytes.NewReader(errorBuffer.Bytes())
3364
3365	errorCode := "UnknownError"
3366	errorMessage := errorCode
3367
3368	code := response.Header.Get("X-Amzn-ErrorType")
3369	if len(code) != 0 {
3370		errorCode = restjson.SanitizeErrorCode(code)
3371	}
3372
3373	var buff [1024]byte
3374	ringBuffer := smithyio.NewRingBuffer(buff[:])
3375
3376	body := io.TeeReader(errorBody, ringBuffer)
3377	decoder := json.NewDecoder(body)
3378	decoder.UseNumber()
3379	code, message, err := restjson.GetErrorInfo(decoder)
3380	if err != nil {
3381		var snapshot bytes.Buffer
3382		io.Copy(&snapshot, ringBuffer)
3383		err = &smithy.DeserializationError{
3384			Err:      fmt.Errorf("failed to decode response body, %w", err),
3385			Snapshot: snapshot.Bytes(),
3386		}
3387		return err
3388	}
3389
3390	errorBody.Seek(0, io.SeekStart)
3391	if len(code) != 0 {
3392		errorCode = restjson.SanitizeErrorCode(code)
3393	}
3394	if len(message) != 0 {
3395		errorMessage = message
3396	}
3397
3398	switch {
3399	case strings.EqualFold("ClientException", errorCode):
3400		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3401
3402	case strings.EqualFold("InvalidParameterException", errorCode):
3403		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3404
3405	case strings.EqualFold("ServerException", errorCode):
3406		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3407
3408	default:
3409		genericError := &smithy.GenericAPIError{
3410			Code:    errorCode,
3411			Message: errorMessage,
3412		}
3413		return genericError
3414
3415	}
3416}
3417
3418type awsAwsjson11_deserializeOpListTaskDefinitions struct {
3419}
3420
3421func (*awsAwsjson11_deserializeOpListTaskDefinitions) ID() string {
3422	return "OperationDeserializer"
3423}
3424
3425func (m *awsAwsjson11_deserializeOpListTaskDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3426	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3427) {
3428	out, metadata, err = next.HandleDeserialize(ctx, in)
3429	if err != nil {
3430		return out, metadata, err
3431	}
3432
3433	response, ok := out.RawResponse.(*smithyhttp.Response)
3434	if !ok {
3435		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3436	}
3437
3438	if response.StatusCode < 200 || response.StatusCode >= 300 {
3439		return out, metadata, awsAwsjson11_deserializeOpErrorListTaskDefinitions(response, &metadata)
3440	}
3441	output := &ListTaskDefinitionsOutput{}
3442	out.Result = output
3443
3444	var buff [1024]byte
3445	ringBuffer := smithyio.NewRingBuffer(buff[:])
3446
3447	body := io.TeeReader(response.Body, ringBuffer)
3448	decoder := json.NewDecoder(body)
3449	decoder.UseNumber()
3450	var shape interface{}
3451	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3452		var snapshot bytes.Buffer
3453		io.Copy(&snapshot, ringBuffer)
3454		err = &smithy.DeserializationError{
3455			Err:      fmt.Errorf("failed to decode response body, %w", err),
3456			Snapshot: snapshot.Bytes(),
3457		}
3458		return out, metadata, err
3459	}
3460
3461	err = awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(&output, shape)
3462	if err != nil {
3463		var snapshot bytes.Buffer
3464		io.Copy(&snapshot, ringBuffer)
3465		err = &smithy.DeserializationError{
3466			Err:      fmt.Errorf("failed to decode response body, %w", err),
3467			Snapshot: snapshot.Bytes(),
3468		}
3469		return out, metadata, err
3470	}
3471
3472	return out, metadata, err
3473}
3474
3475func awsAwsjson11_deserializeOpErrorListTaskDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3476	var errorBuffer bytes.Buffer
3477	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3478		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3479	}
3480	errorBody := bytes.NewReader(errorBuffer.Bytes())
3481
3482	errorCode := "UnknownError"
3483	errorMessage := errorCode
3484
3485	code := response.Header.Get("X-Amzn-ErrorType")
3486	if len(code) != 0 {
3487		errorCode = restjson.SanitizeErrorCode(code)
3488	}
3489
3490	var buff [1024]byte
3491	ringBuffer := smithyio.NewRingBuffer(buff[:])
3492
3493	body := io.TeeReader(errorBody, ringBuffer)
3494	decoder := json.NewDecoder(body)
3495	decoder.UseNumber()
3496	code, message, err := restjson.GetErrorInfo(decoder)
3497	if err != nil {
3498		var snapshot bytes.Buffer
3499		io.Copy(&snapshot, ringBuffer)
3500		err = &smithy.DeserializationError{
3501			Err:      fmt.Errorf("failed to decode response body, %w", err),
3502			Snapshot: snapshot.Bytes(),
3503		}
3504		return err
3505	}
3506
3507	errorBody.Seek(0, io.SeekStart)
3508	if len(code) != 0 {
3509		errorCode = restjson.SanitizeErrorCode(code)
3510	}
3511	if len(message) != 0 {
3512		errorMessage = message
3513	}
3514
3515	switch {
3516	case strings.EqualFold("ClientException", errorCode):
3517		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3518
3519	case strings.EqualFold("InvalidParameterException", errorCode):
3520		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3521
3522	case strings.EqualFold("ServerException", errorCode):
3523		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3524
3525	default:
3526		genericError := &smithy.GenericAPIError{
3527			Code:    errorCode,
3528			Message: errorMessage,
3529		}
3530		return genericError
3531
3532	}
3533}
3534
3535type awsAwsjson11_deserializeOpListTasks struct {
3536}
3537
3538func (*awsAwsjson11_deserializeOpListTasks) ID() string {
3539	return "OperationDeserializer"
3540}
3541
3542func (m *awsAwsjson11_deserializeOpListTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3543	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3544) {
3545	out, metadata, err = next.HandleDeserialize(ctx, in)
3546	if err != nil {
3547		return out, metadata, err
3548	}
3549
3550	response, ok := out.RawResponse.(*smithyhttp.Response)
3551	if !ok {
3552		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3553	}
3554
3555	if response.StatusCode < 200 || response.StatusCode >= 300 {
3556		return out, metadata, awsAwsjson11_deserializeOpErrorListTasks(response, &metadata)
3557	}
3558	output := &ListTasksOutput{}
3559	out.Result = output
3560
3561	var buff [1024]byte
3562	ringBuffer := smithyio.NewRingBuffer(buff[:])
3563
3564	body := io.TeeReader(response.Body, ringBuffer)
3565	decoder := json.NewDecoder(body)
3566	decoder.UseNumber()
3567	var shape interface{}
3568	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3569		var snapshot bytes.Buffer
3570		io.Copy(&snapshot, ringBuffer)
3571		err = &smithy.DeserializationError{
3572			Err:      fmt.Errorf("failed to decode response body, %w", err),
3573			Snapshot: snapshot.Bytes(),
3574		}
3575		return out, metadata, err
3576	}
3577
3578	err = awsAwsjson11_deserializeOpDocumentListTasksOutput(&output, shape)
3579	if err != nil {
3580		var snapshot bytes.Buffer
3581		io.Copy(&snapshot, ringBuffer)
3582		err = &smithy.DeserializationError{
3583			Err:      fmt.Errorf("failed to decode response body, %w", err),
3584			Snapshot: snapshot.Bytes(),
3585		}
3586		return out, metadata, err
3587	}
3588
3589	return out, metadata, err
3590}
3591
3592func awsAwsjson11_deserializeOpErrorListTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3593	var errorBuffer bytes.Buffer
3594	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3595		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3596	}
3597	errorBody := bytes.NewReader(errorBuffer.Bytes())
3598
3599	errorCode := "UnknownError"
3600	errorMessage := errorCode
3601
3602	code := response.Header.Get("X-Amzn-ErrorType")
3603	if len(code) != 0 {
3604		errorCode = restjson.SanitizeErrorCode(code)
3605	}
3606
3607	var buff [1024]byte
3608	ringBuffer := smithyio.NewRingBuffer(buff[:])
3609
3610	body := io.TeeReader(errorBody, ringBuffer)
3611	decoder := json.NewDecoder(body)
3612	decoder.UseNumber()
3613	code, message, err := restjson.GetErrorInfo(decoder)
3614	if err != nil {
3615		var snapshot bytes.Buffer
3616		io.Copy(&snapshot, ringBuffer)
3617		err = &smithy.DeserializationError{
3618			Err:      fmt.Errorf("failed to decode response body, %w", err),
3619			Snapshot: snapshot.Bytes(),
3620		}
3621		return err
3622	}
3623
3624	errorBody.Seek(0, io.SeekStart)
3625	if len(code) != 0 {
3626		errorCode = restjson.SanitizeErrorCode(code)
3627	}
3628	if len(message) != 0 {
3629		errorMessage = message
3630	}
3631
3632	switch {
3633	case strings.EqualFold("ClientException", errorCode):
3634		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3635
3636	case strings.EqualFold("ClusterNotFoundException", errorCode):
3637		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
3638
3639	case strings.EqualFold("InvalidParameterException", errorCode):
3640		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3641
3642	case strings.EqualFold("ServerException", errorCode):
3643		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3644
3645	case strings.EqualFold("ServiceNotFoundException", errorCode):
3646		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
3647
3648	default:
3649		genericError := &smithy.GenericAPIError{
3650			Code:    errorCode,
3651			Message: errorMessage,
3652		}
3653		return genericError
3654
3655	}
3656}
3657
3658type awsAwsjson11_deserializeOpPutAccountSetting struct {
3659}
3660
3661func (*awsAwsjson11_deserializeOpPutAccountSetting) ID() string {
3662	return "OperationDeserializer"
3663}
3664
3665func (m *awsAwsjson11_deserializeOpPutAccountSetting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3666	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3667) {
3668	out, metadata, err = next.HandleDeserialize(ctx, in)
3669	if err != nil {
3670		return out, metadata, err
3671	}
3672
3673	response, ok := out.RawResponse.(*smithyhttp.Response)
3674	if !ok {
3675		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3676	}
3677
3678	if response.StatusCode < 200 || response.StatusCode >= 300 {
3679		return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountSetting(response, &metadata)
3680	}
3681	output := &PutAccountSettingOutput{}
3682	out.Result = output
3683
3684	var buff [1024]byte
3685	ringBuffer := smithyio.NewRingBuffer(buff[:])
3686
3687	body := io.TeeReader(response.Body, ringBuffer)
3688	decoder := json.NewDecoder(body)
3689	decoder.UseNumber()
3690	var shape interface{}
3691	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3692		var snapshot bytes.Buffer
3693		io.Copy(&snapshot, ringBuffer)
3694		err = &smithy.DeserializationError{
3695			Err:      fmt.Errorf("failed to decode response body, %w", err),
3696			Snapshot: snapshot.Bytes(),
3697		}
3698		return out, metadata, err
3699	}
3700
3701	err = awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(&output, shape)
3702	if err != nil {
3703		var snapshot bytes.Buffer
3704		io.Copy(&snapshot, ringBuffer)
3705		err = &smithy.DeserializationError{
3706			Err:      fmt.Errorf("failed to decode response body, %w", err),
3707			Snapshot: snapshot.Bytes(),
3708		}
3709		return out, metadata, err
3710	}
3711
3712	return out, metadata, err
3713}
3714
3715func awsAwsjson11_deserializeOpErrorPutAccountSetting(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3716	var errorBuffer bytes.Buffer
3717	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3718		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3719	}
3720	errorBody := bytes.NewReader(errorBuffer.Bytes())
3721
3722	errorCode := "UnknownError"
3723	errorMessage := errorCode
3724
3725	code := response.Header.Get("X-Amzn-ErrorType")
3726	if len(code) != 0 {
3727		errorCode = restjson.SanitizeErrorCode(code)
3728	}
3729
3730	var buff [1024]byte
3731	ringBuffer := smithyio.NewRingBuffer(buff[:])
3732
3733	body := io.TeeReader(errorBody, ringBuffer)
3734	decoder := json.NewDecoder(body)
3735	decoder.UseNumber()
3736	code, message, err := restjson.GetErrorInfo(decoder)
3737	if err != nil {
3738		var snapshot bytes.Buffer
3739		io.Copy(&snapshot, ringBuffer)
3740		err = &smithy.DeserializationError{
3741			Err:      fmt.Errorf("failed to decode response body, %w", err),
3742			Snapshot: snapshot.Bytes(),
3743		}
3744		return err
3745	}
3746
3747	errorBody.Seek(0, io.SeekStart)
3748	if len(code) != 0 {
3749		errorCode = restjson.SanitizeErrorCode(code)
3750	}
3751	if len(message) != 0 {
3752		errorMessage = message
3753	}
3754
3755	switch {
3756	case strings.EqualFold("ClientException", errorCode):
3757		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3758
3759	case strings.EqualFold("InvalidParameterException", errorCode):
3760		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3761
3762	case strings.EqualFold("ServerException", errorCode):
3763		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3764
3765	default:
3766		genericError := &smithy.GenericAPIError{
3767			Code:    errorCode,
3768			Message: errorMessage,
3769		}
3770		return genericError
3771
3772	}
3773}
3774
3775type awsAwsjson11_deserializeOpPutAccountSettingDefault struct {
3776}
3777
3778func (*awsAwsjson11_deserializeOpPutAccountSettingDefault) ID() string {
3779	return "OperationDeserializer"
3780}
3781
3782func (m *awsAwsjson11_deserializeOpPutAccountSettingDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3783	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3784) {
3785	out, metadata, err = next.HandleDeserialize(ctx, in)
3786	if err != nil {
3787		return out, metadata, err
3788	}
3789
3790	response, ok := out.RawResponse.(*smithyhttp.Response)
3791	if !ok {
3792		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3793	}
3794
3795	if response.StatusCode < 200 || response.StatusCode >= 300 {
3796		return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(response, &metadata)
3797	}
3798	output := &PutAccountSettingDefaultOutput{}
3799	out.Result = output
3800
3801	var buff [1024]byte
3802	ringBuffer := smithyio.NewRingBuffer(buff[:])
3803
3804	body := io.TeeReader(response.Body, ringBuffer)
3805	decoder := json.NewDecoder(body)
3806	decoder.UseNumber()
3807	var shape interface{}
3808	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3809		var snapshot bytes.Buffer
3810		io.Copy(&snapshot, ringBuffer)
3811		err = &smithy.DeserializationError{
3812			Err:      fmt.Errorf("failed to decode response body, %w", err),
3813			Snapshot: snapshot.Bytes(),
3814		}
3815		return out, metadata, err
3816	}
3817
3818	err = awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(&output, shape)
3819	if err != nil {
3820		var snapshot bytes.Buffer
3821		io.Copy(&snapshot, ringBuffer)
3822		err = &smithy.DeserializationError{
3823			Err:      fmt.Errorf("failed to decode response body, %w", err),
3824			Snapshot: snapshot.Bytes(),
3825		}
3826		return out, metadata, err
3827	}
3828
3829	return out, metadata, err
3830}
3831
3832func awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3833	var errorBuffer bytes.Buffer
3834	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3835		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3836	}
3837	errorBody := bytes.NewReader(errorBuffer.Bytes())
3838
3839	errorCode := "UnknownError"
3840	errorMessage := errorCode
3841
3842	code := response.Header.Get("X-Amzn-ErrorType")
3843	if len(code) != 0 {
3844		errorCode = restjson.SanitizeErrorCode(code)
3845	}
3846
3847	var buff [1024]byte
3848	ringBuffer := smithyio.NewRingBuffer(buff[:])
3849
3850	body := io.TeeReader(errorBody, ringBuffer)
3851	decoder := json.NewDecoder(body)
3852	decoder.UseNumber()
3853	code, message, err := restjson.GetErrorInfo(decoder)
3854	if err != nil {
3855		var snapshot bytes.Buffer
3856		io.Copy(&snapshot, ringBuffer)
3857		err = &smithy.DeserializationError{
3858			Err:      fmt.Errorf("failed to decode response body, %w", err),
3859			Snapshot: snapshot.Bytes(),
3860		}
3861		return err
3862	}
3863
3864	errorBody.Seek(0, io.SeekStart)
3865	if len(code) != 0 {
3866		errorCode = restjson.SanitizeErrorCode(code)
3867	}
3868	if len(message) != 0 {
3869		errorMessage = message
3870	}
3871
3872	switch {
3873	case strings.EqualFold("ClientException", errorCode):
3874		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
3875
3876	case strings.EqualFold("InvalidParameterException", errorCode):
3877		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3878
3879	case strings.EqualFold("ServerException", errorCode):
3880		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
3881
3882	default:
3883		genericError := &smithy.GenericAPIError{
3884			Code:    errorCode,
3885			Message: errorMessage,
3886		}
3887		return genericError
3888
3889	}
3890}
3891
3892type awsAwsjson11_deserializeOpPutAttributes struct {
3893}
3894
3895func (*awsAwsjson11_deserializeOpPutAttributes) ID() string {
3896	return "OperationDeserializer"
3897}
3898
3899func (m *awsAwsjson11_deserializeOpPutAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3900	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3901) {
3902	out, metadata, err = next.HandleDeserialize(ctx, in)
3903	if err != nil {
3904		return out, metadata, err
3905	}
3906
3907	response, ok := out.RawResponse.(*smithyhttp.Response)
3908	if !ok {
3909		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3910	}
3911
3912	if response.StatusCode < 200 || response.StatusCode >= 300 {
3913		return out, metadata, awsAwsjson11_deserializeOpErrorPutAttributes(response, &metadata)
3914	}
3915	output := &PutAttributesOutput{}
3916	out.Result = output
3917
3918	var buff [1024]byte
3919	ringBuffer := smithyio.NewRingBuffer(buff[:])
3920
3921	body := io.TeeReader(response.Body, ringBuffer)
3922	decoder := json.NewDecoder(body)
3923	decoder.UseNumber()
3924	var shape interface{}
3925	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3926		var snapshot bytes.Buffer
3927		io.Copy(&snapshot, ringBuffer)
3928		err = &smithy.DeserializationError{
3929			Err:      fmt.Errorf("failed to decode response body, %w", err),
3930			Snapshot: snapshot.Bytes(),
3931		}
3932		return out, metadata, err
3933	}
3934
3935	err = awsAwsjson11_deserializeOpDocumentPutAttributesOutput(&output, shape)
3936	if err != nil {
3937		var snapshot bytes.Buffer
3938		io.Copy(&snapshot, ringBuffer)
3939		err = &smithy.DeserializationError{
3940			Err:      fmt.Errorf("failed to decode response body, %w", err),
3941			Snapshot: snapshot.Bytes(),
3942		}
3943		return out, metadata, err
3944	}
3945
3946	return out, metadata, err
3947}
3948
3949func awsAwsjson11_deserializeOpErrorPutAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3950	var errorBuffer bytes.Buffer
3951	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3952		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3953	}
3954	errorBody := bytes.NewReader(errorBuffer.Bytes())
3955
3956	errorCode := "UnknownError"
3957	errorMessage := errorCode
3958
3959	code := response.Header.Get("X-Amzn-ErrorType")
3960	if len(code) != 0 {
3961		errorCode = restjson.SanitizeErrorCode(code)
3962	}
3963
3964	var buff [1024]byte
3965	ringBuffer := smithyio.NewRingBuffer(buff[:])
3966
3967	body := io.TeeReader(errorBody, ringBuffer)
3968	decoder := json.NewDecoder(body)
3969	decoder.UseNumber()
3970	code, message, err := restjson.GetErrorInfo(decoder)
3971	if err != nil {
3972		var snapshot bytes.Buffer
3973		io.Copy(&snapshot, ringBuffer)
3974		err = &smithy.DeserializationError{
3975			Err:      fmt.Errorf("failed to decode response body, %w", err),
3976			Snapshot: snapshot.Bytes(),
3977		}
3978		return err
3979	}
3980
3981	errorBody.Seek(0, io.SeekStart)
3982	if len(code) != 0 {
3983		errorCode = restjson.SanitizeErrorCode(code)
3984	}
3985	if len(message) != 0 {
3986		errorMessage = message
3987	}
3988
3989	switch {
3990	case strings.EqualFold("AttributeLimitExceededException", errorCode):
3991		return awsAwsjson11_deserializeErrorAttributeLimitExceededException(response, errorBody)
3992
3993	case strings.EqualFold("ClusterNotFoundException", errorCode):
3994		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
3995
3996	case strings.EqualFold("InvalidParameterException", errorCode):
3997		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3998
3999	case strings.EqualFold("TargetNotFoundException", errorCode):
4000		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
4001
4002	default:
4003		genericError := &smithy.GenericAPIError{
4004			Code:    errorCode,
4005			Message: errorMessage,
4006		}
4007		return genericError
4008
4009	}
4010}
4011
4012type awsAwsjson11_deserializeOpPutClusterCapacityProviders struct {
4013}
4014
4015func (*awsAwsjson11_deserializeOpPutClusterCapacityProviders) ID() string {
4016	return "OperationDeserializer"
4017}
4018
4019func (m *awsAwsjson11_deserializeOpPutClusterCapacityProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4020	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4021) {
4022	out, metadata, err = next.HandleDeserialize(ctx, in)
4023	if err != nil {
4024		return out, metadata, err
4025	}
4026
4027	response, ok := out.RawResponse.(*smithyhttp.Response)
4028	if !ok {
4029		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4030	}
4031
4032	if response.StatusCode < 200 || response.StatusCode >= 300 {
4033		return out, metadata, awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(response, &metadata)
4034	}
4035	output := &PutClusterCapacityProvidersOutput{}
4036	out.Result = output
4037
4038	var buff [1024]byte
4039	ringBuffer := smithyio.NewRingBuffer(buff[:])
4040
4041	body := io.TeeReader(response.Body, ringBuffer)
4042	decoder := json.NewDecoder(body)
4043	decoder.UseNumber()
4044	var shape interface{}
4045	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4046		var snapshot bytes.Buffer
4047		io.Copy(&snapshot, ringBuffer)
4048		err = &smithy.DeserializationError{
4049			Err:      fmt.Errorf("failed to decode response body, %w", err),
4050			Snapshot: snapshot.Bytes(),
4051		}
4052		return out, metadata, err
4053	}
4054
4055	err = awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(&output, shape)
4056	if err != nil {
4057		var snapshot bytes.Buffer
4058		io.Copy(&snapshot, ringBuffer)
4059		err = &smithy.DeserializationError{
4060			Err:      fmt.Errorf("failed to decode response body, %w", err),
4061			Snapshot: snapshot.Bytes(),
4062		}
4063		return out, metadata, err
4064	}
4065
4066	return out, metadata, err
4067}
4068
4069func awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4070	var errorBuffer bytes.Buffer
4071	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4072		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4073	}
4074	errorBody := bytes.NewReader(errorBuffer.Bytes())
4075
4076	errorCode := "UnknownError"
4077	errorMessage := errorCode
4078
4079	code := response.Header.Get("X-Amzn-ErrorType")
4080	if len(code) != 0 {
4081		errorCode = restjson.SanitizeErrorCode(code)
4082	}
4083
4084	var buff [1024]byte
4085	ringBuffer := smithyio.NewRingBuffer(buff[:])
4086
4087	body := io.TeeReader(errorBody, ringBuffer)
4088	decoder := json.NewDecoder(body)
4089	decoder.UseNumber()
4090	code, message, err := restjson.GetErrorInfo(decoder)
4091	if err != nil {
4092		var snapshot bytes.Buffer
4093		io.Copy(&snapshot, ringBuffer)
4094		err = &smithy.DeserializationError{
4095			Err:      fmt.Errorf("failed to decode response body, %w", err),
4096			Snapshot: snapshot.Bytes(),
4097		}
4098		return err
4099	}
4100
4101	errorBody.Seek(0, io.SeekStart)
4102	if len(code) != 0 {
4103		errorCode = restjson.SanitizeErrorCode(code)
4104	}
4105	if len(message) != 0 {
4106		errorMessage = message
4107	}
4108
4109	switch {
4110	case strings.EqualFold("ClientException", errorCode):
4111		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4112
4113	case strings.EqualFold("ClusterNotFoundException", errorCode):
4114		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
4115
4116	case strings.EqualFold("InvalidParameterException", errorCode):
4117		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4118
4119	case strings.EqualFold("ResourceInUseException", errorCode):
4120		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
4121
4122	case strings.EqualFold("ServerException", errorCode):
4123		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4124
4125	case strings.EqualFold("UpdateInProgressException", errorCode):
4126		return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
4127
4128	default:
4129		genericError := &smithy.GenericAPIError{
4130			Code:    errorCode,
4131			Message: errorMessage,
4132		}
4133		return genericError
4134
4135	}
4136}
4137
4138type awsAwsjson11_deserializeOpRegisterContainerInstance struct {
4139}
4140
4141func (*awsAwsjson11_deserializeOpRegisterContainerInstance) ID() string {
4142	return "OperationDeserializer"
4143}
4144
4145func (m *awsAwsjson11_deserializeOpRegisterContainerInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4146	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4147) {
4148	out, metadata, err = next.HandleDeserialize(ctx, in)
4149	if err != nil {
4150		return out, metadata, err
4151	}
4152
4153	response, ok := out.RawResponse.(*smithyhttp.Response)
4154	if !ok {
4155		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4156	}
4157
4158	if response.StatusCode < 200 || response.StatusCode >= 300 {
4159		return out, metadata, awsAwsjson11_deserializeOpErrorRegisterContainerInstance(response, &metadata)
4160	}
4161	output := &RegisterContainerInstanceOutput{}
4162	out.Result = output
4163
4164	var buff [1024]byte
4165	ringBuffer := smithyio.NewRingBuffer(buff[:])
4166
4167	body := io.TeeReader(response.Body, ringBuffer)
4168	decoder := json.NewDecoder(body)
4169	decoder.UseNumber()
4170	var shape interface{}
4171	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4172		var snapshot bytes.Buffer
4173		io.Copy(&snapshot, ringBuffer)
4174		err = &smithy.DeserializationError{
4175			Err:      fmt.Errorf("failed to decode response body, %w", err),
4176			Snapshot: snapshot.Bytes(),
4177		}
4178		return out, metadata, err
4179	}
4180
4181	err = awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(&output, shape)
4182	if err != nil {
4183		var snapshot bytes.Buffer
4184		io.Copy(&snapshot, ringBuffer)
4185		err = &smithy.DeserializationError{
4186			Err:      fmt.Errorf("failed to decode response body, %w", err),
4187			Snapshot: snapshot.Bytes(),
4188		}
4189		return out, metadata, err
4190	}
4191
4192	return out, metadata, err
4193}
4194
4195func awsAwsjson11_deserializeOpErrorRegisterContainerInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4196	var errorBuffer bytes.Buffer
4197	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4198		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4199	}
4200	errorBody := bytes.NewReader(errorBuffer.Bytes())
4201
4202	errorCode := "UnknownError"
4203	errorMessage := errorCode
4204
4205	code := response.Header.Get("X-Amzn-ErrorType")
4206	if len(code) != 0 {
4207		errorCode = restjson.SanitizeErrorCode(code)
4208	}
4209
4210	var buff [1024]byte
4211	ringBuffer := smithyio.NewRingBuffer(buff[:])
4212
4213	body := io.TeeReader(errorBody, ringBuffer)
4214	decoder := json.NewDecoder(body)
4215	decoder.UseNumber()
4216	code, message, err := restjson.GetErrorInfo(decoder)
4217	if err != nil {
4218		var snapshot bytes.Buffer
4219		io.Copy(&snapshot, ringBuffer)
4220		err = &smithy.DeserializationError{
4221			Err:      fmt.Errorf("failed to decode response body, %w", err),
4222			Snapshot: snapshot.Bytes(),
4223		}
4224		return err
4225	}
4226
4227	errorBody.Seek(0, io.SeekStart)
4228	if len(code) != 0 {
4229		errorCode = restjson.SanitizeErrorCode(code)
4230	}
4231	if len(message) != 0 {
4232		errorMessage = message
4233	}
4234
4235	switch {
4236	case strings.EqualFold("ClientException", errorCode):
4237		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4238
4239	case strings.EqualFold("InvalidParameterException", errorCode):
4240		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4241
4242	case strings.EqualFold("ServerException", errorCode):
4243		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4244
4245	default:
4246		genericError := &smithy.GenericAPIError{
4247			Code:    errorCode,
4248			Message: errorMessage,
4249		}
4250		return genericError
4251
4252	}
4253}
4254
4255type awsAwsjson11_deserializeOpRegisterTaskDefinition struct {
4256}
4257
4258func (*awsAwsjson11_deserializeOpRegisterTaskDefinition) ID() string {
4259	return "OperationDeserializer"
4260}
4261
4262func (m *awsAwsjson11_deserializeOpRegisterTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4263	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4264) {
4265	out, metadata, err = next.HandleDeserialize(ctx, in)
4266	if err != nil {
4267		return out, metadata, err
4268	}
4269
4270	response, ok := out.RawResponse.(*smithyhttp.Response)
4271	if !ok {
4272		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4273	}
4274
4275	if response.StatusCode < 200 || response.StatusCode >= 300 {
4276		return out, metadata, awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(response, &metadata)
4277	}
4278	output := &RegisterTaskDefinitionOutput{}
4279	out.Result = output
4280
4281	var buff [1024]byte
4282	ringBuffer := smithyio.NewRingBuffer(buff[:])
4283
4284	body := io.TeeReader(response.Body, ringBuffer)
4285	decoder := json.NewDecoder(body)
4286	decoder.UseNumber()
4287	var shape interface{}
4288	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4289		var snapshot bytes.Buffer
4290		io.Copy(&snapshot, ringBuffer)
4291		err = &smithy.DeserializationError{
4292			Err:      fmt.Errorf("failed to decode response body, %w", err),
4293			Snapshot: snapshot.Bytes(),
4294		}
4295		return out, metadata, err
4296	}
4297
4298	err = awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(&output, shape)
4299	if err != nil {
4300		var snapshot bytes.Buffer
4301		io.Copy(&snapshot, ringBuffer)
4302		err = &smithy.DeserializationError{
4303			Err:      fmt.Errorf("failed to decode response body, %w", err),
4304			Snapshot: snapshot.Bytes(),
4305		}
4306		return out, metadata, err
4307	}
4308
4309	return out, metadata, err
4310}
4311
4312func awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4313	var errorBuffer bytes.Buffer
4314	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4315		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4316	}
4317	errorBody := bytes.NewReader(errorBuffer.Bytes())
4318
4319	errorCode := "UnknownError"
4320	errorMessage := errorCode
4321
4322	code := response.Header.Get("X-Amzn-ErrorType")
4323	if len(code) != 0 {
4324		errorCode = restjson.SanitizeErrorCode(code)
4325	}
4326
4327	var buff [1024]byte
4328	ringBuffer := smithyio.NewRingBuffer(buff[:])
4329
4330	body := io.TeeReader(errorBody, ringBuffer)
4331	decoder := json.NewDecoder(body)
4332	decoder.UseNumber()
4333	code, message, err := restjson.GetErrorInfo(decoder)
4334	if err != nil {
4335		var snapshot bytes.Buffer
4336		io.Copy(&snapshot, ringBuffer)
4337		err = &smithy.DeserializationError{
4338			Err:      fmt.Errorf("failed to decode response body, %w", err),
4339			Snapshot: snapshot.Bytes(),
4340		}
4341		return err
4342	}
4343
4344	errorBody.Seek(0, io.SeekStart)
4345	if len(code) != 0 {
4346		errorCode = restjson.SanitizeErrorCode(code)
4347	}
4348	if len(message) != 0 {
4349		errorMessage = message
4350	}
4351
4352	switch {
4353	case strings.EqualFold("ClientException", errorCode):
4354		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4355
4356	case strings.EqualFold("InvalidParameterException", errorCode):
4357		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4358
4359	case strings.EqualFold("ServerException", errorCode):
4360		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4361
4362	default:
4363		genericError := &smithy.GenericAPIError{
4364			Code:    errorCode,
4365			Message: errorMessage,
4366		}
4367		return genericError
4368
4369	}
4370}
4371
4372type awsAwsjson11_deserializeOpRunTask struct {
4373}
4374
4375func (*awsAwsjson11_deserializeOpRunTask) ID() string {
4376	return "OperationDeserializer"
4377}
4378
4379func (m *awsAwsjson11_deserializeOpRunTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4380	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4381) {
4382	out, metadata, err = next.HandleDeserialize(ctx, in)
4383	if err != nil {
4384		return out, metadata, err
4385	}
4386
4387	response, ok := out.RawResponse.(*smithyhttp.Response)
4388	if !ok {
4389		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4390	}
4391
4392	if response.StatusCode < 200 || response.StatusCode >= 300 {
4393		return out, metadata, awsAwsjson11_deserializeOpErrorRunTask(response, &metadata)
4394	}
4395	output := &RunTaskOutput{}
4396	out.Result = output
4397
4398	var buff [1024]byte
4399	ringBuffer := smithyio.NewRingBuffer(buff[:])
4400
4401	body := io.TeeReader(response.Body, ringBuffer)
4402	decoder := json.NewDecoder(body)
4403	decoder.UseNumber()
4404	var shape interface{}
4405	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4406		var snapshot bytes.Buffer
4407		io.Copy(&snapshot, ringBuffer)
4408		err = &smithy.DeserializationError{
4409			Err:      fmt.Errorf("failed to decode response body, %w", err),
4410			Snapshot: snapshot.Bytes(),
4411		}
4412		return out, metadata, err
4413	}
4414
4415	err = awsAwsjson11_deserializeOpDocumentRunTaskOutput(&output, shape)
4416	if err != nil {
4417		var snapshot bytes.Buffer
4418		io.Copy(&snapshot, ringBuffer)
4419		err = &smithy.DeserializationError{
4420			Err:      fmt.Errorf("failed to decode response body, %w", err),
4421			Snapshot: snapshot.Bytes(),
4422		}
4423		return out, metadata, err
4424	}
4425
4426	return out, metadata, err
4427}
4428
4429func awsAwsjson11_deserializeOpErrorRunTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4430	var errorBuffer bytes.Buffer
4431	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4432		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4433	}
4434	errorBody := bytes.NewReader(errorBuffer.Bytes())
4435
4436	errorCode := "UnknownError"
4437	errorMessage := errorCode
4438
4439	code := response.Header.Get("X-Amzn-ErrorType")
4440	if len(code) != 0 {
4441		errorCode = restjson.SanitizeErrorCode(code)
4442	}
4443
4444	var buff [1024]byte
4445	ringBuffer := smithyio.NewRingBuffer(buff[:])
4446
4447	body := io.TeeReader(errorBody, ringBuffer)
4448	decoder := json.NewDecoder(body)
4449	decoder.UseNumber()
4450	code, message, err := restjson.GetErrorInfo(decoder)
4451	if err != nil {
4452		var snapshot bytes.Buffer
4453		io.Copy(&snapshot, ringBuffer)
4454		err = &smithy.DeserializationError{
4455			Err:      fmt.Errorf("failed to decode response body, %w", err),
4456			Snapshot: snapshot.Bytes(),
4457		}
4458		return err
4459	}
4460
4461	errorBody.Seek(0, io.SeekStart)
4462	if len(code) != 0 {
4463		errorCode = restjson.SanitizeErrorCode(code)
4464	}
4465	if len(message) != 0 {
4466		errorMessage = message
4467	}
4468
4469	switch {
4470	case strings.EqualFold("AccessDeniedException", errorCode):
4471		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4472
4473	case strings.EqualFold("BlockedException", errorCode):
4474		return awsAwsjson11_deserializeErrorBlockedException(response, errorBody)
4475
4476	case strings.EqualFold("ClientException", errorCode):
4477		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4478
4479	case strings.EqualFold("ClusterNotFoundException", errorCode):
4480		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
4481
4482	case strings.EqualFold("InvalidParameterException", errorCode):
4483		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4484
4485	case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
4486		return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
4487
4488	case strings.EqualFold("PlatformUnknownException", errorCode):
4489		return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
4490
4491	case strings.EqualFold("ServerException", errorCode):
4492		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4493
4494	case strings.EqualFold("UnsupportedFeatureException", errorCode):
4495		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
4496
4497	default:
4498		genericError := &smithy.GenericAPIError{
4499			Code:    errorCode,
4500			Message: errorMessage,
4501		}
4502		return genericError
4503
4504	}
4505}
4506
4507type awsAwsjson11_deserializeOpStartTask struct {
4508}
4509
4510func (*awsAwsjson11_deserializeOpStartTask) ID() string {
4511	return "OperationDeserializer"
4512}
4513
4514func (m *awsAwsjson11_deserializeOpStartTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4515	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4516) {
4517	out, metadata, err = next.HandleDeserialize(ctx, in)
4518	if err != nil {
4519		return out, metadata, err
4520	}
4521
4522	response, ok := out.RawResponse.(*smithyhttp.Response)
4523	if !ok {
4524		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4525	}
4526
4527	if response.StatusCode < 200 || response.StatusCode >= 300 {
4528		return out, metadata, awsAwsjson11_deserializeOpErrorStartTask(response, &metadata)
4529	}
4530	output := &StartTaskOutput{}
4531	out.Result = output
4532
4533	var buff [1024]byte
4534	ringBuffer := smithyio.NewRingBuffer(buff[:])
4535
4536	body := io.TeeReader(response.Body, ringBuffer)
4537	decoder := json.NewDecoder(body)
4538	decoder.UseNumber()
4539	var shape interface{}
4540	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4541		var snapshot bytes.Buffer
4542		io.Copy(&snapshot, ringBuffer)
4543		err = &smithy.DeserializationError{
4544			Err:      fmt.Errorf("failed to decode response body, %w", err),
4545			Snapshot: snapshot.Bytes(),
4546		}
4547		return out, metadata, err
4548	}
4549
4550	err = awsAwsjson11_deserializeOpDocumentStartTaskOutput(&output, shape)
4551	if err != nil {
4552		var snapshot bytes.Buffer
4553		io.Copy(&snapshot, ringBuffer)
4554		err = &smithy.DeserializationError{
4555			Err:      fmt.Errorf("failed to decode response body, %w", err),
4556			Snapshot: snapshot.Bytes(),
4557		}
4558		return out, metadata, err
4559	}
4560
4561	return out, metadata, err
4562}
4563
4564func awsAwsjson11_deserializeOpErrorStartTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4565	var errorBuffer bytes.Buffer
4566	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4567		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4568	}
4569	errorBody := bytes.NewReader(errorBuffer.Bytes())
4570
4571	errorCode := "UnknownError"
4572	errorMessage := errorCode
4573
4574	code := response.Header.Get("X-Amzn-ErrorType")
4575	if len(code) != 0 {
4576		errorCode = restjson.SanitizeErrorCode(code)
4577	}
4578
4579	var buff [1024]byte
4580	ringBuffer := smithyio.NewRingBuffer(buff[:])
4581
4582	body := io.TeeReader(errorBody, ringBuffer)
4583	decoder := json.NewDecoder(body)
4584	decoder.UseNumber()
4585	code, message, err := restjson.GetErrorInfo(decoder)
4586	if err != nil {
4587		var snapshot bytes.Buffer
4588		io.Copy(&snapshot, ringBuffer)
4589		err = &smithy.DeserializationError{
4590			Err:      fmt.Errorf("failed to decode response body, %w", err),
4591			Snapshot: snapshot.Bytes(),
4592		}
4593		return err
4594	}
4595
4596	errorBody.Seek(0, io.SeekStart)
4597	if len(code) != 0 {
4598		errorCode = restjson.SanitizeErrorCode(code)
4599	}
4600	if len(message) != 0 {
4601		errorMessage = message
4602	}
4603
4604	switch {
4605	case strings.EqualFold("ClientException", errorCode):
4606		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4607
4608	case strings.EqualFold("ClusterNotFoundException", errorCode):
4609		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
4610
4611	case strings.EqualFold("InvalidParameterException", errorCode):
4612		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4613
4614	case strings.EqualFold("ServerException", errorCode):
4615		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4616
4617	default:
4618		genericError := &smithy.GenericAPIError{
4619			Code:    errorCode,
4620			Message: errorMessage,
4621		}
4622		return genericError
4623
4624	}
4625}
4626
4627type awsAwsjson11_deserializeOpStopTask struct {
4628}
4629
4630func (*awsAwsjson11_deserializeOpStopTask) ID() string {
4631	return "OperationDeserializer"
4632}
4633
4634func (m *awsAwsjson11_deserializeOpStopTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4635	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4636) {
4637	out, metadata, err = next.HandleDeserialize(ctx, in)
4638	if err != nil {
4639		return out, metadata, err
4640	}
4641
4642	response, ok := out.RawResponse.(*smithyhttp.Response)
4643	if !ok {
4644		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4645	}
4646
4647	if response.StatusCode < 200 || response.StatusCode >= 300 {
4648		return out, metadata, awsAwsjson11_deserializeOpErrorStopTask(response, &metadata)
4649	}
4650	output := &StopTaskOutput{}
4651	out.Result = output
4652
4653	var buff [1024]byte
4654	ringBuffer := smithyio.NewRingBuffer(buff[:])
4655
4656	body := io.TeeReader(response.Body, ringBuffer)
4657	decoder := json.NewDecoder(body)
4658	decoder.UseNumber()
4659	var shape interface{}
4660	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4661		var snapshot bytes.Buffer
4662		io.Copy(&snapshot, ringBuffer)
4663		err = &smithy.DeserializationError{
4664			Err:      fmt.Errorf("failed to decode response body, %w", err),
4665			Snapshot: snapshot.Bytes(),
4666		}
4667		return out, metadata, err
4668	}
4669
4670	err = awsAwsjson11_deserializeOpDocumentStopTaskOutput(&output, shape)
4671	if err != nil {
4672		var snapshot bytes.Buffer
4673		io.Copy(&snapshot, ringBuffer)
4674		err = &smithy.DeserializationError{
4675			Err:      fmt.Errorf("failed to decode response body, %w", err),
4676			Snapshot: snapshot.Bytes(),
4677		}
4678		return out, metadata, err
4679	}
4680
4681	return out, metadata, err
4682}
4683
4684func awsAwsjson11_deserializeOpErrorStopTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4685	var errorBuffer bytes.Buffer
4686	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4687		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4688	}
4689	errorBody := bytes.NewReader(errorBuffer.Bytes())
4690
4691	errorCode := "UnknownError"
4692	errorMessage := errorCode
4693
4694	code := response.Header.Get("X-Amzn-ErrorType")
4695	if len(code) != 0 {
4696		errorCode = restjson.SanitizeErrorCode(code)
4697	}
4698
4699	var buff [1024]byte
4700	ringBuffer := smithyio.NewRingBuffer(buff[:])
4701
4702	body := io.TeeReader(errorBody, ringBuffer)
4703	decoder := json.NewDecoder(body)
4704	decoder.UseNumber()
4705	code, message, err := restjson.GetErrorInfo(decoder)
4706	if err != nil {
4707		var snapshot bytes.Buffer
4708		io.Copy(&snapshot, ringBuffer)
4709		err = &smithy.DeserializationError{
4710			Err:      fmt.Errorf("failed to decode response body, %w", err),
4711			Snapshot: snapshot.Bytes(),
4712		}
4713		return err
4714	}
4715
4716	errorBody.Seek(0, io.SeekStart)
4717	if len(code) != 0 {
4718		errorCode = restjson.SanitizeErrorCode(code)
4719	}
4720	if len(message) != 0 {
4721		errorMessage = message
4722	}
4723
4724	switch {
4725	case strings.EqualFold("ClientException", errorCode):
4726		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4727
4728	case strings.EqualFold("ClusterNotFoundException", errorCode):
4729		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
4730
4731	case strings.EqualFold("InvalidParameterException", errorCode):
4732		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4733
4734	case strings.EqualFold("ServerException", errorCode):
4735		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4736
4737	default:
4738		genericError := &smithy.GenericAPIError{
4739			Code:    errorCode,
4740			Message: errorMessage,
4741		}
4742		return genericError
4743
4744	}
4745}
4746
4747type awsAwsjson11_deserializeOpSubmitAttachmentStateChanges struct {
4748}
4749
4750func (*awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) ID() string {
4751	return "OperationDeserializer"
4752}
4753
4754func (m *awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4755	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4756) {
4757	out, metadata, err = next.HandleDeserialize(ctx, in)
4758	if err != nil {
4759		return out, metadata, err
4760	}
4761
4762	response, ok := out.RawResponse.(*smithyhttp.Response)
4763	if !ok {
4764		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4765	}
4766
4767	if response.StatusCode < 200 || response.StatusCode >= 300 {
4768		return out, metadata, awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(response, &metadata)
4769	}
4770	output := &SubmitAttachmentStateChangesOutput{}
4771	out.Result = output
4772
4773	var buff [1024]byte
4774	ringBuffer := smithyio.NewRingBuffer(buff[:])
4775
4776	body := io.TeeReader(response.Body, ringBuffer)
4777	decoder := json.NewDecoder(body)
4778	decoder.UseNumber()
4779	var shape interface{}
4780	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4781		var snapshot bytes.Buffer
4782		io.Copy(&snapshot, ringBuffer)
4783		err = &smithy.DeserializationError{
4784			Err:      fmt.Errorf("failed to decode response body, %w", err),
4785			Snapshot: snapshot.Bytes(),
4786		}
4787		return out, metadata, err
4788	}
4789
4790	err = awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(&output, shape)
4791	if err != nil {
4792		var snapshot bytes.Buffer
4793		io.Copy(&snapshot, ringBuffer)
4794		err = &smithy.DeserializationError{
4795			Err:      fmt.Errorf("failed to decode response body, %w", err),
4796			Snapshot: snapshot.Bytes(),
4797		}
4798		return out, metadata, err
4799	}
4800
4801	return out, metadata, err
4802}
4803
4804func awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4805	var errorBuffer bytes.Buffer
4806	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4807		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4808	}
4809	errorBody := bytes.NewReader(errorBuffer.Bytes())
4810
4811	errorCode := "UnknownError"
4812	errorMessage := errorCode
4813
4814	code := response.Header.Get("X-Amzn-ErrorType")
4815	if len(code) != 0 {
4816		errorCode = restjson.SanitizeErrorCode(code)
4817	}
4818
4819	var buff [1024]byte
4820	ringBuffer := smithyio.NewRingBuffer(buff[:])
4821
4822	body := io.TeeReader(errorBody, ringBuffer)
4823	decoder := json.NewDecoder(body)
4824	decoder.UseNumber()
4825	code, message, err := restjson.GetErrorInfo(decoder)
4826	if err != nil {
4827		var snapshot bytes.Buffer
4828		io.Copy(&snapshot, ringBuffer)
4829		err = &smithy.DeserializationError{
4830			Err:      fmt.Errorf("failed to decode response body, %w", err),
4831			Snapshot: snapshot.Bytes(),
4832		}
4833		return err
4834	}
4835
4836	errorBody.Seek(0, io.SeekStart)
4837	if len(code) != 0 {
4838		errorCode = restjson.SanitizeErrorCode(code)
4839	}
4840	if len(message) != 0 {
4841		errorMessage = message
4842	}
4843
4844	switch {
4845	case strings.EqualFold("AccessDeniedException", errorCode):
4846		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4847
4848	case strings.EqualFold("ClientException", errorCode):
4849		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4850
4851	case strings.EqualFold("InvalidParameterException", errorCode):
4852		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4853
4854	case strings.EqualFold("ServerException", errorCode):
4855		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4856
4857	default:
4858		genericError := &smithy.GenericAPIError{
4859			Code:    errorCode,
4860			Message: errorMessage,
4861		}
4862		return genericError
4863
4864	}
4865}
4866
4867type awsAwsjson11_deserializeOpSubmitContainerStateChange struct {
4868}
4869
4870func (*awsAwsjson11_deserializeOpSubmitContainerStateChange) ID() string {
4871	return "OperationDeserializer"
4872}
4873
4874func (m *awsAwsjson11_deserializeOpSubmitContainerStateChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4875	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4876) {
4877	out, metadata, err = next.HandleDeserialize(ctx, in)
4878	if err != nil {
4879		return out, metadata, err
4880	}
4881
4882	response, ok := out.RawResponse.(*smithyhttp.Response)
4883	if !ok {
4884		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4885	}
4886
4887	if response.StatusCode < 200 || response.StatusCode >= 300 {
4888		return out, metadata, awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(response, &metadata)
4889	}
4890	output := &SubmitContainerStateChangeOutput{}
4891	out.Result = output
4892
4893	var buff [1024]byte
4894	ringBuffer := smithyio.NewRingBuffer(buff[:])
4895
4896	body := io.TeeReader(response.Body, ringBuffer)
4897	decoder := json.NewDecoder(body)
4898	decoder.UseNumber()
4899	var shape interface{}
4900	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4901		var snapshot bytes.Buffer
4902		io.Copy(&snapshot, ringBuffer)
4903		err = &smithy.DeserializationError{
4904			Err:      fmt.Errorf("failed to decode response body, %w", err),
4905			Snapshot: snapshot.Bytes(),
4906		}
4907		return out, metadata, err
4908	}
4909
4910	err = awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(&output, shape)
4911	if err != nil {
4912		var snapshot bytes.Buffer
4913		io.Copy(&snapshot, ringBuffer)
4914		err = &smithy.DeserializationError{
4915			Err:      fmt.Errorf("failed to decode response body, %w", err),
4916			Snapshot: snapshot.Bytes(),
4917		}
4918		return out, metadata, err
4919	}
4920
4921	return out, metadata, err
4922}
4923
4924func awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4925	var errorBuffer bytes.Buffer
4926	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4927		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4928	}
4929	errorBody := bytes.NewReader(errorBuffer.Bytes())
4930
4931	errorCode := "UnknownError"
4932	errorMessage := errorCode
4933
4934	code := response.Header.Get("X-Amzn-ErrorType")
4935	if len(code) != 0 {
4936		errorCode = restjson.SanitizeErrorCode(code)
4937	}
4938
4939	var buff [1024]byte
4940	ringBuffer := smithyio.NewRingBuffer(buff[:])
4941
4942	body := io.TeeReader(errorBody, ringBuffer)
4943	decoder := json.NewDecoder(body)
4944	decoder.UseNumber()
4945	code, message, err := restjson.GetErrorInfo(decoder)
4946	if err != nil {
4947		var snapshot bytes.Buffer
4948		io.Copy(&snapshot, ringBuffer)
4949		err = &smithy.DeserializationError{
4950			Err:      fmt.Errorf("failed to decode response body, %w", err),
4951			Snapshot: snapshot.Bytes(),
4952		}
4953		return err
4954	}
4955
4956	errorBody.Seek(0, io.SeekStart)
4957	if len(code) != 0 {
4958		errorCode = restjson.SanitizeErrorCode(code)
4959	}
4960	if len(message) != 0 {
4961		errorMessage = message
4962	}
4963
4964	switch {
4965	case strings.EqualFold("AccessDeniedException", errorCode):
4966		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4967
4968	case strings.EqualFold("ClientException", errorCode):
4969		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
4970
4971	case strings.EqualFold("ServerException", errorCode):
4972		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
4973
4974	default:
4975		genericError := &smithy.GenericAPIError{
4976			Code:    errorCode,
4977			Message: errorMessage,
4978		}
4979		return genericError
4980
4981	}
4982}
4983
4984type awsAwsjson11_deserializeOpSubmitTaskStateChange struct {
4985}
4986
4987func (*awsAwsjson11_deserializeOpSubmitTaskStateChange) ID() string {
4988	return "OperationDeserializer"
4989}
4990
4991func (m *awsAwsjson11_deserializeOpSubmitTaskStateChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4992	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4993) {
4994	out, metadata, err = next.HandleDeserialize(ctx, in)
4995	if err != nil {
4996		return out, metadata, err
4997	}
4998
4999	response, ok := out.RawResponse.(*smithyhttp.Response)
5000	if !ok {
5001		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5002	}
5003
5004	if response.StatusCode < 200 || response.StatusCode >= 300 {
5005		return out, metadata, awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(response, &metadata)
5006	}
5007	output := &SubmitTaskStateChangeOutput{}
5008	out.Result = output
5009
5010	var buff [1024]byte
5011	ringBuffer := smithyio.NewRingBuffer(buff[:])
5012
5013	body := io.TeeReader(response.Body, ringBuffer)
5014	decoder := json.NewDecoder(body)
5015	decoder.UseNumber()
5016	var shape interface{}
5017	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5018		var snapshot bytes.Buffer
5019		io.Copy(&snapshot, ringBuffer)
5020		err = &smithy.DeserializationError{
5021			Err:      fmt.Errorf("failed to decode response body, %w", err),
5022			Snapshot: snapshot.Bytes(),
5023		}
5024		return out, metadata, err
5025	}
5026
5027	err = awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(&output, shape)
5028	if err != nil {
5029		var snapshot bytes.Buffer
5030		io.Copy(&snapshot, ringBuffer)
5031		err = &smithy.DeserializationError{
5032			Err:      fmt.Errorf("failed to decode response body, %w", err),
5033			Snapshot: snapshot.Bytes(),
5034		}
5035		return out, metadata, err
5036	}
5037
5038	return out, metadata, err
5039}
5040
5041func awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5042	var errorBuffer bytes.Buffer
5043	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5044		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5045	}
5046	errorBody := bytes.NewReader(errorBuffer.Bytes())
5047
5048	errorCode := "UnknownError"
5049	errorMessage := errorCode
5050
5051	code := response.Header.Get("X-Amzn-ErrorType")
5052	if len(code) != 0 {
5053		errorCode = restjson.SanitizeErrorCode(code)
5054	}
5055
5056	var buff [1024]byte
5057	ringBuffer := smithyio.NewRingBuffer(buff[:])
5058
5059	body := io.TeeReader(errorBody, ringBuffer)
5060	decoder := json.NewDecoder(body)
5061	decoder.UseNumber()
5062	code, message, err := restjson.GetErrorInfo(decoder)
5063	if err != nil {
5064		var snapshot bytes.Buffer
5065		io.Copy(&snapshot, ringBuffer)
5066		err = &smithy.DeserializationError{
5067			Err:      fmt.Errorf("failed to decode response body, %w", err),
5068			Snapshot: snapshot.Bytes(),
5069		}
5070		return err
5071	}
5072
5073	errorBody.Seek(0, io.SeekStart)
5074	if len(code) != 0 {
5075		errorCode = restjson.SanitizeErrorCode(code)
5076	}
5077	if len(message) != 0 {
5078		errorMessage = message
5079	}
5080
5081	switch {
5082	case strings.EqualFold("AccessDeniedException", errorCode):
5083		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5084
5085	case strings.EqualFold("ClientException", errorCode):
5086		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5087
5088	case strings.EqualFold("InvalidParameterException", errorCode):
5089		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5090
5091	case strings.EqualFold("ServerException", errorCode):
5092		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5093
5094	default:
5095		genericError := &smithy.GenericAPIError{
5096			Code:    errorCode,
5097			Message: errorMessage,
5098		}
5099		return genericError
5100
5101	}
5102}
5103
5104type awsAwsjson11_deserializeOpTagResource struct {
5105}
5106
5107func (*awsAwsjson11_deserializeOpTagResource) ID() string {
5108	return "OperationDeserializer"
5109}
5110
5111func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5112	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5113) {
5114	out, metadata, err = next.HandleDeserialize(ctx, in)
5115	if err != nil {
5116		return out, metadata, err
5117	}
5118
5119	response, ok := out.RawResponse.(*smithyhttp.Response)
5120	if !ok {
5121		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5122	}
5123
5124	if response.StatusCode < 200 || response.StatusCode >= 300 {
5125		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
5126	}
5127	output := &TagResourceOutput{}
5128	out.Result = output
5129
5130	var buff [1024]byte
5131	ringBuffer := smithyio.NewRingBuffer(buff[:])
5132
5133	body := io.TeeReader(response.Body, ringBuffer)
5134	decoder := json.NewDecoder(body)
5135	decoder.UseNumber()
5136	var shape interface{}
5137	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5138		var snapshot bytes.Buffer
5139		io.Copy(&snapshot, ringBuffer)
5140		err = &smithy.DeserializationError{
5141			Err:      fmt.Errorf("failed to decode response body, %w", err),
5142			Snapshot: snapshot.Bytes(),
5143		}
5144		return out, metadata, err
5145	}
5146
5147	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
5148	if err != nil {
5149		var snapshot bytes.Buffer
5150		io.Copy(&snapshot, ringBuffer)
5151		err = &smithy.DeserializationError{
5152			Err:      fmt.Errorf("failed to decode response body, %w", err),
5153			Snapshot: snapshot.Bytes(),
5154		}
5155		return out, metadata, err
5156	}
5157
5158	return out, metadata, err
5159}
5160
5161func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5162	var errorBuffer bytes.Buffer
5163	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5164		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5165	}
5166	errorBody := bytes.NewReader(errorBuffer.Bytes())
5167
5168	errorCode := "UnknownError"
5169	errorMessage := errorCode
5170
5171	code := response.Header.Get("X-Amzn-ErrorType")
5172	if len(code) != 0 {
5173		errorCode = restjson.SanitizeErrorCode(code)
5174	}
5175
5176	var buff [1024]byte
5177	ringBuffer := smithyio.NewRingBuffer(buff[:])
5178
5179	body := io.TeeReader(errorBody, ringBuffer)
5180	decoder := json.NewDecoder(body)
5181	decoder.UseNumber()
5182	code, message, err := restjson.GetErrorInfo(decoder)
5183	if err != nil {
5184		var snapshot bytes.Buffer
5185		io.Copy(&snapshot, ringBuffer)
5186		err = &smithy.DeserializationError{
5187			Err:      fmt.Errorf("failed to decode response body, %w", err),
5188			Snapshot: snapshot.Bytes(),
5189		}
5190		return err
5191	}
5192
5193	errorBody.Seek(0, io.SeekStart)
5194	if len(code) != 0 {
5195		errorCode = restjson.SanitizeErrorCode(code)
5196	}
5197	if len(message) != 0 {
5198		errorMessage = message
5199	}
5200
5201	switch {
5202	case strings.EqualFold("ClientException", errorCode):
5203		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5204
5205	case strings.EqualFold("ClusterNotFoundException", errorCode):
5206		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5207
5208	case strings.EqualFold("InvalidParameterException", errorCode):
5209		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5210
5211	case strings.EqualFold("ResourceNotFoundException", errorCode):
5212		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5213
5214	case strings.EqualFold("ServerException", errorCode):
5215		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5216
5217	default:
5218		genericError := &smithy.GenericAPIError{
5219			Code:    errorCode,
5220			Message: errorMessage,
5221		}
5222		return genericError
5223
5224	}
5225}
5226
5227type awsAwsjson11_deserializeOpUntagResource struct {
5228}
5229
5230func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
5231	return "OperationDeserializer"
5232}
5233
5234func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5235	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5236) {
5237	out, metadata, err = next.HandleDeserialize(ctx, in)
5238	if err != nil {
5239		return out, metadata, err
5240	}
5241
5242	response, ok := out.RawResponse.(*smithyhttp.Response)
5243	if !ok {
5244		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5245	}
5246
5247	if response.StatusCode < 200 || response.StatusCode >= 300 {
5248		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
5249	}
5250	output := &UntagResourceOutput{}
5251	out.Result = output
5252
5253	var buff [1024]byte
5254	ringBuffer := smithyio.NewRingBuffer(buff[:])
5255
5256	body := io.TeeReader(response.Body, ringBuffer)
5257	decoder := json.NewDecoder(body)
5258	decoder.UseNumber()
5259	var shape interface{}
5260	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5261		var snapshot bytes.Buffer
5262		io.Copy(&snapshot, ringBuffer)
5263		err = &smithy.DeserializationError{
5264			Err:      fmt.Errorf("failed to decode response body, %w", err),
5265			Snapshot: snapshot.Bytes(),
5266		}
5267		return out, metadata, err
5268	}
5269
5270	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
5271	if err != nil {
5272		var snapshot bytes.Buffer
5273		io.Copy(&snapshot, ringBuffer)
5274		err = &smithy.DeserializationError{
5275			Err:      fmt.Errorf("failed to decode response body, %w", err),
5276			Snapshot: snapshot.Bytes(),
5277		}
5278		return out, metadata, err
5279	}
5280
5281	return out, metadata, err
5282}
5283
5284func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5285	var errorBuffer bytes.Buffer
5286	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5287		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5288	}
5289	errorBody := bytes.NewReader(errorBuffer.Bytes())
5290
5291	errorCode := "UnknownError"
5292	errorMessage := errorCode
5293
5294	code := response.Header.Get("X-Amzn-ErrorType")
5295	if len(code) != 0 {
5296		errorCode = restjson.SanitizeErrorCode(code)
5297	}
5298
5299	var buff [1024]byte
5300	ringBuffer := smithyio.NewRingBuffer(buff[:])
5301
5302	body := io.TeeReader(errorBody, ringBuffer)
5303	decoder := json.NewDecoder(body)
5304	decoder.UseNumber()
5305	code, message, err := restjson.GetErrorInfo(decoder)
5306	if err != nil {
5307		var snapshot bytes.Buffer
5308		io.Copy(&snapshot, ringBuffer)
5309		err = &smithy.DeserializationError{
5310			Err:      fmt.Errorf("failed to decode response body, %w", err),
5311			Snapshot: snapshot.Bytes(),
5312		}
5313		return err
5314	}
5315
5316	errorBody.Seek(0, io.SeekStart)
5317	if len(code) != 0 {
5318		errorCode = restjson.SanitizeErrorCode(code)
5319	}
5320	if len(message) != 0 {
5321		errorMessage = message
5322	}
5323
5324	switch {
5325	case strings.EqualFold("ClientException", errorCode):
5326		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5327
5328	case strings.EqualFold("ClusterNotFoundException", errorCode):
5329		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5330
5331	case strings.EqualFold("InvalidParameterException", errorCode):
5332		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5333
5334	case strings.EqualFold("ResourceNotFoundException", errorCode):
5335		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5336
5337	case strings.EqualFold("ServerException", errorCode):
5338		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5339
5340	default:
5341		genericError := &smithy.GenericAPIError{
5342			Code:    errorCode,
5343			Message: errorMessage,
5344		}
5345		return genericError
5346
5347	}
5348}
5349
5350type awsAwsjson11_deserializeOpUpdateCapacityProvider struct {
5351}
5352
5353func (*awsAwsjson11_deserializeOpUpdateCapacityProvider) ID() string {
5354	return "OperationDeserializer"
5355}
5356
5357func (m *awsAwsjson11_deserializeOpUpdateCapacityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5358	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5359) {
5360	out, metadata, err = next.HandleDeserialize(ctx, in)
5361	if err != nil {
5362		return out, metadata, err
5363	}
5364
5365	response, ok := out.RawResponse.(*smithyhttp.Response)
5366	if !ok {
5367		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5368	}
5369
5370	if response.StatusCode < 200 || response.StatusCode >= 300 {
5371		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(response, &metadata)
5372	}
5373	output := &UpdateCapacityProviderOutput{}
5374	out.Result = output
5375
5376	var buff [1024]byte
5377	ringBuffer := smithyio.NewRingBuffer(buff[:])
5378
5379	body := io.TeeReader(response.Body, ringBuffer)
5380	decoder := json.NewDecoder(body)
5381	decoder.UseNumber()
5382	var shape interface{}
5383	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5384		var snapshot bytes.Buffer
5385		io.Copy(&snapshot, ringBuffer)
5386		err = &smithy.DeserializationError{
5387			Err:      fmt.Errorf("failed to decode response body, %w", err),
5388			Snapshot: snapshot.Bytes(),
5389		}
5390		return out, metadata, err
5391	}
5392
5393	err = awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(&output, shape)
5394	if err != nil {
5395		var snapshot bytes.Buffer
5396		io.Copy(&snapshot, ringBuffer)
5397		err = &smithy.DeserializationError{
5398			Err:      fmt.Errorf("failed to decode response body, %w", err),
5399			Snapshot: snapshot.Bytes(),
5400		}
5401		return out, metadata, err
5402	}
5403
5404	return out, metadata, err
5405}
5406
5407func awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5408	var errorBuffer bytes.Buffer
5409	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5410		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5411	}
5412	errorBody := bytes.NewReader(errorBuffer.Bytes())
5413
5414	errorCode := "UnknownError"
5415	errorMessage := errorCode
5416
5417	code := response.Header.Get("X-Amzn-ErrorType")
5418	if len(code) != 0 {
5419		errorCode = restjson.SanitizeErrorCode(code)
5420	}
5421
5422	var buff [1024]byte
5423	ringBuffer := smithyio.NewRingBuffer(buff[:])
5424
5425	body := io.TeeReader(errorBody, ringBuffer)
5426	decoder := json.NewDecoder(body)
5427	decoder.UseNumber()
5428	code, message, err := restjson.GetErrorInfo(decoder)
5429	if err != nil {
5430		var snapshot bytes.Buffer
5431		io.Copy(&snapshot, ringBuffer)
5432		err = &smithy.DeserializationError{
5433			Err:      fmt.Errorf("failed to decode response body, %w", err),
5434			Snapshot: snapshot.Bytes(),
5435		}
5436		return err
5437	}
5438
5439	errorBody.Seek(0, io.SeekStart)
5440	if len(code) != 0 {
5441		errorCode = restjson.SanitizeErrorCode(code)
5442	}
5443	if len(message) != 0 {
5444		errorMessage = message
5445	}
5446
5447	switch {
5448	case strings.EqualFold("ClientException", errorCode):
5449		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5450
5451	case strings.EqualFold("InvalidParameterException", errorCode):
5452		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5453
5454	case strings.EqualFold("ServerException", errorCode):
5455		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5456
5457	default:
5458		genericError := &smithy.GenericAPIError{
5459			Code:    errorCode,
5460			Message: errorMessage,
5461		}
5462		return genericError
5463
5464	}
5465}
5466
5467type awsAwsjson11_deserializeOpUpdateCluster struct {
5468}
5469
5470func (*awsAwsjson11_deserializeOpUpdateCluster) ID() string {
5471	return "OperationDeserializer"
5472}
5473
5474func (m *awsAwsjson11_deserializeOpUpdateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5475	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5476) {
5477	out, metadata, err = next.HandleDeserialize(ctx, in)
5478	if err != nil {
5479		return out, metadata, err
5480	}
5481
5482	response, ok := out.RawResponse.(*smithyhttp.Response)
5483	if !ok {
5484		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5485	}
5486
5487	if response.StatusCode < 200 || response.StatusCode >= 300 {
5488		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCluster(response, &metadata)
5489	}
5490	output := &UpdateClusterOutput{}
5491	out.Result = output
5492
5493	var buff [1024]byte
5494	ringBuffer := smithyio.NewRingBuffer(buff[:])
5495
5496	body := io.TeeReader(response.Body, ringBuffer)
5497	decoder := json.NewDecoder(body)
5498	decoder.UseNumber()
5499	var shape interface{}
5500	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5501		var snapshot bytes.Buffer
5502		io.Copy(&snapshot, ringBuffer)
5503		err = &smithy.DeserializationError{
5504			Err:      fmt.Errorf("failed to decode response body, %w", err),
5505			Snapshot: snapshot.Bytes(),
5506		}
5507		return out, metadata, err
5508	}
5509
5510	err = awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(&output, shape)
5511	if err != nil {
5512		var snapshot bytes.Buffer
5513		io.Copy(&snapshot, ringBuffer)
5514		err = &smithy.DeserializationError{
5515			Err:      fmt.Errorf("failed to decode response body, %w", err),
5516			Snapshot: snapshot.Bytes(),
5517		}
5518		return out, metadata, err
5519	}
5520
5521	return out, metadata, err
5522}
5523
5524func awsAwsjson11_deserializeOpErrorUpdateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5525	var errorBuffer bytes.Buffer
5526	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5527		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5528	}
5529	errorBody := bytes.NewReader(errorBuffer.Bytes())
5530
5531	errorCode := "UnknownError"
5532	errorMessage := errorCode
5533
5534	code := response.Header.Get("X-Amzn-ErrorType")
5535	if len(code) != 0 {
5536		errorCode = restjson.SanitizeErrorCode(code)
5537	}
5538
5539	var buff [1024]byte
5540	ringBuffer := smithyio.NewRingBuffer(buff[:])
5541
5542	body := io.TeeReader(errorBody, ringBuffer)
5543	decoder := json.NewDecoder(body)
5544	decoder.UseNumber()
5545	code, message, err := restjson.GetErrorInfo(decoder)
5546	if err != nil {
5547		var snapshot bytes.Buffer
5548		io.Copy(&snapshot, ringBuffer)
5549		err = &smithy.DeserializationError{
5550			Err:      fmt.Errorf("failed to decode response body, %w", err),
5551			Snapshot: snapshot.Bytes(),
5552		}
5553		return err
5554	}
5555
5556	errorBody.Seek(0, io.SeekStart)
5557	if len(code) != 0 {
5558		errorCode = restjson.SanitizeErrorCode(code)
5559	}
5560	if len(message) != 0 {
5561		errorMessage = message
5562	}
5563
5564	switch {
5565	case strings.EqualFold("ClientException", errorCode):
5566		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5567
5568	case strings.EqualFold("ClusterNotFoundException", errorCode):
5569		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5570
5571	case strings.EqualFold("InvalidParameterException", errorCode):
5572		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5573
5574	case strings.EqualFold("ServerException", errorCode):
5575		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5576
5577	default:
5578		genericError := &smithy.GenericAPIError{
5579			Code:    errorCode,
5580			Message: errorMessage,
5581		}
5582		return genericError
5583
5584	}
5585}
5586
5587type awsAwsjson11_deserializeOpUpdateClusterSettings struct {
5588}
5589
5590func (*awsAwsjson11_deserializeOpUpdateClusterSettings) ID() string {
5591	return "OperationDeserializer"
5592}
5593
5594func (m *awsAwsjson11_deserializeOpUpdateClusterSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5595	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5596) {
5597	out, metadata, err = next.HandleDeserialize(ctx, in)
5598	if err != nil {
5599		return out, metadata, err
5600	}
5601
5602	response, ok := out.RawResponse.(*smithyhttp.Response)
5603	if !ok {
5604		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5605	}
5606
5607	if response.StatusCode < 200 || response.StatusCode >= 300 {
5608		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateClusterSettings(response, &metadata)
5609	}
5610	output := &UpdateClusterSettingsOutput{}
5611	out.Result = output
5612
5613	var buff [1024]byte
5614	ringBuffer := smithyio.NewRingBuffer(buff[:])
5615
5616	body := io.TeeReader(response.Body, ringBuffer)
5617	decoder := json.NewDecoder(body)
5618	decoder.UseNumber()
5619	var shape interface{}
5620	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5621		var snapshot bytes.Buffer
5622		io.Copy(&snapshot, ringBuffer)
5623		err = &smithy.DeserializationError{
5624			Err:      fmt.Errorf("failed to decode response body, %w", err),
5625			Snapshot: snapshot.Bytes(),
5626		}
5627		return out, metadata, err
5628	}
5629
5630	err = awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(&output, shape)
5631	if err != nil {
5632		var snapshot bytes.Buffer
5633		io.Copy(&snapshot, ringBuffer)
5634		err = &smithy.DeserializationError{
5635			Err:      fmt.Errorf("failed to decode response body, %w", err),
5636			Snapshot: snapshot.Bytes(),
5637		}
5638		return out, metadata, err
5639	}
5640
5641	return out, metadata, err
5642}
5643
5644func awsAwsjson11_deserializeOpErrorUpdateClusterSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5645	var errorBuffer bytes.Buffer
5646	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5647		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5648	}
5649	errorBody := bytes.NewReader(errorBuffer.Bytes())
5650
5651	errorCode := "UnknownError"
5652	errorMessage := errorCode
5653
5654	code := response.Header.Get("X-Amzn-ErrorType")
5655	if len(code) != 0 {
5656		errorCode = restjson.SanitizeErrorCode(code)
5657	}
5658
5659	var buff [1024]byte
5660	ringBuffer := smithyio.NewRingBuffer(buff[:])
5661
5662	body := io.TeeReader(errorBody, ringBuffer)
5663	decoder := json.NewDecoder(body)
5664	decoder.UseNumber()
5665	code, message, err := restjson.GetErrorInfo(decoder)
5666	if err != nil {
5667		var snapshot bytes.Buffer
5668		io.Copy(&snapshot, ringBuffer)
5669		err = &smithy.DeserializationError{
5670			Err:      fmt.Errorf("failed to decode response body, %w", err),
5671			Snapshot: snapshot.Bytes(),
5672		}
5673		return err
5674	}
5675
5676	errorBody.Seek(0, io.SeekStart)
5677	if len(code) != 0 {
5678		errorCode = restjson.SanitizeErrorCode(code)
5679	}
5680	if len(message) != 0 {
5681		errorMessage = message
5682	}
5683
5684	switch {
5685	case strings.EqualFold("ClientException", errorCode):
5686		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5687
5688	case strings.EqualFold("ClusterNotFoundException", errorCode):
5689		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5690
5691	case strings.EqualFold("InvalidParameterException", errorCode):
5692		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5693
5694	case strings.EqualFold("ServerException", errorCode):
5695		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5696
5697	default:
5698		genericError := &smithy.GenericAPIError{
5699			Code:    errorCode,
5700			Message: errorMessage,
5701		}
5702		return genericError
5703
5704	}
5705}
5706
5707type awsAwsjson11_deserializeOpUpdateContainerAgent struct {
5708}
5709
5710func (*awsAwsjson11_deserializeOpUpdateContainerAgent) ID() string {
5711	return "OperationDeserializer"
5712}
5713
5714func (m *awsAwsjson11_deserializeOpUpdateContainerAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5715	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5716) {
5717	out, metadata, err = next.HandleDeserialize(ctx, in)
5718	if err != nil {
5719		return out, metadata, err
5720	}
5721
5722	response, ok := out.RawResponse.(*smithyhttp.Response)
5723	if !ok {
5724		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5725	}
5726
5727	if response.StatusCode < 200 || response.StatusCode >= 300 {
5728		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerAgent(response, &metadata)
5729	}
5730	output := &UpdateContainerAgentOutput{}
5731	out.Result = output
5732
5733	var buff [1024]byte
5734	ringBuffer := smithyio.NewRingBuffer(buff[:])
5735
5736	body := io.TeeReader(response.Body, ringBuffer)
5737	decoder := json.NewDecoder(body)
5738	decoder.UseNumber()
5739	var shape interface{}
5740	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5741		var snapshot bytes.Buffer
5742		io.Copy(&snapshot, ringBuffer)
5743		err = &smithy.DeserializationError{
5744			Err:      fmt.Errorf("failed to decode response body, %w", err),
5745			Snapshot: snapshot.Bytes(),
5746		}
5747		return out, metadata, err
5748	}
5749
5750	err = awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(&output, shape)
5751	if err != nil {
5752		var snapshot bytes.Buffer
5753		io.Copy(&snapshot, ringBuffer)
5754		err = &smithy.DeserializationError{
5755			Err:      fmt.Errorf("failed to decode response body, %w", err),
5756			Snapshot: snapshot.Bytes(),
5757		}
5758		return out, metadata, err
5759	}
5760
5761	return out, metadata, err
5762}
5763
5764func awsAwsjson11_deserializeOpErrorUpdateContainerAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5765	var errorBuffer bytes.Buffer
5766	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5767		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5768	}
5769	errorBody := bytes.NewReader(errorBuffer.Bytes())
5770
5771	errorCode := "UnknownError"
5772	errorMessage := errorCode
5773
5774	code := response.Header.Get("X-Amzn-ErrorType")
5775	if len(code) != 0 {
5776		errorCode = restjson.SanitizeErrorCode(code)
5777	}
5778
5779	var buff [1024]byte
5780	ringBuffer := smithyio.NewRingBuffer(buff[:])
5781
5782	body := io.TeeReader(errorBody, ringBuffer)
5783	decoder := json.NewDecoder(body)
5784	decoder.UseNumber()
5785	code, message, err := restjson.GetErrorInfo(decoder)
5786	if err != nil {
5787		var snapshot bytes.Buffer
5788		io.Copy(&snapshot, ringBuffer)
5789		err = &smithy.DeserializationError{
5790			Err:      fmt.Errorf("failed to decode response body, %w", err),
5791			Snapshot: snapshot.Bytes(),
5792		}
5793		return err
5794	}
5795
5796	errorBody.Seek(0, io.SeekStart)
5797	if len(code) != 0 {
5798		errorCode = restjson.SanitizeErrorCode(code)
5799	}
5800	if len(message) != 0 {
5801		errorMessage = message
5802	}
5803
5804	switch {
5805	case strings.EqualFold("ClientException", errorCode):
5806		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5807
5808	case strings.EqualFold("ClusterNotFoundException", errorCode):
5809		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5810
5811	case strings.EqualFold("InvalidParameterException", errorCode):
5812		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5813
5814	case strings.EqualFold("MissingVersionException", errorCode):
5815		return awsAwsjson11_deserializeErrorMissingVersionException(response, errorBody)
5816
5817	case strings.EqualFold("NoUpdateAvailableException", errorCode):
5818		return awsAwsjson11_deserializeErrorNoUpdateAvailableException(response, errorBody)
5819
5820	case strings.EqualFold("ServerException", errorCode):
5821		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5822
5823	case strings.EqualFold("UpdateInProgressException", errorCode):
5824		return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody)
5825
5826	default:
5827		genericError := &smithy.GenericAPIError{
5828			Code:    errorCode,
5829			Message: errorMessage,
5830		}
5831		return genericError
5832
5833	}
5834}
5835
5836type awsAwsjson11_deserializeOpUpdateContainerInstancesState struct {
5837}
5838
5839func (*awsAwsjson11_deserializeOpUpdateContainerInstancesState) ID() string {
5840	return "OperationDeserializer"
5841}
5842
5843func (m *awsAwsjson11_deserializeOpUpdateContainerInstancesState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5844	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5845) {
5846	out, metadata, err = next.HandleDeserialize(ctx, in)
5847	if err != nil {
5848		return out, metadata, err
5849	}
5850
5851	response, ok := out.RawResponse.(*smithyhttp.Response)
5852	if !ok {
5853		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5854	}
5855
5856	if response.StatusCode < 200 || response.StatusCode >= 300 {
5857		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(response, &metadata)
5858	}
5859	output := &UpdateContainerInstancesStateOutput{}
5860	out.Result = output
5861
5862	var buff [1024]byte
5863	ringBuffer := smithyio.NewRingBuffer(buff[:])
5864
5865	body := io.TeeReader(response.Body, ringBuffer)
5866	decoder := json.NewDecoder(body)
5867	decoder.UseNumber()
5868	var shape interface{}
5869	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5870		var snapshot bytes.Buffer
5871		io.Copy(&snapshot, ringBuffer)
5872		err = &smithy.DeserializationError{
5873			Err:      fmt.Errorf("failed to decode response body, %w", err),
5874			Snapshot: snapshot.Bytes(),
5875		}
5876		return out, metadata, err
5877	}
5878
5879	err = awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(&output, shape)
5880	if err != nil {
5881		var snapshot bytes.Buffer
5882		io.Copy(&snapshot, ringBuffer)
5883		err = &smithy.DeserializationError{
5884			Err:      fmt.Errorf("failed to decode response body, %w", err),
5885			Snapshot: snapshot.Bytes(),
5886		}
5887		return out, metadata, err
5888	}
5889
5890	return out, metadata, err
5891}
5892
5893func awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5894	var errorBuffer bytes.Buffer
5895	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5896		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5897	}
5898	errorBody := bytes.NewReader(errorBuffer.Bytes())
5899
5900	errorCode := "UnknownError"
5901	errorMessage := errorCode
5902
5903	code := response.Header.Get("X-Amzn-ErrorType")
5904	if len(code) != 0 {
5905		errorCode = restjson.SanitizeErrorCode(code)
5906	}
5907
5908	var buff [1024]byte
5909	ringBuffer := smithyio.NewRingBuffer(buff[:])
5910
5911	body := io.TeeReader(errorBody, ringBuffer)
5912	decoder := json.NewDecoder(body)
5913	decoder.UseNumber()
5914	code, message, err := restjson.GetErrorInfo(decoder)
5915	if err != nil {
5916		var snapshot bytes.Buffer
5917		io.Copy(&snapshot, ringBuffer)
5918		err = &smithy.DeserializationError{
5919			Err:      fmt.Errorf("failed to decode response body, %w", err),
5920			Snapshot: snapshot.Bytes(),
5921		}
5922		return err
5923	}
5924
5925	errorBody.Seek(0, io.SeekStart)
5926	if len(code) != 0 {
5927		errorCode = restjson.SanitizeErrorCode(code)
5928	}
5929	if len(message) != 0 {
5930		errorMessage = message
5931	}
5932
5933	switch {
5934	case strings.EqualFold("ClientException", errorCode):
5935		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
5936
5937	case strings.EqualFold("ClusterNotFoundException", errorCode):
5938		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
5939
5940	case strings.EqualFold("InvalidParameterException", errorCode):
5941		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5942
5943	case strings.EqualFold("ServerException", errorCode):
5944		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
5945
5946	default:
5947		genericError := &smithy.GenericAPIError{
5948			Code:    errorCode,
5949			Message: errorMessage,
5950		}
5951		return genericError
5952
5953	}
5954}
5955
5956type awsAwsjson11_deserializeOpUpdateService struct {
5957}
5958
5959func (*awsAwsjson11_deserializeOpUpdateService) ID() string {
5960	return "OperationDeserializer"
5961}
5962
5963func (m *awsAwsjson11_deserializeOpUpdateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5964	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5965) {
5966	out, metadata, err = next.HandleDeserialize(ctx, in)
5967	if err != nil {
5968		return out, metadata, err
5969	}
5970
5971	response, ok := out.RawResponse.(*smithyhttp.Response)
5972	if !ok {
5973		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5974	}
5975
5976	if response.StatusCode < 200 || response.StatusCode >= 300 {
5977		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateService(response, &metadata)
5978	}
5979	output := &UpdateServiceOutput{}
5980	out.Result = output
5981
5982	var buff [1024]byte
5983	ringBuffer := smithyio.NewRingBuffer(buff[:])
5984
5985	body := io.TeeReader(response.Body, ringBuffer)
5986	decoder := json.NewDecoder(body)
5987	decoder.UseNumber()
5988	var shape interface{}
5989	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5990		var snapshot bytes.Buffer
5991		io.Copy(&snapshot, ringBuffer)
5992		err = &smithy.DeserializationError{
5993			Err:      fmt.Errorf("failed to decode response body, %w", err),
5994			Snapshot: snapshot.Bytes(),
5995		}
5996		return out, metadata, err
5997	}
5998
5999	err = awsAwsjson11_deserializeOpDocumentUpdateServiceOutput(&output, shape)
6000	if err != nil {
6001		var snapshot bytes.Buffer
6002		io.Copy(&snapshot, ringBuffer)
6003		err = &smithy.DeserializationError{
6004			Err:      fmt.Errorf("failed to decode response body, %w", err),
6005			Snapshot: snapshot.Bytes(),
6006		}
6007		return out, metadata, err
6008	}
6009
6010	return out, metadata, err
6011}
6012
6013func awsAwsjson11_deserializeOpErrorUpdateService(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6014	var errorBuffer bytes.Buffer
6015	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6016		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6017	}
6018	errorBody := bytes.NewReader(errorBuffer.Bytes())
6019
6020	errorCode := "UnknownError"
6021	errorMessage := errorCode
6022
6023	code := response.Header.Get("X-Amzn-ErrorType")
6024	if len(code) != 0 {
6025		errorCode = restjson.SanitizeErrorCode(code)
6026	}
6027
6028	var buff [1024]byte
6029	ringBuffer := smithyio.NewRingBuffer(buff[:])
6030
6031	body := io.TeeReader(errorBody, ringBuffer)
6032	decoder := json.NewDecoder(body)
6033	decoder.UseNumber()
6034	code, message, err := restjson.GetErrorInfo(decoder)
6035	if err != nil {
6036		var snapshot bytes.Buffer
6037		io.Copy(&snapshot, ringBuffer)
6038		err = &smithy.DeserializationError{
6039			Err:      fmt.Errorf("failed to decode response body, %w", err),
6040			Snapshot: snapshot.Bytes(),
6041		}
6042		return err
6043	}
6044
6045	errorBody.Seek(0, io.SeekStart)
6046	if len(code) != 0 {
6047		errorCode = restjson.SanitizeErrorCode(code)
6048	}
6049	if len(message) != 0 {
6050		errorMessage = message
6051	}
6052
6053	switch {
6054	case strings.EqualFold("AccessDeniedException", errorCode):
6055		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6056
6057	case strings.EqualFold("ClientException", errorCode):
6058		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
6059
6060	case strings.EqualFold("ClusterNotFoundException", errorCode):
6061		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
6062
6063	case strings.EqualFold("InvalidParameterException", errorCode):
6064		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6065
6066	case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode):
6067		return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody)
6068
6069	case strings.EqualFold("PlatformUnknownException", errorCode):
6070		return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody)
6071
6072	case strings.EqualFold("ServerException", errorCode):
6073		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
6074
6075	case strings.EqualFold("ServiceNotActiveException", errorCode):
6076		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
6077
6078	case strings.EqualFold("ServiceNotFoundException", errorCode):
6079		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
6080
6081	default:
6082		genericError := &smithy.GenericAPIError{
6083			Code:    errorCode,
6084			Message: errorMessage,
6085		}
6086		return genericError
6087
6088	}
6089}
6090
6091type awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet struct {
6092}
6093
6094func (*awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) ID() string {
6095	return "OperationDeserializer"
6096}
6097
6098func (m *awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6099	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6100) {
6101	out, metadata, err = next.HandleDeserialize(ctx, in)
6102	if err != nil {
6103		return out, metadata, err
6104	}
6105
6106	response, ok := out.RawResponse.(*smithyhttp.Response)
6107	if !ok {
6108		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6109	}
6110
6111	if response.StatusCode < 200 || response.StatusCode >= 300 {
6112		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(response, &metadata)
6113	}
6114	output := &UpdateServicePrimaryTaskSetOutput{}
6115	out.Result = output
6116
6117	var buff [1024]byte
6118	ringBuffer := smithyio.NewRingBuffer(buff[:])
6119
6120	body := io.TeeReader(response.Body, ringBuffer)
6121	decoder := json.NewDecoder(body)
6122	decoder.UseNumber()
6123	var shape interface{}
6124	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6125		var snapshot bytes.Buffer
6126		io.Copy(&snapshot, ringBuffer)
6127		err = &smithy.DeserializationError{
6128			Err:      fmt.Errorf("failed to decode response body, %w", err),
6129			Snapshot: snapshot.Bytes(),
6130		}
6131		return out, metadata, err
6132	}
6133
6134	err = awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(&output, shape)
6135	if err != nil {
6136		var snapshot bytes.Buffer
6137		io.Copy(&snapshot, ringBuffer)
6138		err = &smithy.DeserializationError{
6139			Err:      fmt.Errorf("failed to decode response body, %w", err),
6140			Snapshot: snapshot.Bytes(),
6141		}
6142		return out, metadata, err
6143	}
6144
6145	return out, metadata, err
6146}
6147
6148func awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6149	var errorBuffer bytes.Buffer
6150	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6151		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6152	}
6153	errorBody := bytes.NewReader(errorBuffer.Bytes())
6154
6155	errorCode := "UnknownError"
6156	errorMessage := errorCode
6157
6158	code := response.Header.Get("X-Amzn-ErrorType")
6159	if len(code) != 0 {
6160		errorCode = restjson.SanitizeErrorCode(code)
6161	}
6162
6163	var buff [1024]byte
6164	ringBuffer := smithyio.NewRingBuffer(buff[:])
6165
6166	body := io.TeeReader(errorBody, ringBuffer)
6167	decoder := json.NewDecoder(body)
6168	decoder.UseNumber()
6169	code, message, err := restjson.GetErrorInfo(decoder)
6170	if err != nil {
6171		var snapshot bytes.Buffer
6172		io.Copy(&snapshot, ringBuffer)
6173		err = &smithy.DeserializationError{
6174			Err:      fmt.Errorf("failed to decode response body, %w", err),
6175			Snapshot: snapshot.Bytes(),
6176		}
6177		return err
6178	}
6179
6180	errorBody.Seek(0, io.SeekStart)
6181	if len(code) != 0 {
6182		errorCode = restjson.SanitizeErrorCode(code)
6183	}
6184	if len(message) != 0 {
6185		errorMessage = message
6186	}
6187
6188	switch {
6189	case strings.EqualFold("AccessDeniedException", errorCode):
6190		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6191
6192	case strings.EqualFold("ClientException", errorCode):
6193		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
6194
6195	case strings.EqualFold("ClusterNotFoundException", errorCode):
6196		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
6197
6198	case strings.EqualFold("InvalidParameterException", errorCode):
6199		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6200
6201	case strings.EqualFold("ServerException", errorCode):
6202		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
6203
6204	case strings.EqualFold("ServiceNotActiveException", errorCode):
6205		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
6206
6207	case strings.EqualFold("ServiceNotFoundException", errorCode):
6208		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
6209
6210	case strings.EqualFold("TaskSetNotFoundException", errorCode):
6211		return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
6212
6213	case strings.EqualFold("UnsupportedFeatureException", errorCode):
6214		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
6215
6216	default:
6217		genericError := &smithy.GenericAPIError{
6218			Code:    errorCode,
6219			Message: errorMessage,
6220		}
6221		return genericError
6222
6223	}
6224}
6225
6226type awsAwsjson11_deserializeOpUpdateTaskSet struct {
6227}
6228
6229func (*awsAwsjson11_deserializeOpUpdateTaskSet) ID() string {
6230	return "OperationDeserializer"
6231}
6232
6233func (m *awsAwsjson11_deserializeOpUpdateTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6234	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6235) {
6236	out, metadata, err = next.HandleDeserialize(ctx, in)
6237	if err != nil {
6238		return out, metadata, err
6239	}
6240
6241	response, ok := out.RawResponse.(*smithyhttp.Response)
6242	if !ok {
6243		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6244	}
6245
6246	if response.StatusCode < 200 || response.StatusCode >= 300 {
6247		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTaskSet(response, &metadata)
6248	}
6249	output := &UpdateTaskSetOutput{}
6250	out.Result = output
6251
6252	var buff [1024]byte
6253	ringBuffer := smithyio.NewRingBuffer(buff[:])
6254
6255	body := io.TeeReader(response.Body, ringBuffer)
6256	decoder := json.NewDecoder(body)
6257	decoder.UseNumber()
6258	var shape interface{}
6259	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6260		var snapshot bytes.Buffer
6261		io.Copy(&snapshot, ringBuffer)
6262		err = &smithy.DeserializationError{
6263			Err:      fmt.Errorf("failed to decode response body, %w", err),
6264			Snapshot: snapshot.Bytes(),
6265		}
6266		return out, metadata, err
6267	}
6268
6269	err = awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(&output, shape)
6270	if err != nil {
6271		var snapshot bytes.Buffer
6272		io.Copy(&snapshot, ringBuffer)
6273		err = &smithy.DeserializationError{
6274			Err:      fmt.Errorf("failed to decode response body, %w", err),
6275			Snapshot: snapshot.Bytes(),
6276		}
6277		return out, metadata, err
6278	}
6279
6280	return out, metadata, err
6281}
6282
6283func awsAwsjson11_deserializeOpErrorUpdateTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6284	var errorBuffer bytes.Buffer
6285	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6286		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6287	}
6288	errorBody := bytes.NewReader(errorBuffer.Bytes())
6289
6290	errorCode := "UnknownError"
6291	errorMessage := errorCode
6292
6293	code := response.Header.Get("X-Amzn-ErrorType")
6294	if len(code) != 0 {
6295		errorCode = restjson.SanitizeErrorCode(code)
6296	}
6297
6298	var buff [1024]byte
6299	ringBuffer := smithyio.NewRingBuffer(buff[:])
6300
6301	body := io.TeeReader(errorBody, ringBuffer)
6302	decoder := json.NewDecoder(body)
6303	decoder.UseNumber()
6304	code, message, err := restjson.GetErrorInfo(decoder)
6305	if err != nil {
6306		var snapshot bytes.Buffer
6307		io.Copy(&snapshot, ringBuffer)
6308		err = &smithy.DeserializationError{
6309			Err:      fmt.Errorf("failed to decode response body, %w", err),
6310			Snapshot: snapshot.Bytes(),
6311		}
6312		return err
6313	}
6314
6315	errorBody.Seek(0, io.SeekStart)
6316	if len(code) != 0 {
6317		errorCode = restjson.SanitizeErrorCode(code)
6318	}
6319	if len(message) != 0 {
6320		errorMessage = message
6321	}
6322
6323	switch {
6324	case strings.EqualFold("AccessDeniedException", errorCode):
6325		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6326
6327	case strings.EqualFold("ClientException", errorCode):
6328		return awsAwsjson11_deserializeErrorClientException(response, errorBody)
6329
6330	case strings.EqualFold("ClusterNotFoundException", errorCode):
6331		return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody)
6332
6333	case strings.EqualFold("InvalidParameterException", errorCode):
6334		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6335
6336	case strings.EqualFold("ServerException", errorCode):
6337		return awsAwsjson11_deserializeErrorServerException(response, errorBody)
6338
6339	case strings.EqualFold("ServiceNotActiveException", errorCode):
6340		return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody)
6341
6342	case strings.EqualFold("ServiceNotFoundException", errorCode):
6343		return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody)
6344
6345	case strings.EqualFold("TaskSetNotFoundException", errorCode):
6346		return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody)
6347
6348	case strings.EqualFold("UnsupportedFeatureException", errorCode):
6349		return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody)
6350
6351	default:
6352		genericError := &smithy.GenericAPIError{
6353			Code:    errorCode,
6354			Message: errorMessage,
6355		}
6356		return genericError
6357
6358	}
6359}
6360
6361func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6362	var buff [1024]byte
6363	ringBuffer := smithyio.NewRingBuffer(buff[:])
6364
6365	body := io.TeeReader(errorBody, ringBuffer)
6366	decoder := json.NewDecoder(body)
6367	decoder.UseNumber()
6368	var shape interface{}
6369	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6370		var snapshot bytes.Buffer
6371		io.Copy(&snapshot, ringBuffer)
6372		err = &smithy.DeserializationError{
6373			Err:      fmt.Errorf("failed to decode response body, %w", err),
6374			Snapshot: snapshot.Bytes(),
6375		}
6376		return err
6377	}
6378
6379	output := &types.AccessDeniedException{}
6380	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
6381
6382	if err != nil {
6383		var snapshot bytes.Buffer
6384		io.Copy(&snapshot, ringBuffer)
6385		err = &smithy.DeserializationError{
6386			Err:      fmt.Errorf("failed to decode response body, %w", err),
6387			Snapshot: snapshot.Bytes(),
6388		}
6389		return err
6390	}
6391
6392	errorBody.Seek(0, io.SeekStart)
6393	return output
6394}
6395
6396func awsAwsjson11_deserializeErrorAttributeLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6397	var buff [1024]byte
6398	ringBuffer := smithyio.NewRingBuffer(buff[:])
6399
6400	body := io.TeeReader(errorBody, ringBuffer)
6401	decoder := json.NewDecoder(body)
6402	decoder.UseNumber()
6403	var shape interface{}
6404	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6405		var snapshot bytes.Buffer
6406		io.Copy(&snapshot, ringBuffer)
6407		err = &smithy.DeserializationError{
6408			Err:      fmt.Errorf("failed to decode response body, %w", err),
6409			Snapshot: snapshot.Bytes(),
6410		}
6411		return err
6412	}
6413
6414	output := &types.AttributeLimitExceededException{}
6415	err := awsAwsjson11_deserializeDocumentAttributeLimitExceededException(&output, shape)
6416
6417	if err != nil {
6418		var snapshot bytes.Buffer
6419		io.Copy(&snapshot, ringBuffer)
6420		err = &smithy.DeserializationError{
6421			Err:      fmt.Errorf("failed to decode response body, %w", err),
6422			Snapshot: snapshot.Bytes(),
6423		}
6424		return err
6425	}
6426
6427	errorBody.Seek(0, io.SeekStart)
6428	return output
6429}
6430
6431func awsAwsjson11_deserializeErrorBlockedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6432	var buff [1024]byte
6433	ringBuffer := smithyio.NewRingBuffer(buff[:])
6434
6435	body := io.TeeReader(errorBody, 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 err
6447	}
6448
6449	output := &types.BlockedException{}
6450	err := awsAwsjson11_deserializeDocumentBlockedException(&output, shape)
6451
6452	if err != nil {
6453		var snapshot bytes.Buffer
6454		io.Copy(&snapshot, ringBuffer)
6455		err = &smithy.DeserializationError{
6456			Err:      fmt.Errorf("failed to decode response body, %w", err),
6457			Snapshot: snapshot.Bytes(),
6458		}
6459		return err
6460	}
6461
6462	errorBody.Seek(0, io.SeekStart)
6463	return output
6464}
6465
6466func awsAwsjson11_deserializeErrorClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6467	var buff [1024]byte
6468	ringBuffer := smithyio.NewRingBuffer(buff[:])
6469
6470	body := io.TeeReader(errorBody, ringBuffer)
6471	decoder := json.NewDecoder(body)
6472	decoder.UseNumber()
6473	var shape interface{}
6474	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6475		var snapshot bytes.Buffer
6476		io.Copy(&snapshot, ringBuffer)
6477		err = &smithy.DeserializationError{
6478			Err:      fmt.Errorf("failed to decode response body, %w", err),
6479			Snapshot: snapshot.Bytes(),
6480		}
6481		return err
6482	}
6483
6484	output := &types.ClientException{}
6485	err := awsAwsjson11_deserializeDocumentClientException(&output, shape)
6486
6487	if err != nil {
6488		var snapshot bytes.Buffer
6489		io.Copy(&snapshot, ringBuffer)
6490		err = &smithy.DeserializationError{
6491			Err:      fmt.Errorf("failed to decode response body, %w", err),
6492			Snapshot: snapshot.Bytes(),
6493		}
6494		return err
6495	}
6496
6497	errorBody.Seek(0, io.SeekStart)
6498	return output
6499}
6500
6501func awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6502	var buff [1024]byte
6503	ringBuffer := smithyio.NewRingBuffer(buff[:])
6504
6505	body := io.TeeReader(errorBody, ringBuffer)
6506	decoder := json.NewDecoder(body)
6507	decoder.UseNumber()
6508	var shape interface{}
6509	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6510		var snapshot bytes.Buffer
6511		io.Copy(&snapshot, ringBuffer)
6512		err = &smithy.DeserializationError{
6513			Err:      fmt.Errorf("failed to decode response body, %w", err),
6514			Snapshot: snapshot.Bytes(),
6515		}
6516		return err
6517	}
6518
6519	output := &types.ClusterContainsContainerInstancesException{}
6520	err := awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(&output, shape)
6521
6522	if err != nil {
6523		var snapshot bytes.Buffer
6524		io.Copy(&snapshot, ringBuffer)
6525		err = &smithy.DeserializationError{
6526			Err:      fmt.Errorf("failed to decode response body, %w", err),
6527			Snapshot: snapshot.Bytes(),
6528		}
6529		return err
6530	}
6531
6532	errorBody.Seek(0, io.SeekStart)
6533	return output
6534}
6535
6536func awsAwsjson11_deserializeErrorClusterContainsServicesException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6537	var buff [1024]byte
6538	ringBuffer := smithyio.NewRingBuffer(buff[:])
6539
6540	body := io.TeeReader(errorBody, ringBuffer)
6541	decoder := json.NewDecoder(body)
6542	decoder.UseNumber()
6543	var shape interface{}
6544	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6545		var snapshot bytes.Buffer
6546		io.Copy(&snapshot, ringBuffer)
6547		err = &smithy.DeserializationError{
6548			Err:      fmt.Errorf("failed to decode response body, %w", err),
6549			Snapshot: snapshot.Bytes(),
6550		}
6551		return err
6552	}
6553
6554	output := &types.ClusterContainsServicesException{}
6555	err := awsAwsjson11_deserializeDocumentClusterContainsServicesException(&output, shape)
6556
6557	if err != nil {
6558		var snapshot bytes.Buffer
6559		io.Copy(&snapshot, ringBuffer)
6560		err = &smithy.DeserializationError{
6561			Err:      fmt.Errorf("failed to decode response body, %w", err),
6562			Snapshot: snapshot.Bytes(),
6563		}
6564		return err
6565	}
6566
6567	errorBody.Seek(0, io.SeekStart)
6568	return output
6569}
6570
6571func awsAwsjson11_deserializeErrorClusterContainsTasksException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6572	var buff [1024]byte
6573	ringBuffer := smithyio.NewRingBuffer(buff[:])
6574
6575	body := io.TeeReader(errorBody, ringBuffer)
6576	decoder := json.NewDecoder(body)
6577	decoder.UseNumber()
6578	var shape interface{}
6579	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 err
6587	}
6588
6589	output := &types.ClusterContainsTasksException{}
6590	err := awsAwsjson11_deserializeDocumentClusterContainsTasksException(&output, shape)
6591
6592	if err != nil {
6593		var snapshot bytes.Buffer
6594		io.Copy(&snapshot, ringBuffer)
6595		err = &smithy.DeserializationError{
6596			Err:      fmt.Errorf("failed to decode response body, %w", err),
6597			Snapshot: snapshot.Bytes(),
6598		}
6599		return err
6600	}
6601
6602	errorBody.Seek(0, io.SeekStart)
6603	return output
6604}
6605
6606func awsAwsjson11_deserializeErrorClusterNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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	var shape interface{}
6614	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	output := &types.ClusterNotFoundException{}
6625	err := awsAwsjson11_deserializeDocumentClusterNotFoundException(&output, shape)
6626
6627	if err != nil {
6628		var snapshot bytes.Buffer
6629		io.Copy(&snapshot, ringBuffer)
6630		err = &smithy.DeserializationError{
6631			Err:      fmt.Errorf("failed to decode response body, %w", err),
6632			Snapshot: snapshot.Bytes(),
6633		}
6634		return err
6635	}
6636
6637	errorBody.Seek(0, io.SeekStart)
6638	return output
6639}
6640
6641func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6642	var buff [1024]byte
6643	ringBuffer := smithyio.NewRingBuffer(buff[:])
6644
6645	body := io.TeeReader(errorBody, ringBuffer)
6646	decoder := json.NewDecoder(body)
6647	decoder.UseNumber()
6648	var shape interface{}
6649	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6650		var snapshot bytes.Buffer
6651		io.Copy(&snapshot, ringBuffer)
6652		err = &smithy.DeserializationError{
6653			Err:      fmt.Errorf("failed to decode response body, %w", err),
6654			Snapshot: snapshot.Bytes(),
6655		}
6656		return err
6657	}
6658
6659	output := &types.InvalidParameterException{}
6660	err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape)
6661
6662	if err != nil {
6663		var snapshot bytes.Buffer
6664		io.Copy(&snapshot, ringBuffer)
6665		err = &smithy.DeserializationError{
6666			Err:      fmt.Errorf("failed to decode response body, %w", err),
6667			Snapshot: snapshot.Bytes(),
6668		}
6669		return err
6670	}
6671
6672	errorBody.Seek(0, io.SeekStart)
6673	return output
6674}
6675
6676func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6677	var buff [1024]byte
6678	ringBuffer := smithyio.NewRingBuffer(buff[:])
6679
6680	body := io.TeeReader(errorBody, ringBuffer)
6681	decoder := json.NewDecoder(body)
6682	decoder.UseNumber()
6683	var shape interface{}
6684	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6685		var snapshot bytes.Buffer
6686		io.Copy(&snapshot, ringBuffer)
6687		err = &smithy.DeserializationError{
6688			Err:      fmt.Errorf("failed to decode response body, %w", err),
6689			Snapshot: snapshot.Bytes(),
6690		}
6691		return err
6692	}
6693
6694	output := &types.LimitExceededException{}
6695	err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
6696
6697	if err != nil {
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 err
6705	}
6706
6707	errorBody.Seek(0, io.SeekStart)
6708	return output
6709}
6710
6711func awsAwsjson11_deserializeErrorMissingVersionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6712	var buff [1024]byte
6713	ringBuffer := smithyio.NewRingBuffer(buff[:])
6714
6715	body := io.TeeReader(errorBody, ringBuffer)
6716	decoder := json.NewDecoder(body)
6717	decoder.UseNumber()
6718	var shape interface{}
6719	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6720		var snapshot bytes.Buffer
6721		io.Copy(&snapshot, ringBuffer)
6722		err = &smithy.DeserializationError{
6723			Err:      fmt.Errorf("failed to decode response body, %w", err),
6724			Snapshot: snapshot.Bytes(),
6725		}
6726		return err
6727	}
6728
6729	output := &types.MissingVersionException{}
6730	err := awsAwsjson11_deserializeDocumentMissingVersionException(&output, shape)
6731
6732	if err != nil {
6733		var snapshot bytes.Buffer
6734		io.Copy(&snapshot, ringBuffer)
6735		err = &smithy.DeserializationError{
6736			Err:      fmt.Errorf("failed to decode response body, %w", err),
6737			Snapshot: snapshot.Bytes(),
6738		}
6739		return err
6740	}
6741
6742	errorBody.Seek(0, io.SeekStart)
6743	return output
6744}
6745
6746func awsAwsjson11_deserializeErrorNoUpdateAvailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6747	var buff [1024]byte
6748	ringBuffer := smithyio.NewRingBuffer(buff[:])
6749
6750	body := io.TeeReader(errorBody, ringBuffer)
6751	decoder := json.NewDecoder(body)
6752	decoder.UseNumber()
6753	var shape interface{}
6754	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6755		var snapshot bytes.Buffer
6756		io.Copy(&snapshot, ringBuffer)
6757		err = &smithy.DeserializationError{
6758			Err:      fmt.Errorf("failed to decode response body, %w", err),
6759			Snapshot: snapshot.Bytes(),
6760		}
6761		return err
6762	}
6763
6764	output := &types.NoUpdateAvailableException{}
6765	err := awsAwsjson11_deserializeDocumentNoUpdateAvailableException(&output, shape)
6766
6767	if err != nil {
6768		var snapshot bytes.Buffer
6769		io.Copy(&snapshot, ringBuffer)
6770		err = &smithy.DeserializationError{
6771			Err:      fmt.Errorf("failed to decode response body, %w", err),
6772			Snapshot: snapshot.Bytes(),
6773		}
6774		return err
6775	}
6776
6777	errorBody.Seek(0, io.SeekStart)
6778	return output
6779}
6780
6781func awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6782	var buff [1024]byte
6783	ringBuffer := smithyio.NewRingBuffer(buff[:])
6784
6785	body := io.TeeReader(errorBody, ringBuffer)
6786	decoder := json.NewDecoder(body)
6787	decoder.UseNumber()
6788	var shape interface{}
6789	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6790		var snapshot bytes.Buffer
6791		io.Copy(&snapshot, ringBuffer)
6792		err = &smithy.DeserializationError{
6793			Err:      fmt.Errorf("failed to decode response body, %w", err),
6794			Snapshot: snapshot.Bytes(),
6795		}
6796		return err
6797	}
6798
6799	output := &types.PlatformTaskDefinitionIncompatibilityException{}
6800	err := awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(&output, shape)
6801
6802	if err != nil {
6803		var snapshot bytes.Buffer
6804		io.Copy(&snapshot, ringBuffer)
6805		err = &smithy.DeserializationError{
6806			Err:      fmt.Errorf("failed to decode response body, %w", err),
6807			Snapshot: snapshot.Bytes(),
6808		}
6809		return err
6810	}
6811
6812	errorBody.Seek(0, io.SeekStart)
6813	return output
6814}
6815
6816func awsAwsjson11_deserializeErrorPlatformUnknownException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6817	var buff [1024]byte
6818	ringBuffer := smithyio.NewRingBuffer(buff[:])
6819
6820	body := io.TeeReader(errorBody, ringBuffer)
6821	decoder := json.NewDecoder(body)
6822	decoder.UseNumber()
6823	var shape interface{}
6824	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6825		var snapshot bytes.Buffer
6826		io.Copy(&snapshot, ringBuffer)
6827		err = &smithy.DeserializationError{
6828			Err:      fmt.Errorf("failed to decode response body, %w", err),
6829			Snapshot: snapshot.Bytes(),
6830		}
6831		return err
6832	}
6833
6834	output := &types.PlatformUnknownException{}
6835	err := awsAwsjson11_deserializeDocumentPlatformUnknownException(&output, shape)
6836
6837	if err != nil {
6838		var snapshot bytes.Buffer
6839		io.Copy(&snapshot, ringBuffer)
6840		err = &smithy.DeserializationError{
6841			Err:      fmt.Errorf("failed to decode response body, %w", err),
6842			Snapshot: snapshot.Bytes(),
6843		}
6844		return err
6845	}
6846
6847	errorBody.Seek(0, io.SeekStart)
6848	return output
6849}
6850
6851func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6852	var buff [1024]byte
6853	ringBuffer := smithyio.NewRingBuffer(buff[:])
6854
6855	body := io.TeeReader(errorBody, ringBuffer)
6856	decoder := json.NewDecoder(body)
6857	decoder.UseNumber()
6858	var shape interface{}
6859	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6860		var snapshot bytes.Buffer
6861		io.Copy(&snapshot, ringBuffer)
6862		err = &smithy.DeserializationError{
6863			Err:      fmt.Errorf("failed to decode response body, %w", err),
6864			Snapshot: snapshot.Bytes(),
6865		}
6866		return err
6867	}
6868
6869	output := &types.ResourceInUseException{}
6870	err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape)
6871
6872	if err != nil {
6873		var snapshot bytes.Buffer
6874		io.Copy(&snapshot, ringBuffer)
6875		err = &smithy.DeserializationError{
6876			Err:      fmt.Errorf("failed to decode response body, %w", err),
6877			Snapshot: snapshot.Bytes(),
6878		}
6879		return err
6880	}
6881
6882	errorBody.Seek(0, io.SeekStart)
6883	return output
6884}
6885
6886func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6887	var buff [1024]byte
6888	ringBuffer := smithyio.NewRingBuffer(buff[:])
6889
6890	body := io.TeeReader(errorBody, ringBuffer)
6891	decoder := json.NewDecoder(body)
6892	decoder.UseNumber()
6893	var shape interface{}
6894	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6895		var snapshot bytes.Buffer
6896		io.Copy(&snapshot, ringBuffer)
6897		err = &smithy.DeserializationError{
6898			Err:      fmt.Errorf("failed to decode response body, %w", err),
6899			Snapshot: snapshot.Bytes(),
6900		}
6901		return err
6902	}
6903
6904	output := &types.ResourceNotFoundException{}
6905	err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape)
6906
6907	if err != nil {
6908		var snapshot bytes.Buffer
6909		io.Copy(&snapshot, ringBuffer)
6910		err = &smithy.DeserializationError{
6911			Err:      fmt.Errorf("failed to decode response body, %w", err),
6912			Snapshot: snapshot.Bytes(),
6913		}
6914		return err
6915	}
6916
6917	errorBody.Seek(0, io.SeekStart)
6918	return output
6919}
6920
6921func awsAwsjson11_deserializeErrorServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6922	var buff [1024]byte
6923	ringBuffer := smithyio.NewRingBuffer(buff[:])
6924
6925	body := io.TeeReader(errorBody, ringBuffer)
6926	decoder := json.NewDecoder(body)
6927	decoder.UseNumber()
6928	var shape interface{}
6929	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6930		var snapshot bytes.Buffer
6931		io.Copy(&snapshot, ringBuffer)
6932		err = &smithy.DeserializationError{
6933			Err:      fmt.Errorf("failed to decode response body, %w", err),
6934			Snapshot: snapshot.Bytes(),
6935		}
6936		return err
6937	}
6938
6939	output := &types.ServerException{}
6940	err := awsAwsjson11_deserializeDocumentServerException(&output, shape)
6941
6942	if err != nil {
6943		var snapshot bytes.Buffer
6944		io.Copy(&snapshot, ringBuffer)
6945		err = &smithy.DeserializationError{
6946			Err:      fmt.Errorf("failed to decode response body, %w", err),
6947			Snapshot: snapshot.Bytes(),
6948		}
6949		return err
6950	}
6951
6952	errorBody.Seek(0, io.SeekStart)
6953	return output
6954}
6955
6956func awsAwsjson11_deserializeErrorServiceNotActiveException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6957	var buff [1024]byte
6958	ringBuffer := smithyio.NewRingBuffer(buff[:])
6959
6960	body := io.TeeReader(errorBody, ringBuffer)
6961	decoder := json.NewDecoder(body)
6962	decoder.UseNumber()
6963	var shape interface{}
6964	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6965		var snapshot bytes.Buffer
6966		io.Copy(&snapshot, ringBuffer)
6967		err = &smithy.DeserializationError{
6968			Err:      fmt.Errorf("failed to decode response body, %w", err),
6969			Snapshot: snapshot.Bytes(),
6970		}
6971		return err
6972	}
6973
6974	output := &types.ServiceNotActiveException{}
6975	err := awsAwsjson11_deserializeDocumentServiceNotActiveException(&output, shape)
6976
6977	if err != nil {
6978		var snapshot bytes.Buffer
6979		io.Copy(&snapshot, ringBuffer)
6980		err = &smithy.DeserializationError{
6981			Err:      fmt.Errorf("failed to decode response body, %w", err),
6982			Snapshot: snapshot.Bytes(),
6983		}
6984		return err
6985	}
6986
6987	errorBody.Seek(0, io.SeekStart)
6988	return output
6989}
6990
6991func awsAwsjson11_deserializeErrorServiceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6992	var buff [1024]byte
6993	ringBuffer := smithyio.NewRingBuffer(buff[:])
6994
6995	body := io.TeeReader(errorBody, ringBuffer)
6996	decoder := json.NewDecoder(body)
6997	decoder.UseNumber()
6998	var shape interface{}
6999	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7000		var snapshot bytes.Buffer
7001		io.Copy(&snapshot, ringBuffer)
7002		err = &smithy.DeserializationError{
7003			Err:      fmt.Errorf("failed to decode response body, %w", err),
7004			Snapshot: snapshot.Bytes(),
7005		}
7006		return err
7007	}
7008
7009	output := &types.ServiceNotFoundException{}
7010	err := awsAwsjson11_deserializeDocumentServiceNotFoundException(&output, shape)
7011
7012	if err != nil {
7013		var snapshot bytes.Buffer
7014		io.Copy(&snapshot, ringBuffer)
7015		err = &smithy.DeserializationError{
7016			Err:      fmt.Errorf("failed to decode response body, %w", err),
7017			Snapshot: snapshot.Bytes(),
7018		}
7019		return err
7020	}
7021
7022	errorBody.Seek(0, io.SeekStart)
7023	return output
7024}
7025
7026func awsAwsjson11_deserializeErrorTargetNotConnectedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7027	var buff [1024]byte
7028	ringBuffer := smithyio.NewRingBuffer(buff[:])
7029
7030	body := io.TeeReader(errorBody, ringBuffer)
7031	decoder := json.NewDecoder(body)
7032	decoder.UseNumber()
7033	var shape interface{}
7034	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7035		var snapshot bytes.Buffer
7036		io.Copy(&snapshot, ringBuffer)
7037		err = &smithy.DeserializationError{
7038			Err:      fmt.Errorf("failed to decode response body, %w", err),
7039			Snapshot: snapshot.Bytes(),
7040		}
7041		return err
7042	}
7043
7044	output := &types.TargetNotConnectedException{}
7045	err := awsAwsjson11_deserializeDocumentTargetNotConnectedException(&output, shape)
7046
7047	if err != nil {
7048		var snapshot bytes.Buffer
7049		io.Copy(&snapshot, ringBuffer)
7050		err = &smithy.DeserializationError{
7051			Err:      fmt.Errorf("failed to decode response body, %w", err),
7052			Snapshot: snapshot.Bytes(),
7053		}
7054		return err
7055	}
7056
7057	errorBody.Seek(0, io.SeekStart)
7058	return output
7059}
7060
7061func awsAwsjson11_deserializeErrorTargetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7062	var buff [1024]byte
7063	ringBuffer := smithyio.NewRingBuffer(buff[:])
7064
7065	body := io.TeeReader(errorBody, ringBuffer)
7066	decoder := json.NewDecoder(body)
7067	decoder.UseNumber()
7068	var shape interface{}
7069	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7070		var snapshot bytes.Buffer
7071		io.Copy(&snapshot, ringBuffer)
7072		err = &smithy.DeserializationError{
7073			Err:      fmt.Errorf("failed to decode response body, %w", err),
7074			Snapshot: snapshot.Bytes(),
7075		}
7076		return err
7077	}
7078
7079	output := &types.TargetNotFoundException{}
7080	err := awsAwsjson11_deserializeDocumentTargetNotFoundException(&output, shape)
7081
7082	if err != nil {
7083		var snapshot bytes.Buffer
7084		io.Copy(&snapshot, ringBuffer)
7085		err = &smithy.DeserializationError{
7086			Err:      fmt.Errorf("failed to decode response body, %w", err),
7087			Snapshot: snapshot.Bytes(),
7088		}
7089		return err
7090	}
7091
7092	errorBody.Seek(0, io.SeekStart)
7093	return output
7094}
7095
7096func awsAwsjson11_deserializeErrorTaskSetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7097	var buff [1024]byte
7098	ringBuffer := smithyio.NewRingBuffer(buff[:])
7099
7100	body := io.TeeReader(errorBody, ringBuffer)
7101	decoder := json.NewDecoder(body)
7102	decoder.UseNumber()
7103	var shape interface{}
7104	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7105		var snapshot bytes.Buffer
7106		io.Copy(&snapshot, ringBuffer)
7107		err = &smithy.DeserializationError{
7108			Err:      fmt.Errorf("failed to decode response body, %w", err),
7109			Snapshot: snapshot.Bytes(),
7110		}
7111		return err
7112	}
7113
7114	output := &types.TaskSetNotFoundException{}
7115	err := awsAwsjson11_deserializeDocumentTaskSetNotFoundException(&output, shape)
7116
7117	if err != nil {
7118		var snapshot bytes.Buffer
7119		io.Copy(&snapshot, ringBuffer)
7120		err = &smithy.DeserializationError{
7121			Err:      fmt.Errorf("failed to decode response body, %w", err),
7122			Snapshot: snapshot.Bytes(),
7123		}
7124		return err
7125	}
7126
7127	errorBody.Seek(0, io.SeekStart)
7128	return output
7129}
7130
7131func awsAwsjson11_deserializeErrorUnsupportedFeatureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7132	var buff [1024]byte
7133	ringBuffer := smithyio.NewRingBuffer(buff[:])
7134
7135	body := io.TeeReader(errorBody, ringBuffer)
7136	decoder := json.NewDecoder(body)
7137	decoder.UseNumber()
7138	var shape interface{}
7139	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7140		var snapshot bytes.Buffer
7141		io.Copy(&snapshot, ringBuffer)
7142		err = &smithy.DeserializationError{
7143			Err:      fmt.Errorf("failed to decode response body, %w", err),
7144			Snapshot: snapshot.Bytes(),
7145		}
7146		return err
7147	}
7148
7149	output := &types.UnsupportedFeatureException{}
7150	err := awsAwsjson11_deserializeDocumentUnsupportedFeatureException(&output, shape)
7151
7152	if err != nil {
7153		var snapshot bytes.Buffer
7154		io.Copy(&snapshot, ringBuffer)
7155		err = &smithy.DeserializationError{
7156			Err:      fmt.Errorf("failed to decode response body, %w", err),
7157			Snapshot: snapshot.Bytes(),
7158		}
7159		return err
7160	}
7161
7162	errorBody.Seek(0, io.SeekStart)
7163	return output
7164}
7165
7166func awsAwsjson11_deserializeErrorUpdateInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7167	var buff [1024]byte
7168	ringBuffer := smithyio.NewRingBuffer(buff[:])
7169
7170	body := io.TeeReader(errorBody, ringBuffer)
7171	decoder := json.NewDecoder(body)
7172	decoder.UseNumber()
7173	var shape interface{}
7174	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7175		var snapshot bytes.Buffer
7176		io.Copy(&snapshot, ringBuffer)
7177		err = &smithy.DeserializationError{
7178			Err:      fmt.Errorf("failed to decode response body, %w", err),
7179			Snapshot: snapshot.Bytes(),
7180		}
7181		return err
7182	}
7183
7184	output := &types.UpdateInProgressException{}
7185	err := awsAwsjson11_deserializeDocumentUpdateInProgressException(&output, shape)
7186
7187	if err != nil {
7188		var snapshot bytes.Buffer
7189		io.Copy(&snapshot, ringBuffer)
7190		err = &smithy.DeserializationError{
7191			Err:      fmt.Errorf("failed to decode response body, %w", err),
7192			Snapshot: snapshot.Bytes(),
7193		}
7194		return err
7195	}
7196
7197	errorBody.Seek(0, io.SeekStart)
7198	return output
7199}
7200
7201func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
7202	if v == nil {
7203		return fmt.Errorf("unexpected nil of type %T", v)
7204	}
7205	if value == nil {
7206		return nil
7207	}
7208
7209	shape, ok := value.(map[string]interface{})
7210	if !ok {
7211		return fmt.Errorf("unexpected JSON type %v", value)
7212	}
7213
7214	var sv *types.AccessDeniedException
7215	if *v == nil {
7216		sv = &types.AccessDeniedException{}
7217	} else {
7218		sv = *v
7219	}
7220
7221	for key, value := range shape {
7222		switch key {
7223		case "message":
7224			if value != nil {
7225				jtv, ok := value.(string)
7226				if !ok {
7227					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7228				}
7229				sv.Message = ptr.String(jtv)
7230			}
7231
7232		default:
7233			_, _ = key, value
7234
7235		}
7236	}
7237	*v = sv
7238	return nil
7239}
7240
7241func awsAwsjson11_deserializeDocumentAttachment(v **types.Attachment, value interface{}) error {
7242	if v == nil {
7243		return fmt.Errorf("unexpected nil of type %T", v)
7244	}
7245	if value == nil {
7246		return nil
7247	}
7248
7249	shape, ok := value.(map[string]interface{})
7250	if !ok {
7251		return fmt.Errorf("unexpected JSON type %v", value)
7252	}
7253
7254	var sv *types.Attachment
7255	if *v == nil {
7256		sv = &types.Attachment{}
7257	} else {
7258		sv = *v
7259	}
7260
7261	for key, value := range shape {
7262		switch key {
7263		case "details":
7264			if err := awsAwsjson11_deserializeDocumentAttachmentDetails(&sv.Details, value); err != nil {
7265				return err
7266			}
7267
7268		case "id":
7269			if value != nil {
7270				jtv, ok := value.(string)
7271				if !ok {
7272					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7273				}
7274				sv.Id = ptr.String(jtv)
7275			}
7276
7277		case "status":
7278			if value != nil {
7279				jtv, ok := value.(string)
7280				if !ok {
7281					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7282				}
7283				sv.Status = ptr.String(jtv)
7284			}
7285
7286		case "type":
7287			if value != nil {
7288				jtv, ok := value.(string)
7289				if !ok {
7290					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7291				}
7292				sv.Type = ptr.String(jtv)
7293			}
7294
7295		default:
7296			_, _ = key, value
7297
7298		}
7299	}
7300	*v = sv
7301	return nil
7302}
7303
7304func awsAwsjson11_deserializeDocumentAttachmentDetails(v *[]types.KeyValuePair, value interface{}) error {
7305	if v == nil {
7306		return fmt.Errorf("unexpected nil of type %T", v)
7307	}
7308	if value == nil {
7309		return nil
7310	}
7311
7312	shape, ok := value.([]interface{})
7313	if !ok {
7314		return fmt.Errorf("unexpected JSON type %v", value)
7315	}
7316
7317	var cv []types.KeyValuePair
7318	if *v == nil {
7319		cv = []types.KeyValuePair{}
7320	} else {
7321		cv = *v
7322	}
7323
7324	for _, value := range shape {
7325		var col types.KeyValuePair
7326		destAddr := &col
7327		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
7328			return err
7329		}
7330		col = *destAddr
7331		cv = append(cv, col)
7332
7333	}
7334	*v = cv
7335	return nil
7336}
7337
7338func awsAwsjson11_deserializeDocumentAttachments(v *[]types.Attachment, value interface{}) error {
7339	if v == nil {
7340		return fmt.Errorf("unexpected nil of type %T", v)
7341	}
7342	if value == nil {
7343		return nil
7344	}
7345
7346	shape, ok := value.([]interface{})
7347	if !ok {
7348		return fmt.Errorf("unexpected JSON type %v", value)
7349	}
7350
7351	var cv []types.Attachment
7352	if *v == nil {
7353		cv = []types.Attachment{}
7354	} else {
7355		cv = *v
7356	}
7357
7358	for _, value := range shape {
7359		var col types.Attachment
7360		destAddr := &col
7361		if err := awsAwsjson11_deserializeDocumentAttachment(&destAddr, value); err != nil {
7362			return err
7363		}
7364		col = *destAddr
7365		cv = append(cv, col)
7366
7367	}
7368	*v = cv
7369	return nil
7370}
7371
7372func awsAwsjson11_deserializeDocumentAttribute(v **types.Attribute, value interface{}) error {
7373	if v == nil {
7374		return fmt.Errorf("unexpected nil of type %T", v)
7375	}
7376	if value == nil {
7377		return nil
7378	}
7379
7380	shape, ok := value.(map[string]interface{})
7381	if !ok {
7382		return fmt.Errorf("unexpected JSON type %v", value)
7383	}
7384
7385	var sv *types.Attribute
7386	if *v == nil {
7387		sv = &types.Attribute{}
7388	} else {
7389		sv = *v
7390	}
7391
7392	for key, value := range shape {
7393		switch key {
7394		case "name":
7395			if value != nil {
7396				jtv, ok := value.(string)
7397				if !ok {
7398					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7399				}
7400				sv.Name = ptr.String(jtv)
7401			}
7402
7403		case "targetId":
7404			if value != nil {
7405				jtv, ok := value.(string)
7406				if !ok {
7407					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7408				}
7409				sv.TargetId = ptr.String(jtv)
7410			}
7411
7412		case "targetType":
7413			if value != nil {
7414				jtv, ok := value.(string)
7415				if !ok {
7416					return fmt.Errorf("expected TargetType to be of type string, got %T instead", value)
7417				}
7418				sv.TargetType = types.TargetType(jtv)
7419			}
7420
7421		case "value":
7422			if value != nil {
7423				jtv, ok := value.(string)
7424				if !ok {
7425					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7426				}
7427				sv.Value = ptr.String(jtv)
7428			}
7429
7430		default:
7431			_, _ = key, value
7432
7433		}
7434	}
7435	*v = sv
7436	return nil
7437}
7438
7439func awsAwsjson11_deserializeDocumentAttributeLimitExceededException(v **types.AttributeLimitExceededException, value interface{}) error {
7440	if v == nil {
7441		return fmt.Errorf("unexpected nil of type %T", v)
7442	}
7443	if value == nil {
7444		return nil
7445	}
7446
7447	shape, ok := value.(map[string]interface{})
7448	if !ok {
7449		return fmt.Errorf("unexpected JSON type %v", value)
7450	}
7451
7452	var sv *types.AttributeLimitExceededException
7453	if *v == nil {
7454		sv = &types.AttributeLimitExceededException{}
7455	} else {
7456		sv = *v
7457	}
7458
7459	for key, value := range shape {
7460		switch key {
7461		case "message":
7462			if value != nil {
7463				jtv, ok := value.(string)
7464				if !ok {
7465					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7466				}
7467				sv.Message = ptr.String(jtv)
7468			}
7469
7470		default:
7471			_, _ = key, value
7472
7473		}
7474	}
7475	*v = sv
7476	return nil
7477}
7478
7479func awsAwsjson11_deserializeDocumentAttributes(v *[]types.Attribute, value interface{}) error {
7480	if v == nil {
7481		return fmt.Errorf("unexpected nil of type %T", v)
7482	}
7483	if value == nil {
7484		return nil
7485	}
7486
7487	shape, ok := value.([]interface{})
7488	if !ok {
7489		return fmt.Errorf("unexpected JSON type %v", value)
7490	}
7491
7492	var cv []types.Attribute
7493	if *v == nil {
7494		cv = []types.Attribute{}
7495	} else {
7496		cv = *v
7497	}
7498
7499	for _, value := range shape {
7500		var col types.Attribute
7501		destAddr := &col
7502		if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil {
7503			return err
7504		}
7505		col = *destAddr
7506		cv = append(cv, col)
7507
7508	}
7509	*v = cv
7510	return nil
7511}
7512
7513func awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(v **types.AutoScalingGroupProvider, value interface{}) error {
7514	if v == nil {
7515		return fmt.Errorf("unexpected nil of type %T", v)
7516	}
7517	if value == nil {
7518		return nil
7519	}
7520
7521	shape, ok := value.(map[string]interface{})
7522	if !ok {
7523		return fmt.Errorf("unexpected JSON type %v", value)
7524	}
7525
7526	var sv *types.AutoScalingGroupProvider
7527	if *v == nil {
7528		sv = &types.AutoScalingGroupProvider{}
7529	} else {
7530		sv = *v
7531	}
7532
7533	for key, value := range shape {
7534		switch key {
7535		case "autoScalingGroupArn":
7536			if value != nil {
7537				jtv, ok := value.(string)
7538				if !ok {
7539					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7540				}
7541				sv.AutoScalingGroupArn = ptr.String(jtv)
7542			}
7543
7544		case "managedScaling":
7545			if err := awsAwsjson11_deserializeDocumentManagedScaling(&sv.ManagedScaling, value); err != nil {
7546				return err
7547			}
7548
7549		case "managedTerminationProtection":
7550			if value != nil {
7551				jtv, ok := value.(string)
7552				if !ok {
7553					return fmt.Errorf("expected ManagedTerminationProtection to be of type string, got %T instead", value)
7554				}
7555				sv.ManagedTerminationProtection = types.ManagedTerminationProtection(jtv)
7556			}
7557
7558		default:
7559			_, _ = key, value
7560
7561		}
7562	}
7563	*v = sv
7564	return nil
7565}
7566
7567func awsAwsjson11_deserializeDocumentAwsVpcConfiguration(v **types.AwsVpcConfiguration, value interface{}) error {
7568	if v == nil {
7569		return fmt.Errorf("unexpected nil of type %T", v)
7570	}
7571	if value == nil {
7572		return nil
7573	}
7574
7575	shape, ok := value.(map[string]interface{})
7576	if !ok {
7577		return fmt.Errorf("unexpected JSON type %v", value)
7578	}
7579
7580	var sv *types.AwsVpcConfiguration
7581	if *v == nil {
7582		sv = &types.AwsVpcConfiguration{}
7583	} else {
7584		sv = *v
7585	}
7586
7587	for key, value := range shape {
7588		switch key {
7589		case "assignPublicIp":
7590			if value != nil {
7591				jtv, ok := value.(string)
7592				if !ok {
7593					return fmt.Errorf("expected AssignPublicIp to be of type string, got %T instead", value)
7594				}
7595				sv.AssignPublicIp = types.AssignPublicIp(jtv)
7596			}
7597
7598		case "securityGroups":
7599			if err := awsAwsjson11_deserializeDocumentStringList(&sv.SecurityGroups, value); err != nil {
7600				return err
7601			}
7602
7603		case "subnets":
7604			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Subnets, value); err != nil {
7605				return err
7606			}
7607
7608		default:
7609			_, _ = key, value
7610
7611		}
7612	}
7613	*v = sv
7614	return nil
7615}
7616
7617func awsAwsjson11_deserializeDocumentBlockedException(v **types.BlockedException, value interface{}) error {
7618	if v == nil {
7619		return fmt.Errorf("unexpected nil of type %T", v)
7620	}
7621	if value == nil {
7622		return nil
7623	}
7624
7625	shape, ok := value.(map[string]interface{})
7626	if !ok {
7627		return fmt.Errorf("unexpected JSON type %v", value)
7628	}
7629
7630	var sv *types.BlockedException
7631	if *v == nil {
7632		sv = &types.BlockedException{}
7633	} else {
7634		sv = *v
7635	}
7636
7637	for key, value := range shape {
7638		switch key {
7639		case "message":
7640			if value != nil {
7641				jtv, ok := value.(string)
7642				if !ok {
7643					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7644				}
7645				sv.Message = ptr.String(jtv)
7646			}
7647
7648		default:
7649			_, _ = key, value
7650
7651		}
7652	}
7653	*v = sv
7654	return nil
7655}
7656
7657func awsAwsjson11_deserializeDocumentCapacityProvider(v **types.CapacityProvider, value interface{}) error {
7658	if v == nil {
7659		return fmt.Errorf("unexpected nil of type %T", v)
7660	}
7661	if value == nil {
7662		return nil
7663	}
7664
7665	shape, ok := value.(map[string]interface{})
7666	if !ok {
7667		return fmt.Errorf("unexpected JSON type %v", value)
7668	}
7669
7670	var sv *types.CapacityProvider
7671	if *v == nil {
7672		sv = &types.CapacityProvider{}
7673	} else {
7674		sv = *v
7675	}
7676
7677	for key, value := range shape {
7678		switch key {
7679		case "autoScalingGroupProvider":
7680			if err := awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(&sv.AutoScalingGroupProvider, value); err != nil {
7681				return err
7682			}
7683
7684		case "capacityProviderArn":
7685			if value != nil {
7686				jtv, ok := value.(string)
7687				if !ok {
7688					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7689				}
7690				sv.CapacityProviderArn = ptr.String(jtv)
7691			}
7692
7693		case "name":
7694			if value != nil {
7695				jtv, ok := value.(string)
7696				if !ok {
7697					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7698				}
7699				sv.Name = ptr.String(jtv)
7700			}
7701
7702		case "status":
7703			if value != nil {
7704				jtv, ok := value.(string)
7705				if !ok {
7706					return fmt.Errorf("expected CapacityProviderStatus to be of type string, got %T instead", value)
7707				}
7708				sv.Status = types.CapacityProviderStatus(jtv)
7709			}
7710
7711		case "tags":
7712			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
7713				return err
7714			}
7715
7716		case "updateStatus":
7717			if value != nil {
7718				jtv, ok := value.(string)
7719				if !ok {
7720					return fmt.Errorf("expected CapacityProviderUpdateStatus to be of type string, got %T instead", value)
7721				}
7722				sv.UpdateStatus = types.CapacityProviderUpdateStatus(jtv)
7723			}
7724
7725		case "updateStatusReason":
7726			if value != nil {
7727				jtv, ok := value.(string)
7728				if !ok {
7729					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7730				}
7731				sv.UpdateStatusReason = ptr.String(jtv)
7732			}
7733
7734		default:
7735			_, _ = key, value
7736
7737		}
7738	}
7739	*v = sv
7740	return nil
7741}
7742
7743func awsAwsjson11_deserializeDocumentCapacityProviders(v *[]types.CapacityProvider, value interface{}) error {
7744	if v == nil {
7745		return fmt.Errorf("unexpected nil of type %T", v)
7746	}
7747	if value == nil {
7748		return nil
7749	}
7750
7751	shape, ok := value.([]interface{})
7752	if !ok {
7753		return fmt.Errorf("unexpected JSON type %v", value)
7754	}
7755
7756	var cv []types.CapacityProvider
7757	if *v == nil {
7758		cv = []types.CapacityProvider{}
7759	} else {
7760		cv = *v
7761	}
7762
7763	for _, value := range shape {
7764		var col types.CapacityProvider
7765		destAddr := &col
7766		if err := awsAwsjson11_deserializeDocumentCapacityProvider(&destAddr, value); err != nil {
7767			return err
7768		}
7769		col = *destAddr
7770		cv = append(cv, col)
7771
7772	}
7773	*v = cv
7774	return nil
7775}
7776
7777func awsAwsjson11_deserializeDocumentCapacityProviderStrategy(v *[]types.CapacityProviderStrategyItem, value interface{}) error {
7778	if v == nil {
7779		return fmt.Errorf("unexpected nil of type %T", v)
7780	}
7781	if value == nil {
7782		return nil
7783	}
7784
7785	shape, ok := value.([]interface{})
7786	if !ok {
7787		return fmt.Errorf("unexpected JSON type %v", value)
7788	}
7789
7790	var cv []types.CapacityProviderStrategyItem
7791	if *v == nil {
7792		cv = []types.CapacityProviderStrategyItem{}
7793	} else {
7794		cv = *v
7795	}
7796
7797	for _, value := range shape {
7798		var col types.CapacityProviderStrategyItem
7799		destAddr := &col
7800		if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(&destAddr, value); err != nil {
7801			return err
7802		}
7803		col = *destAddr
7804		cv = append(cv, col)
7805
7806	}
7807	*v = cv
7808	return nil
7809}
7810
7811func awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(v **types.CapacityProviderStrategyItem, value interface{}) error {
7812	if v == nil {
7813		return fmt.Errorf("unexpected nil of type %T", v)
7814	}
7815	if value == nil {
7816		return nil
7817	}
7818
7819	shape, ok := value.(map[string]interface{})
7820	if !ok {
7821		return fmt.Errorf("unexpected JSON type %v", value)
7822	}
7823
7824	var sv *types.CapacityProviderStrategyItem
7825	if *v == nil {
7826		sv = &types.CapacityProviderStrategyItem{}
7827	} else {
7828		sv = *v
7829	}
7830
7831	for key, value := range shape {
7832		switch key {
7833		case "base":
7834			if value != nil {
7835				jtv, ok := value.(json.Number)
7836				if !ok {
7837					return fmt.Errorf("expected CapacityProviderStrategyItemBase to be json.Number, got %T instead", value)
7838				}
7839				i64, err := jtv.Int64()
7840				if err != nil {
7841					return err
7842				}
7843				sv.Base = int32(i64)
7844			}
7845
7846		case "capacityProvider":
7847			if value != nil {
7848				jtv, ok := value.(string)
7849				if !ok {
7850					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7851				}
7852				sv.CapacityProvider = ptr.String(jtv)
7853			}
7854
7855		case "weight":
7856			if value != nil {
7857				jtv, ok := value.(json.Number)
7858				if !ok {
7859					return fmt.Errorf("expected CapacityProviderStrategyItemWeight to be json.Number, got %T instead", value)
7860				}
7861				i64, err := jtv.Int64()
7862				if err != nil {
7863					return err
7864				}
7865				sv.Weight = int32(i64)
7866			}
7867
7868		default:
7869			_, _ = key, value
7870
7871		}
7872	}
7873	*v = sv
7874	return nil
7875}
7876
7877func awsAwsjson11_deserializeDocumentClientException(v **types.ClientException, value interface{}) error {
7878	if v == nil {
7879		return fmt.Errorf("unexpected nil of type %T", v)
7880	}
7881	if value == nil {
7882		return nil
7883	}
7884
7885	shape, ok := value.(map[string]interface{})
7886	if !ok {
7887		return fmt.Errorf("unexpected JSON type %v", value)
7888	}
7889
7890	var sv *types.ClientException
7891	if *v == nil {
7892		sv = &types.ClientException{}
7893	} else {
7894		sv = *v
7895	}
7896
7897	for key, value := range shape {
7898		switch key {
7899		case "message":
7900			if value != nil {
7901				jtv, ok := value.(string)
7902				if !ok {
7903					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7904				}
7905				sv.Message = ptr.String(jtv)
7906			}
7907
7908		default:
7909			_, _ = key, value
7910
7911		}
7912	}
7913	*v = sv
7914	return nil
7915}
7916
7917func awsAwsjson11_deserializeDocumentCluster(v **types.Cluster, value interface{}) error {
7918	if v == nil {
7919		return fmt.Errorf("unexpected nil of type %T", v)
7920	}
7921	if value == nil {
7922		return nil
7923	}
7924
7925	shape, ok := value.(map[string]interface{})
7926	if !ok {
7927		return fmt.Errorf("unexpected JSON type %v", value)
7928	}
7929
7930	var sv *types.Cluster
7931	if *v == nil {
7932		sv = &types.Cluster{}
7933	} else {
7934		sv = *v
7935	}
7936
7937	for key, value := range shape {
7938		switch key {
7939		case "activeServicesCount":
7940			if value != nil {
7941				jtv, ok := value.(json.Number)
7942				if !ok {
7943					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
7944				}
7945				i64, err := jtv.Int64()
7946				if err != nil {
7947					return err
7948				}
7949				sv.ActiveServicesCount = int32(i64)
7950			}
7951
7952		case "attachments":
7953			if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
7954				return err
7955			}
7956
7957		case "attachmentsStatus":
7958			if value != nil {
7959				jtv, ok := value.(string)
7960				if !ok {
7961					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7962				}
7963				sv.AttachmentsStatus = ptr.String(jtv)
7964			}
7965
7966		case "capacityProviders":
7967			if err := awsAwsjson11_deserializeDocumentStringList(&sv.CapacityProviders, value); err != nil {
7968				return err
7969			}
7970
7971		case "clusterArn":
7972			if value != nil {
7973				jtv, ok := value.(string)
7974				if !ok {
7975					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7976				}
7977				sv.ClusterArn = ptr.String(jtv)
7978			}
7979
7980		case "clusterName":
7981			if value != nil {
7982				jtv, ok := value.(string)
7983				if !ok {
7984					return fmt.Errorf("expected String to be of type string, got %T instead", value)
7985				}
7986				sv.ClusterName = ptr.String(jtv)
7987			}
7988
7989		case "configuration":
7990			if err := awsAwsjson11_deserializeDocumentClusterConfiguration(&sv.Configuration, value); err != nil {
7991				return err
7992			}
7993
7994		case "defaultCapacityProviderStrategy":
7995			if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.DefaultCapacityProviderStrategy, value); err != nil {
7996				return err
7997			}
7998
7999		case "pendingTasksCount":
8000			if value != nil {
8001				jtv, ok := value.(json.Number)
8002				if !ok {
8003					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
8004				}
8005				i64, err := jtv.Int64()
8006				if err != nil {
8007					return err
8008				}
8009				sv.PendingTasksCount = int32(i64)
8010			}
8011
8012		case "registeredContainerInstancesCount":
8013			if value != nil {
8014				jtv, ok := value.(json.Number)
8015				if !ok {
8016					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
8017				}
8018				i64, err := jtv.Int64()
8019				if err != nil {
8020					return err
8021				}
8022				sv.RegisteredContainerInstancesCount = int32(i64)
8023			}
8024
8025		case "runningTasksCount":
8026			if value != nil {
8027				jtv, ok := value.(json.Number)
8028				if !ok {
8029					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
8030				}
8031				i64, err := jtv.Int64()
8032				if err != nil {
8033					return err
8034				}
8035				sv.RunningTasksCount = int32(i64)
8036			}
8037
8038		case "settings":
8039			if err := awsAwsjson11_deserializeDocumentClusterSettings(&sv.Settings, value); err != nil {
8040				return err
8041			}
8042
8043		case "statistics":
8044			if err := awsAwsjson11_deserializeDocumentStatistics(&sv.Statistics, value); err != nil {
8045				return err
8046			}
8047
8048		case "status":
8049			if value != nil {
8050				jtv, ok := value.(string)
8051				if !ok {
8052					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8053				}
8054				sv.Status = ptr.String(jtv)
8055			}
8056
8057		case "tags":
8058			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
8059				return err
8060			}
8061
8062		default:
8063			_, _ = key, value
8064
8065		}
8066	}
8067	*v = sv
8068	return nil
8069}
8070
8071func awsAwsjson11_deserializeDocumentClusterConfiguration(v **types.ClusterConfiguration, value interface{}) error {
8072	if v == nil {
8073		return fmt.Errorf("unexpected nil of type %T", v)
8074	}
8075	if value == nil {
8076		return nil
8077	}
8078
8079	shape, ok := value.(map[string]interface{})
8080	if !ok {
8081		return fmt.Errorf("unexpected JSON type %v", value)
8082	}
8083
8084	var sv *types.ClusterConfiguration
8085	if *v == nil {
8086		sv = &types.ClusterConfiguration{}
8087	} else {
8088		sv = *v
8089	}
8090
8091	for key, value := range shape {
8092		switch key {
8093		case "executeCommandConfiguration":
8094			if err := awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(&sv.ExecuteCommandConfiguration, value); err != nil {
8095				return err
8096			}
8097
8098		default:
8099			_, _ = key, value
8100
8101		}
8102	}
8103	*v = sv
8104	return nil
8105}
8106
8107func awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(v **types.ClusterContainsContainerInstancesException, value interface{}) error {
8108	if v == nil {
8109		return fmt.Errorf("unexpected nil of type %T", v)
8110	}
8111	if value == nil {
8112		return nil
8113	}
8114
8115	shape, ok := value.(map[string]interface{})
8116	if !ok {
8117		return fmt.Errorf("unexpected JSON type %v", value)
8118	}
8119
8120	var sv *types.ClusterContainsContainerInstancesException
8121	if *v == nil {
8122		sv = &types.ClusterContainsContainerInstancesException{}
8123	} else {
8124		sv = *v
8125	}
8126
8127	for key, value := range shape {
8128		switch key {
8129		case "message":
8130			if value != nil {
8131				jtv, ok := value.(string)
8132				if !ok {
8133					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8134				}
8135				sv.Message = ptr.String(jtv)
8136			}
8137
8138		default:
8139			_, _ = key, value
8140
8141		}
8142	}
8143	*v = sv
8144	return nil
8145}
8146
8147func awsAwsjson11_deserializeDocumentClusterContainsServicesException(v **types.ClusterContainsServicesException, value interface{}) error {
8148	if v == nil {
8149		return fmt.Errorf("unexpected nil of type %T", v)
8150	}
8151	if value == nil {
8152		return nil
8153	}
8154
8155	shape, ok := value.(map[string]interface{})
8156	if !ok {
8157		return fmt.Errorf("unexpected JSON type %v", value)
8158	}
8159
8160	var sv *types.ClusterContainsServicesException
8161	if *v == nil {
8162		sv = &types.ClusterContainsServicesException{}
8163	} else {
8164		sv = *v
8165	}
8166
8167	for key, value := range shape {
8168		switch key {
8169		case "message":
8170			if value != nil {
8171				jtv, ok := value.(string)
8172				if !ok {
8173					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8174				}
8175				sv.Message = ptr.String(jtv)
8176			}
8177
8178		default:
8179			_, _ = key, value
8180
8181		}
8182	}
8183	*v = sv
8184	return nil
8185}
8186
8187func awsAwsjson11_deserializeDocumentClusterContainsTasksException(v **types.ClusterContainsTasksException, value interface{}) error {
8188	if v == nil {
8189		return fmt.Errorf("unexpected nil of type %T", v)
8190	}
8191	if value == nil {
8192		return nil
8193	}
8194
8195	shape, ok := value.(map[string]interface{})
8196	if !ok {
8197		return fmt.Errorf("unexpected JSON type %v", value)
8198	}
8199
8200	var sv *types.ClusterContainsTasksException
8201	if *v == nil {
8202		sv = &types.ClusterContainsTasksException{}
8203	} else {
8204		sv = *v
8205	}
8206
8207	for key, value := range shape {
8208		switch key {
8209		case "message":
8210			if value != nil {
8211				jtv, ok := value.(string)
8212				if !ok {
8213					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8214				}
8215				sv.Message = ptr.String(jtv)
8216			}
8217
8218		default:
8219			_, _ = key, value
8220
8221		}
8222	}
8223	*v = sv
8224	return nil
8225}
8226
8227func awsAwsjson11_deserializeDocumentClusterNotFoundException(v **types.ClusterNotFoundException, value interface{}) error {
8228	if v == nil {
8229		return fmt.Errorf("unexpected nil of type %T", v)
8230	}
8231	if value == nil {
8232		return nil
8233	}
8234
8235	shape, ok := value.(map[string]interface{})
8236	if !ok {
8237		return fmt.Errorf("unexpected JSON type %v", value)
8238	}
8239
8240	var sv *types.ClusterNotFoundException
8241	if *v == nil {
8242		sv = &types.ClusterNotFoundException{}
8243	} else {
8244		sv = *v
8245	}
8246
8247	for key, value := range shape {
8248		switch key {
8249		case "message":
8250			if value != nil {
8251				jtv, ok := value.(string)
8252				if !ok {
8253					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8254				}
8255				sv.Message = ptr.String(jtv)
8256			}
8257
8258		default:
8259			_, _ = key, value
8260
8261		}
8262	}
8263	*v = sv
8264	return nil
8265}
8266
8267func awsAwsjson11_deserializeDocumentClusters(v *[]types.Cluster, value interface{}) error {
8268	if v == nil {
8269		return fmt.Errorf("unexpected nil of type %T", v)
8270	}
8271	if value == nil {
8272		return nil
8273	}
8274
8275	shape, ok := value.([]interface{})
8276	if !ok {
8277		return fmt.Errorf("unexpected JSON type %v", value)
8278	}
8279
8280	var cv []types.Cluster
8281	if *v == nil {
8282		cv = []types.Cluster{}
8283	} else {
8284		cv = *v
8285	}
8286
8287	for _, value := range shape {
8288		var col types.Cluster
8289		destAddr := &col
8290		if err := awsAwsjson11_deserializeDocumentCluster(&destAddr, value); err != nil {
8291			return err
8292		}
8293		col = *destAddr
8294		cv = append(cv, col)
8295
8296	}
8297	*v = cv
8298	return nil
8299}
8300
8301func awsAwsjson11_deserializeDocumentClusterSetting(v **types.ClusterSetting, value interface{}) error {
8302	if v == nil {
8303		return fmt.Errorf("unexpected nil of type %T", v)
8304	}
8305	if value == nil {
8306		return nil
8307	}
8308
8309	shape, ok := value.(map[string]interface{})
8310	if !ok {
8311		return fmt.Errorf("unexpected JSON type %v", value)
8312	}
8313
8314	var sv *types.ClusterSetting
8315	if *v == nil {
8316		sv = &types.ClusterSetting{}
8317	} else {
8318		sv = *v
8319	}
8320
8321	for key, value := range shape {
8322		switch key {
8323		case "name":
8324			if value != nil {
8325				jtv, ok := value.(string)
8326				if !ok {
8327					return fmt.Errorf("expected ClusterSettingName to be of type string, got %T instead", value)
8328				}
8329				sv.Name = types.ClusterSettingName(jtv)
8330			}
8331
8332		case "value":
8333			if value != nil {
8334				jtv, ok := value.(string)
8335				if !ok {
8336					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8337				}
8338				sv.Value = ptr.String(jtv)
8339			}
8340
8341		default:
8342			_, _ = key, value
8343
8344		}
8345	}
8346	*v = sv
8347	return nil
8348}
8349
8350func awsAwsjson11_deserializeDocumentClusterSettings(v *[]types.ClusterSetting, value interface{}) error {
8351	if v == nil {
8352		return fmt.Errorf("unexpected nil of type %T", v)
8353	}
8354	if value == nil {
8355		return nil
8356	}
8357
8358	shape, ok := value.([]interface{})
8359	if !ok {
8360		return fmt.Errorf("unexpected JSON type %v", value)
8361	}
8362
8363	var cv []types.ClusterSetting
8364	if *v == nil {
8365		cv = []types.ClusterSetting{}
8366	} else {
8367		cv = *v
8368	}
8369
8370	for _, value := range shape {
8371		var col types.ClusterSetting
8372		destAddr := &col
8373		if err := awsAwsjson11_deserializeDocumentClusterSetting(&destAddr, value); err != nil {
8374			return err
8375		}
8376		col = *destAddr
8377		cv = append(cv, col)
8378
8379	}
8380	*v = cv
8381	return nil
8382}
8383
8384func awsAwsjson11_deserializeDocumentCompatibilityList(v *[]types.Compatibility, value interface{}) error {
8385	if v == nil {
8386		return fmt.Errorf("unexpected nil of type %T", v)
8387	}
8388	if value == nil {
8389		return nil
8390	}
8391
8392	shape, ok := value.([]interface{})
8393	if !ok {
8394		return fmt.Errorf("unexpected JSON type %v", value)
8395	}
8396
8397	var cv []types.Compatibility
8398	if *v == nil {
8399		cv = []types.Compatibility{}
8400	} else {
8401		cv = *v
8402	}
8403
8404	for _, value := range shape {
8405		var col types.Compatibility
8406		if value != nil {
8407			jtv, ok := value.(string)
8408			if !ok {
8409				return fmt.Errorf("expected Compatibility to be of type string, got %T instead", value)
8410			}
8411			col = types.Compatibility(jtv)
8412		}
8413		cv = append(cv, col)
8414
8415	}
8416	*v = cv
8417	return nil
8418}
8419
8420func awsAwsjson11_deserializeDocumentContainer(v **types.Container, value interface{}) error {
8421	if v == nil {
8422		return fmt.Errorf("unexpected nil of type %T", v)
8423	}
8424	if value == nil {
8425		return nil
8426	}
8427
8428	shape, ok := value.(map[string]interface{})
8429	if !ok {
8430		return fmt.Errorf("unexpected JSON type %v", value)
8431	}
8432
8433	var sv *types.Container
8434	if *v == nil {
8435		sv = &types.Container{}
8436	} else {
8437		sv = *v
8438	}
8439
8440	for key, value := range shape {
8441		switch key {
8442		case "containerArn":
8443			if value != nil {
8444				jtv, ok := value.(string)
8445				if !ok {
8446					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8447				}
8448				sv.ContainerArn = ptr.String(jtv)
8449			}
8450
8451		case "cpu":
8452			if value != nil {
8453				jtv, ok := value.(string)
8454				if !ok {
8455					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8456				}
8457				sv.Cpu = ptr.String(jtv)
8458			}
8459
8460		case "exitCode":
8461			if value != nil {
8462				jtv, ok := value.(json.Number)
8463				if !ok {
8464					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
8465				}
8466				i64, err := jtv.Int64()
8467				if err != nil {
8468					return err
8469				}
8470				sv.ExitCode = ptr.Int32(int32(i64))
8471			}
8472
8473		case "gpuIds":
8474			if err := awsAwsjson11_deserializeDocumentGpuIds(&sv.GpuIds, value); err != nil {
8475				return err
8476			}
8477
8478		case "healthStatus":
8479			if value != nil {
8480				jtv, ok := value.(string)
8481				if !ok {
8482					return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value)
8483				}
8484				sv.HealthStatus = types.HealthStatus(jtv)
8485			}
8486
8487		case "image":
8488			if value != nil {
8489				jtv, ok := value.(string)
8490				if !ok {
8491					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8492				}
8493				sv.Image = ptr.String(jtv)
8494			}
8495
8496		case "imageDigest":
8497			if value != nil {
8498				jtv, ok := value.(string)
8499				if !ok {
8500					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8501				}
8502				sv.ImageDigest = ptr.String(jtv)
8503			}
8504
8505		case "lastStatus":
8506			if value != nil {
8507				jtv, ok := value.(string)
8508				if !ok {
8509					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8510				}
8511				sv.LastStatus = ptr.String(jtv)
8512			}
8513
8514		case "managedAgents":
8515			if err := awsAwsjson11_deserializeDocumentManagedAgents(&sv.ManagedAgents, value); err != nil {
8516				return err
8517			}
8518
8519		case "memory":
8520			if value != nil {
8521				jtv, ok := value.(string)
8522				if !ok {
8523					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8524				}
8525				sv.Memory = ptr.String(jtv)
8526			}
8527
8528		case "memoryReservation":
8529			if value != nil {
8530				jtv, ok := value.(string)
8531				if !ok {
8532					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8533				}
8534				sv.MemoryReservation = ptr.String(jtv)
8535			}
8536
8537		case "name":
8538			if value != nil {
8539				jtv, ok := value.(string)
8540				if !ok {
8541					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8542				}
8543				sv.Name = ptr.String(jtv)
8544			}
8545
8546		case "networkBindings":
8547			if err := awsAwsjson11_deserializeDocumentNetworkBindings(&sv.NetworkBindings, value); err != nil {
8548				return err
8549			}
8550
8551		case "networkInterfaces":
8552			if err := awsAwsjson11_deserializeDocumentNetworkInterfaces(&sv.NetworkInterfaces, value); err != nil {
8553				return err
8554			}
8555
8556		case "reason":
8557			if value != nil {
8558				jtv, ok := value.(string)
8559				if !ok {
8560					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8561				}
8562				sv.Reason = ptr.String(jtv)
8563			}
8564
8565		case "runtimeId":
8566			if value != nil {
8567				jtv, ok := value.(string)
8568				if !ok {
8569					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8570				}
8571				sv.RuntimeId = ptr.String(jtv)
8572			}
8573
8574		case "taskArn":
8575			if value != nil {
8576				jtv, ok := value.(string)
8577				if !ok {
8578					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8579				}
8580				sv.TaskArn = ptr.String(jtv)
8581			}
8582
8583		default:
8584			_, _ = key, value
8585
8586		}
8587	}
8588	*v = sv
8589	return nil
8590}
8591
8592func awsAwsjson11_deserializeDocumentContainerDefinition(v **types.ContainerDefinition, value interface{}) error {
8593	if v == nil {
8594		return fmt.Errorf("unexpected nil of type %T", v)
8595	}
8596	if value == nil {
8597		return nil
8598	}
8599
8600	shape, ok := value.(map[string]interface{})
8601	if !ok {
8602		return fmt.Errorf("unexpected JSON type %v", value)
8603	}
8604
8605	var sv *types.ContainerDefinition
8606	if *v == nil {
8607		sv = &types.ContainerDefinition{}
8608	} else {
8609		sv = *v
8610	}
8611
8612	for key, value := range shape {
8613		switch key {
8614		case "command":
8615			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
8616				return err
8617			}
8618
8619		case "cpu":
8620			if value != nil {
8621				jtv, ok := value.(json.Number)
8622				if !ok {
8623					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
8624				}
8625				i64, err := jtv.Int64()
8626				if err != nil {
8627					return err
8628				}
8629				sv.Cpu = int32(i64)
8630			}
8631
8632		case "dependsOn":
8633			if err := awsAwsjson11_deserializeDocumentContainerDependencies(&sv.DependsOn, value); err != nil {
8634				return err
8635			}
8636
8637		case "disableNetworking":
8638			if value != nil {
8639				jtv, ok := value.(bool)
8640				if !ok {
8641					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8642				}
8643				sv.DisableNetworking = ptr.Bool(jtv)
8644			}
8645
8646		case "dnsSearchDomains":
8647			if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsSearchDomains, value); err != nil {
8648				return err
8649			}
8650
8651		case "dnsServers":
8652			if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsServers, value); err != nil {
8653				return err
8654			}
8655
8656		case "dockerLabels":
8657			if err := awsAwsjson11_deserializeDocumentDockerLabelsMap(&sv.DockerLabels, value); err != nil {
8658				return err
8659			}
8660
8661		case "dockerSecurityOptions":
8662			if err := awsAwsjson11_deserializeDocumentStringList(&sv.DockerSecurityOptions, value); err != nil {
8663				return err
8664			}
8665
8666		case "entryPoint":
8667			if err := awsAwsjson11_deserializeDocumentStringList(&sv.EntryPoint, value); err != nil {
8668				return err
8669			}
8670
8671		case "environment":
8672			if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil {
8673				return err
8674			}
8675
8676		case "environmentFiles":
8677			if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil {
8678				return err
8679			}
8680
8681		case "essential":
8682			if value != nil {
8683				jtv, ok := value.(bool)
8684				if !ok {
8685					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8686				}
8687				sv.Essential = ptr.Bool(jtv)
8688			}
8689
8690		case "extraHosts":
8691			if err := awsAwsjson11_deserializeDocumentHostEntryList(&sv.ExtraHosts, value); err != nil {
8692				return err
8693			}
8694
8695		case "firelensConfiguration":
8696			if err := awsAwsjson11_deserializeDocumentFirelensConfiguration(&sv.FirelensConfiguration, value); err != nil {
8697				return err
8698			}
8699
8700		case "healthCheck":
8701			if err := awsAwsjson11_deserializeDocumentHealthCheck(&sv.HealthCheck, value); err != nil {
8702				return err
8703			}
8704
8705		case "hostname":
8706			if value != nil {
8707				jtv, ok := value.(string)
8708				if !ok {
8709					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8710				}
8711				sv.Hostname = ptr.String(jtv)
8712			}
8713
8714		case "image":
8715			if value != nil {
8716				jtv, ok := value.(string)
8717				if !ok {
8718					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8719				}
8720				sv.Image = ptr.String(jtv)
8721			}
8722
8723		case "interactive":
8724			if value != nil {
8725				jtv, ok := value.(bool)
8726				if !ok {
8727					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8728				}
8729				sv.Interactive = ptr.Bool(jtv)
8730			}
8731
8732		case "links":
8733			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Links, value); err != nil {
8734				return err
8735			}
8736
8737		case "linuxParameters":
8738			if err := awsAwsjson11_deserializeDocumentLinuxParameters(&sv.LinuxParameters, value); err != nil {
8739				return err
8740			}
8741
8742		case "logConfiguration":
8743			if err := awsAwsjson11_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
8744				return err
8745			}
8746
8747		case "memory":
8748			if value != nil {
8749				jtv, ok := value.(json.Number)
8750				if !ok {
8751					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
8752				}
8753				i64, err := jtv.Int64()
8754				if err != nil {
8755					return err
8756				}
8757				sv.Memory = ptr.Int32(int32(i64))
8758			}
8759
8760		case "memoryReservation":
8761			if value != nil {
8762				jtv, ok := value.(json.Number)
8763				if !ok {
8764					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
8765				}
8766				i64, err := jtv.Int64()
8767				if err != nil {
8768					return err
8769				}
8770				sv.MemoryReservation = ptr.Int32(int32(i64))
8771			}
8772
8773		case "mountPoints":
8774			if err := awsAwsjson11_deserializeDocumentMountPointList(&sv.MountPoints, value); err != nil {
8775				return err
8776			}
8777
8778		case "name":
8779			if value != nil {
8780				jtv, ok := value.(string)
8781				if !ok {
8782					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8783				}
8784				sv.Name = ptr.String(jtv)
8785			}
8786
8787		case "portMappings":
8788			if err := awsAwsjson11_deserializeDocumentPortMappingList(&sv.PortMappings, value); err != nil {
8789				return err
8790			}
8791
8792		case "privileged":
8793			if value != nil {
8794				jtv, ok := value.(bool)
8795				if !ok {
8796					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8797				}
8798				sv.Privileged = ptr.Bool(jtv)
8799			}
8800
8801		case "pseudoTerminal":
8802			if value != nil {
8803				jtv, ok := value.(bool)
8804				if !ok {
8805					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8806				}
8807				sv.PseudoTerminal = ptr.Bool(jtv)
8808			}
8809
8810		case "readonlyRootFilesystem":
8811			if value != nil {
8812				jtv, ok := value.(bool)
8813				if !ok {
8814					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
8815				}
8816				sv.ReadonlyRootFilesystem = ptr.Bool(jtv)
8817			}
8818
8819		case "repositoryCredentials":
8820			if err := awsAwsjson11_deserializeDocumentRepositoryCredentials(&sv.RepositoryCredentials, value); err != nil {
8821				return err
8822			}
8823
8824		case "resourceRequirements":
8825			if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil {
8826				return err
8827			}
8828
8829		case "secrets":
8830			if err := awsAwsjson11_deserializeDocumentSecretList(&sv.Secrets, value); err != nil {
8831				return err
8832			}
8833
8834		case "startTimeout":
8835			if value != nil {
8836				jtv, ok := value.(json.Number)
8837				if !ok {
8838					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
8839				}
8840				i64, err := jtv.Int64()
8841				if err != nil {
8842					return err
8843				}
8844				sv.StartTimeout = ptr.Int32(int32(i64))
8845			}
8846
8847		case "stopTimeout":
8848			if value != nil {
8849				jtv, ok := value.(json.Number)
8850				if !ok {
8851					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
8852				}
8853				i64, err := jtv.Int64()
8854				if err != nil {
8855					return err
8856				}
8857				sv.StopTimeout = ptr.Int32(int32(i64))
8858			}
8859
8860		case "systemControls":
8861			if err := awsAwsjson11_deserializeDocumentSystemControls(&sv.SystemControls, value); err != nil {
8862				return err
8863			}
8864
8865		case "ulimits":
8866			if err := awsAwsjson11_deserializeDocumentUlimitList(&sv.Ulimits, value); err != nil {
8867				return err
8868			}
8869
8870		case "user":
8871			if value != nil {
8872				jtv, ok := value.(string)
8873				if !ok {
8874					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8875				}
8876				sv.User = ptr.String(jtv)
8877			}
8878
8879		case "volumesFrom":
8880			if err := awsAwsjson11_deserializeDocumentVolumeFromList(&sv.VolumesFrom, value); err != nil {
8881				return err
8882			}
8883
8884		case "workingDirectory":
8885			if value != nil {
8886				jtv, ok := value.(string)
8887				if !ok {
8888					return fmt.Errorf("expected String to be of type string, got %T instead", value)
8889				}
8890				sv.WorkingDirectory = ptr.String(jtv)
8891			}
8892
8893		default:
8894			_, _ = key, value
8895
8896		}
8897	}
8898	*v = sv
8899	return nil
8900}
8901
8902func awsAwsjson11_deserializeDocumentContainerDefinitions(v *[]types.ContainerDefinition, value interface{}) error {
8903	if v == nil {
8904		return fmt.Errorf("unexpected nil of type %T", v)
8905	}
8906	if value == nil {
8907		return nil
8908	}
8909
8910	shape, ok := value.([]interface{})
8911	if !ok {
8912		return fmt.Errorf("unexpected JSON type %v", value)
8913	}
8914
8915	var cv []types.ContainerDefinition
8916	if *v == nil {
8917		cv = []types.ContainerDefinition{}
8918	} else {
8919		cv = *v
8920	}
8921
8922	for _, value := range shape {
8923		var col types.ContainerDefinition
8924		destAddr := &col
8925		if err := awsAwsjson11_deserializeDocumentContainerDefinition(&destAddr, value); err != nil {
8926			return err
8927		}
8928		col = *destAddr
8929		cv = append(cv, col)
8930
8931	}
8932	*v = cv
8933	return nil
8934}
8935
8936func awsAwsjson11_deserializeDocumentContainerDependencies(v *[]types.ContainerDependency, value interface{}) error {
8937	if v == nil {
8938		return fmt.Errorf("unexpected nil of type %T", v)
8939	}
8940	if value == nil {
8941		return nil
8942	}
8943
8944	shape, ok := value.([]interface{})
8945	if !ok {
8946		return fmt.Errorf("unexpected JSON type %v", value)
8947	}
8948
8949	var cv []types.ContainerDependency
8950	if *v == nil {
8951		cv = []types.ContainerDependency{}
8952	} else {
8953		cv = *v
8954	}
8955
8956	for _, value := range shape {
8957		var col types.ContainerDependency
8958		destAddr := &col
8959		if err := awsAwsjson11_deserializeDocumentContainerDependency(&destAddr, value); err != nil {
8960			return err
8961		}
8962		col = *destAddr
8963		cv = append(cv, col)
8964
8965	}
8966	*v = cv
8967	return nil
8968}
8969
8970func awsAwsjson11_deserializeDocumentContainerDependency(v **types.ContainerDependency, value interface{}) error {
8971	if v == nil {
8972		return fmt.Errorf("unexpected nil of type %T", v)
8973	}
8974	if value == nil {
8975		return nil
8976	}
8977
8978	shape, ok := value.(map[string]interface{})
8979	if !ok {
8980		return fmt.Errorf("unexpected JSON type %v", value)
8981	}
8982
8983	var sv *types.ContainerDependency
8984	if *v == nil {
8985		sv = &types.ContainerDependency{}
8986	} else {
8987		sv = *v
8988	}
8989
8990	for key, value := range shape {
8991		switch key {
8992		case "condition":
8993			if value != nil {
8994				jtv, ok := value.(string)
8995				if !ok {
8996					return fmt.Errorf("expected ContainerCondition to be of type string, got %T instead", value)
8997				}
8998				sv.Condition = types.ContainerCondition(jtv)
8999			}
9000
9001		case "containerName":
9002			if value != nil {
9003				jtv, ok := value.(string)
9004				if !ok {
9005					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9006				}
9007				sv.ContainerName = ptr.String(jtv)
9008			}
9009
9010		default:
9011			_, _ = key, value
9012
9013		}
9014	}
9015	*v = sv
9016	return nil
9017}
9018
9019func awsAwsjson11_deserializeDocumentContainerInstance(v **types.ContainerInstance, value interface{}) error {
9020	if v == nil {
9021		return fmt.Errorf("unexpected nil of type %T", v)
9022	}
9023	if value == nil {
9024		return nil
9025	}
9026
9027	shape, ok := value.(map[string]interface{})
9028	if !ok {
9029		return fmt.Errorf("unexpected JSON type %v", value)
9030	}
9031
9032	var sv *types.ContainerInstance
9033	if *v == nil {
9034		sv = &types.ContainerInstance{}
9035	} else {
9036		sv = *v
9037	}
9038
9039	for key, value := range shape {
9040		switch key {
9041		case "agentConnected":
9042			if value != nil {
9043				jtv, ok := value.(bool)
9044				if !ok {
9045					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
9046				}
9047				sv.AgentConnected = jtv
9048			}
9049
9050		case "agentUpdateStatus":
9051			if value != nil {
9052				jtv, ok := value.(string)
9053				if !ok {
9054					return fmt.Errorf("expected AgentUpdateStatus to be of type string, got %T instead", value)
9055				}
9056				sv.AgentUpdateStatus = types.AgentUpdateStatus(jtv)
9057			}
9058
9059		case "attachments":
9060			if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
9061				return err
9062			}
9063
9064		case "attributes":
9065			if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
9066				return err
9067			}
9068
9069		case "capacityProviderName":
9070			if value != nil {
9071				jtv, ok := value.(string)
9072				if !ok {
9073					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9074				}
9075				sv.CapacityProviderName = ptr.String(jtv)
9076			}
9077
9078		case "containerInstanceArn":
9079			if value != nil {
9080				jtv, ok := value.(string)
9081				if !ok {
9082					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9083				}
9084				sv.ContainerInstanceArn = ptr.String(jtv)
9085			}
9086
9087		case "ec2InstanceId":
9088			if value != nil {
9089				jtv, ok := value.(string)
9090				if !ok {
9091					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9092				}
9093				sv.Ec2InstanceId = ptr.String(jtv)
9094			}
9095
9096		case "pendingTasksCount":
9097			if value != nil {
9098				jtv, ok := value.(json.Number)
9099				if !ok {
9100					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9101				}
9102				i64, err := jtv.Int64()
9103				if err != nil {
9104					return err
9105				}
9106				sv.PendingTasksCount = int32(i64)
9107			}
9108
9109		case "registeredAt":
9110			if value != nil {
9111				jtv, ok := value.(json.Number)
9112				if !ok {
9113					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9114				}
9115				f64, err := jtv.Float64()
9116				if err != nil {
9117					return err
9118				}
9119				sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9120			}
9121
9122		case "registeredResources":
9123			if err := awsAwsjson11_deserializeDocumentResources(&sv.RegisteredResources, value); err != nil {
9124				return err
9125			}
9126
9127		case "remainingResources":
9128			if err := awsAwsjson11_deserializeDocumentResources(&sv.RemainingResources, value); err != nil {
9129				return err
9130			}
9131
9132		case "runningTasksCount":
9133			if value != nil {
9134				jtv, ok := value.(json.Number)
9135				if !ok {
9136					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9137				}
9138				i64, err := jtv.Int64()
9139				if err != nil {
9140					return err
9141				}
9142				sv.RunningTasksCount = int32(i64)
9143			}
9144
9145		case "status":
9146			if value != nil {
9147				jtv, ok := value.(string)
9148				if !ok {
9149					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9150				}
9151				sv.Status = ptr.String(jtv)
9152			}
9153
9154		case "statusReason":
9155			if value != nil {
9156				jtv, ok := value.(string)
9157				if !ok {
9158					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9159				}
9160				sv.StatusReason = ptr.String(jtv)
9161			}
9162
9163		case "tags":
9164			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
9165				return err
9166			}
9167
9168		case "version":
9169			if value != nil {
9170				jtv, ok := value.(json.Number)
9171				if !ok {
9172					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
9173				}
9174				i64, err := jtv.Int64()
9175				if err != nil {
9176					return err
9177				}
9178				sv.Version = i64
9179			}
9180
9181		case "versionInfo":
9182			if err := awsAwsjson11_deserializeDocumentVersionInfo(&sv.VersionInfo, value); err != nil {
9183				return err
9184			}
9185
9186		default:
9187			_, _ = key, value
9188
9189		}
9190	}
9191	*v = sv
9192	return nil
9193}
9194
9195func awsAwsjson11_deserializeDocumentContainerInstances(v *[]types.ContainerInstance, value interface{}) error {
9196	if v == nil {
9197		return fmt.Errorf("unexpected nil of type %T", v)
9198	}
9199	if value == nil {
9200		return nil
9201	}
9202
9203	shape, ok := value.([]interface{})
9204	if !ok {
9205		return fmt.Errorf("unexpected JSON type %v", value)
9206	}
9207
9208	var cv []types.ContainerInstance
9209	if *v == nil {
9210		cv = []types.ContainerInstance{}
9211	} else {
9212		cv = *v
9213	}
9214
9215	for _, value := range shape {
9216		var col types.ContainerInstance
9217		destAddr := &col
9218		if err := awsAwsjson11_deserializeDocumentContainerInstance(&destAddr, value); err != nil {
9219			return err
9220		}
9221		col = *destAddr
9222		cv = append(cv, col)
9223
9224	}
9225	*v = cv
9226	return nil
9227}
9228
9229func awsAwsjson11_deserializeDocumentContainerOverride(v **types.ContainerOverride, value interface{}) error {
9230	if v == nil {
9231		return fmt.Errorf("unexpected nil of type %T", v)
9232	}
9233	if value == nil {
9234		return nil
9235	}
9236
9237	shape, ok := value.(map[string]interface{})
9238	if !ok {
9239		return fmt.Errorf("unexpected JSON type %v", value)
9240	}
9241
9242	var sv *types.ContainerOverride
9243	if *v == nil {
9244		sv = &types.ContainerOverride{}
9245	} else {
9246		sv = *v
9247	}
9248
9249	for key, value := range shape {
9250		switch key {
9251		case "command":
9252			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
9253				return err
9254			}
9255
9256		case "cpu":
9257			if value != nil {
9258				jtv, ok := value.(json.Number)
9259				if !ok {
9260					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
9261				}
9262				i64, err := jtv.Int64()
9263				if err != nil {
9264					return err
9265				}
9266				sv.Cpu = ptr.Int32(int32(i64))
9267			}
9268
9269		case "environment":
9270			if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil {
9271				return err
9272			}
9273
9274		case "environmentFiles":
9275			if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil {
9276				return err
9277			}
9278
9279		case "memory":
9280			if value != nil {
9281				jtv, ok := value.(json.Number)
9282				if !ok {
9283					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
9284				}
9285				i64, err := jtv.Int64()
9286				if err != nil {
9287					return err
9288				}
9289				sv.Memory = ptr.Int32(int32(i64))
9290			}
9291
9292		case "memoryReservation":
9293			if value != nil {
9294				jtv, ok := value.(json.Number)
9295				if !ok {
9296					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
9297				}
9298				i64, err := jtv.Int64()
9299				if err != nil {
9300					return err
9301				}
9302				sv.MemoryReservation = ptr.Int32(int32(i64))
9303			}
9304
9305		case "name":
9306			if value != nil {
9307				jtv, ok := value.(string)
9308				if !ok {
9309					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9310				}
9311				sv.Name = ptr.String(jtv)
9312			}
9313
9314		case "resourceRequirements":
9315			if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil {
9316				return err
9317			}
9318
9319		default:
9320			_, _ = key, value
9321
9322		}
9323	}
9324	*v = sv
9325	return nil
9326}
9327
9328func awsAwsjson11_deserializeDocumentContainerOverrides(v *[]types.ContainerOverride, value interface{}) error {
9329	if v == nil {
9330		return fmt.Errorf("unexpected nil of type %T", v)
9331	}
9332	if value == nil {
9333		return nil
9334	}
9335
9336	shape, ok := value.([]interface{})
9337	if !ok {
9338		return fmt.Errorf("unexpected JSON type %v", value)
9339	}
9340
9341	var cv []types.ContainerOverride
9342	if *v == nil {
9343		cv = []types.ContainerOverride{}
9344	} else {
9345		cv = *v
9346	}
9347
9348	for _, value := range shape {
9349		var col types.ContainerOverride
9350		destAddr := &col
9351		if err := awsAwsjson11_deserializeDocumentContainerOverride(&destAddr, value); err != nil {
9352			return err
9353		}
9354		col = *destAddr
9355		cv = append(cv, col)
9356
9357	}
9358	*v = cv
9359	return nil
9360}
9361
9362func awsAwsjson11_deserializeDocumentContainers(v *[]types.Container, value interface{}) error {
9363	if v == nil {
9364		return fmt.Errorf("unexpected nil of type %T", v)
9365	}
9366	if value == nil {
9367		return nil
9368	}
9369
9370	shape, ok := value.([]interface{})
9371	if !ok {
9372		return fmt.Errorf("unexpected JSON type %v", value)
9373	}
9374
9375	var cv []types.Container
9376	if *v == nil {
9377		cv = []types.Container{}
9378	} else {
9379		cv = *v
9380	}
9381
9382	for _, value := range shape {
9383		var col types.Container
9384		destAddr := &col
9385		if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil {
9386			return err
9387		}
9388		col = *destAddr
9389		cv = append(cv, col)
9390
9391	}
9392	*v = cv
9393	return nil
9394}
9395
9396func awsAwsjson11_deserializeDocumentDeployment(v **types.Deployment, value interface{}) error {
9397	if v == nil {
9398		return fmt.Errorf("unexpected nil of type %T", v)
9399	}
9400	if value == nil {
9401		return nil
9402	}
9403
9404	shape, ok := value.(map[string]interface{})
9405	if !ok {
9406		return fmt.Errorf("unexpected JSON type %v", value)
9407	}
9408
9409	var sv *types.Deployment
9410	if *v == nil {
9411		sv = &types.Deployment{}
9412	} else {
9413		sv = *v
9414	}
9415
9416	for key, value := range shape {
9417		switch key {
9418		case "capacityProviderStrategy":
9419			if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil {
9420				return err
9421			}
9422
9423		case "createdAt":
9424			if value != nil {
9425				jtv, ok := value.(json.Number)
9426				if !ok {
9427					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9428				}
9429				f64, err := jtv.Float64()
9430				if err != nil {
9431					return err
9432				}
9433				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9434			}
9435
9436		case "desiredCount":
9437			if value != nil {
9438				jtv, ok := value.(json.Number)
9439				if !ok {
9440					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9441				}
9442				i64, err := jtv.Int64()
9443				if err != nil {
9444					return err
9445				}
9446				sv.DesiredCount = int32(i64)
9447			}
9448
9449		case "failedTasks":
9450			if value != nil {
9451				jtv, ok := value.(json.Number)
9452				if !ok {
9453					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9454				}
9455				i64, err := jtv.Int64()
9456				if err != nil {
9457					return err
9458				}
9459				sv.FailedTasks = int32(i64)
9460			}
9461
9462		case "id":
9463			if value != nil {
9464				jtv, ok := value.(string)
9465				if !ok {
9466					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9467				}
9468				sv.Id = ptr.String(jtv)
9469			}
9470
9471		case "launchType":
9472			if value != nil {
9473				jtv, ok := value.(string)
9474				if !ok {
9475					return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
9476				}
9477				sv.LaunchType = types.LaunchType(jtv)
9478			}
9479
9480		case "networkConfiguration":
9481			if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
9482				return err
9483			}
9484
9485		case "pendingCount":
9486			if value != nil {
9487				jtv, ok := value.(json.Number)
9488				if !ok {
9489					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9490				}
9491				i64, err := jtv.Int64()
9492				if err != nil {
9493					return err
9494				}
9495				sv.PendingCount = int32(i64)
9496			}
9497
9498		case "platformVersion":
9499			if value != nil {
9500				jtv, ok := value.(string)
9501				if !ok {
9502					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9503				}
9504				sv.PlatformVersion = ptr.String(jtv)
9505			}
9506
9507		case "rolloutState":
9508			if value != nil {
9509				jtv, ok := value.(string)
9510				if !ok {
9511					return fmt.Errorf("expected DeploymentRolloutState to be of type string, got %T instead", value)
9512				}
9513				sv.RolloutState = types.DeploymentRolloutState(jtv)
9514			}
9515
9516		case "rolloutStateReason":
9517			if value != nil {
9518				jtv, ok := value.(string)
9519				if !ok {
9520					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9521				}
9522				sv.RolloutStateReason = ptr.String(jtv)
9523			}
9524
9525		case "runningCount":
9526			if value != nil {
9527				jtv, ok := value.(json.Number)
9528				if !ok {
9529					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
9530				}
9531				i64, err := jtv.Int64()
9532				if err != nil {
9533					return err
9534				}
9535				sv.RunningCount = int32(i64)
9536			}
9537
9538		case "status":
9539			if value != nil {
9540				jtv, ok := value.(string)
9541				if !ok {
9542					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9543				}
9544				sv.Status = ptr.String(jtv)
9545			}
9546
9547		case "taskDefinition":
9548			if value != nil {
9549				jtv, ok := value.(string)
9550				if !ok {
9551					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9552				}
9553				sv.TaskDefinition = ptr.String(jtv)
9554			}
9555
9556		case "updatedAt":
9557			if value != nil {
9558				jtv, ok := value.(json.Number)
9559				if !ok {
9560					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9561				}
9562				f64, err := jtv.Float64()
9563				if err != nil {
9564					return err
9565				}
9566				sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
9567			}
9568
9569		default:
9570			_, _ = key, value
9571
9572		}
9573	}
9574	*v = sv
9575	return nil
9576}
9577
9578func awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(v **types.DeploymentCircuitBreaker, value interface{}) error {
9579	if v == nil {
9580		return fmt.Errorf("unexpected nil of type %T", v)
9581	}
9582	if value == nil {
9583		return nil
9584	}
9585
9586	shape, ok := value.(map[string]interface{})
9587	if !ok {
9588		return fmt.Errorf("unexpected JSON type %v", value)
9589	}
9590
9591	var sv *types.DeploymentCircuitBreaker
9592	if *v == nil {
9593		sv = &types.DeploymentCircuitBreaker{}
9594	} else {
9595		sv = *v
9596	}
9597
9598	for key, value := range shape {
9599		switch key {
9600		case "enable":
9601			if value != nil {
9602				jtv, ok := value.(bool)
9603				if !ok {
9604					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
9605				}
9606				sv.Enable = jtv
9607			}
9608
9609		case "rollback":
9610			if value != nil {
9611				jtv, ok := value.(bool)
9612				if !ok {
9613					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
9614				}
9615				sv.Rollback = jtv
9616			}
9617
9618		default:
9619			_, _ = key, value
9620
9621		}
9622	}
9623	*v = sv
9624	return nil
9625}
9626
9627func awsAwsjson11_deserializeDocumentDeploymentConfiguration(v **types.DeploymentConfiguration, value interface{}) error {
9628	if v == nil {
9629		return fmt.Errorf("unexpected nil of type %T", v)
9630	}
9631	if value == nil {
9632		return nil
9633	}
9634
9635	shape, ok := value.(map[string]interface{})
9636	if !ok {
9637		return fmt.Errorf("unexpected JSON type %v", value)
9638	}
9639
9640	var sv *types.DeploymentConfiguration
9641	if *v == nil {
9642		sv = &types.DeploymentConfiguration{}
9643	} else {
9644		sv = *v
9645	}
9646
9647	for key, value := range shape {
9648		switch key {
9649		case "deploymentCircuitBreaker":
9650			if err := awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(&sv.DeploymentCircuitBreaker, value); err != nil {
9651				return err
9652			}
9653
9654		case "maximumPercent":
9655			if value != nil {
9656				jtv, ok := value.(json.Number)
9657				if !ok {
9658					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
9659				}
9660				i64, err := jtv.Int64()
9661				if err != nil {
9662					return err
9663				}
9664				sv.MaximumPercent = ptr.Int32(int32(i64))
9665			}
9666
9667		case "minimumHealthyPercent":
9668			if value != nil {
9669				jtv, ok := value.(json.Number)
9670				if !ok {
9671					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
9672				}
9673				i64, err := jtv.Int64()
9674				if err != nil {
9675					return err
9676				}
9677				sv.MinimumHealthyPercent = ptr.Int32(int32(i64))
9678			}
9679
9680		default:
9681			_, _ = key, value
9682
9683		}
9684	}
9685	*v = sv
9686	return nil
9687}
9688
9689func awsAwsjson11_deserializeDocumentDeploymentController(v **types.DeploymentController, value interface{}) error {
9690	if v == nil {
9691		return fmt.Errorf("unexpected nil of type %T", v)
9692	}
9693	if value == nil {
9694		return nil
9695	}
9696
9697	shape, ok := value.(map[string]interface{})
9698	if !ok {
9699		return fmt.Errorf("unexpected JSON type %v", value)
9700	}
9701
9702	var sv *types.DeploymentController
9703	if *v == nil {
9704		sv = &types.DeploymentController{}
9705	} else {
9706		sv = *v
9707	}
9708
9709	for key, value := range shape {
9710		switch key {
9711		case "type":
9712			if value != nil {
9713				jtv, ok := value.(string)
9714				if !ok {
9715					return fmt.Errorf("expected DeploymentControllerType to be of type string, got %T instead", value)
9716				}
9717				sv.Type = types.DeploymentControllerType(jtv)
9718			}
9719
9720		default:
9721			_, _ = key, value
9722
9723		}
9724	}
9725	*v = sv
9726	return nil
9727}
9728
9729func awsAwsjson11_deserializeDocumentDeployments(v *[]types.Deployment, value interface{}) error {
9730	if v == nil {
9731		return fmt.Errorf("unexpected nil of type %T", v)
9732	}
9733	if value == nil {
9734		return nil
9735	}
9736
9737	shape, ok := value.([]interface{})
9738	if !ok {
9739		return fmt.Errorf("unexpected JSON type %v", value)
9740	}
9741
9742	var cv []types.Deployment
9743	if *v == nil {
9744		cv = []types.Deployment{}
9745	} else {
9746		cv = *v
9747	}
9748
9749	for _, value := range shape {
9750		var col types.Deployment
9751		destAddr := &col
9752		if err := awsAwsjson11_deserializeDocumentDeployment(&destAddr, value); err != nil {
9753			return err
9754		}
9755		col = *destAddr
9756		cv = append(cv, col)
9757
9758	}
9759	*v = cv
9760	return nil
9761}
9762
9763func awsAwsjson11_deserializeDocumentDevice(v **types.Device, value interface{}) error {
9764	if v == nil {
9765		return fmt.Errorf("unexpected nil of type %T", v)
9766	}
9767	if value == nil {
9768		return nil
9769	}
9770
9771	shape, ok := value.(map[string]interface{})
9772	if !ok {
9773		return fmt.Errorf("unexpected JSON type %v", value)
9774	}
9775
9776	var sv *types.Device
9777	if *v == nil {
9778		sv = &types.Device{}
9779	} else {
9780		sv = *v
9781	}
9782
9783	for key, value := range shape {
9784		switch key {
9785		case "containerPath":
9786			if value != nil {
9787				jtv, ok := value.(string)
9788				if !ok {
9789					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9790				}
9791				sv.ContainerPath = ptr.String(jtv)
9792			}
9793
9794		case "hostPath":
9795			if value != nil {
9796				jtv, ok := value.(string)
9797				if !ok {
9798					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9799				}
9800				sv.HostPath = ptr.String(jtv)
9801			}
9802
9803		case "permissions":
9804			if err := awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(&sv.Permissions, value); err != nil {
9805				return err
9806			}
9807
9808		default:
9809			_, _ = key, value
9810
9811		}
9812	}
9813	*v = sv
9814	return nil
9815}
9816
9817func awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(v *[]types.DeviceCgroupPermission, value interface{}) error {
9818	if v == nil {
9819		return fmt.Errorf("unexpected nil of type %T", v)
9820	}
9821	if value == nil {
9822		return nil
9823	}
9824
9825	shape, ok := value.([]interface{})
9826	if !ok {
9827		return fmt.Errorf("unexpected JSON type %v", value)
9828	}
9829
9830	var cv []types.DeviceCgroupPermission
9831	if *v == nil {
9832		cv = []types.DeviceCgroupPermission{}
9833	} else {
9834		cv = *v
9835	}
9836
9837	for _, value := range shape {
9838		var col types.DeviceCgroupPermission
9839		if value != nil {
9840			jtv, ok := value.(string)
9841			if !ok {
9842				return fmt.Errorf("expected DeviceCgroupPermission to be of type string, got %T instead", value)
9843			}
9844			col = types.DeviceCgroupPermission(jtv)
9845		}
9846		cv = append(cv, col)
9847
9848	}
9849	*v = cv
9850	return nil
9851}
9852
9853func awsAwsjson11_deserializeDocumentDevicesList(v *[]types.Device, value interface{}) error {
9854	if v == nil {
9855		return fmt.Errorf("unexpected nil of type %T", v)
9856	}
9857	if value == nil {
9858		return nil
9859	}
9860
9861	shape, ok := value.([]interface{})
9862	if !ok {
9863		return fmt.Errorf("unexpected JSON type %v", value)
9864	}
9865
9866	var cv []types.Device
9867	if *v == nil {
9868		cv = []types.Device{}
9869	} else {
9870		cv = *v
9871	}
9872
9873	for _, value := range shape {
9874		var col types.Device
9875		destAddr := &col
9876		if err := awsAwsjson11_deserializeDocumentDevice(&destAddr, value); err != nil {
9877			return err
9878		}
9879		col = *destAddr
9880		cv = append(cv, col)
9881
9882	}
9883	*v = cv
9884	return nil
9885}
9886
9887func awsAwsjson11_deserializeDocumentDockerLabelsMap(v *map[string]string, value interface{}) error {
9888	if v == nil {
9889		return fmt.Errorf("unexpected nil of type %T", v)
9890	}
9891	if value == nil {
9892		return nil
9893	}
9894
9895	shape, ok := value.(map[string]interface{})
9896	if !ok {
9897		return fmt.Errorf("unexpected JSON type %v", value)
9898	}
9899
9900	var mv map[string]string
9901	if *v == nil {
9902		mv = map[string]string{}
9903	} else {
9904		mv = *v
9905	}
9906
9907	for key, value := range shape {
9908		var parsedVal string
9909		if value != nil {
9910			jtv, ok := value.(string)
9911			if !ok {
9912				return fmt.Errorf("expected String to be of type string, got %T instead", value)
9913			}
9914			parsedVal = jtv
9915		}
9916		mv[key] = parsedVal
9917
9918	}
9919	*v = mv
9920	return nil
9921}
9922
9923func awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(v **types.DockerVolumeConfiguration, value interface{}) error {
9924	if v == nil {
9925		return fmt.Errorf("unexpected nil of type %T", v)
9926	}
9927	if value == nil {
9928		return nil
9929	}
9930
9931	shape, ok := value.(map[string]interface{})
9932	if !ok {
9933		return fmt.Errorf("unexpected JSON type %v", value)
9934	}
9935
9936	var sv *types.DockerVolumeConfiguration
9937	if *v == nil {
9938		sv = &types.DockerVolumeConfiguration{}
9939	} else {
9940		sv = *v
9941	}
9942
9943	for key, value := range shape {
9944		switch key {
9945		case "autoprovision":
9946			if value != nil {
9947				jtv, ok := value.(bool)
9948				if !ok {
9949					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
9950				}
9951				sv.Autoprovision = ptr.Bool(jtv)
9952			}
9953
9954		case "driver":
9955			if value != nil {
9956				jtv, ok := value.(string)
9957				if !ok {
9958					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9959				}
9960				sv.Driver = ptr.String(jtv)
9961			}
9962
9963		case "driverOpts":
9964			if err := awsAwsjson11_deserializeDocumentStringMap(&sv.DriverOpts, value); err != nil {
9965				return err
9966			}
9967
9968		case "labels":
9969			if err := awsAwsjson11_deserializeDocumentStringMap(&sv.Labels, value); err != nil {
9970				return err
9971			}
9972
9973		case "scope":
9974			if value != nil {
9975				jtv, ok := value.(string)
9976				if !ok {
9977					return fmt.Errorf("expected Scope to be of type string, got %T instead", value)
9978				}
9979				sv.Scope = types.Scope(jtv)
9980			}
9981
9982		default:
9983			_, _ = key, value
9984
9985		}
9986	}
9987	*v = sv
9988	return nil
9989}
9990
9991func awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(v **types.EFSAuthorizationConfig, value interface{}) error {
9992	if v == nil {
9993		return fmt.Errorf("unexpected nil of type %T", v)
9994	}
9995	if value == nil {
9996		return nil
9997	}
9998
9999	shape, ok := value.(map[string]interface{})
10000	if !ok {
10001		return fmt.Errorf("unexpected JSON type %v", value)
10002	}
10003
10004	var sv *types.EFSAuthorizationConfig
10005	if *v == nil {
10006		sv = &types.EFSAuthorizationConfig{}
10007	} else {
10008		sv = *v
10009	}
10010
10011	for key, value := range shape {
10012		switch key {
10013		case "accessPointId":
10014			if value != nil {
10015				jtv, ok := value.(string)
10016				if !ok {
10017					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10018				}
10019				sv.AccessPointId = ptr.String(jtv)
10020			}
10021
10022		case "iam":
10023			if value != nil {
10024				jtv, ok := value.(string)
10025				if !ok {
10026					return fmt.Errorf("expected EFSAuthorizationConfigIAM to be of type string, got %T instead", value)
10027				}
10028				sv.Iam = types.EFSAuthorizationConfigIAM(jtv)
10029			}
10030
10031		default:
10032			_, _ = key, value
10033
10034		}
10035	}
10036	*v = sv
10037	return nil
10038}
10039
10040func awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(v **types.EFSVolumeConfiguration, value interface{}) error {
10041	if v == nil {
10042		return fmt.Errorf("unexpected nil of type %T", v)
10043	}
10044	if value == nil {
10045		return nil
10046	}
10047
10048	shape, ok := value.(map[string]interface{})
10049	if !ok {
10050		return fmt.Errorf("unexpected JSON type %v", value)
10051	}
10052
10053	var sv *types.EFSVolumeConfiguration
10054	if *v == nil {
10055		sv = &types.EFSVolumeConfiguration{}
10056	} else {
10057		sv = *v
10058	}
10059
10060	for key, value := range shape {
10061		switch key {
10062		case "authorizationConfig":
10063			if err := awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil {
10064				return err
10065			}
10066
10067		case "fileSystemId":
10068			if value != nil {
10069				jtv, ok := value.(string)
10070				if !ok {
10071					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10072				}
10073				sv.FileSystemId = ptr.String(jtv)
10074			}
10075
10076		case "rootDirectory":
10077			if value != nil {
10078				jtv, ok := value.(string)
10079				if !ok {
10080					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10081				}
10082				sv.RootDirectory = ptr.String(jtv)
10083			}
10084
10085		case "transitEncryption":
10086			if value != nil {
10087				jtv, ok := value.(string)
10088				if !ok {
10089					return fmt.Errorf("expected EFSTransitEncryption to be of type string, got %T instead", value)
10090				}
10091				sv.TransitEncryption = types.EFSTransitEncryption(jtv)
10092			}
10093
10094		case "transitEncryptionPort":
10095			if value != nil {
10096				jtv, ok := value.(json.Number)
10097				if !ok {
10098					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
10099				}
10100				i64, err := jtv.Int64()
10101				if err != nil {
10102					return err
10103				}
10104				sv.TransitEncryptionPort = ptr.Int32(int32(i64))
10105			}
10106
10107		default:
10108			_, _ = key, value
10109
10110		}
10111	}
10112	*v = sv
10113	return nil
10114}
10115
10116func awsAwsjson11_deserializeDocumentEnvironmentFile(v **types.EnvironmentFile, value interface{}) error {
10117	if v == nil {
10118		return fmt.Errorf("unexpected nil of type %T", v)
10119	}
10120	if value == nil {
10121		return nil
10122	}
10123
10124	shape, ok := value.(map[string]interface{})
10125	if !ok {
10126		return fmt.Errorf("unexpected JSON type %v", value)
10127	}
10128
10129	var sv *types.EnvironmentFile
10130	if *v == nil {
10131		sv = &types.EnvironmentFile{}
10132	} else {
10133		sv = *v
10134	}
10135
10136	for key, value := range shape {
10137		switch key {
10138		case "type":
10139			if value != nil {
10140				jtv, ok := value.(string)
10141				if !ok {
10142					return fmt.Errorf("expected EnvironmentFileType to be of type string, got %T instead", value)
10143				}
10144				sv.Type = types.EnvironmentFileType(jtv)
10145			}
10146
10147		case "value":
10148			if value != nil {
10149				jtv, ok := value.(string)
10150				if !ok {
10151					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10152				}
10153				sv.Value = ptr.String(jtv)
10154			}
10155
10156		default:
10157			_, _ = key, value
10158
10159		}
10160	}
10161	*v = sv
10162	return nil
10163}
10164
10165func awsAwsjson11_deserializeDocumentEnvironmentFiles(v *[]types.EnvironmentFile, value interface{}) error {
10166	if v == nil {
10167		return fmt.Errorf("unexpected nil of type %T", v)
10168	}
10169	if value == nil {
10170		return nil
10171	}
10172
10173	shape, ok := value.([]interface{})
10174	if !ok {
10175		return fmt.Errorf("unexpected JSON type %v", value)
10176	}
10177
10178	var cv []types.EnvironmentFile
10179	if *v == nil {
10180		cv = []types.EnvironmentFile{}
10181	} else {
10182		cv = *v
10183	}
10184
10185	for _, value := range shape {
10186		var col types.EnvironmentFile
10187		destAddr := &col
10188		if err := awsAwsjson11_deserializeDocumentEnvironmentFile(&destAddr, value); err != nil {
10189			return err
10190		}
10191		col = *destAddr
10192		cv = append(cv, col)
10193
10194	}
10195	*v = cv
10196	return nil
10197}
10198
10199func awsAwsjson11_deserializeDocumentEnvironmentVariables(v *[]types.KeyValuePair, value interface{}) error {
10200	if v == nil {
10201		return fmt.Errorf("unexpected nil of type %T", v)
10202	}
10203	if value == nil {
10204		return nil
10205	}
10206
10207	shape, ok := value.([]interface{})
10208	if !ok {
10209		return fmt.Errorf("unexpected JSON type %v", value)
10210	}
10211
10212	var cv []types.KeyValuePair
10213	if *v == nil {
10214		cv = []types.KeyValuePair{}
10215	} else {
10216		cv = *v
10217	}
10218
10219	for _, value := range shape {
10220		var col types.KeyValuePair
10221		destAddr := &col
10222		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
10223			return err
10224		}
10225		col = *destAddr
10226		cv = append(cv, col)
10227
10228	}
10229	*v = cv
10230	return nil
10231}
10232
10233func awsAwsjson11_deserializeDocumentEphemeralStorage(v **types.EphemeralStorage, value interface{}) error {
10234	if v == nil {
10235		return fmt.Errorf("unexpected nil of type %T", v)
10236	}
10237	if value == nil {
10238		return nil
10239	}
10240
10241	shape, ok := value.(map[string]interface{})
10242	if !ok {
10243		return fmt.Errorf("unexpected JSON type %v", value)
10244	}
10245
10246	var sv *types.EphemeralStorage
10247	if *v == nil {
10248		sv = &types.EphemeralStorage{}
10249	} else {
10250		sv = *v
10251	}
10252
10253	for key, value := range shape {
10254		switch key {
10255		case "sizeInGiB":
10256			if value != nil {
10257				jtv, ok := value.(json.Number)
10258				if !ok {
10259					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
10260				}
10261				i64, err := jtv.Int64()
10262				if err != nil {
10263					return err
10264				}
10265				sv.SizeInGiB = int32(i64)
10266			}
10267
10268		default:
10269			_, _ = key, value
10270
10271		}
10272	}
10273	*v = sv
10274	return nil
10275}
10276
10277func awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(v **types.ExecuteCommandConfiguration, value interface{}) error {
10278	if v == nil {
10279		return fmt.Errorf("unexpected nil of type %T", v)
10280	}
10281	if value == nil {
10282		return nil
10283	}
10284
10285	shape, ok := value.(map[string]interface{})
10286	if !ok {
10287		return fmt.Errorf("unexpected JSON type %v", value)
10288	}
10289
10290	var sv *types.ExecuteCommandConfiguration
10291	if *v == nil {
10292		sv = &types.ExecuteCommandConfiguration{}
10293	} else {
10294		sv = *v
10295	}
10296
10297	for key, value := range shape {
10298		switch key {
10299		case "kmsKeyId":
10300			if value != nil {
10301				jtv, ok := value.(string)
10302				if !ok {
10303					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10304				}
10305				sv.KmsKeyId = ptr.String(jtv)
10306			}
10307
10308		case "logConfiguration":
10309			if err := awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(&sv.LogConfiguration, value); err != nil {
10310				return err
10311			}
10312
10313		case "logging":
10314			if value != nil {
10315				jtv, ok := value.(string)
10316				if !ok {
10317					return fmt.Errorf("expected ExecuteCommandLogging to be of type string, got %T instead", value)
10318				}
10319				sv.Logging = types.ExecuteCommandLogging(jtv)
10320			}
10321
10322		default:
10323			_, _ = key, value
10324
10325		}
10326	}
10327	*v = sv
10328	return nil
10329}
10330
10331func awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(v **types.ExecuteCommandLogConfiguration, value interface{}) error {
10332	if v == nil {
10333		return fmt.Errorf("unexpected nil of type %T", v)
10334	}
10335	if value == nil {
10336		return nil
10337	}
10338
10339	shape, ok := value.(map[string]interface{})
10340	if !ok {
10341		return fmt.Errorf("unexpected JSON type %v", value)
10342	}
10343
10344	var sv *types.ExecuteCommandLogConfiguration
10345	if *v == nil {
10346		sv = &types.ExecuteCommandLogConfiguration{}
10347	} else {
10348		sv = *v
10349	}
10350
10351	for key, value := range shape {
10352		switch key {
10353		case "cloudWatchEncryptionEnabled":
10354			if value != nil {
10355				jtv, ok := value.(bool)
10356				if !ok {
10357					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
10358				}
10359				sv.CloudWatchEncryptionEnabled = jtv
10360			}
10361
10362		case "cloudWatchLogGroupName":
10363			if value != nil {
10364				jtv, ok := value.(string)
10365				if !ok {
10366					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10367				}
10368				sv.CloudWatchLogGroupName = ptr.String(jtv)
10369			}
10370
10371		case "s3BucketName":
10372			if value != nil {
10373				jtv, ok := value.(string)
10374				if !ok {
10375					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10376				}
10377				sv.S3BucketName = ptr.String(jtv)
10378			}
10379
10380		case "s3EncryptionEnabled":
10381			if value != nil {
10382				jtv, ok := value.(bool)
10383				if !ok {
10384					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
10385				}
10386				sv.S3EncryptionEnabled = jtv
10387			}
10388
10389		case "s3KeyPrefix":
10390			if value != nil {
10391				jtv, ok := value.(string)
10392				if !ok {
10393					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10394				}
10395				sv.S3KeyPrefix = ptr.String(jtv)
10396			}
10397
10398		default:
10399			_, _ = key, value
10400
10401		}
10402	}
10403	*v = sv
10404	return nil
10405}
10406
10407func awsAwsjson11_deserializeDocumentFailure(v **types.Failure, value interface{}) error {
10408	if v == nil {
10409		return fmt.Errorf("unexpected nil of type %T", v)
10410	}
10411	if value == nil {
10412		return nil
10413	}
10414
10415	shape, ok := value.(map[string]interface{})
10416	if !ok {
10417		return fmt.Errorf("unexpected JSON type %v", value)
10418	}
10419
10420	var sv *types.Failure
10421	if *v == nil {
10422		sv = &types.Failure{}
10423	} else {
10424		sv = *v
10425	}
10426
10427	for key, value := range shape {
10428		switch key {
10429		case "arn":
10430			if value != nil {
10431				jtv, ok := value.(string)
10432				if !ok {
10433					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10434				}
10435				sv.Arn = ptr.String(jtv)
10436			}
10437
10438		case "detail":
10439			if value != nil {
10440				jtv, ok := value.(string)
10441				if !ok {
10442					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10443				}
10444				sv.Detail = ptr.String(jtv)
10445			}
10446
10447		case "reason":
10448			if value != nil {
10449				jtv, ok := value.(string)
10450				if !ok {
10451					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10452				}
10453				sv.Reason = ptr.String(jtv)
10454			}
10455
10456		default:
10457			_, _ = key, value
10458
10459		}
10460	}
10461	*v = sv
10462	return nil
10463}
10464
10465func awsAwsjson11_deserializeDocumentFailures(v *[]types.Failure, value interface{}) error {
10466	if v == nil {
10467		return fmt.Errorf("unexpected nil of type %T", v)
10468	}
10469	if value == nil {
10470		return nil
10471	}
10472
10473	shape, ok := value.([]interface{})
10474	if !ok {
10475		return fmt.Errorf("unexpected JSON type %v", value)
10476	}
10477
10478	var cv []types.Failure
10479	if *v == nil {
10480		cv = []types.Failure{}
10481	} else {
10482		cv = *v
10483	}
10484
10485	for _, value := range shape {
10486		var col types.Failure
10487		destAddr := &col
10488		if err := awsAwsjson11_deserializeDocumentFailure(&destAddr, value); err != nil {
10489			return err
10490		}
10491		col = *destAddr
10492		cv = append(cv, col)
10493
10494	}
10495	*v = cv
10496	return nil
10497}
10498
10499func awsAwsjson11_deserializeDocumentFirelensConfiguration(v **types.FirelensConfiguration, value interface{}) error {
10500	if v == nil {
10501		return fmt.Errorf("unexpected nil of type %T", v)
10502	}
10503	if value == nil {
10504		return nil
10505	}
10506
10507	shape, ok := value.(map[string]interface{})
10508	if !ok {
10509		return fmt.Errorf("unexpected JSON type %v", value)
10510	}
10511
10512	var sv *types.FirelensConfiguration
10513	if *v == nil {
10514		sv = &types.FirelensConfiguration{}
10515	} else {
10516		sv = *v
10517	}
10518
10519	for key, value := range shape {
10520		switch key {
10521		case "options":
10522			if err := awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(&sv.Options, value); err != nil {
10523				return err
10524			}
10525
10526		case "type":
10527			if value != nil {
10528				jtv, ok := value.(string)
10529				if !ok {
10530					return fmt.Errorf("expected FirelensConfigurationType to be of type string, got %T instead", value)
10531				}
10532				sv.Type = types.FirelensConfigurationType(jtv)
10533			}
10534
10535		default:
10536			_, _ = key, value
10537
10538		}
10539	}
10540	*v = sv
10541	return nil
10542}
10543
10544func awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(v *map[string]string, value interface{}) error {
10545	if v == nil {
10546		return fmt.Errorf("unexpected nil of type %T", v)
10547	}
10548	if value == nil {
10549		return nil
10550	}
10551
10552	shape, ok := value.(map[string]interface{})
10553	if !ok {
10554		return fmt.Errorf("unexpected JSON type %v", value)
10555	}
10556
10557	var mv map[string]string
10558	if *v == nil {
10559		mv = map[string]string{}
10560	} else {
10561		mv = *v
10562	}
10563
10564	for key, value := range shape {
10565		var parsedVal string
10566		if value != nil {
10567			jtv, ok := value.(string)
10568			if !ok {
10569				return fmt.Errorf("expected String to be of type string, got %T instead", value)
10570			}
10571			parsedVal = jtv
10572		}
10573		mv[key] = parsedVal
10574
10575	}
10576	*v = mv
10577	return nil
10578}
10579
10580func awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(v **types.FSxWindowsFileServerAuthorizationConfig, value interface{}) error {
10581	if v == nil {
10582		return fmt.Errorf("unexpected nil of type %T", v)
10583	}
10584	if value == nil {
10585		return nil
10586	}
10587
10588	shape, ok := value.(map[string]interface{})
10589	if !ok {
10590		return fmt.Errorf("unexpected JSON type %v", value)
10591	}
10592
10593	var sv *types.FSxWindowsFileServerAuthorizationConfig
10594	if *v == nil {
10595		sv = &types.FSxWindowsFileServerAuthorizationConfig{}
10596	} else {
10597		sv = *v
10598	}
10599
10600	for key, value := range shape {
10601		switch key {
10602		case "credentialsParameter":
10603			if value != nil {
10604				jtv, ok := value.(string)
10605				if !ok {
10606					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10607				}
10608				sv.CredentialsParameter = ptr.String(jtv)
10609			}
10610
10611		case "domain":
10612			if value != nil {
10613				jtv, ok := value.(string)
10614				if !ok {
10615					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10616				}
10617				sv.Domain = ptr.String(jtv)
10618			}
10619
10620		default:
10621			_, _ = key, value
10622
10623		}
10624	}
10625	*v = sv
10626	return nil
10627}
10628
10629func awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(v **types.FSxWindowsFileServerVolumeConfiguration, value interface{}) error {
10630	if v == nil {
10631		return fmt.Errorf("unexpected nil of type %T", v)
10632	}
10633	if value == nil {
10634		return nil
10635	}
10636
10637	shape, ok := value.(map[string]interface{})
10638	if !ok {
10639		return fmt.Errorf("unexpected JSON type %v", value)
10640	}
10641
10642	var sv *types.FSxWindowsFileServerVolumeConfiguration
10643	if *v == nil {
10644		sv = &types.FSxWindowsFileServerVolumeConfiguration{}
10645	} else {
10646		sv = *v
10647	}
10648
10649	for key, value := range shape {
10650		switch key {
10651		case "authorizationConfig":
10652			if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil {
10653				return err
10654			}
10655
10656		case "fileSystemId":
10657			if value != nil {
10658				jtv, ok := value.(string)
10659				if !ok {
10660					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10661				}
10662				sv.FileSystemId = ptr.String(jtv)
10663			}
10664
10665		case "rootDirectory":
10666			if value != nil {
10667				jtv, ok := value.(string)
10668				if !ok {
10669					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10670				}
10671				sv.RootDirectory = ptr.String(jtv)
10672			}
10673
10674		default:
10675			_, _ = key, value
10676
10677		}
10678	}
10679	*v = sv
10680	return nil
10681}
10682
10683func awsAwsjson11_deserializeDocumentGpuIds(v *[]string, value interface{}) error {
10684	if v == nil {
10685		return fmt.Errorf("unexpected nil of type %T", v)
10686	}
10687	if value == nil {
10688		return nil
10689	}
10690
10691	shape, ok := value.([]interface{})
10692	if !ok {
10693		return fmt.Errorf("unexpected JSON type %v", value)
10694	}
10695
10696	var cv []string
10697	if *v == nil {
10698		cv = []string{}
10699	} else {
10700		cv = *v
10701	}
10702
10703	for _, value := range shape {
10704		var col string
10705		if value != nil {
10706			jtv, ok := value.(string)
10707			if !ok {
10708				return fmt.Errorf("expected String to be of type string, got %T instead", value)
10709			}
10710			col = jtv
10711		}
10712		cv = append(cv, col)
10713
10714	}
10715	*v = cv
10716	return nil
10717}
10718
10719func awsAwsjson11_deserializeDocumentHealthCheck(v **types.HealthCheck, value interface{}) error {
10720	if v == nil {
10721		return fmt.Errorf("unexpected nil of type %T", v)
10722	}
10723	if value == nil {
10724		return nil
10725	}
10726
10727	shape, ok := value.(map[string]interface{})
10728	if !ok {
10729		return fmt.Errorf("unexpected JSON type %v", value)
10730	}
10731
10732	var sv *types.HealthCheck
10733	if *v == nil {
10734		sv = &types.HealthCheck{}
10735	} else {
10736		sv = *v
10737	}
10738
10739	for key, value := range shape {
10740		switch key {
10741		case "command":
10742			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil {
10743				return err
10744			}
10745
10746		case "interval":
10747			if value != nil {
10748				jtv, ok := value.(json.Number)
10749				if !ok {
10750					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
10751				}
10752				i64, err := jtv.Int64()
10753				if err != nil {
10754					return err
10755				}
10756				sv.Interval = ptr.Int32(int32(i64))
10757			}
10758
10759		case "retries":
10760			if value != nil {
10761				jtv, ok := value.(json.Number)
10762				if !ok {
10763					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
10764				}
10765				i64, err := jtv.Int64()
10766				if err != nil {
10767					return err
10768				}
10769				sv.Retries = ptr.Int32(int32(i64))
10770			}
10771
10772		case "startPeriod":
10773			if value != nil {
10774				jtv, ok := value.(json.Number)
10775				if !ok {
10776					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
10777				}
10778				i64, err := jtv.Int64()
10779				if err != nil {
10780					return err
10781				}
10782				sv.StartPeriod = ptr.Int32(int32(i64))
10783			}
10784
10785		case "timeout":
10786			if value != nil {
10787				jtv, ok := value.(json.Number)
10788				if !ok {
10789					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
10790				}
10791				i64, err := jtv.Int64()
10792				if err != nil {
10793					return err
10794				}
10795				sv.Timeout = ptr.Int32(int32(i64))
10796			}
10797
10798		default:
10799			_, _ = key, value
10800
10801		}
10802	}
10803	*v = sv
10804	return nil
10805}
10806
10807func awsAwsjson11_deserializeDocumentHostEntry(v **types.HostEntry, value interface{}) error {
10808	if v == nil {
10809		return fmt.Errorf("unexpected nil of type %T", v)
10810	}
10811	if value == nil {
10812		return nil
10813	}
10814
10815	shape, ok := value.(map[string]interface{})
10816	if !ok {
10817		return fmt.Errorf("unexpected JSON type %v", value)
10818	}
10819
10820	var sv *types.HostEntry
10821	if *v == nil {
10822		sv = &types.HostEntry{}
10823	} else {
10824		sv = *v
10825	}
10826
10827	for key, value := range shape {
10828		switch key {
10829		case "hostname":
10830			if value != nil {
10831				jtv, ok := value.(string)
10832				if !ok {
10833					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10834				}
10835				sv.Hostname = ptr.String(jtv)
10836			}
10837
10838		case "ipAddress":
10839			if value != nil {
10840				jtv, ok := value.(string)
10841				if !ok {
10842					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10843				}
10844				sv.IpAddress = ptr.String(jtv)
10845			}
10846
10847		default:
10848			_, _ = key, value
10849
10850		}
10851	}
10852	*v = sv
10853	return nil
10854}
10855
10856func awsAwsjson11_deserializeDocumentHostEntryList(v *[]types.HostEntry, value interface{}) error {
10857	if v == nil {
10858		return fmt.Errorf("unexpected nil of type %T", v)
10859	}
10860	if value == nil {
10861		return nil
10862	}
10863
10864	shape, ok := value.([]interface{})
10865	if !ok {
10866		return fmt.Errorf("unexpected JSON type %v", value)
10867	}
10868
10869	var cv []types.HostEntry
10870	if *v == nil {
10871		cv = []types.HostEntry{}
10872	} else {
10873		cv = *v
10874	}
10875
10876	for _, value := range shape {
10877		var col types.HostEntry
10878		destAddr := &col
10879		if err := awsAwsjson11_deserializeDocumentHostEntry(&destAddr, value); err != nil {
10880			return err
10881		}
10882		col = *destAddr
10883		cv = append(cv, col)
10884
10885	}
10886	*v = cv
10887	return nil
10888}
10889
10890func awsAwsjson11_deserializeDocumentHostVolumeProperties(v **types.HostVolumeProperties, value interface{}) error {
10891	if v == nil {
10892		return fmt.Errorf("unexpected nil of type %T", v)
10893	}
10894	if value == nil {
10895		return nil
10896	}
10897
10898	shape, ok := value.(map[string]interface{})
10899	if !ok {
10900		return fmt.Errorf("unexpected JSON type %v", value)
10901	}
10902
10903	var sv *types.HostVolumeProperties
10904	if *v == nil {
10905		sv = &types.HostVolumeProperties{}
10906	} else {
10907		sv = *v
10908	}
10909
10910	for key, value := range shape {
10911		switch key {
10912		case "sourcePath":
10913			if value != nil {
10914				jtv, ok := value.(string)
10915				if !ok {
10916					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10917				}
10918				sv.SourcePath = ptr.String(jtv)
10919			}
10920
10921		default:
10922			_, _ = key, value
10923
10924		}
10925	}
10926	*v = sv
10927	return nil
10928}
10929
10930func awsAwsjson11_deserializeDocumentInferenceAccelerator(v **types.InferenceAccelerator, value interface{}) error {
10931	if v == nil {
10932		return fmt.Errorf("unexpected nil of type %T", v)
10933	}
10934	if value == nil {
10935		return nil
10936	}
10937
10938	shape, ok := value.(map[string]interface{})
10939	if !ok {
10940		return fmt.Errorf("unexpected JSON type %v", value)
10941	}
10942
10943	var sv *types.InferenceAccelerator
10944	if *v == nil {
10945		sv = &types.InferenceAccelerator{}
10946	} else {
10947		sv = *v
10948	}
10949
10950	for key, value := range shape {
10951		switch key {
10952		case "deviceName":
10953			if value != nil {
10954				jtv, ok := value.(string)
10955				if !ok {
10956					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10957				}
10958				sv.DeviceName = ptr.String(jtv)
10959			}
10960
10961		case "deviceType":
10962			if value != nil {
10963				jtv, ok := value.(string)
10964				if !ok {
10965					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10966				}
10967				sv.DeviceType = ptr.String(jtv)
10968			}
10969
10970		default:
10971			_, _ = key, value
10972
10973		}
10974	}
10975	*v = sv
10976	return nil
10977}
10978
10979func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(v **types.InferenceAcceleratorOverride, value interface{}) error {
10980	if v == nil {
10981		return fmt.Errorf("unexpected nil of type %T", v)
10982	}
10983	if value == nil {
10984		return nil
10985	}
10986
10987	shape, ok := value.(map[string]interface{})
10988	if !ok {
10989		return fmt.Errorf("unexpected JSON type %v", value)
10990	}
10991
10992	var sv *types.InferenceAcceleratorOverride
10993	if *v == nil {
10994		sv = &types.InferenceAcceleratorOverride{}
10995	} else {
10996		sv = *v
10997	}
10998
10999	for key, value := range shape {
11000		switch key {
11001		case "deviceName":
11002			if value != nil {
11003				jtv, ok := value.(string)
11004				if !ok {
11005					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11006				}
11007				sv.DeviceName = ptr.String(jtv)
11008			}
11009
11010		case "deviceType":
11011			if value != nil {
11012				jtv, ok := value.(string)
11013				if !ok {
11014					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11015				}
11016				sv.DeviceType = ptr.String(jtv)
11017			}
11018
11019		default:
11020			_, _ = key, value
11021
11022		}
11023	}
11024	*v = sv
11025	return nil
11026}
11027
11028func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(v *[]types.InferenceAcceleratorOverride, value interface{}) error {
11029	if v == nil {
11030		return fmt.Errorf("unexpected nil of type %T", v)
11031	}
11032	if value == nil {
11033		return nil
11034	}
11035
11036	shape, ok := value.([]interface{})
11037	if !ok {
11038		return fmt.Errorf("unexpected JSON type %v", value)
11039	}
11040
11041	var cv []types.InferenceAcceleratorOverride
11042	if *v == nil {
11043		cv = []types.InferenceAcceleratorOverride{}
11044	} else {
11045		cv = *v
11046	}
11047
11048	for _, value := range shape {
11049		var col types.InferenceAcceleratorOverride
11050		destAddr := &col
11051		if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(&destAddr, value); err != nil {
11052			return err
11053		}
11054		col = *destAddr
11055		cv = append(cv, col)
11056
11057	}
11058	*v = cv
11059	return nil
11060}
11061
11062func awsAwsjson11_deserializeDocumentInferenceAccelerators(v *[]types.InferenceAccelerator, value interface{}) error {
11063	if v == nil {
11064		return fmt.Errorf("unexpected nil of type %T", v)
11065	}
11066	if value == nil {
11067		return nil
11068	}
11069
11070	shape, ok := value.([]interface{})
11071	if !ok {
11072		return fmt.Errorf("unexpected JSON type %v", value)
11073	}
11074
11075	var cv []types.InferenceAccelerator
11076	if *v == nil {
11077		cv = []types.InferenceAccelerator{}
11078	} else {
11079		cv = *v
11080	}
11081
11082	for _, value := range shape {
11083		var col types.InferenceAccelerator
11084		destAddr := &col
11085		if err := awsAwsjson11_deserializeDocumentInferenceAccelerator(&destAddr, value); err != nil {
11086			return err
11087		}
11088		col = *destAddr
11089		cv = append(cv, col)
11090
11091	}
11092	*v = cv
11093	return nil
11094}
11095
11096func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error {
11097	if v == nil {
11098		return fmt.Errorf("unexpected nil of type %T", v)
11099	}
11100	if value == nil {
11101		return nil
11102	}
11103
11104	shape, ok := value.(map[string]interface{})
11105	if !ok {
11106		return fmt.Errorf("unexpected JSON type %v", value)
11107	}
11108
11109	var sv *types.InvalidParameterException
11110	if *v == nil {
11111		sv = &types.InvalidParameterException{}
11112	} else {
11113		sv = *v
11114	}
11115
11116	for key, value := range shape {
11117		switch key {
11118		case "message":
11119			if value != nil {
11120				jtv, ok := value.(string)
11121				if !ok {
11122					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11123				}
11124				sv.Message = ptr.String(jtv)
11125			}
11126
11127		default:
11128			_, _ = key, value
11129
11130		}
11131	}
11132	*v = sv
11133	return nil
11134}
11135
11136func awsAwsjson11_deserializeDocumentKernelCapabilities(v **types.KernelCapabilities, value interface{}) error {
11137	if v == nil {
11138		return fmt.Errorf("unexpected nil of type %T", v)
11139	}
11140	if value == nil {
11141		return nil
11142	}
11143
11144	shape, ok := value.(map[string]interface{})
11145	if !ok {
11146		return fmt.Errorf("unexpected JSON type %v", value)
11147	}
11148
11149	var sv *types.KernelCapabilities
11150	if *v == nil {
11151		sv = &types.KernelCapabilities{}
11152	} else {
11153		sv = *v
11154	}
11155
11156	for key, value := range shape {
11157		switch key {
11158		case "add":
11159			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Add, value); err != nil {
11160				return err
11161			}
11162
11163		case "drop":
11164			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Drop, value); err != nil {
11165				return err
11166			}
11167
11168		default:
11169			_, _ = key, value
11170
11171		}
11172	}
11173	*v = sv
11174	return nil
11175}
11176
11177func awsAwsjson11_deserializeDocumentKeyValuePair(v **types.KeyValuePair, value interface{}) error {
11178	if v == nil {
11179		return fmt.Errorf("unexpected nil of type %T", v)
11180	}
11181	if value == nil {
11182		return nil
11183	}
11184
11185	shape, ok := value.(map[string]interface{})
11186	if !ok {
11187		return fmt.Errorf("unexpected JSON type %v", value)
11188	}
11189
11190	var sv *types.KeyValuePair
11191	if *v == nil {
11192		sv = &types.KeyValuePair{}
11193	} else {
11194		sv = *v
11195	}
11196
11197	for key, value := range shape {
11198		switch key {
11199		case "name":
11200			if value != nil {
11201				jtv, ok := value.(string)
11202				if !ok {
11203					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11204				}
11205				sv.Name = ptr.String(jtv)
11206			}
11207
11208		case "value":
11209			if value != nil {
11210				jtv, ok := value.(string)
11211				if !ok {
11212					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11213				}
11214				sv.Value = ptr.String(jtv)
11215			}
11216
11217		default:
11218			_, _ = key, value
11219
11220		}
11221	}
11222	*v = sv
11223	return nil
11224}
11225
11226func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
11227	if v == nil {
11228		return fmt.Errorf("unexpected nil of type %T", v)
11229	}
11230	if value == nil {
11231		return nil
11232	}
11233
11234	shape, ok := value.(map[string]interface{})
11235	if !ok {
11236		return fmt.Errorf("unexpected JSON type %v", value)
11237	}
11238
11239	var sv *types.LimitExceededException
11240	if *v == nil {
11241		sv = &types.LimitExceededException{}
11242	} else {
11243		sv = *v
11244	}
11245
11246	for key, value := range shape {
11247		switch key {
11248		case "message":
11249			if value != nil {
11250				jtv, ok := value.(string)
11251				if !ok {
11252					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11253				}
11254				sv.Message = ptr.String(jtv)
11255			}
11256
11257		default:
11258			_, _ = key, value
11259
11260		}
11261	}
11262	*v = sv
11263	return nil
11264}
11265
11266func awsAwsjson11_deserializeDocumentLinuxParameters(v **types.LinuxParameters, value interface{}) error {
11267	if v == nil {
11268		return fmt.Errorf("unexpected nil of type %T", v)
11269	}
11270	if value == nil {
11271		return nil
11272	}
11273
11274	shape, ok := value.(map[string]interface{})
11275	if !ok {
11276		return fmt.Errorf("unexpected JSON type %v", value)
11277	}
11278
11279	var sv *types.LinuxParameters
11280	if *v == nil {
11281		sv = &types.LinuxParameters{}
11282	} else {
11283		sv = *v
11284	}
11285
11286	for key, value := range shape {
11287		switch key {
11288		case "capabilities":
11289			if err := awsAwsjson11_deserializeDocumentKernelCapabilities(&sv.Capabilities, value); err != nil {
11290				return err
11291			}
11292
11293		case "devices":
11294			if err := awsAwsjson11_deserializeDocumentDevicesList(&sv.Devices, value); err != nil {
11295				return err
11296			}
11297
11298		case "initProcessEnabled":
11299			if value != nil {
11300				jtv, ok := value.(bool)
11301				if !ok {
11302					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
11303				}
11304				sv.InitProcessEnabled = ptr.Bool(jtv)
11305			}
11306
11307		case "maxSwap":
11308			if value != nil {
11309				jtv, ok := value.(json.Number)
11310				if !ok {
11311					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11312				}
11313				i64, err := jtv.Int64()
11314				if err != nil {
11315					return err
11316				}
11317				sv.MaxSwap = ptr.Int32(int32(i64))
11318			}
11319
11320		case "sharedMemorySize":
11321			if value != nil {
11322				jtv, ok := value.(json.Number)
11323				if !ok {
11324					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11325				}
11326				i64, err := jtv.Int64()
11327				if err != nil {
11328					return err
11329				}
11330				sv.SharedMemorySize = ptr.Int32(int32(i64))
11331			}
11332
11333		case "swappiness":
11334			if value != nil {
11335				jtv, ok := value.(json.Number)
11336				if !ok {
11337					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11338				}
11339				i64, err := jtv.Int64()
11340				if err != nil {
11341					return err
11342				}
11343				sv.Swappiness = ptr.Int32(int32(i64))
11344			}
11345
11346		case "tmpfs":
11347			if err := awsAwsjson11_deserializeDocumentTmpfsList(&sv.Tmpfs, value); err != nil {
11348				return err
11349			}
11350
11351		default:
11352			_, _ = key, value
11353
11354		}
11355	}
11356	*v = sv
11357	return nil
11358}
11359
11360func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, value interface{}) error {
11361	if v == nil {
11362		return fmt.Errorf("unexpected nil of type %T", v)
11363	}
11364	if value == nil {
11365		return nil
11366	}
11367
11368	shape, ok := value.(map[string]interface{})
11369	if !ok {
11370		return fmt.Errorf("unexpected JSON type %v", value)
11371	}
11372
11373	var sv *types.LoadBalancer
11374	if *v == nil {
11375		sv = &types.LoadBalancer{}
11376	} else {
11377		sv = *v
11378	}
11379
11380	for key, value := range shape {
11381		switch key {
11382		case "containerName":
11383			if value != nil {
11384				jtv, ok := value.(string)
11385				if !ok {
11386					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11387				}
11388				sv.ContainerName = ptr.String(jtv)
11389			}
11390
11391		case "containerPort":
11392			if value != nil {
11393				jtv, ok := value.(json.Number)
11394				if !ok {
11395					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11396				}
11397				i64, err := jtv.Int64()
11398				if err != nil {
11399					return err
11400				}
11401				sv.ContainerPort = ptr.Int32(int32(i64))
11402			}
11403
11404		case "loadBalancerName":
11405			if value != nil {
11406				jtv, ok := value.(string)
11407				if !ok {
11408					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11409				}
11410				sv.LoadBalancerName = ptr.String(jtv)
11411			}
11412
11413		case "targetGroupArn":
11414			if value != nil {
11415				jtv, ok := value.(string)
11416				if !ok {
11417					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11418				}
11419				sv.TargetGroupArn = ptr.String(jtv)
11420			}
11421
11422		default:
11423			_, _ = key, value
11424
11425		}
11426	}
11427	*v = sv
11428	return nil
11429}
11430
11431func awsAwsjson11_deserializeDocumentLoadBalancers(v *[]types.LoadBalancer, value interface{}) error {
11432	if v == nil {
11433		return fmt.Errorf("unexpected nil of type %T", v)
11434	}
11435	if value == nil {
11436		return nil
11437	}
11438
11439	shape, ok := value.([]interface{})
11440	if !ok {
11441		return fmt.Errorf("unexpected JSON type %v", value)
11442	}
11443
11444	var cv []types.LoadBalancer
11445	if *v == nil {
11446		cv = []types.LoadBalancer{}
11447	} else {
11448		cv = *v
11449	}
11450
11451	for _, value := range shape {
11452		var col types.LoadBalancer
11453		destAddr := &col
11454		if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil {
11455			return err
11456		}
11457		col = *destAddr
11458		cv = append(cv, col)
11459
11460	}
11461	*v = cv
11462	return nil
11463}
11464
11465func awsAwsjson11_deserializeDocumentLogConfiguration(v **types.LogConfiguration, value interface{}) error {
11466	if v == nil {
11467		return fmt.Errorf("unexpected nil of type %T", v)
11468	}
11469	if value == nil {
11470		return nil
11471	}
11472
11473	shape, ok := value.(map[string]interface{})
11474	if !ok {
11475		return fmt.Errorf("unexpected JSON type %v", value)
11476	}
11477
11478	var sv *types.LogConfiguration
11479	if *v == nil {
11480		sv = &types.LogConfiguration{}
11481	} else {
11482		sv = *v
11483	}
11484
11485	for key, value := range shape {
11486		switch key {
11487		case "logDriver":
11488			if value != nil {
11489				jtv, ok := value.(string)
11490				if !ok {
11491					return fmt.Errorf("expected LogDriver to be of type string, got %T instead", value)
11492				}
11493				sv.LogDriver = types.LogDriver(jtv)
11494			}
11495
11496		case "options":
11497			if err := awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(&sv.Options, value); err != nil {
11498				return err
11499			}
11500
11501		case "secretOptions":
11502			if err := awsAwsjson11_deserializeDocumentSecretList(&sv.SecretOptions, value); err != nil {
11503				return err
11504			}
11505
11506		default:
11507			_, _ = key, value
11508
11509		}
11510	}
11511	*v = sv
11512	return nil
11513}
11514
11515func awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(v *map[string]string, value interface{}) error {
11516	if v == nil {
11517		return fmt.Errorf("unexpected nil of type %T", v)
11518	}
11519	if value == nil {
11520		return nil
11521	}
11522
11523	shape, ok := value.(map[string]interface{})
11524	if !ok {
11525		return fmt.Errorf("unexpected JSON type %v", value)
11526	}
11527
11528	var mv map[string]string
11529	if *v == nil {
11530		mv = map[string]string{}
11531	} else {
11532		mv = *v
11533	}
11534
11535	for key, value := range shape {
11536		var parsedVal string
11537		if value != nil {
11538			jtv, ok := value.(string)
11539			if !ok {
11540				return fmt.Errorf("expected String to be of type string, got %T instead", value)
11541			}
11542			parsedVal = jtv
11543		}
11544		mv[key] = parsedVal
11545
11546	}
11547	*v = mv
11548	return nil
11549}
11550
11551func awsAwsjson11_deserializeDocumentManagedAgent(v **types.ManagedAgent, value interface{}) error {
11552	if v == nil {
11553		return fmt.Errorf("unexpected nil of type %T", v)
11554	}
11555	if value == nil {
11556		return nil
11557	}
11558
11559	shape, ok := value.(map[string]interface{})
11560	if !ok {
11561		return fmt.Errorf("unexpected JSON type %v", value)
11562	}
11563
11564	var sv *types.ManagedAgent
11565	if *v == nil {
11566		sv = &types.ManagedAgent{}
11567	} else {
11568		sv = *v
11569	}
11570
11571	for key, value := range shape {
11572		switch key {
11573		case "lastStartedAt":
11574			if value != nil {
11575				jtv, ok := value.(json.Number)
11576				if !ok {
11577					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
11578				}
11579				f64, err := jtv.Float64()
11580				if err != nil {
11581					return err
11582				}
11583				sv.LastStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
11584			}
11585
11586		case "lastStatus":
11587			if value != nil {
11588				jtv, ok := value.(string)
11589				if !ok {
11590					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11591				}
11592				sv.LastStatus = ptr.String(jtv)
11593			}
11594
11595		case "name":
11596			if value != nil {
11597				jtv, ok := value.(string)
11598				if !ok {
11599					return fmt.Errorf("expected ManagedAgentName to be of type string, got %T instead", value)
11600				}
11601				sv.Name = types.ManagedAgentName(jtv)
11602			}
11603
11604		case "reason":
11605			if value != nil {
11606				jtv, ok := value.(string)
11607				if !ok {
11608					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11609				}
11610				sv.Reason = ptr.String(jtv)
11611			}
11612
11613		default:
11614			_, _ = key, value
11615
11616		}
11617	}
11618	*v = sv
11619	return nil
11620}
11621
11622func awsAwsjson11_deserializeDocumentManagedAgents(v *[]types.ManagedAgent, value interface{}) error {
11623	if v == nil {
11624		return fmt.Errorf("unexpected nil of type %T", v)
11625	}
11626	if value == nil {
11627		return nil
11628	}
11629
11630	shape, ok := value.([]interface{})
11631	if !ok {
11632		return fmt.Errorf("unexpected JSON type %v", value)
11633	}
11634
11635	var cv []types.ManagedAgent
11636	if *v == nil {
11637		cv = []types.ManagedAgent{}
11638	} else {
11639		cv = *v
11640	}
11641
11642	for _, value := range shape {
11643		var col types.ManagedAgent
11644		destAddr := &col
11645		if err := awsAwsjson11_deserializeDocumentManagedAgent(&destAddr, value); err != nil {
11646			return err
11647		}
11648		col = *destAddr
11649		cv = append(cv, col)
11650
11651	}
11652	*v = cv
11653	return nil
11654}
11655
11656func awsAwsjson11_deserializeDocumentManagedScaling(v **types.ManagedScaling, value interface{}) error {
11657	if v == nil {
11658		return fmt.Errorf("unexpected nil of type %T", v)
11659	}
11660	if value == nil {
11661		return nil
11662	}
11663
11664	shape, ok := value.(map[string]interface{})
11665	if !ok {
11666		return fmt.Errorf("unexpected JSON type %v", value)
11667	}
11668
11669	var sv *types.ManagedScaling
11670	if *v == nil {
11671		sv = &types.ManagedScaling{}
11672	} else {
11673		sv = *v
11674	}
11675
11676	for key, value := range shape {
11677		switch key {
11678		case "instanceWarmupPeriod":
11679			if value != nil {
11680				jtv, ok := value.(json.Number)
11681				if !ok {
11682					return fmt.Errorf("expected ManagedScalingInstanceWarmupPeriod to be json.Number, got %T instead", value)
11683				}
11684				i64, err := jtv.Int64()
11685				if err != nil {
11686					return err
11687				}
11688				sv.InstanceWarmupPeriod = ptr.Int32(int32(i64))
11689			}
11690
11691		case "maximumScalingStepSize":
11692			if value != nil {
11693				jtv, ok := value.(json.Number)
11694				if !ok {
11695					return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value)
11696				}
11697				i64, err := jtv.Int64()
11698				if err != nil {
11699					return err
11700				}
11701				sv.MaximumScalingStepSize = ptr.Int32(int32(i64))
11702			}
11703
11704		case "minimumScalingStepSize":
11705			if value != nil {
11706				jtv, ok := value.(json.Number)
11707				if !ok {
11708					return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value)
11709				}
11710				i64, err := jtv.Int64()
11711				if err != nil {
11712					return err
11713				}
11714				sv.MinimumScalingStepSize = ptr.Int32(int32(i64))
11715			}
11716
11717		case "status":
11718			if value != nil {
11719				jtv, ok := value.(string)
11720				if !ok {
11721					return fmt.Errorf("expected ManagedScalingStatus to be of type string, got %T instead", value)
11722				}
11723				sv.Status = types.ManagedScalingStatus(jtv)
11724			}
11725
11726		case "targetCapacity":
11727			if value != nil {
11728				jtv, ok := value.(json.Number)
11729				if !ok {
11730					return fmt.Errorf("expected ManagedScalingTargetCapacity to be json.Number, got %T instead", value)
11731				}
11732				i64, err := jtv.Int64()
11733				if err != nil {
11734					return err
11735				}
11736				sv.TargetCapacity = ptr.Int32(int32(i64))
11737			}
11738
11739		default:
11740			_, _ = key, value
11741
11742		}
11743	}
11744	*v = sv
11745	return nil
11746}
11747
11748func awsAwsjson11_deserializeDocumentMissingVersionException(v **types.MissingVersionException, value interface{}) error {
11749	if v == nil {
11750		return fmt.Errorf("unexpected nil of type %T", v)
11751	}
11752	if value == nil {
11753		return nil
11754	}
11755
11756	shape, ok := value.(map[string]interface{})
11757	if !ok {
11758		return fmt.Errorf("unexpected JSON type %v", value)
11759	}
11760
11761	var sv *types.MissingVersionException
11762	if *v == nil {
11763		sv = &types.MissingVersionException{}
11764	} else {
11765		sv = *v
11766	}
11767
11768	for key, value := range shape {
11769		switch key {
11770		case "message":
11771			if value != nil {
11772				jtv, ok := value.(string)
11773				if !ok {
11774					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11775				}
11776				sv.Message = ptr.String(jtv)
11777			}
11778
11779		default:
11780			_, _ = key, value
11781
11782		}
11783	}
11784	*v = sv
11785	return nil
11786}
11787
11788func awsAwsjson11_deserializeDocumentMountPoint(v **types.MountPoint, value interface{}) error {
11789	if v == nil {
11790		return fmt.Errorf("unexpected nil of type %T", v)
11791	}
11792	if value == nil {
11793		return nil
11794	}
11795
11796	shape, ok := value.(map[string]interface{})
11797	if !ok {
11798		return fmt.Errorf("unexpected JSON type %v", value)
11799	}
11800
11801	var sv *types.MountPoint
11802	if *v == nil {
11803		sv = &types.MountPoint{}
11804	} else {
11805		sv = *v
11806	}
11807
11808	for key, value := range shape {
11809		switch key {
11810		case "containerPath":
11811			if value != nil {
11812				jtv, ok := value.(string)
11813				if !ok {
11814					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11815				}
11816				sv.ContainerPath = ptr.String(jtv)
11817			}
11818
11819		case "readOnly":
11820			if value != nil {
11821				jtv, ok := value.(bool)
11822				if !ok {
11823					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
11824				}
11825				sv.ReadOnly = ptr.Bool(jtv)
11826			}
11827
11828		case "sourceVolume":
11829			if value != nil {
11830				jtv, ok := value.(string)
11831				if !ok {
11832					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11833				}
11834				sv.SourceVolume = ptr.String(jtv)
11835			}
11836
11837		default:
11838			_, _ = key, value
11839
11840		}
11841	}
11842	*v = sv
11843	return nil
11844}
11845
11846func awsAwsjson11_deserializeDocumentMountPointList(v *[]types.MountPoint, value interface{}) error {
11847	if v == nil {
11848		return fmt.Errorf("unexpected nil of type %T", v)
11849	}
11850	if value == nil {
11851		return nil
11852	}
11853
11854	shape, ok := value.([]interface{})
11855	if !ok {
11856		return fmt.Errorf("unexpected JSON type %v", value)
11857	}
11858
11859	var cv []types.MountPoint
11860	if *v == nil {
11861		cv = []types.MountPoint{}
11862	} else {
11863		cv = *v
11864	}
11865
11866	for _, value := range shape {
11867		var col types.MountPoint
11868		destAddr := &col
11869		if err := awsAwsjson11_deserializeDocumentMountPoint(&destAddr, value); err != nil {
11870			return err
11871		}
11872		col = *destAddr
11873		cv = append(cv, col)
11874
11875	}
11876	*v = cv
11877	return nil
11878}
11879
11880func awsAwsjson11_deserializeDocumentNetworkBinding(v **types.NetworkBinding, value interface{}) error {
11881	if v == nil {
11882		return fmt.Errorf("unexpected nil of type %T", v)
11883	}
11884	if value == nil {
11885		return nil
11886	}
11887
11888	shape, ok := value.(map[string]interface{})
11889	if !ok {
11890		return fmt.Errorf("unexpected JSON type %v", value)
11891	}
11892
11893	var sv *types.NetworkBinding
11894	if *v == nil {
11895		sv = &types.NetworkBinding{}
11896	} else {
11897		sv = *v
11898	}
11899
11900	for key, value := range shape {
11901		switch key {
11902		case "bindIP":
11903			if value != nil {
11904				jtv, ok := value.(string)
11905				if !ok {
11906					return fmt.Errorf("expected String to be of type string, got %T instead", value)
11907				}
11908				sv.BindIP = ptr.String(jtv)
11909			}
11910
11911		case "containerPort":
11912			if value != nil {
11913				jtv, ok := value.(json.Number)
11914				if !ok {
11915					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11916				}
11917				i64, err := jtv.Int64()
11918				if err != nil {
11919					return err
11920				}
11921				sv.ContainerPort = ptr.Int32(int32(i64))
11922			}
11923
11924		case "hostPort":
11925			if value != nil {
11926				jtv, ok := value.(json.Number)
11927				if !ok {
11928					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
11929				}
11930				i64, err := jtv.Int64()
11931				if err != nil {
11932					return err
11933				}
11934				sv.HostPort = ptr.Int32(int32(i64))
11935			}
11936
11937		case "protocol":
11938			if value != nil {
11939				jtv, ok := value.(string)
11940				if !ok {
11941					return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value)
11942				}
11943				sv.Protocol = types.TransportProtocol(jtv)
11944			}
11945
11946		default:
11947			_, _ = key, value
11948
11949		}
11950	}
11951	*v = sv
11952	return nil
11953}
11954
11955func awsAwsjson11_deserializeDocumentNetworkBindings(v *[]types.NetworkBinding, value interface{}) error {
11956	if v == nil {
11957		return fmt.Errorf("unexpected nil of type %T", v)
11958	}
11959	if value == nil {
11960		return nil
11961	}
11962
11963	shape, ok := value.([]interface{})
11964	if !ok {
11965		return fmt.Errorf("unexpected JSON type %v", value)
11966	}
11967
11968	var cv []types.NetworkBinding
11969	if *v == nil {
11970		cv = []types.NetworkBinding{}
11971	} else {
11972		cv = *v
11973	}
11974
11975	for _, value := range shape {
11976		var col types.NetworkBinding
11977		destAddr := &col
11978		if err := awsAwsjson11_deserializeDocumentNetworkBinding(&destAddr, value); err != nil {
11979			return err
11980		}
11981		col = *destAddr
11982		cv = append(cv, col)
11983
11984	}
11985	*v = cv
11986	return nil
11987}
11988
11989func awsAwsjson11_deserializeDocumentNetworkConfiguration(v **types.NetworkConfiguration, value interface{}) error {
11990	if v == nil {
11991		return fmt.Errorf("unexpected nil of type %T", v)
11992	}
11993	if value == nil {
11994		return nil
11995	}
11996
11997	shape, ok := value.(map[string]interface{})
11998	if !ok {
11999		return fmt.Errorf("unexpected JSON type %v", value)
12000	}
12001
12002	var sv *types.NetworkConfiguration
12003	if *v == nil {
12004		sv = &types.NetworkConfiguration{}
12005	} else {
12006		sv = *v
12007	}
12008
12009	for key, value := range shape {
12010		switch key {
12011		case "awsvpcConfiguration":
12012			if err := awsAwsjson11_deserializeDocumentAwsVpcConfiguration(&sv.AwsvpcConfiguration, value); err != nil {
12013				return err
12014			}
12015
12016		default:
12017			_, _ = key, value
12018
12019		}
12020	}
12021	*v = sv
12022	return nil
12023}
12024
12025func awsAwsjson11_deserializeDocumentNetworkInterface(v **types.NetworkInterface, value interface{}) error {
12026	if v == nil {
12027		return fmt.Errorf("unexpected nil of type %T", v)
12028	}
12029	if value == nil {
12030		return nil
12031	}
12032
12033	shape, ok := value.(map[string]interface{})
12034	if !ok {
12035		return fmt.Errorf("unexpected JSON type %v", value)
12036	}
12037
12038	var sv *types.NetworkInterface
12039	if *v == nil {
12040		sv = &types.NetworkInterface{}
12041	} else {
12042		sv = *v
12043	}
12044
12045	for key, value := range shape {
12046		switch key {
12047		case "attachmentId":
12048			if value != nil {
12049				jtv, ok := value.(string)
12050				if !ok {
12051					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12052				}
12053				sv.AttachmentId = ptr.String(jtv)
12054			}
12055
12056		case "ipv6Address":
12057			if value != nil {
12058				jtv, ok := value.(string)
12059				if !ok {
12060					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12061				}
12062				sv.Ipv6Address = ptr.String(jtv)
12063			}
12064
12065		case "privateIpv4Address":
12066			if value != nil {
12067				jtv, ok := value.(string)
12068				if !ok {
12069					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12070				}
12071				sv.PrivateIpv4Address = ptr.String(jtv)
12072			}
12073
12074		default:
12075			_, _ = key, value
12076
12077		}
12078	}
12079	*v = sv
12080	return nil
12081}
12082
12083func awsAwsjson11_deserializeDocumentNetworkInterfaces(v *[]types.NetworkInterface, value interface{}) error {
12084	if v == nil {
12085		return fmt.Errorf("unexpected nil of type %T", v)
12086	}
12087	if value == nil {
12088		return nil
12089	}
12090
12091	shape, ok := value.([]interface{})
12092	if !ok {
12093		return fmt.Errorf("unexpected JSON type %v", value)
12094	}
12095
12096	var cv []types.NetworkInterface
12097	if *v == nil {
12098		cv = []types.NetworkInterface{}
12099	} else {
12100		cv = *v
12101	}
12102
12103	for _, value := range shape {
12104		var col types.NetworkInterface
12105		destAddr := &col
12106		if err := awsAwsjson11_deserializeDocumentNetworkInterface(&destAddr, value); err != nil {
12107			return err
12108		}
12109		col = *destAddr
12110		cv = append(cv, col)
12111
12112	}
12113	*v = cv
12114	return nil
12115}
12116
12117func awsAwsjson11_deserializeDocumentNoUpdateAvailableException(v **types.NoUpdateAvailableException, value interface{}) error {
12118	if v == nil {
12119		return fmt.Errorf("unexpected nil of type %T", v)
12120	}
12121	if value == nil {
12122		return nil
12123	}
12124
12125	shape, ok := value.(map[string]interface{})
12126	if !ok {
12127		return fmt.Errorf("unexpected JSON type %v", value)
12128	}
12129
12130	var sv *types.NoUpdateAvailableException
12131	if *v == nil {
12132		sv = &types.NoUpdateAvailableException{}
12133	} else {
12134		sv = *v
12135	}
12136
12137	for key, value := range shape {
12138		switch key {
12139		case "message":
12140			if value != nil {
12141				jtv, ok := value.(string)
12142				if !ok {
12143					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12144				}
12145				sv.Message = ptr.String(jtv)
12146			}
12147
12148		default:
12149			_, _ = key, value
12150
12151		}
12152	}
12153	*v = sv
12154	return nil
12155}
12156
12157func awsAwsjson11_deserializeDocumentPlacementConstraint(v **types.PlacementConstraint, value interface{}) error {
12158	if v == nil {
12159		return fmt.Errorf("unexpected nil of type %T", v)
12160	}
12161	if value == nil {
12162		return nil
12163	}
12164
12165	shape, ok := value.(map[string]interface{})
12166	if !ok {
12167		return fmt.Errorf("unexpected JSON type %v", value)
12168	}
12169
12170	var sv *types.PlacementConstraint
12171	if *v == nil {
12172		sv = &types.PlacementConstraint{}
12173	} else {
12174		sv = *v
12175	}
12176
12177	for key, value := range shape {
12178		switch key {
12179		case "expression":
12180			if value != nil {
12181				jtv, ok := value.(string)
12182				if !ok {
12183					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12184				}
12185				sv.Expression = ptr.String(jtv)
12186			}
12187
12188		case "type":
12189			if value != nil {
12190				jtv, ok := value.(string)
12191				if !ok {
12192					return fmt.Errorf("expected PlacementConstraintType to be of type string, got %T instead", value)
12193				}
12194				sv.Type = types.PlacementConstraintType(jtv)
12195			}
12196
12197		default:
12198			_, _ = key, value
12199
12200		}
12201	}
12202	*v = sv
12203	return nil
12204}
12205
12206func awsAwsjson11_deserializeDocumentPlacementConstraints(v *[]types.PlacementConstraint, value interface{}) error {
12207	if v == nil {
12208		return fmt.Errorf("unexpected nil of type %T", v)
12209	}
12210	if value == nil {
12211		return nil
12212	}
12213
12214	shape, ok := value.([]interface{})
12215	if !ok {
12216		return fmt.Errorf("unexpected JSON type %v", value)
12217	}
12218
12219	var cv []types.PlacementConstraint
12220	if *v == nil {
12221		cv = []types.PlacementConstraint{}
12222	} else {
12223		cv = *v
12224	}
12225
12226	for _, value := range shape {
12227		var col types.PlacementConstraint
12228		destAddr := &col
12229		if err := awsAwsjson11_deserializeDocumentPlacementConstraint(&destAddr, value); err != nil {
12230			return err
12231		}
12232		col = *destAddr
12233		cv = append(cv, col)
12234
12235	}
12236	*v = cv
12237	return nil
12238}
12239
12240func awsAwsjson11_deserializeDocumentPlacementStrategies(v *[]types.PlacementStrategy, value interface{}) error {
12241	if v == nil {
12242		return fmt.Errorf("unexpected nil of type %T", v)
12243	}
12244	if value == nil {
12245		return nil
12246	}
12247
12248	shape, ok := value.([]interface{})
12249	if !ok {
12250		return fmt.Errorf("unexpected JSON type %v", value)
12251	}
12252
12253	var cv []types.PlacementStrategy
12254	if *v == nil {
12255		cv = []types.PlacementStrategy{}
12256	} else {
12257		cv = *v
12258	}
12259
12260	for _, value := range shape {
12261		var col types.PlacementStrategy
12262		destAddr := &col
12263		if err := awsAwsjson11_deserializeDocumentPlacementStrategy(&destAddr, value); err != nil {
12264			return err
12265		}
12266		col = *destAddr
12267		cv = append(cv, col)
12268
12269	}
12270	*v = cv
12271	return nil
12272}
12273
12274func awsAwsjson11_deserializeDocumentPlacementStrategy(v **types.PlacementStrategy, value interface{}) error {
12275	if v == nil {
12276		return fmt.Errorf("unexpected nil of type %T", v)
12277	}
12278	if value == nil {
12279		return nil
12280	}
12281
12282	shape, ok := value.(map[string]interface{})
12283	if !ok {
12284		return fmt.Errorf("unexpected JSON type %v", value)
12285	}
12286
12287	var sv *types.PlacementStrategy
12288	if *v == nil {
12289		sv = &types.PlacementStrategy{}
12290	} else {
12291		sv = *v
12292	}
12293
12294	for key, value := range shape {
12295		switch key {
12296		case "field":
12297			if value != nil {
12298				jtv, ok := value.(string)
12299				if !ok {
12300					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12301				}
12302				sv.Field = ptr.String(jtv)
12303			}
12304
12305		case "type":
12306			if value != nil {
12307				jtv, ok := value.(string)
12308				if !ok {
12309					return fmt.Errorf("expected PlacementStrategyType to be of type string, got %T instead", value)
12310				}
12311				sv.Type = types.PlacementStrategyType(jtv)
12312			}
12313
12314		default:
12315			_, _ = key, value
12316
12317		}
12318	}
12319	*v = sv
12320	return nil
12321}
12322
12323func awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(v **types.PlatformTaskDefinitionIncompatibilityException, value interface{}) error {
12324	if v == nil {
12325		return fmt.Errorf("unexpected nil of type %T", v)
12326	}
12327	if value == nil {
12328		return nil
12329	}
12330
12331	shape, ok := value.(map[string]interface{})
12332	if !ok {
12333		return fmt.Errorf("unexpected JSON type %v", value)
12334	}
12335
12336	var sv *types.PlatformTaskDefinitionIncompatibilityException
12337	if *v == nil {
12338		sv = &types.PlatformTaskDefinitionIncompatibilityException{}
12339	} else {
12340		sv = *v
12341	}
12342
12343	for key, value := range shape {
12344		switch key {
12345		case "message":
12346			if value != nil {
12347				jtv, ok := value.(string)
12348				if !ok {
12349					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12350				}
12351				sv.Message = ptr.String(jtv)
12352			}
12353
12354		default:
12355			_, _ = key, value
12356
12357		}
12358	}
12359	*v = sv
12360	return nil
12361}
12362
12363func awsAwsjson11_deserializeDocumentPlatformUnknownException(v **types.PlatformUnknownException, value interface{}) error {
12364	if v == nil {
12365		return fmt.Errorf("unexpected nil of type %T", v)
12366	}
12367	if value == nil {
12368		return nil
12369	}
12370
12371	shape, ok := value.(map[string]interface{})
12372	if !ok {
12373		return fmt.Errorf("unexpected JSON type %v", value)
12374	}
12375
12376	var sv *types.PlatformUnknownException
12377	if *v == nil {
12378		sv = &types.PlatformUnknownException{}
12379	} else {
12380		sv = *v
12381	}
12382
12383	for key, value := range shape {
12384		switch key {
12385		case "message":
12386			if value != nil {
12387				jtv, ok := value.(string)
12388				if !ok {
12389					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12390				}
12391				sv.Message = ptr.String(jtv)
12392			}
12393
12394		default:
12395			_, _ = key, value
12396
12397		}
12398	}
12399	*v = sv
12400	return nil
12401}
12402
12403func awsAwsjson11_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error {
12404	if v == nil {
12405		return fmt.Errorf("unexpected nil of type %T", v)
12406	}
12407	if value == nil {
12408		return nil
12409	}
12410
12411	shape, ok := value.(map[string]interface{})
12412	if !ok {
12413		return fmt.Errorf("unexpected JSON type %v", value)
12414	}
12415
12416	var sv *types.PortMapping
12417	if *v == nil {
12418		sv = &types.PortMapping{}
12419	} else {
12420		sv = *v
12421	}
12422
12423	for key, value := range shape {
12424		switch key {
12425		case "containerPort":
12426			if value != nil {
12427				jtv, ok := value.(json.Number)
12428				if !ok {
12429					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
12430				}
12431				i64, err := jtv.Int64()
12432				if err != nil {
12433					return err
12434				}
12435				sv.ContainerPort = ptr.Int32(int32(i64))
12436			}
12437
12438		case "hostPort":
12439			if value != nil {
12440				jtv, ok := value.(json.Number)
12441				if !ok {
12442					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
12443				}
12444				i64, err := jtv.Int64()
12445				if err != nil {
12446					return err
12447				}
12448				sv.HostPort = ptr.Int32(int32(i64))
12449			}
12450
12451		case "protocol":
12452			if value != nil {
12453				jtv, ok := value.(string)
12454				if !ok {
12455					return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value)
12456				}
12457				sv.Protocol = types.TransportProtocol(jtv)
12458			}
12459
12460		default:
12461			_, _ = key, value
12462
12463		}
12464	}
12465	*v = sv
12466	return nil
12467}
12468
12469func awsAwsjson11_deserializeDocumentPortMappingList(v *[]types.PortMapping, value interface{}) error {
12470	if v == nil {
12471		return fmt.Errorf("unexpected nil of type %T", v)
12472	}
12473	if value == nil {
12474		return nil
12475	}
12476
12477	shape, ok := value.([]interface{})
12478	if !ok {
12479		return fmt.Errorf("unexpected JSON type %v", value)
12480	}
12481
12482	var cv []types.PortMapping
12483	if *v == nil {
12484		cv = []types.PortMapping{}
12485	} else {
12486		cv = *v
12487	}
12488
12489	for _, value := range shape {
12490		var col types.PortMapping
12491		destAddr := &col
12492		if err := awsAwsjson11_deserializeDocumentPortMapping(&destAddr, value); err != nil {
12493			return err
12494		}
12495		col = *destAddr
12496		cv = append(cv, col)
12497
12498	}
12499	*v = cv
12500	return nil
12501}
12502
12503func awsAwsjson11_deserializeDocumentProxyConfiguration(v **types.ProxyConfiguration, value interface{}) error {
12504	if v == nil {
12505		return fmt.Errorf("unexpected nil of type %T", v)
12506	}
12507	if value == nil {
12508		return nil
12509	}
12510
12511	shape, ok := value.(map[string]interface{})
12512	if !ok {
12513		return fmt.Errorf("unexpected JSON type %v", value)
12514	}
12515
12516	var sv *types.ProxyConfiguration
12517	if *v == nil {
12518		sv = &types.ProxyConfiguration{}
12519	} else {
12520		sv = *v
12521	}
12522
12523	for key, value := range shape {
12524		switch key {
12525		case "containerName":
12526			if value != nil {
12527				jtv, ok := value.(string)
12528				if !ok {
12529					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12530				}
12531				sv.ContainerName = ptr.String(jtv)
12532			}
12533
12534		case "properties":
12535			if err := awsAwsjson11_deserializeDocumentProxyConfigurationProperties(&sv.Properties, value); err != nil {
12536				return err
12537			}
12538
12539		case "type":
12540			if value != nil {
12541				jtv, ok := value.(string)
12542				if !ok {
12543					return fmt.Errorf("expected ProxyConfigurationType to be of type string, got %T instead", value)
12544				}
12545				sv.Type = types.ProxyConfigurationType(jtv)
12546			}
12547
12548		default:
12549			_, _ = key, value
12550
12551		}
12552	}
12553	*v = sv
12554	return nil
12555}
12556
12557func awsAwsjson11_deserializeDocumentProxyConfigurationProperties(v *[]types.KeyValuePair, value interface{}) error {
12558	if v == nil {
12559		return fmt.Errorf("unexpected nil of type %T", v)
12560	}
12561	if value == nil {
12562		return nil
12563	}
12564
12565	shape, ok := value.([]interface{})
12566	if !ok {
12567		return fmt.Errorf("unexpected JSON type %v", value)
12568	}
12569
12570	var cv []types.KeyValuePair
12571	if *v == nil {
12572		cv = []types.KeyValuePair{}
12573	} else {
12574		cv = *v
12575	}
12576
12577	for _, value := range shape {
12578		var col types.KeyValuePair
12579		destAddr := &col
12580		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
12581			return err
12582		}
12583		col = *destAddr
12584		cv = append(cv, col)
12585
12586	}
12587	*v = cv
12588	return nil
12589}
12590
12591func awsAwsjson11_deserializeDocumentRepositoryCredentials(v **types.RepositoryCredentials, value interface{}) error {
12592	if v == nil {
12593		return fmt.Errorf("unexpected nil of type %T", v)
12594	}
12595	if value == nil {
12596		return nil
12597	}
12598
12599	shape, ok := value.(map[string]interface{})
12600	if !ok {
12601		return fmt.Errorf("unexpected JSON type %v", value)
12602	}
12603
12604	var sv *types.RepositoryCredentials
12605	if *v == nil {
12606		sv = &types.RepositoryCredentials{}
12607	} else {
12608		sv = *v
12609	}
12610
12611	for key, value := range shape {
12612		switch key {
12613		case "credentialsParameter":
12614			if value != nil {
12615				jtv, ok := value.(string)
12616				if !ok {
12617					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12618				}
12619				sv.CredentialsParameter = ptr.String(jtv)
12620			}
12621
12622		default:
12623			_, _ = key, value
12624
12625		}
12626	}
12627	*v = sv
12628	return nil
12629}
12630
12631func awsAwsjson11_deserializeDocumentRequiresAttributes(v *[]types.Attribute, value interface{}) error {
12632	if v == nil {
12633		return fmt.Errorf("unexpected nil of type %T", v)
12634	}
12635	if value == nil {
12636		return nil
12637	}
12638
12639	shape, ok := value.([]interface{})
12640	if !ok {
12641		return fmt.Errorf("unexpected JSON type %v", value)
12642	}
12643
12644	var cv []types.Attribute
12645	if *v == nil {
12646		cv = []types.Attribute{}
12647	} else {
12648		cv = *v
12649	}
12650
12651	for _, value := range shape {
12652		var col types.Attribute
12653		destAddr := &col
12654		if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil {
12655			return err
12656		}
12657		col = *destAddr
12658		cv = append(cv, col)
12659
12660	}
12661	*v = cv
12662	return nil
12663}
12664
12665func awsAwsjson11_deserializeDocumentResource(v **types.Resource, value interface{}) error {
12666	if v == nil {
12667		return fmt.Errorf("unexpected nil of type %T", v)
12668	}
12669	if value == nil {
12670		return nil
12671	}
12672
12673	shape, ok := value.(map[string]interface{})
12674	if !ok {
12675		return fmt.Errorf("unexpected JSON type %v", value)
12676	}
12677
12678	var sv *types.Resource
12679	if *v == nil {
12680		sv = &types.Resource{}
12681	} else {
12682		sv = *v
12683	}
12684
12685	for key, value := range shape {
12686		switch key {
12687		case "doubleValue":
12688			if value != nil {
12689				jtv, ok := value.(json.Number)
12690				if !ok {
12691					return fmt.Errorf("expected Double to be json.Number, got %T instead", value)
12692				}
12693				f64, err := jtv.Float64()
12694				if err != nil {
12695					return err
12696				}
12697				sv.DoubleValue = f64
12698			}
12699
12700		case "integerValue":
12701			if value != nil {
12702				jtv, ok := value.(json.Number)
12703				if !ok {
12704					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
12705				}
12706				i64, err := jtv.Int64()
12707				if err != nil {
12708					return err
12709				}
12710				sv.IntegerValue = int32(i64)
12711			}
12712
12713		case "longValue":
12714			if value != nil {
12715				jtv, ok := value.(json.Number)
12716				if !ok {
12717					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
12718				}
12719				i64, err := jtv.Int64()
12720				if err != nil {
12721					return err
12722				}
12723				sv.LongValue = i64
12724			}
12725
12726		case "name":
12727			if value != nil {
12728				jtv, ok := value.(string)
12729				if !ok {
12730					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12731				}
12732				sv.Name = ptr.String(jtv)
12733			}
12734
12735		case "stringSetValue":
12736			if err := awsAwsjson11_deserializeDocumentStringList(&sv.StringSetValue, value); err != nil {
12737				return err
12738			}
12739
12740		case "type":
12741			if value != nil {
12742				jtv, ok := value.(string)
12743				if !ok {
12744					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12745				}
12746				sv.Type = ptr.String(jtv)
12747			}
12748
12749		default:
12750			_, _ = key, value
12751
12752		}
12753	}
12754	*v = sv
12755	return nil
12756}
12757
12758func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error {
12759	if v == nil {
12760		return fmt.Errorf("unexpected nil of type %T", v)
12761	}
12762	if value == nil {
12763		return nil
12764	}
12765
12766	shape, ok := value.(map[string]interface{})
12767	if !ok {
12768		return fmt.Errorf("unexpected JSON type %v", value)
12769	}
12770
12771	var sv *types.ResourceInUseException
12772	if *v == nil {
12773		sv = &types.ResourceInUseException{}
12774	} else {
12775		sv = *v
12776	}
12777
12778	for key, value := range shape {
12779		switch key {
12780		case "message":
12781			if value != nil {
12782				jtv, ok := value.(string)
12783				if !ok {
12784					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12785				}
12786				sv.Message = ptr.String(jtv)
12787			}
12788
12789		default:
12790			_, _ = key, value
12791
12792		}
12793	}
12794	*v = sv
12795	return nil
12796}
12797
12798func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
12799	if v == nil {
12800		return fmt.Errorf("unexpected nil of type %T", v)
12801	}
12802	if value == nil {
12803		return nil
12804	}
12805
12806	shape, ok := value.(map[string]interface{})
12807	if !ok {
12808		return fmt.Errorf("unexpected JSON type %v", value)
12809	}
12810
12811	var sv *types.ResourceNotFoundException
12812	if *v == nil {
12813		sv = &types.ResourceNotFoundException{}
12814	} else {
12815		sv = *v
12816	}
12817
12818	for key, value := range shape {
12819		switch key {
12820		case "message":
12821			if value != nil {
12822				jtv, ok := value.(string)
12823				if !ok {
12824					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12825				}
12826				sv.Message = ptr.String(jtv)
12827			}
12828
12829		default:
12830			_, _ = key, value
12831
12832		}
12833	}
12834	*v = sv
12835	return nil
12836}
12837
12838func awsAwsjson11_deserializeDocumentResourceRequirement(v **types.ResourceRequirement, value interface{}) error {
12839	if v == nil {
12840		return fmt.Errorf("unexpected nil of type %T", v)
12841	}
12842	if value == nil {
12843		return nil
12844	}
12845
12846	shape, ok := value.(map[string]interface{})
12847	if !ok {
12848		return fmt.Errorf("unexpected JSON type %v", value)
12849	}
12850
12851	var sv *types.ResourceRequirement
12852	if *v == nil {
12853		sv = &types.ResourceRequirement{}
12854	} else {
12855		sv = *v
12856	}
12857
12858	for key, value := range shape {
12859		switch key {
12860		case "type":
12861			if value != nil {
12862				jtv, ok := value.(string)
12863				if !ok {
12864					return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
12865				}
12866				sv.Type = types.ResourceType(jtv)
12867			}
12868
12869		case "value":
12870			if value != nil {
12871				jtv, ok := value.(string)
12872				if !ok {
12873					return fmt.Errorf("expected String to be of type string, got %T instead", value)
12874				}
12875				sv.Value = ptr.String(jtv)
12876			}
12877
12878		default:
12879			_, _ = key, value
12880
12881		}
12882	}
12883	*v = sv
12884	return nil
12885}
12886
12887func awsAwsjson11_deserializeDocumentResourceRequirements(v *[]types.ResourceRequirement, value interface{}) error {
12888	if v == nil {
12889		return fmt.Errorf("unexpected nil of type %T", v)
12890	}
12891	if value == nil {
12892		return nil
12893	}
12894
12895	shape, ok := value.([]interface{})
12896	if !ok {
12897		return fmt.Errorf("unexpected JSON type %v", value)
12898	}
12899
12900	var cv []types.ResourceRequirement
12901	if *v == nil {
12902		cv = []types.ResourceRequirement{}
12903	} else {
12904		cv = *v
12905	}
12906
12907	for _, value := range shape {
12908		var col types.ResourceRequirement
12909		destAddr := &col
12910		if err := awsAwsjson11_deserializeDocumentResourceRequirement(&destAddr, value); err != nil {
12911			return err
12912		}
12913		col = *destAddr
12914		cv = append(cv, col)
12915
12916	}
12917	*v = cv
12918	return nil
12919}
12920
12921func awsAwsjson11_deserializeDocumentResources(v *[]types.Resource, value interface{}) error {
12922	if v == nil {
12923		return fmt.Errorf("unexpected nil of type %T", v)
12924	}
12925	if value == nil {
12926		return nil
12927	}
12928
12929	shape, ok := value.([]interface{})
12930	if !ok {
12931		return fmt.Errorf("unexpected JSON type %v", value)
12932	}
12933
12934	var cv []types.Resource
12935	if *v == nil {
12936		cv = []types.Resource{}
12937	} else {
12938		cv = *v
12939	}
12940
12941	for _, value := range shape {
12942		var col types.Resource
12943		destAddr := &col
12944		if err := awsAwsjson11_deserializeDocumentResource(&destAddr, value); err != nil {
12945			return err
12946		}
12947		col = *destAddr
12948		cv = append(cv, col)
12949
12950	}
12951	*v = cv
12952	return nil
12953}
12954
12955func awsAwsjson11_deserializeDocumentScale(v **types.Scale, value interface{}) error {
12956	if v == nil {
12957		return fmt.Errorf("unexpected nil of type %T", v)
12958	}
12959	if value == nil {
12960		return nil
12961	}
12962
12963	shape, ok := value.(map[string]interface{})
12964	if !ok {
12965		return fmt.Errorf("unexpected JSON type %v", value)
12966	}
12967
12968	var sv *types.Scale
12969	if *v == nil {
12970		sv = &types.Scale{}
12971	} else {
12972		sv = *v
12973	}
12974
12975	for key, value := range shape {
12976		switch key {
12977		case "unit":
12978			if value != nil {
12979				jtv, ok := value.(string)
12980				if !ok {
12981					return fmt.Errorf("expected ScaleUnit to be of type string, got %T instead", value)
12982				}
12983				sv.Unit = types.ScaleUnit(jtv)
12984			}
12985
12986		case "value":
12987			if value != nil {
12988				jtv, ok := value.(json.Number)
12989				if !ok {
12990					return fmt.Errorf("expected Double to be json.Number, got %T instead", value)
12991				}
12992				f64, err := jtv.Float64()
12993				if err != nil {
12994					return err
12995				}
12996				sv.Value = f64
12997			}
12998
12999		default:
13000			_, _ = key, value
13001
13002		}
13003	}
13004	*v = sv
13005	return nil
13006}
13007
13008func awsAwsjson11_deserializeDocumentSecret(v **types.Secret, value interface{}) error {
13009	if v == nil {
13010		return fmt.Errorf("unexpected nil of type %T", v)
13011	}
13012	if value == nil {
13013		return nil
13014	}
13015
13016	shape, ok := value.(map[string]interface{})
13017	if !ok {
13018		return fmt.Errorf("unexpected JSON type %v", value)
13019	}
13020
13021	var sv *types.Secret
13022	if *v == nil {
13023		sv = &types.Secret{}
13024	} else {
13025		sv = *v
13026	}
13027
13028	for key, value := range shape {
13029		switch key {
13030		case "name":
13031			if value != nil {
13032				jtv, ok := value.(string)
13033				if !ok {
13034					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13035				}
13036				sv.Name = ptr.String(jtv)
13037			}
13038
13039		case "valueFrom":
13040			if value != nil {
13041				jtv, ok := value.(string)
13042				if !ok {
13043					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13044				}
13045				sv.ValueFrom = ptr.String(jtv)
13046			}
13047
13048		default:
13049			_, _ = key, value
13050
13051		}
13052	}
13053	*v = sv
13054	return nil
13055}
13056
13057func awsAwsjson11_deserializeDocumentSecretList(v *[]types.Secret, value interface{}) error {
13058	if v == nil {
13059		return fmt.Errorf("unexpected nil of type %T", v)
13060	}
13061	if value == nil {
13062		return nil
13063	}
13064
13065	shape, ok := value.([]interface{})
13066	if !ok {
13067		return fmt.Errorf("unexpected JSON type %v", value)
13068	}
13069
13070	var cv []types.Secret
13071	if *v == nil {
13072		cv = []types.Secret{}
13073	} else {
13074		cv = *v
13075	}
13076
13077	for _, value := range shape {
13078		var col types.Secret
13079		destAddr := &col
13080		if err := awsAwsjson11_deserializeDocumentSecret(&destAddr, value); err != nil {
13081			return err
13082		}
13083		col = *destAddr
13084		cv = append(cv, col)
13085
13086	}
13087	*v = cv
13088	return nil
13089}
13090
13091func awsAwsjson11_deserializeDocumentServerException(v **types.ServerException, value interface{}) error {
13092	if v == nil {
13093		return fmt.Errorf("unexpected nil of type %T", v)
13094	}
13095	if value == nil {
13096		return nil
13097	}
13098
13099	shape, ok := value.(map[string]interface{})
13100	if !ok {
13101		return fmt.Errorf("unexpected JSON type %v", value)
13102	}
13103
13104	var sv *types.ServerException
13105	if *v == nil {
13106		sv = &types.ServerException{}
13107	} else {
13108		sv = *v
13109	}
13110
13111	for key, value := range shape {
13112		switch key {
13113		case "message":
13114			if value != nil {
13115				jtv, ok := value.(string)
13116				if !ok {
13117					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13118				}
13119				sv.Message = ptr.String(jtv)
13120			}
13121
13122		default:
13123			_, _ = key, value
13124
13125		}
13126	}
13127	*v = sv
13128	return nil
13129}
13130
13131func awsAwsjson11_deserializeDocumentService(v **types.Service, value interface{}) error {
13132	if v == nil {
13133		return fmt.Errorf("unexpected nil of type %T", v)
13134	}
13135	if value == nil {
13136		return nil
13137	}
13138
13139	shape, ok := value.(map[string]interface{})
13140	if !ok {
13141		return fmt.Errorf("unexpected JSON type %v", value)
13142	}
13143
13144	var sv *types.Service
13145	if *v == nil {
13146		sv = &types.Service{}
13147	} else {
13148		sv = *v
13149	}
13150
13151	for key, value := range shape {
13152		switch key {
13153		case "capacityProviderStrategy":
13154			if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil {
13155				return err
13156			}
13157
13158		case "clusterArn":
13159			if value != nil {
13160				jtv, ok := value.(string)
13161				if !ok {
13162					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13163				}
13164				sv.ClusterArn = ptr.String(jtv)
13165			}
13166
13167		case "createdAt":
13168			if value != nil {
13169				jtv, ok := value.(json.Number)
13170				if !ok {
13171					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
13172				}
13173				f64, err := jtv.Float64()
13174				if err != nil {
13175					return err
13176				}
13177				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
13178			}
13179
13180		case "createdBy":
13181			if value != nil {
13182				jtv, ok := value.(string)
13183				if !ok {
13184					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13185				}
13186				sv.CreatedBy = ptr.String(jtv)
13187			}
13188
13189		case "deploymentConfiguration":
13190			if err := awsAwsjson11_deserializeDocumentDeploymentConfiguration(&sv.DeploymentConfiguration, value); err != nil {
13191				return err
13192			}
13193
13194		case "deploymentController":
13195			if err := awsAwsjson11_deserializeDocumentDeploymentController(&sv.DeploymentController, value); err != nil {
13196				return err
13197			}
13198
13199		case "deployments":
13200			if err := awsAwsjson11_deserializeDocumentDeployments(&sv.Deployments, value); err != nil {
13201				return err
13202			}
13203
13204		case "desiredCount":
13205			if value != nil {
13206				jtv, ok := value.(json.Number)
13207				if !ok {
13208					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
13209				}
13210				i64, err := jtv.Int64()
13211				if err != nil {
13212					return err
13213				}
13214				sv.DesiredCount = int32(i64)
13215			}
13216
13217		case "enableECSManagedTags":
13218			if value != nil {
13219				jtv, ok := value.(bool)
13220				if !ok {
13221					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
13222				}
13223				sv.EnableECSManagedTags = jtv
13224			}
13225
13226		case "enableExecuteCommand":
13227			if value != nil {
13228				jtv, ok := value.(bool)
13229				if !ok {
13230					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
13231				}
13232				sv.EnableExecuteCommand = jtv
13233			}
13234
13235		case "events":
13236			if err := awsAwsjson11_deserializeDocumentServiceEvents(&sv.Events, value); err != nil {
13237				return err
13238			}
13239
13240		case "healthCheckGracePeriodSeconds":
13241			if value != nil {
13242				jtv, ok := value.(json.Number)
13243				if !ok {
13244					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
13245				}
13246				i64, err := jtv.Int64()
13247				if err != nil {
13248					return err
13249				}
13250				sv.HealthCheckGracePeriodSeconds = ptr.Int32(int32(i64))
13251			}
13252
13253		case "launchType":
13254			if value != nil {
13255				jtv, ok := value.(string)
13256				if !ok {
13257					return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
13258				}
13259				sv.LaunchType = types.LaunchType(jtv)
13260			}
13261
13262		case "loadBalancers":
13263			if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil {
13264				return err
13265			}
13266
13267		case "networkConfiguration":
13268			if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
13269				return err
13270			}
13271
13272		case "pendingCount":
13273			if value != nil {
13274				jtv, ok := value.(json.Number)
13275				if !ok {
13276					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
13277				}
13278				i64, err := jtv.Int64()
13279				if err != nil {
13280					return err
13281				}
13282				sv.PendingCount = int32(i64)
13283			}
13284
13285		case "placementConstraints":
13286			if err := awsAwsjson11_deserializeDocumentPlacementConstraints(&sv.PlacementConstraints, value); err != nil {
13287				return err
13288			}
13289
13290		case "placementStrategy":
13291			if err := awsAwsjson11_deserializeDocumentPlacementStrategies(&sv.PlacementStrategy, value); err != nil {
13292				return err
13293			}
13294
13295		case "platformVersion":
13296			if value != nil {
13297				jtv, ok := value.(string)
13298				if !ok {
13299					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13300				}
13301				sv.PlatformVersion = ptr.String(jtv)
13302			}
13303
13304		case "propagateTags":
13305			if value != nil {
13306				jtv, ok := value.(string)
13307				if !ok {
13308					return fmt.Errorf("expected PropagateTags to be of type string, got %T instead", value)
13309				}
13310				sv.PropagateTags = types.PropagateTags(jtv)
13311			}
13312
13313		case "roleArn":
13314			if value != nil {
13315				jtv, ok := value.(string)
13316				if !ok {
13317					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13318				}
13319				sv.RoleArn = ptr.String(jtv)
13320			}
13321
13322		case "runningCount":
13323			if value != nil {
13324				jtv, ok := value.(json.Number)
13325				if !ok {
13326					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
13327				}
13328				i64, err := jtv.Int64()
13329				if err != nil {
13330					return err
13331				}
13332				sv.RunningCount = int32(i64)
13333			}
13334
13335		case "schedulingStrategy":
13336			if value != nil {
13337				jtv, ok := value.(string)
13338				if !ok {
13339					return fmt.Errorf("expected SchedulingStrategy to be of type string, got %T instead", value)
13340				}
13341				sv.SchedulingStrategy = types.SchedulingStrategy(jtv)
13342			}
13343
13344		case "serviceArn":
13345			if value != nil {
13346				jtv, ok := value.(string)
13347				if !ok {
13348					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13349				}
13350				sv.ServiceArn = ptr.String(jtv)
13351			}
13352
13353		case "serviceName":
13354			if value != nil {
13355				jtv, ok := value.(string)
13356				if !ok {
13357					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13358				}
13359				sv.ServiceName = ptr.String(jtv)
13360			}
13361
13362		case "serviceRegistries":
13363			if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil {
13364				return err
13365			}
13366
13367		case "status":
13368			if value != nil {
13369				jtv, ok := value.(string)
13370				if !ok {
13371					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13372				}
13373				sv.Status = ptr.String(jtv)
13374			}
13375
13376		case "tags":
13377			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
13378				return err
13379			}
13380
13381		case "taskDefinition":
13382			if value != nil {
13383				jtv, ok := value.(string)
13384				if !ok {
13385					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13386				}
13387				sv.TaskDefinition = ptr.String(jtv)
13388			}
13389
13390		case "taskSets":
13391			if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil {
13392				return err
13393			}
13394
13395		default:
13396			_, _ = key, value
13397
13398		}
13399	}
13400	*v = sv
13401	return nil
13402}
13403
13404func awsAwsjson11_deserializeDocumentServiceEvent(v **types.ServiceEvent, value interface{}) error {
13405	if v == nil {
13406		return fmt.Errorf("unexpected nil of type %T", v)
13407	}
13408	if value == nil {
13409		return nil
13410	}
13411
13412	shape, ok := value.(map[string]interface{})
13413	if !ok {
13414		return fmt.Errorf("unexpected JSON type %v", value)
13415	}
13416
13417	var sv *types.ServiceEvent
13418	if *v == nil {
13419		sv = &types.ServiceEvent{}
13420	} else {
13421		sv = *v
13422	}
13423
13424	for key, value := range shape {
13425		switch key {
13426		case "createdAt":
13427			if value != nil {
13428				jtv, ok := value.(json.Number)
13429				if !ok {
13430					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
13431				}
13432				f64, err := jtv.Float64()
13433				if err != nil {
13434					return err
13435				}
13436				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
13437			}
13438
13439		case "id":
13440			if value != nil {
13441				jtv, ok := value.(string)
13442				if !ok {
13443					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13444				}
13445				sv.Id = ptr.String(jtv)
13446			}
13447
13448		case "message":
13449			if value != nil {
13450				jtv, ok := value.(string)
13451				if !ok {
13452					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13453				}
13454				sv.Message = ptr.String(jtv)
13455			}
13456
13457		default:
13458			_, _ = key, value
13459
13460		}
13461	}
13462	*v = sv
13463	return nil
13464}
13465
13466func awsAwsjson11_deserializeDocumentServiceEvents(v *[]types.ServiceEvent, value interface{}) error {
13467	if v == nil {
13468		return fmt.Errorf("unexpected nil of type %T", v)
13469	}
13470	if value == nil {
13471		return nil
13472	}
13473
13474	shape, ok := value.([]interface{})
13475	if !ok {
13476		return fmt.Errorf("unexpected JSON type %v", value)
13477	}
13478
13479	var cv []types.ServiceEvent
13480	if *v == nil {
13481		cv = []types.ServiceEvent{}
13482	} else {
13483		cv = *v
13484	}
13485
13486	for _, value := range shape {
13487		var col types.ServiceEvent
13488		destAddr := &col
13489		if err := awsAwsjson11_deserializeDocumentServiceEvent(&destAddr, value); err != nil {
13490			return err
13491		}
13492		col = *destAddr
13493		cv = append(cv, col)
13494
13495	}
13496	*v = cv
13497	return nil
13498}
13499
13500func awsAwsjson11_deserializeDocumentServiceNotActiveException(v **types.ServiceNotActiveException, value interface{}) error {
13501	if v == nil {
13502		return fmt.Errorf("unexpected nil of type %T", v)
13503	}
13504	if value == nil {
13505		return nil
13506	}
13507
13508	shape, ok := value.(map[string]interface{})
13509	if !ok {
13510		return fmt.Errorf("unexpected JSON type %v", value)
13511	}
13512
13513	var sv *types.ServiceNotActiveException
13514	if *v == nil {
13515		sv = &types.ServiceNotActiveException{}
13516	} else {
13517		sv = *v
13518	}
13519
13520	for key, value := range shape {
13521		switch key {
13522		case "message":
13523			if value != nil {
13524				jtv, ok := value.(string)
13525				if !ok {
13526					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13527				}
13528				sv.Message = ptr.String(jtv)
13529			}
13530
13531		default:
13532			_, _ = key, value
13533
13534		}
13535	}
13536	*v = sv
13537	return nil
13538}
13539
13540func awsAwsjson11_deserializeDocumentServiceNotFoundException(v **types.ServiceNotFoundException, value interface{}) error {
13541	if v == nil {
13542		return fmt.Errorf("unexpected nil of type %T", v)
13543	}
13544	if value == nil {
13545		return nil
13546	}
13547
13548	shape, ok := value.(map[string]interface{})
13549	if !ok {
13550		return fmt.Errorf("unexpected JSON type %v", value)
13551	}
13552
13553	var sv *types.ServiceNotFoundException
13554	if *v == nil {
13555		sv = &types.ServiceNotFoundException{}
13556	} else {
13557		sv = *v
13558	}
13559
13560	for key, value := range shape {
13561		switch key {
13562		case "message":
13563			if value != nil {
13564				jtv, ok := value.(string)
13565				if !ok {
13566					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13567				}
13568				sv.Message = ptr.String(jtv)
13569			}
13570
13571		default:
13572			_, _ = key, value
13573
13574		}
13575	}
13576	*v = sv
13577	return nil
13578}
13579
13580func awsAwsjson11_deserializeDocumentServiceRegistries(v *[]types.ServiceRegistry, value interface{}) error {
13581	if v == nil {
13582		return fmt.Errorf("unexpected nil of type %T", v)
13583	}
13584	if value == nil {
13585		return nil
13586	}
13587
13588	shape, ok := value.([]interface{})
13589	if !ok {
13590		return fmt.Errorf("unexpected JSON type %v", value)
13591	}
13592
13593	var cv []types.ServiceRegistry
13594	if *v == nil {
13595		cv = []types.ServiceRegistry{}
13596	} else {
13597		cv = *v
13598	}
13599
13600	for _, value := range shape {
13601		var col types.ServiceRegistry
13602		destAddr := &col
13603		if err := awsAwsjson11_deserializeDocumentServiceRegistry(&destAddr, value); err != nil {
13604			return err
13605		}
13606		col = *destAddr
13607		cv = append(cv, col)
13608
13609	}
13610	*v = cv
13611	return nil
13612}
13613
13614func awsAwsjson11_deserializeDocumentServiceRegistry(v **types.ServiceRegistry, value interface{}) error {
13615	if v == nil {
13616		return fmt.Errorf("unexpected nil of type %T", v)
13617	}
13618	if value == nil {
13619		return nil
13620	}
13621
13622	shape, ok := value.(map[string]interface{})
13623	if !ok {
13624		return fmt.Errorf("unexpected JSON type %v", value)
13625	}
13626
13627	var sv *types.ServiceRegistry
13628	if *v == nil {
13629		sv = &types.ServiceRegistry{}
13630	} else {
13631		sv = *v
13632	}
13633
13634	for key, value := range shape {
13635		switch key {
13636		case "containerName":
13637			if value != nil {
13638				jtv, ok := value.(string)
13639				if !ok {
13640					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13641				}
13642				sv.ContainerName = ptr.String(jtv)
13643			}
13644
13645		case "containerPort":
13646			if value != nil {
13647				jtv, ok := value.(json.Number)
13648				if !ok {
13649					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
13650				}
13651				i64, err := jtv.Int64()
13652				if err != nil {
13653					return err
13654				}
13655				sv.ContainerPort = ptr.Int32(int32(i64))
13656			}
13657
13658		case "port":
13659			if value != nil {
13660				jtv, ok := value.(json.Number)
13661				if !ok {
13662					return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value)
13663				}
13664				i64, err := jtv.Int64()
13665				if err != nil {
13666					return err
13667				}
13668				sv.Port = ptr.Int32(int32(i64))
13669			}
13670
13671		case "registryArn":
13672			if value != nil {
13673				jtv, ok := value.(string)
13674				if !ok {
13675					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13676				}
13677				sv.RegistryArn = ptr.String(jtv)
13678			}
13679
13680		default:
13681			_, _ = key, value
13682
13683		}
13684	}
13685	*v = sv
13686	return nil
13687}
13688
13689func awsAwsjson11_deserializeDocumentServices(v *[]types.Service, value interface{}) error {
13690	if v == nil {
13691		return fmt.Errorf("unexpected nil of type %T", v)
13692	}
13693	if value == nil {
13694		return nil
13695	}
13696
13697	shape, ok := value.([]interface{})
13698	if !ok {
13699		return fmt.Errorf("unexpected JSON type %v", value)
13700	}
13701
13702	var cv []types.Service
13703	if *v == nil {
13704		cv = []types.Service{}
13705	} else {
13706		cv = *v
13707	}
13708
13709	for _, value := range shape {
13710		var col types.Service
13711		destAddr := &col
13712		if err := awsAwsjson11_deserializeDocumentService(&destAddr, value); err != nil {
13713			return err
13714		}
13715		col = *destAddr
13716		cv = append(cv, col)
13717
13718	}
13719	*v = cv
13720	return nil
13721}
13722
13723func awsAwsjson11_deserializeDocumentSession(v **types.Session, value interface{}) error {
13724	if v == nil {
13725		return fmt.Errorf("unexpected nil of type %T", v)
13726	}
13727	if value == nil {
13728		return nil
13729	}
13730
13731	shape, ok := value.(map[string]interface{})
13732	if !ok {
13733		return fmt.Errorf("unexpected JSON type %v", value)
13734	}
13735
13736	var sv *types.Session
13737	if *v == nil {
13738		sv = &types.Session{}
13739	} else {
13740		sv = *v
13741	}
13742
13743	for key, value := range shape {
13744		switch key {
13745		case "sessionId":
13746			if value != nil {
13747				jtv, ok := value.(string)
13748				if !ok {
13749					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13750				}
13751				sv.SessionId = ptr.String(jtv)
13752			}
13753
13754		case "streamUrl":
13755			if value != nil {
13756				jtv, ok := value.(string)
13757				if !ok {
13758					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13759				}
13760				sv.StreamUrl = ptr.String(jtv)
13761			}
13762
13763		case "tokenValue":
13764			if value != nil {
13765				jtv, ok := value.(string)
13766				if !ok {
13767					return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value)
13768				}
13769				sv.TokenValue = ptr.String(jtv)
13770			}
13771
13772		default:
13773			_, _ = key, value
13774
13775		}
13776	}
13777	*v = sv
13778	return nil
13779}
13780
13781func awsAwsjson11_deserializeDocumentSetting(v **types.Setting, value interface{}) error {
13782	if v == nil {
13783		return fmt.Errorf("unexpected nil of type %T", v)
13784	}
13785	if value == nil {
13786		return nil
13787	}
13788
13789	shape, ok := value.(map[string]interface{})
13790	if !ok {
13791		return fmt.Errorf("unexpected JSON type %v", value)
13792	}
13793
13794	var sv *types.Setting
13795	if *v == nil {
13796		sv = &types.Setting{}
13797	} else {
13798		sv = *v
13799	}
13800
13801	for key, value := range shape {
13802		switch key {
13803		case "name":
13804			if value != nil {
13805				jtv, ok := value.(string)
13806				if !ok {
13807					return fmt.Errorf("expected SettingName to be of type string, got %T instead", value)
13808				}
13809				sv.Name = types.SettingName(jtv)
13810			}
13811
13812		case "principalArn":
13813			if value != nil {
13814				jtv, ok := value.(string)
13815				if !ok {
13816					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13817				}
13818				sv.PrincipalArn = ptr.String(jtv)
13819			}
13820
13821		case "value":
13822			if value != nil {
13823				jtv, ok := value.(string)
13824				if !ok {
13825					return fmt.Errorf("expected String to be of type string, got %T instead", value)
13826				}
13827				sv.Value = ptr.String(jtv)
13828			}
13829
13830		default:
13831			_, _ = key, value
13832
13833		}
13834	}
13835	*v = sv
13836	return nil
13837}
13838
13839func awsAwsjson11_deserializeDocumentSettings(v *[]types.Setting, value interface{}) error {
13840	if v == nil {
13841		return fmt.Errorf("unexpected nil of type %T", v)
13842	}
13843	if value == nil {
13844		return nil
13845	}
13846
13847	shape, ok := value.([]interface{})
13848	if !ok {
13849		return fmt.Errorf("unexpected JSON type %v", value)
13850	}
13851
13852	var cv []types.Setting
13853	if *v == nil {
13854		cv = []types.Setting{}
13855	} else {
13856		cv = *v
13857	}
13858
13859	for _, value := range shape {
13860		var col types.Setting
13861		destAddr := &col
13862		if err := awsAwsjson11_deserializeDocumentSetting(&destAddr, value); err != nil {
13863			return err
13864		}
13865		col = *destAddr
13866		cv = append(cv, col)
13867
13868	}
13869	*v = cv
13870	return nil
13871}
13872
13873func awsAwsjson11_deserializeDocumentStatistics(v *[]types.KeyValuePair, value interface{}) error {
13874	if v == nil {
13875		return fmt.Errorf("unexpected nil of type %T", v)
13876	}
13877	if value == nil {
13878		return nil
13879	}
13880
13881	shape, ok := value.([]interface{})
13882	if !ok {
13883		return fmt.Errorf("unexpected JSON type %v", value)
13884	}
13885
13886	var cv []types.KeyValuePair
13887	if *v == nil {
13888		cv = []types.KeyValuePair{}
13889	} else {
13890		cv = *v
13891	}
13892
13893	for _, value := range shape {
13894		var col types.KeyValuePair
13895		destAddr := &col
13896		if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil {
13897			return err
13898		}
13899		col = *destAddr
13900		cv = append(cv, col)
13901
13902	}
13903	*v = cv
13904	return nil
13905}
13906
13907func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error {
13908	if v == nil {
13909		return fmt.Errorf("unexpected nil of type %T", v)
13910	}
13911	if value == nil {
13912		return nil
13913	}
13914
13915	shape, ok := value.([]interface{})
13916	if !ok {
13917		return fmt.Errorf("unexpected JSON type %v", value)
13918	}
13919
13920	var cv []string
13921	if *v == nil {
13922		cv = []string{}
13923	} else {
13924		cv = *v
13925	}
13926
13927	for _, value := range shape {
13928		var col string
13929		if value != nil {
13930			jtv, ok := value.(string)
13931			if !ok {
13932				return fmt.Errorf("expected String to be of type string, got %T instead", value)
13933			}
13934			col = jtv
13935		}
13936		cv = append(cv, col)
13937
13938	}
13939	*v = cv
13940	return nil
13941}
13942
13943func awsAwsjson11_deserializeDocumentStringMap(v *map[string]string, value interface{}) error {
13944	if v == nil {
13945		return fmt.Errorf("unexpected nil of type %T", v)
13946	}
13947	if value == nil {
13948		return nil
13949	}
13950
13951	shape, ok := value.(map[string]interface{})
13952	if !ok {
13953		return fmt.Errorf("unexpected JSON type %v", value)
13954	}
13955
13956	var mv map[string]string
13957	if *v == nil {
13958		mv = map[string]string{}
13959	} else {
13960		mv = *v
13961	}
13962
13963	for key, value := range shape {
13964		var parsedVal string
13965		if value != nil {
13966			jtv, ok := value.(string)
13967			if !ok {
13968				return fmt.Errorf("expected String to be of type string, got %T instead", value)
13969			}
13970			parsedVal = jtv
13971		}
13972		mv[key] = parsedVal
13973
13974	}
13975	*v = mv
13976	return nil
13977}
13978
13979func awsAwsjson11_deserializeDocumentSystemControl(v **types.SystemControl, value interface{}) error {
13980	if v == nil {
13981		return fmt.Errorf("unexpected nil of type %T", v)
13982	}
13983	if value == nil {
13984		return nil
13985	}
13986
13987	shape, ok := value.(map[string]interface{})
13988	if !ok {
13989		return fmt.Errorf("unexpected JSON type %v", value)
13990	}
13991
13992	var sv *types.SystemControl
13993	if *v == nil {
13994		sv = &types.SystemControl{}
13995	} else {
13996		sv = *v
13997	}
13998
13999	for key, value := range shape {
14000		switch key {
14001		case "namespace":
14002			if value != nil {
14003				jtv, ok := value.(string)
14004				if !ok {
14005					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14006				}
14007				sv.Namespace = ptr.String(jtv)
14008			}
14009
14010		case "value":
14011			if value != nil {
14012				jtv, ok := value.(string)
14013				if !ok {
14014					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14015				}
14016				sv.Value = ptr.String(jtv)
14017			}
14018
14019		default:
14020			_, _ = key, value
14021
14022		}
14023	}
14024	*v = sv
14025	return nil
14026}
14027
14028func awsAwsjson11_deserializeDocumentSystemControls(v *[]types.SystemControl, value interface{}) error {
14029	if v == nil {
14030		return fmt.Errorf("unexpected nil of type %T", v)
14031	}
14032	if value == nil {
14033		return nil
14034	}
14035
14036	shape, ok := value.([]interface{})
14037	if !ok {
14038		return fmt.Errorf("unexpected JSON type %v", value)
14039	}
14040
14041	var cv []types.SystemControl
14042	if *v == nil {
14043		cv = []types.SystemControl{}
14044	} else {
14045		cv = *v
14046	}
14047
14048	for _, value := range shape {
14049		var col types.SystemControl
14050		destAddr := &col
14051		if err := awsAwsjson11_deserializeDocumentSystemControl(&destAddr, value); err != nil {
14052			return err
14053		}
14054		col = *destAddr
14055		cv = append(cv, col)
14056
14057	}
14058	*v = cv
14059	return nil
14060}
14061
14062func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
14063	if v == nil {
14064		return fmt.Errorf("unexpected nil of type %T", v)
14065	}
14066	if value == nil {
14067		return nil
14068	}
14069
14070	shape, ok := value.(map[string]interface{})
14071	if !ok {
14072		return fmt.Errorf("unexpected JSON type %v", value)
14073	}
14074
14075	var sv *types.Tag
14076	if *v == nil {
14077		sv = &types.Tag{}
14078	} else {
14079		sv = *v
14080	}
14081
14082	for key, value := range shape {
14083		switch key {
14084		case "key":
14085			if value != nil {
14086				jtv, ok := value.(string)
14087				if !ok {
14088					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
14089				}
14090				sv.Key = ptr.String(jtv)
14091			}
14092
14093		case "value":
14094			if value != nil {
14095				jtv, ok := value.(string)
14096				if !ok {
14097					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
14098				}
14099				sv.Value = ptr.String(jtv)
14100			}
14101
14102		default:
14103			_, _ = key, value
14104
14105		}
14106	}
14107	*v = sv
14108	return nil
14109}
14110
14111func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error {
14112	if v == nil {
14113		return fmt.Errorf("unexpected nil of type %T", v)
14114	}
14115	if value == nil {
14116		return nil
14117	}
14118
14119	shape, ok := value.([]interface{})
14120	if !ok {
14121		return fmt.Errorf("unexpected JSON type %v", value)
14122	}
14123
14124	var cv []types.Tag
14125	if *v == nil {
14126		cv = []types.Tag{}
14127	} else {
14128		cv = *v
14129	}
14130
14131	for _, value := range shape {
14132		var col types.Tag
14133		destAddr := &col
14134		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
14135			return err
14136		}
14137		col = *destAddr
14138		cv = append(cv, col)
14139
14140	}
14141	*v = cv
14142	return nil
14143}
14144
14145func awsAwsjson11_deserializeDocumentTargetNotConnectedException(v **types.TargetNotConnectedException, value interface{}) error {
14146	if v == nil {
14147		return fmt.Errorf("unexpected nil of type %T", v)
14148	}
14149	if value == nil {
14150		return nil
14151	}
14152
14153	shape, ok := value.(map[string]interface{})
14154	if !ok {
14155		return fmt.Errorf("unexpected JSON type %v", value)
14156	}
14157
14158	var sv *types.TargetNotConnectedException
14159	if *v == nil {
14160		sv = &types.TargetNotConnectedException{}
14161	} else {
14162		sv = *v
14163	}
14164
14165	for key, value := range shape {
14166		switch key {
14167		case "message":
14168			if value != nil {
14169				jtv, ok := value.(string)
14170				if !ok {
14171					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14172				}
14173				sv.Message = ptr.String(jtv)
14174			}
14175
14176		default:
14177			_, _ = key, value
14178
14179		}
14180	}
14181	*v = sv
14182	return nil
14183}
14184
14185func awsAwsjson11_deserializeDocumentTargetNotFoundException(v **types.TargetNotFoundException, value interface{}) error {
14186	if v == nil {
14187		return fmt.Errorf("unexpected nil of type %T", v)
14188	}
14189	if value == nil {
14190		return nil
14191	}
14192
14193	shape, ok := value.(map[string]interface{})
14194	if !ok {
14195		return fmt.Errorf("unexpected JSON type %v", value)
14196	}
14197
14198	var sv *types.TargetNotFoundException
14199	if *v == nil {
14200		sv = &types.TargetNotFoundException{}
14201	} else {
14202		sv = *v
14203	}
14204
14205	for key, value := range shape {
14206		switch key {
14207		case "message":
14208			if value != nil {
14209				jtv, ok := value.(string)
14210				if !ok {
14211					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14212				}
14213				sv.Message = ptr.String(jtv)
14214			}
14215
14216		default:
14217			_, _ = key, value
14218
14219		}
14220	}
14221	*v = sv
14222	return nil
14223}
14224
14225func awsAwsjson11_deserializeDocumentTask(v **types.Task, value interface{}) error {
14226	if v == nil {
14227		return fmt.Errorf("unexpected nil of type %T", v)
14228	}
14229	if value == nil {
14230		return nil
14231	}
14232
14233	shape, ok := value.(map[string]interface{})
14234	if !ok {
14235		return fmt.Errorf("unexpected JSON type %v", value)
14236	}
14237
14238	var sv *types.Task
14239	if *v == nil {
14240		sv = &types.Task{}
14241	} else {
14242		sv = *v
14243	}
14244
14245	for key, value := range shape {
14246		switch key {
14247		case "attachments":
14248			if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil {
14249				return err
14250			}
14251
14252		case "attributes":
14253			if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
14254				return err
14255			}
14256
14257		case "availabilityZone":
14258			if value != nil {
14259				jtv, ok := value.(string)
14260				if !ok {
14261					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14262				}
14263				sv.AvailabilityZone = ptr.String(jtv)
14264			}
14265
14266		case "capacityProviderName":
14267			if value != nil {
14268				jtv, ok := value.(string)
14269				if !ok {
14270					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14271				}
14272				sv.CapacityProviderName = ptr.String(jtv)
14273			}
14274
14275		case "clusterArn":
14276			if value != nil {
14277				jtv, ok := value.(string)
14278				if !ok {
14279					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14280				}
14281				sv.ClusterArn = ptr.String(jtv)
14282			}
14283
14284		case "connectivity":
14285			if value != nil {
14286				jtv, ok := value.(string)
14287				if !ok {
14288					return fmt.Errorf("expected Connectivity to be of type string, got %T instead", value)
14289				}
14290				sv.Connectivity = types.Connectivity(jtv)
14291			}
14292
14293		case "connectivityAt":
14294			if value != nil {
14295				jtv, ok := value.(json.Number)
14296				if !ok {
14297					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14298				}
14299				f64, err := jtv.Float64()
14300				if err != nil {
14301					return err
14302				}
14303				sv.ConnectivityAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14304			}
14305
14306		case "containerInstanceArn":
14307			if value != nil {
14308				jtv, ok := value.(string)
14309				if !ok {
14310					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14311				}
14312				sv.ContainerInstanceArn = ptr.String(jtv)
14313			}
14314
14315		case "containers":
14316			if err := awsAwsjson11_deserializeDocumentContainers(&sv.Containers, value); err != nil {
14317				return err
14318			}
14319
14320		case "cpu":
14321			if value != nil {
14322				jtv, ok := value.(string)
14323				if !ok {
14324					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14325				}
14326				sv.Cpu = ptr.String(jtv)
14327			}
14328
14329		case "createdAt":
14330			if value != nil {
14331				jtv, ok := value.(json.Number)
14332				if !ok {
14333					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14334				}
14335				f64, err := jtv.Float64()
14336				if err != nil {
14337					return err
14338				}
14339				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14340			}
14341
14342		case "desiredStatus":
14343			if value != nil {
14344				jtv, ok := value.(string)
14345				if !ok {
14346					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14347				}
14348				sv.DesiredStatus = ptr.String(jtv)
14349			}
14350
14351		case "enableExecuteCommand":
14352			if value != nil {
14353				jtv, ok := value.(bool)
14354				if !ok {
14355					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
14356				}
14357				sv.EnableExecuteCommand = jtv
14358			}
14359
14360		case "ephemeralStorage":
14361			if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
14362				return err
14363			}
14364
14365		case "executionStoppedAt":
14366			if value != nil {
14367				jtv, ok := value.(json.Number)
14368				if !ok {
14369					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14370				}
14371				f64, err := jtv.Float64()
14372				if err != nil {
14373					return err
14374				}
14375				sv.ExecutionStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14376			}
14377
14378		case "group":
14379			if value != nil {
14380				jtv, ok := value.(string)
14381				if !ok {
14382					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14383				}
14384				sv.Group = ptr.String(jtv)
14385			}
14386
14387		case "healthStatus":
14388			if value != nil {
14389				jtv, ok := value.(string)
14390				if !ok {
14391					return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value)
14392				}
14393				sv.HealthStatus = types.HealthStatus(jtv)
14394			}
14395
14396		case "inferenceAccelerators":
14397			if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil {
14398				return err
14399			}
14400
14401		case "lastStatus":
14402			if value != nil {
14403				jtv, ok := value.(string)
14404				if !ok {
14405					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14406				}
14407				sv.LastStatus = ptr.String(jtv)
14408			}
14409
14410		case "launchType":
14411			if value != nil {
14412				jtv, ok := value.(string)
14413				if !ok {
14414					return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
14415				}
14416				sv.LaunchType = types.LaunchType(jtv)
14417			}
14418
14419		case "memory":
14420			if value != nil {
14421				jtv, ok := value.(string)
14422				if !ok {
14423					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14424				}
14425				sv.Memory = ptr.String(jtv)
14426			}
14427
14428		case "overrides":
14429			if err := awsAwsjson11_deserializeDocumentTaskOverride(&sv.Overrides, value); err != nil {
14430				return err
14431			}
14432
14433		case "platformVersion":
14434			if value != nil {
14435				jtv, ok := value.(string)
14436				if !ok {
14437					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14438				}
14439				sv.PlatformVersion = ptr.String(jtv)
14440			}
14441
14442		case "pullStartedAt":
14443			if value != nil {
14444				jtv, ok := value.(json.Number)
14445				if !ok {
14446					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14447				}
14448				f64, err := jtv.Float64()
14449				if err != nil {
14450					return err
14451				}
14452				sv.PullStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14453			}
14454
14455		case "pullStoppedAt":
14456			if value != nil {
14457				jtv, ok := value.(json.Number)
14458				if !ok {
14459					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14460				}
14461				f64, err := jtv.Float64()
14462				if err != nil {
14463					return err
14464				}
14465				sv.PullStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14466			}
14467
14468		case "startedAt":
14469			if value != nil {
14470				jtv, ok := value.(json.Number)
14471				if !ok {
14472					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14473				}
14474				f64, err := jtv.Float64()
14475				if err != nil {
14476					return err
14477				}
14478				sv.StartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14479			}
14480
14481		case "startedBy":
14482			if value != nil {
14483				jtv, ok := value.(string)
14484				if !ok {
14485					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14486				}
14487				sv.StartedBy = ptr.String(jtv)
14488			}
14489
14490		case "stopCode":
14491			if value != nil {
14492				jtv, ok := value.(string)
14493				if !ok {
14494					return fmt.Errorf("expected TaskStopCode to be of type string, got %T instead", value)
14495				}
14496				sv.StopCode = types.TaskStopCode(jtv)
14497			}
14498
14499		case "stoppedAt":
14500			if value != nil {
14501				jtv, ok := value.(json.Number)
14502				if !ok {
14503					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14504				}
14505				f64, err := jtv.Float64()
14506				if err != nil {
14507					return err
14508				}
14509				sv.StoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14510			}
14511
14512		case "stoppedReason":
14513			if value != nil {
14514				jtv, ok := value.(string)
14515				if !ok {
14516					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14517				}
14518				sv.StoppedReason = ptr.String(jtv)
14519			}
14520
14521		case "stoppingAt":
14522			if value != nil {
14523				jtv, ok := value.(json.Number)
14524				if !ok {
14525					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14526				}
14527				f64, err := jtv.Float64()
14528				if err != nil {
14529					return err
14530				}
14531				sv.StoppingAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14532			}
14533
14534		case "tags":
14535			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
14536				return err
14537			}
14538
14539		case "taskArn":
14540			if value != nil {
14541				jtv, ok := value.(string)
14542				if !ok {
14543					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14544				}
14545				sv.TaskArn = ptr.String(jtv)
14546			}
14547
14548		case "taskDefinitionArn":
14549			if value != nil {
14550				jtv, ok := value.(string)
14551				if !ok {
14552					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14553				}
14554				sv.TaskDefinitionArn = ptr.String(jtv)
14555			}
14556
14557		case "version":
14558			if value != nil {
14559				jtv, ok := value.(json.Number)
14560				if !ok {
14561					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
14562				}
14563				i64, err := jtv.Int64()
14564				if err != nil {
14565					return err
14566				}
14567				sv.Version = i64
14568			}
14569
14570		default:
14571			_, _ = key, value
14572
14573		}
14574	}
14575	*v = sv
14576	return nil
14577}
14578
14579func awsAwsjson11_deserializeDocumentTaskDefinition(v **types.TaskDefinition, value interface{}) error {
14580	if v == nil {
14581		return fmt.Errorf("unexpected nil of type %T", v)
14582	}
14583	if value == nil {
14584		return nil
14585	}
14586
14587	shape, ok := value.(map[string]interface{})
14588	if !ok {
14589		return fmt.Errorf("unexpected JSON type %v", value)
14590	}
14591
14592	var sv *types.TaskDefinition
14593	if *v == nil {
14594		sv = &types.TaskDefinition{}
14595	} else {
14596		sv = *v
14597	}
14598
14599	for key, value := range shape {
14600		switch key {
14601		case "compatibilities":
14602			if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.Compatibilities, value); err != nil {
14603				return err
14604			}
14605
14606		case "containerDefinitions":
14607			if err := awsAwsjson11_deserializeDocumentContainerDefinitions(&sv.ContainerDefinitions, value); err != nil {
14608				return err
14609			}
14610
14611		case "cpu":
14612			if value != nil {
14613				jtv, ok := value.(string)
14614				if !ok {
14615					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14616				}
14617				sv.Cpu = ptr.String(jtv)
14618			}
14619
14620		case "deregisteredAt":
14621			if value != nil {
14622				jtv, ok := value.(json.Number)
14623				if !ok {
14624					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14625				}
14626				f64, err := jtv.Float64()
14627				if err != nil {
14628					return err
14629				}
14630				sv.DeregisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14631			}
14632
14633		case "ephemeralStorage":
14634			if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
14635				return err
14636			}
14637
14638		case "executionRoleArn":
14639			if value != nil {
14640				jtv, ok := value.(string)
14641				if !ok {
14642					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14643				}
14644				sv.ExecutionRoleArn = ptr.String(jtv)
14645			}
14646
14647		case "family":
14648			if value != nil {
14649				jtv, ok := value.(string)
14650				if !ok {
14651					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14652				}
14653				sv.Family = ptr.String(jtv)
14654			}
14655
14656		case "inferenceAccelerators":
14657			if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil {
14658				return err
14659			}
14660
14661		case "ipcMode":
14662			if value != nil {
14663				jtv, ok := value.(string)
14664				if !ok {
14665					return fmt.Errorf("expected IpcMode to be of type string, got %T instead", value)
14666				}
14667				sv.IpcMode = types.IpcMode(jtv)
14668			}
14669
14670		case "memory":
14671			if value != nil {
14672				jtv, ok := value.(string)
14673				if !ok {
14674					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14675				}
14676				sv.Memory = ptr.String(jtv)
14677			}
14678
14679		case "networkMode":
14680			if value != nil {
14681				jtv, ok := value.(string)
14682				if !ok {
14683					return fmt.Errorf("expected NetworkMode to be of type string, got %T instead", value)
14684				}
14685				sv.NetworkMode = types.NetworkMode(jtv)
14686			}
14687
14688		case "pidMode":
14689			if value != nil {
14690				jtv, ok := value.(string)
14691				if !ok {
14692					return fmt.Errorf("expected PidMode to be of type string, got %T instead", value)
14693				}
14694				sv.PidMode = types.PidMode(jtv)
14695			}
14696
14697		case "placementConstraints":
14698			if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(&sv.PlacementConstraints, value); err != nil {
14699				return err
14700			}
14701
14702		case "proxyConfiguration":
14703			if err := awsAwsjson11_deserializeDocumentProxyConfiguration(&sv.ProxyConfiguration, value); err != nil {
14704				return err
14705			}
14706
14707		case "registeredAt":
14708			if value != nil {
14709				jtv, ok := value.(json.Number)
14710				if !ok {
14711					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
14712				}
14713				f64, err := jtv.Float64()
14714				if err != nil {
14715					return err
14716				}
14717				sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
14718			}
14719
14720		case "registeredBy":
14721			if value != nil {
14722				jtv, ok := value.(string)
14723				if !ok {
14724					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14725				}
14726				sv.RegisteredBy = ptr.String(jtv)
14727			}
14728
14729		case "requiresAttributes":
14730			if err := awsAwsjson11_deserializeDocumentRequiresAttributes(&sv.RequiresAttributes, value); err != nil {
14731				return err
14732			}
14733
14734		case "requiresCompatibilities":
14735			if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.RequiresCompatibilities, value); err != nil {
14736				return err
14737			}
14738
14739		case "revision":
14740			if value != nil {
14741				jtv, ok := value.(json.Number)
14742				if !ok {
14743					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
14744				}
14745				i64, err := jtv.Int64()
14746				if err != nil {
14747					return err
14748				}
14749				sv.Revision = int32(i64)
14750			}
14751
14752		case "status":
14753			if value != nil {
14754				jtv, ok := value.(string)
14755				if !ok {
14756					return fmt.Errorf("expected TaskDefinitionStatus to be of type string, got %T instead", value)
14757				}
14758				sv.Status = types.TaskDefinitionStatus(jtv)
14759			}
14760
14761		case "taskDefinitionArn":
14762			if value != nil {
14763				jtv, ok := value.(string)
14764				if !ok {
14765					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14766				}
14767				sv.TaskDefinitionArn = ptr.String(jtv)
14768			}
14769
14770		case "taskRoleArn":
14771			if value != nil {
14772				jtv, ok := value.(string)
14773				if !ok {
14774					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14775				}
14776				sv.TaskRoleArn = ptr.String(jtv)
14777			}
14778
14779		case "volumes":
14780			if err := awsAwsjson11_deserializeDocumentVolumeList(&sv.Volumes, value); err != nil {
14781				return err
14782			}
14783
14784		default:
14785			_, _ = key, value
14786
14787		}
14788	}
14789	*v = sv
14790	return nil
14791}
14792
14793func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(v **types.TaskDefinitionPlacementConstraint, value interface{}) error {
14794	if v == nil {
14795		return fmt.Errorf("unexpected nil of type %T", v)
14796	}
14797	if value == nil {
14798		return nil
14799	}
14800
14801	shape, ok := value.(map[string]interface{})
14802	if !ok {
14803		return fmt.Errorf("unexpected JSON type %v", value)
14804	}
14805
14806	var sv *types.TaskDefinitionPlacementConstraint
14807	if *v == nil {
14808		sv = &types.TaskDefinitionPlacementConstraint{}
14809	} else {
14810		sv = *v
14811	}
14812
14813	for key, value := range shape {
14814		switch key {
14815		case "expression":
14816			if value != nil {
14817				jtv, ok := value.(string)
14818				if !ok {
14819					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14820				}
14821				sv.Expression = ptr.String(jtv)
14822			}
14823
14824		case "type":
14825			if value != nil {
14826				jtv, ok := value.(string)
14827				if !ok {
14828					return fmt.Errorf("expected TaskDefinitionPlacementConstraintType to be of type string, got %T instead", value)
14829				}
14830				sv.Type = types.TaskDefinitionPlacementConstraintType(jtv)
14831			}
14832
14833		default:
14834			_, _ = key, value
14835
14836		}
14837	}
14838	*v = sv
14839	return nil
14840}
14841
14842func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(v *[]types.TaskDefinitionPlacementConstraint, value interface{}) error {
14843	if v == nil {
14844		return fmt.Errorf("unexpected nil of type %T", v)
14845	}
14846	if value == nil {
14847		return nil
14848	}
14849
14850	shape, ok := value.([]interface{})
14851	if !ok {
14852		return fmt.Errorf("unexpected JSON type %v", value)
14853	}
14854
14855	var cv []types.TaskDefinitionPlacementConstraint
14856	if *v == nil {
14857		cv = []types.TaskDefinitionPlacementConstraint{}
14858	} else {
14859		cv = *v
14860	}
14861
14862	for _, value := range shape {
14863		var col types.TaskDefinitionPlacementConstraint
14864		destAddr := &col
14865		if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(&destAddr, value); err != nil {
14866			return err
14867		}
14868		col = *destAddr
14869		cv = append(cv, col)
14870
14871	}
14872	*v = cv
14873	return nil
14874}
14875
14876func awsAwsjson11_deserializeDocumentTaskOverride(v **types.TaskOverride, value interface{}) error {
14877	if v == nil {
14878		return fmt.Errorf("unexpected nil of type %T", v)
14879	}
14880	if value == nil {
14881		return nil
14882	}
14883
14884	shape, ok := value.(map[string]interface{})
14885	if !ok {
14886		return fmt.Errorf("unexpected JSON type %v", value)
14887	}
14888
14889	var sv *types.TaskOverride
14890	if *v == nil {
14891		sv = &types.TaskOverride{}
14892	} else {
14893		sv = *v
14894	}
14895
14896	for key, value := range shape {
14897		switch key {
14898		case "containerOverrides":
14899			if err := awsAwsjson11_deserializeDocumentContainerOverrides(&sv.ContainerOverrides, value); err != nil {
14900				return err
14901			}
14902
14903		case "cpu":
14904			if value != nil {
14905				jtv, ok := value.(string)
14906				if !ok {
14907					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14908				}
14909				sv.Cpu = ptr.String(jtv)
14910			}
14911
14912		case "ephemeralStorage":
14913			if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil {
14914				return err
14915			}
14916
14917		case "executionRoleArn":
14918			if value != nil {
14919				jtv, ok := value.(string)
14920				if !ok {
14921					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14922				}
14923				sv.ExecutionRoleArn = ptr.String(jtv)
14924			}
14925
14926		case "inferenceAcceleratorOverrides":
14927			if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(&sv.InferenceAcceleratorOverrides, value); err != nil {
14928				return err
14929			}
14930
14931		case "memory":
14932			if value != nil {
14933				jtv, ok := value.(string)
14934				if !ok {
14935					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14936				}
14937				sv.Memory = ptr.String(jtv)
14938			}
14939
14940		case "taskRoleArn":
14941			if value != nil {
14942				jtv, ok := value.(string)
14943				if !ok {
14944					return fmt.Errorf("expected String to be of type string, got %T instead", value)
14945				}
14946				sv.TaskRoleArn = ptr.String(jtv)
14947			}
14948
14949		default:
14950			_, _ = key, value
14951
14952		}
14953	}
14954	*v = sv
14955	return nil
14956}
14957
14958func awsAwsjson11_deserializeDocumentTasks(v *[]types.Task, value interface{}) error {
14959	if v == nil {
14960		return fmt.Errorf("unexpected nil of type %T", v)
14961	}
14962	if value == nil {
14963		return nil
14964	}
14965
14966	shape, ok := value.([]interface{})
14967	if !ok {
14968		return fmt.Errorf("unexpected JSON type %v", value)
14969	}
14970
14971	var cv []types.Task
14972	if *v == nil {
14973		cv = []types.Task{}
14974	} else {
14975		cv = *v
14976	}
14977
14978	for _, value := range shape {
14979		var col types.Task
14980		destAddr := &col
14981		if err := awsAwsjson11_deserializeDocumentTask(&destAddr, value); err != nil {
14982			return err
14983		}
14984		col = *destAddr
14985		cv = append(cv, col)
14986
14987	}
14988	*v = cv
14989	return nil
14990}
14991
14992func awsAwsjson11_deserializeDocumentTaskSet(v **types.TaskSet, value interface{}) error {
14993	if v == nil {
14994		return fmt.Errorf("unexpected nil of type %T", v)
14995	}
14996	if value == nil {
14997		return nil
14998	}
14999
15000	shape, ok := value.(map[string]interface{})
15001	if !ok {
15002		return fmt.Errorf("unexpected JSON type %v", value)
15003	}
15004
15005	var sv *types.TaskSet
15006	if *v == nil {
15007		sv = &types.TaskSet{}
15008	} else {
15009		sv = *v
15010	}
15011
15012	for key, value := range shape {
15013		switch key {
15014		case "capacityProviderStrategy":
15015			if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil {
15016				return err
15017			}
15018
15019		case "clusterArn":
15020			if value != nil {
15021				jtv, ok := value.(string)
15022				if !ok {
15023					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15024				}
15025				sv.ClusterArn = ptr.String(jtv)
15026			}
15027
15028		case "computedDesiredCount":
15029			if value != nil {
15030				jtv, ok := value.(json.Number)
15031				if !ok {
15032					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15033				}
15034				i64, err := jtv.Int64()
15035				if err != nil {
15036					return err
15037				}
15038				sv.ComputedDesiredCount = int32(i64)
15039			}
15040
15041		case "createdAt":
15042			if value != nil {
15043				jtv, ok := value.(json.Number)
15044				if !ok {
15045					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
15046				}
15047				f64, err := jtv.Float64()
15048				if err != nil {
15049					return err
15050				}
15051				sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
15052			}
15053
15054		case "externalId":
15055			if value != nil {
15056				jtv, ok := value.(string)
15057				if !ok {
15058					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15059				}
15060				sv.ExternalId = ptr.String(jtv)
15061			}
15062
15063		case "id":
15064			if value != nil {
15065				jtv, ok := value.(string)
15066				if !ok {
15067					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15068				}
15069				sv.Id = ptr.String(jtv)
15070			}
15071
15072		case "launchType":
15073			if value != nil {
15074				jtv, ok := value.(string)
15075				if !ok {
15076					return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value)
15077				}
15078				sv.LaunchType = types.LaunchType(jtv)
15079			}
15080
15081		case "loadBalancers":
15082			if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil {
15083				return err
15084			}
15085
15086		case "networkConfiguration":
15087			if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil {
15088				return err
15089			}
15090
15091		case "pendingCount":
15092			if value != nil {
15093				jtv, ok := value.(json.Number)
15094				if !ok {
15095					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15096				}
15097				i64, err := jtv.Int64()
15098				if err != nil {
15099					return err
15100				}
15101				sv.PendingCount = int32(i64)
15102			}
15103
15104		case "platformVersion":
15105			if value != nil {
15106				jtv, ok := value.(string)
15107				if !ok {
15108					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15109				}
15110				sv.PlatformVersion = ptr.String(jtv)
15111			}
15112
15113		case "runningCount":
15114			if value != nil {
15115				jtv, ok := value.(json.Number)
15116				if !ok {
15117					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15118				}
15119				i64, err := jtv.Int64()
15120				if err != nil {
15121					return err
15122				}
15123				sv.RunningCount = int32(i64)
15124			}
15125
15126		case "scale":
15127			if err := awsAwsjson11_deserializeDocumentScale(&sv.Scale, value); err != nil {
15128				return err
15129			}
15130
15131		case "serviceArn":
15132			if value != nil {
15133				jtv, ok := value.(string)
15134				if !ok {
15135					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15136				}
15137				sv.ServiceArn = ptr.String(jtv)
15138			}
15139
15140		case "serviceRegistries":
15141			if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil {
15142				return err
15143			}
15144
15145		case "stabilityStatus":
15146			if value != nil {
15147				jtv, ok := value.(string)
15148				if !ok {
15149					return fmt.Errorf("expected StabilityStatus to be of type string, got %T instead", value)
15150				}
15151				sv.StabilityStatus = types.StabilityStatus(jtv)
15152			}
15153
15154		case "stabilityStatusAt":
15155			if value != nil {
15156				jtv, ok := value.(json.Number)
15157				if !ok {
15158					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
15159				}
15160				f64, err := jtv.Float64()
15161				if err != nil {
15162					return err
15163				}
15164				sv.StabilityStatusAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
15165			}
15166
15167		case "startedBy":
15168			if value != nil {
15169				jtv, ok := value.(string)
15170				if !ok {
15171					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15172				}
15173				sv.StartedBy = ptr.String(jtv)
15174			}
15175
15176		case "status":
15177			if value != nil {
15178				jtv, ok := value.(string)
15179				if !ok {
15180					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15181				}
15182				sv.Status = ptr.String(jtv)
15183			}
15184
15185		case "tags":
15186			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
15187				return err
15188			}
15189
15190		case "taskDefinition":
15191			if value != nil {
15192				jtv, ok := value.(string)
15193				if !ok {
15194					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15195				}
15196				sv.TaskDefinition = ptr.String(jtv)
15197			}
15198
15199		case "taskSetArn":
15200			if value != nil {
15201				jtv, ok := value.(string)
15202				if !ok {
15203					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15204				}
15205				sv.TaskSetArn = ptr.String(jtv)
15206			}
15207
15208		case "updatedAt":
15209			if value != nil {
15210				jtv, ok := value.(json.Number)
15211				if !ok {
15212					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
15213				}
15214				f64, err := jtv.Float64()
15215				if err != nil {
15216					return err
15217				}
15218				sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
15219			}
15220
15221		default:
15222			_, _ = key, value
15223
15224		}
15225	}
15226	*v = sv
15227	return nil
15228}
15229
15230func awsAwsjson11_deserializeDocumentTaskSetNotFoundException(v **types.TaskSetNotFoundException, value interface{}) error {
15231	if v == nil {
15232		return fmt.Errorf("unexpected nil of type %T", v)
15233	}
15234	if value == nil {
15235		return nil
15236	}
15237
15238	shape, ok := value.(map[string]interface{})
15239	if !ok {
15240		return fmt.Errorf("unexpected JSON type %v", value)
15241	}
15242
15243	var sv *types.TaskSetNotFoundException
15244	if *v == nil {
15245		sv = &types.TaskSetNotFoundException{}
15246	} else {
15247		sv = *v
15248	}
15249
15250	for key, value := range shape {
15251		switch key {
15252		case "message":
15253			if value != nil {
15254				jtv, ok := value.(string)
15255				if !ok {
15256					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15257				}
15258				sv.Message = ptr.String(jtv)
15259			}
15260
15261		default:
15262			_, _ = key, value
15263
15264		}
15265	}
15266	*v = sv
15267	return nil
15268}
15269
15270func awsAwsjson11_deserializeDocumentTaskSets(v *[]types.TaskSet, value interface{}) error {
15271	if v == nil {
15272		return fmt.Errorf("unexpected nil of type %T", v)
15273	}
15274	if value == nil {
15275		return nil
15276	}
15277
15278	shape, ok := value.([]interface{})
15279	if !ok {
15280		return fmt.Errorf("unexpected JSON type %v", value)
15281	}
15282
15283	var cv []types.TaskSet
15284	if *v == nil {
15285		cv = []types.TaskSet{}
15286	} else {
15287		cv = *v
15288	}
15289
15290	for _, value := range shape {
15291		var col types.TaskSet
15292		destAddr := &col
15293		if err := awsAwsjson11_deserializeDocumentTaskSet(&destAddr, value); err != nil {
15294			return err
15295		}
15296		col = *destAddr
15297		cv = append(cv, col)
15298
15299	}
15300	*v = cv
15301	return nil
15302}
15303
15304func awsAwsjson11_deserializeDocumentTmpfs(v **types.Tmpfs, value interface{}) error {
15305	if v == nil {
15306		return fmt.Errorf("unexpected nil of type %T", v)
15307	}
15308	if value == nil {
15309		return nil
15310	}
15311
15312	shape, ok := value.(map[string]interface{})
15313	if !ok {
15314		return fmt.Errorf("unexpected JSON type %v", value)
15315	}
15316
15317	var sv *types.Tmpfs
15318	if *v == nil {
15319		sv = &types.Tmpfs{}
15320	} else {
15321		sv = *v
15322	}
15323
15324	for key, value := range shape {
15325		switch key {
15326		case "containerPath":
15327			if value != nil {
15328				jtv, ok := value.(string)
15329				if !ok {
15330					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15331				}
15332				sv.ContainerPath = ptr.String(jtv)
15333			}
15334
15335		case "mountOptions":
15336			if err := awsAwsjson11_deserializeDocumentStringList(&sv.MountOptions, value); err != nil {
15337				return err
15338			}
15339
15340		case "size":
15341			if value != nil {
15342				jtv, ok := value.(json.Number)
15343				if !ok {
15344					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15345				}
15346				i64, err := jtv.Int64()
15347				if err != nil {
15348					return err
15349				}
15350				sv.Size = int32(i64)
15351			}
15352
15353		default:
15354			_, _ = key, value
15355
15356		}
15357	}
15358	*v = sv
15359	return nil
15360}
15361
15362func awsAwsjson11_deserializeDocumentTmpfsList(v *[]types.Tmpfs, value interface{}) error {
15363	if v == nil {
15364		return fmt.Errorf("unexpected nil of type %T", v)
15365	}
15366	if value == nil {
15367		return nil
15368	}
15369
15370	shape, ok := value.([]interface{})
15371	if !ok {
15372		return fmt.Errorf("unexpected JSON type %v", value)
15373	}
15374
15375	var cv []types.Tmpfs
15376	if *v == nil {
15377		cv = []types.Tmpfs{}
15378	} else {
15379		cv = *v
15380	}
15381
15382	for _, value := range shape {
15383		var col types.Tmpfs
15384		destAddr := &col
15385		if err := awsAwsjson11_deserializeDocumentTmpfs(&destAddr, value); err != nil {
15386			return err
15387		}
15388		col = *destAddr
15389		cv = append(cv, col)
15390
15391	}
15392	*v = cv
15393	return nil
15394}
15395
15396func awsAwsjson11_deserializeDocumentUlimit(v **types.Ulimit, value interface{}) error {
15397	if v == nil {
15398		return fmt.Errorf("unexpected nil of type %T", v)
15399	}
15400	if value == nil {
15401		return nil
15402	}
15403
15404	shape, ok := value.(map[string]interface{})
15405	if !ok {
15406		return fmt.Errorf("unexpected JSON type %v", value)
15407	}
15408
15409	var sv *types.Ulimit
15410	if *v == nil {
15411		sv = &types.Ulimit{}
15412	} else {
15413		sv = *v
15414	}
15415
15416	for key, value := range shape {
15417		switch key {
15418		case "hardLimit":
15419			if value != nil {
15420				jtv, ok := value.(json.Number)
15421				if !ok {
15422					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15423				}
15424				i64, err := jtv.Int64()
15425				if err != nil {
15426					return err
15427				}
15428				sv.HardLimit = int32(i64)
15429			}
15430
15431		case "name":
15432			if value != nil {
15433				jtv, ok := value.(string)
15434				if !ok {
15435					return fmt.Errorf("expected UlimitName to be of type string, got %T instead", value)
15436				}
15437				sv.Name = types.UlimitName(jtv)
15438			}
15439
15440		case "softLimit":
15441			if value != nil {
15442				jtv, ok := value.(json.Number)
15443				if !ok {
15444					return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
15445				}
15446				i64, err := jtv.Int64()
15447				if err != nil {
15448					return err
15449				}
15450				sv.SoftLimit = int32(i64)
15451			}
15452
15453		default:
15454			_, _ = key, value
15455
15456		}
15457	}
15458	*v = sv
15459	return nil
15460}
15461
15462func awsAwsjson11_deserializeDocumentUlimitList(v *[]types.Ulimit, value interface{}) error {
15463	if v == nil {
15464		return fmt.Errorf("unexpected nil of type %T", v)
15465	}
15466	if value == nil {
15467		return nil
15468	}
15469
15470	shape, ok := value.([]interface{})
15471	if !ok {
15472		return fmt.Errorf("unexpected JSON type %v", value)
15473	}
15474
15475	var cv []types.Ulimit
15476	if *v == nil {
15477		cv = []types.Ulimit{}
15478	} else {
15479		cv = *v
15480	}
15481
15482	for _, value := range shape {
15483		var col types.Ulimit
15484		destAddr := &col
15485		if err := awsAwsjson11_deserializeDocumentUlimit(&destAddr, value); err != nil {
15486			return err
15487		}
15488		col = *destAddr
15489		cv = append(cv, col)
15490
15491	}
15492	*v = cv
15493	return nil
15494}
15495
15496func awsAwsjson11_deserializeDocumentUnsupportedFeatureException(v **types.UnsupportedFeatureException, value interface{}) error {
15497	if v == nil {
15498		return fmt.Errorf("unexpected nil of type %T", v)
15499	}
15500	if value == nil {
15501		return nil
15502	}
15503
15504	shape, ok := value.(map[string]interface{})
15505	if !ok {
15506		return fmt.Errorf("unexpected JSON type %v", value)
15507	}
15508
15509	var sv *types.UnsupportedFeatureException
15510	if *v == nil {
15511		sv = &types.UnsupportedFeatureException{}
15512	} else {
15513		sv = *v
15514	}
15515
15516	for key, value := range shape {
15517		switch key {
15518		case "message":
15519			if value != nil {
15520				jtv, ok := value.(string)
15521				if !ok {
15522					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15523				}
15524				sv.Message = ptr.String(jtv)
15525			}
15526
15527		default:
15528			_, _ = key, value
15529
15530		}
15531	}
15532	*v = sv
15533	return nil
15534}
15535
15536func awsAwsjson11_deserializeDocumentUpdateInProgressException(v **types.UpdateInProgressException, value interface{}) error {
15537	if v == nil {
15538		return fmt.Errorf("unexpected nil of type %T", v)
15539	}
15540	if value == nil {
15541		return nil
15542	}
15543
15544	shape, ok := value.(map[string]interface{})
15545	if !ok {
15546		return fmt.Errorf("unexpected JSON type %v", value)
15547	}
15548
15549	var sv *types.UpdateInProgressException
15550	if *v == nil {
15551		sv = &types.UpdateInProgressException{}
15552	} else {
15553		sv = *v
15554	}
15555
15556	for key, value := range shape {
15557		switch key {
15558		case "message":
15559			if value != nil {
15560				jtv, ok := value.(string)
15561				if !ok {
15562					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15563				}
15564				sv.Message = ptr.String(jtv)
15565			}
15566
15567		default:
15568			_, _ = key, value
15569
15570		}
15571	}
15572	*v = sv
15573	return nil
15574}
15575
15576func awsAwsjson11_deserializeDocumentVersionInfo(v **types.VersionInfo, value interface{}) error {
15577	if v == nil {
15578		return fmt.Errorf("unexpected nil of type %T", v)
15579	}
15580	if value == nil {
15581		return nil
15582	}
15583
15584	shape, ok := value.(map[string]interface{})
15585	if !ok {
15586		return fmt.Errorf("unexpected JSON type %v", value)
15587	}
15588
15589	var sv *types.VersionInfo
15590	if *v == nil {
15591		sv = &types.VersionInfo{}
15592	} else {
15593		sv = *v
15594	}
15595
15596	for key, value := range shape {
15597		switch key {
15598		case "agentHash":
15599			if value != nil {
15600				jtv, ok := value.(string)
15601				if !ok {
15602					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15603				}
15604				sv.AgentHash = ptr.String(jtv)
15605			}
15606
15607		case "agentVersion":
15608			if value != nil {
15609				jtv, ok := value.(string)
15610				if !ok {
15611					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15612				}
15613				sv.AgentVersion = ptr.String(jtv)
15614			}
15615
15616		case "dockerVersion":
15617			if value != nil {
15618				jtv, ok := value.(string)
15619				if !ok {
15620					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15621				}
15622				sv.DockerVersion = ptr.String(jtv)
15623			}
15624
15625		default:
15626			_, _ = key, value
15627
15628		}
15629	}
15630	*v = sv
15631	return nil
15632}
15633
15634func awsAwsjson11_deserializeDocumentVolume(v **types.Volume, value interface{}) error {
15635	if v == nil {
15636		return fmt.Errorf("unexpected nil of type %T", v)
15637	}
15638	if value == nil {
15639		return nil
15640	}
15641
15642	shape, ok := value.(map[string]interface{})
15643	if !ok {
15644		return fmt.Errorf("unexpected JSON type %v", value)
15645	}
15646
15647	var sv *types.Volume
15648	if *v == nil {
15649		sv = &types.Volume{}
15650	} else {
15651		sv = *v
15652	}
15653
15654	for key, value := range shape {
15655		switch key {
15656		case "dockerVolumeConfiguration":
15657			if err := awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(&sv.DockerVolumeConfiguration, value); err != nil {
15658				return err
15659			}
15660
15661		case "efsVolumeConfiguration":
15662			if err := awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(&sv.EfsVolumeConfiguration, value); err != nil {
15663				return err
15664			}
15665
15666		case "fsxWindowsFileServerVolumeConfiguration":
15667			if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(&sv.FsxWindowsFileServerVolumeConfiguration, value); err != nil {
15668				return err
15669			}
15670
15671		case "host":
15672			if err := awsAwsjson11_deserializeDocumentHostVolumeProperties(&sv.Host, value); err != nil {
15673				return err
15674			}
15675
15676		case "name":
15677			if value != nil {
15678				jtv, ok := value.(string)
15679				if !ok {
15680					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15681				}
15682				sv.Name = ptr.String(jtv)
15683			}
15684
15685		default:
15686			_, _ = key, value
15687
15688		}
15689	}
15690	*v = sv
15691	return nil
15692}
15693
15694func awsAwsjson11_deserializeDocumentVolumeFrom(v **types.VolumeFrom, value interface{}) error {
15695	if v == nil {
15696		return fmt.Errorf("unexpected nil of type %T", v)
15697	}
15698	if value == nil {
15699		return nil
15700	}
15701
15702	shape, ok := value.(map[string]interface{})
15703	if !ok {
15704		return fmt.Errorf("unexpected JSON type %v", value)
15705	}
15706
15707	var sv *types.VolumeFrom
15708	if *v == nil {
15709		sv = &types.VolumeFrom{}
15710	} else {
15711		sv = *v
15712	}
15713
15714	for key, value := range shape {
15715		switch key {
15716		case "readOnly":
15717			if value != nil {
15718				jtv, ok := value.(bool)
15719				if !ok {
15720					return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value)
15721				}
15722				sv.ReadOnly = ptr.Bool(jtv)
15723			}
15724
15725		case "sourceContainer":
15726			if value != nil {
15727				jtv, ok := value.(string)
15728				if !ok {
15729					return fmt.Errorf("expected String to be of type string, got %T instead", value)
15730				}
15731				sv.SourceContainer = ptr.String(jtv)
15732			}
15733
15734		default:
15735			_, _ = key, value
15736
15737		}
15738	}
15739	*v = sv
15740	return nil
15741}
15742
15743func awsAwsjson11_deserializeDocumentVolumeFromList(v *[]types.VolumeFrom, value interface{}) error {
15744	if v == nil {
15745		return fmt.Errorf("unexpected nil of type %T", v)
15746	}
15747	if value == nil {
15748		return nil
15749	}
15750
15751	shape, ok := value.([]interface{})
15752	if !ok {
15753		return fmt.Errorf("unexpected JSON type %v", value)
15754	}
15755
15756	var cv []types.VolumeFrom
15757	if *v == nil {
15758		cv = []types.VolumeFrom{}
15759	} else {
15760		cv = *v
15761	}
15762
15763	for _, value := range shape {
15764		var col types.VolumeFrom
15765		destAddr := &col
15766		if err := awsAwsjson11_deserializeDocumentVolumeFrom(&destAddr, value); err != nil {
15767			return err
15768		}
15769		col = *destAddr
15770		cv = append(cv, col)
15771
15772	}
15773	*v = cv
15774	return nil
15775}
15776
15777func awsAwsjson11_deserializeDocumentVolumeList(v *[]types.Volume, value interface{}) error {
15778	if v == nil {
15779		return fmt.Errorf("unexpected nil of type %T", v)
15780	}
15781	if value == nil {
15782		return nil
15783	}
15784
15785	shape, ok := value.([]interface{})
15786	if !ok {
15787		return fmt.Errorf("unexpected JSON type %v", value)
15788	}
15789
15790	var cv []types.Volume
15791	if *v == nil {
15792		cv = []types.Volume{}
15793	} else {
15794		cv = *v
15795	}
15796
15797	for _, value := range shape {
15798		var col types.Volume
15799		destAddr := &col
15800		if err := awsAwsjson11_deserializeDocumentVolume(&destAddr, value); err != nil {
15801			return err
15802		}
15803		col = *destAddr
15804		cv = append(cv, col)
15805
15806	}
15807	*v = cv
15808	return nil
15809}
15810
15811func awsAwsjson11_deserializeOpDocumentCreateCapacityProviderOutput(v **CreateCapacityProviderOutput, value interface{}) error {
15812	if v == nil {
15813		return fmt.Errorf("unexpected nil of type %T", v)
15814	}
15815	if value == nil {
15816		return nil
15817	}
15818
15819	shape, ok := value.(map[string]interface{})
15820	if !ok {
15821		return fmt.Errorf("unexpected JSON type %v", value)
15822	}
15823
15824	var sv *CreateCapacityProviderOutput
15825	if *v == nil {
15826		sv = &CreateCapacityProviderOutput{}
15827	} else {
15828		sv = *v
15829	}
15830
15831	for key, value := range shape {
15832		switch key {
15833		case "capacityProvider":
15834			if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
15835				return err
15836			}
15837
15838		default:
15839			_, _ = key, value
15840
15841		}
15842	}
15843	*v = sv
15844	return nil
15845}
15846
15847func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, value interface{}) error {
15848	if v == nil {
15849		return fmt.Errorf("unexpected nil of type %T", v)
15850	}
15851	if value == nil {
15852		return nil
15853	}
15854
15855	shape, ok := value.(map[string]interface{})
15856	if !ok {
15857		return fmt.Errorf("unexpected JSON type %v", value)
15858	}
15859
15860	var sv *CreateClusterOutput
15861	if *v == nil {
15862		sv = &CreateClusterOutput{}
15863	} else {
15864		sv = *v
15865	}
15866
15867	for key, value := range shape {
15868		switch key {
15869		case "cluster":
15870			if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
15871				return err
15872			}
15873
15874		default:
15875			_, _ = key, value
15876
15877		}
15878	}
15879	*v = sv
15880	return nil
15881}
15882
15883func awsAwsjson11_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutput, value interface{}) error {
15884	if v == nil {
15885		return fmt.Errorf("unexpected nil of type %T", v)
15886	}
15887	if value == nil {
15888		return nil
15889	}
15890
15891	shape, ok := value.(map[string]interface{})
15892	if !ok {
15893		return fmt.Errorf("unexpected JSON type %v", value)
15894	}
15895
15896	var sv *CreateServiceOutput
15897	if *v == nil {
15898		sv = &CreateServiceOutput{}
15899	} else {
15900		sv = *v
15901	}
15902
15903	for key, value := range shape {
15904		switch key {
15905		case "service":
15906			if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
15907				return err
15908			}
15909
15910		default:
15911			_, _ = key, value
15912
15913		}
15914	}
15915	*v = sv
15916	return nil
15917}
15918
15919func awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(v **CreateTaskSetOutput, value interface{}) error {
15920	if v == nil {
15921		return fmt.Errorf("unexpected nil of type %T", v)
15922	}
15923	if value == nil {
15924		return nil
15925	}
15926
15927	shape, ok := value.(map[string]interface{})
15928	if !ok {
15929		return fmt.Errorf("unexpected JSON type %v", value)
15930	}
15931
15932	var sv *CreateTaskSetOutput
15933	if *v == nil {
15934		sv = &CreateTaskSetOutput{}
15935	} else {
15936		sv = *v
15937	}
15938
15939	for key, value := range shape {
15940		switch key {
15941		case "taskSet":
15942			if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
15943				return err
15944			}
15945
15946		default:
15947			_, _ = key, value
15948
15949		}
15950	}
15951	*v = sv
15952	return nil
15953}
15954
15955func awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(v **DeleteAccountSettingOutput, value interface{}) error {
15956	if v == nil {
15957		return fmt.Errorf("unexpected nil of type %T", v)
15958	}
15959	if value == nil {
15960		return nil
15961	}
15962
15963	shape, ok := value.(map[string]interface{})
15964	if !ok {
15965		return fmt.Errorf("unexpected JSON type %v", value)
15966	}
15967
15968	var sv *DeleteAccountSettingOutput
15969	if *v == nil {
15970		sv = &DeleteAccountSettingOutput{}
15971	} else {
15972		sv = *v
15973	}
15974
15975	for key, value := range shape {
15976		switch key {
15977		case "setting":
15978			if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
15979				return err
15980			}
15981
15982		default:
15983			_, _ = key, value
15984
15985		}
15986	}
15987	*v = sv
15988	return nil
15989}
15990
15991func awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(v **DeleteAttributesOutput, value interface{}) error {
15992	if v == nil {
15993		return fmt.Errorf("unexpected nil of type %T", v)
15994	}
15995	if value == nil {
15996		return nil
15997	}
15998
15999	shape, ok := value.(map[string]interface{})
16000	if !ok {
16001		return fmt.Errorf("unexpected JSON type %v", value)
16002	}
16003
16004	var sv *DeleteAttributesOutput
16005	if *v == nil {
16006		sv = &DeleteAttributesOutput{}
16007	} else {
16008		sv = *v
16009	}
16010
16011	for key, value := range shape {
16012		switch key {
16013		case "attributes":
16014			if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
16015				return err
16016			}
16017
16018		default:
16019			_, _ = key, value
16020
16021		}
16022	}
16023	*v = sv
16024	return nil
16025}
16026
16027func awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(v **DeleteCapacityProviderOutput, value interface{}) error {
16028	if v == nil {
16029		return fmt.Errorf("unexpected nil of type %T", v)
16030	}
16031	if value == nil {
16032		return nil
16033	}
16034
16035	shape, ok := value.(map[string]interface{})
16036	if !ok {
16037		return fmt.Errorf("unexpected JSON type %v", value)
16038	}
16039
16040	var sv *DeleteCapacityProviderOutput
16041	if *v == nil {
16042		sv = &DeleteCapacityProviderOutput{}
16043	} else {
16044		sv = *v
16045	}
16046
16047	for key, value := range shape {
16048		switch key {
16049		case "capacityProvider":
16050			if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
16051				return err
16052			}
16053
16054		default:
16055			_, _ = key, value
16056
16057		}
16058	}
16059	*v = sv
16060	return nil
16061}
16062
16063func awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(v **DeleteClusterOutput, value interface{}) error {
16064	if v == nil {
16065		return fmt.Errorf("unexpected nil of type %T", v)
16066	}
16067	if value == nil {
16068		return nil
16069	}
16070
16071	shape, ok := value.(map[string]interface{})
16072	if !ok {
16073		return fmt.Errorf("unexpected JSON type %v", value)
16074	}
16075
16076	var sv *DeleteClusterOutput
16077	if *v == nil {
16078		sv = &DeleteClusterOutput{}
16079	} else {
16080		sv = *v
16081	}
16082
16083	for key, value := range shape {
16084		switch key {
16085		case "cluster":
16086			if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
16087				return err
16088			}
16089
16090		default:
16091			_, _ = key, value
16092
16093		}
16094	}
16095	*v = sv
16096	return nil
16097}
16098
16099func awsAwsjson11_deserializeOpDocumentDeleteServiceOutput(v **DeleteServiceOutput, value interface{}) error {
16100	if v == nil {
16101		return fmt.Errorf("unexpected nil of type %T", v)
16102	}
16103	if value == nil {
16104		return nil
16105	}
16106
16107	shape, ok := value.(map[string]interface{})
16108	if !ok {
16109		return fmt.Errorf("unexpected JSON type %v", value)
16110	}
16111
16112	var sv *DeleteServiceOutput
16113	if *v == nil {
16114		sv = &DeleteServiceOutput{}
16115	} else {
16116		sv = *v
16117	}
16118
16119	for key, value := range shape {
16120		switch key {
16121		case "service":
16122			if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
16123				return err
16124			}
16125
16126		default:
16127			_, _ = key, value
16128
16129		}
16130	}
16131	*v = sv
16132	return nil
16133}
16134
16135func awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(v **DeleteTaskSetOutput, value interface{}) error {
16136	if v == nil {
16137		return fmt.Errorf("unexpected nil of type %T", v)
16138	}
16139	if value == nil {
16140		return nil
16141	}
16142
16143	shape, ok := value.(map[string]interface{})
16144	if !ok {
16145		return fmt.Errorf("unexpected JSON type %v", value)
16146	}
16147
16148	var sv *DeleteTaskSetOutput
16149	if *v == nil {
16150		sv = &DeleteTaskSetOutput{}
16151	} else {
16152		sv = *v
16153	}
16154
16155	for key, value := range shape {
16156		switch key {
16157		case "taskSet":
16158			if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
16159				return err
16160			}
16161
16162		default:
16163			_, _ = key, value
16164
16165		}
16166	}
16167	*v = sv
16168	return nil
16169}
16170
16171func awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(v **DeregisterContainerInstanceOutput, value interface{}) error {
16172	if v == nil {
16173		return fmt.Errorf("unexpected nil of type %T", v)
16174	}
16175	if value == nil {
16176		return nil
16177	}
16178
16179	shape, ok := value.(map[string]interface{})
16180	if !ok {
16181		return fmt.Errorf("unexpected JSON type %v", value)
16182	}
16183
16184	var sv *DeregisterContainerInstanceOutput
16185	if *v == nil {
16186		sv = &DeregisterContainerInstanceOutput{}
16187	} else {
16188		sv = *v
16189	}
16190
16191	for key, value := range shape {
16192		switch key {
16193		case "containerInstance":
16194			if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
16195				return err
16196			}
16197
16198		default:
16199			_, _ = key, value
16200
16201		}
16202	}
16203	*v = sv
16204	return nil
16205}
16206
16207func awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(v **DeregisterTaskDefinitionOutput, value interface{}) error {
16208	if v == nil {
16209		return fmt.Errorf("unexpected nil of type %T", v)
16210	}
16211	if value == nil {
16212		return nil
16213	}
16214
16215	shape, ok := value.(map[string]interface{})
16216	if !ok {
16217		return fmt.Errorf("unexpected JSON type %v", value)
16218	}
16219
16220	var sv *DeregisterTaskDefinitionOutput
16221	if *v == nil {
16222		sv = &DeregisterTaskDefinitionOutput{}
16223	} else {
16224		sv = *v
16225	}
16226
16227	for key, value := range shape {
16228		switch key {
16229		case "taskDefinition":
16230			if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
16231				return err
16232			}
16233
16234		default:
16235			_, _ = key, value
16236
16237		}
16238	}
16239	*v = sv
16240	return nil
16241}
16242
16243func awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(v **DescribeCapacityProvidersOutput, value interface{}) error {
16244	if v == nil {
16245		return fmt.Errorf("unexpected nil of type %T", v)
16246	}
16247	if value == nil {
16248		return nil
16249	}
16250
16251	shape, ok := value.(map[string]interface{})
16252	if !ok {
16253		return fmt.Errorf("unexpected JSON type %v", value)
16254	}
16255
16256	var sv *DescribeCapacityProvidersOutput
16257	if *v == nil {
16258		sv = &DescribeCapacityProvidersOutput{}
16259	} else {
16260		sv = *v
16261	}
16262
16263	for key, value := range shape {
16264		switch key {
16265		case "capacityProviders":
16266			if err := awsAwsjson11_deserializeDocumentCapacityProviders(&sv.CapacityProviders, value); err != nil {
16267				return err
16268			}
16269
16270		case "failures":
16271			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16272				return err
16273			}
16274
16275		case "nextToken":
16276			if value != nil {
16277				jtv, ok := value.(string)
16278				if !ok {
16279					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16280				}
16281				sv.NextToken = ptr.String(jtv)
16282			}
16283
16284		default:
16285			_, _ = key, value
16286
16287		}
16288	}
16289	*v = sv
16290	return nil
16291}
16292
16293func awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(v **DescribeClustersOutput, value interface{}) error {
16294	if v == nil {
16295		return fmt.Errorf("unexpected nil of type %T", v)
16296	}
16297	if value == nil {
16298		return nil
16299	}
16300
16301	shape, ok := value.(map[string]interface{})
16302	if !ok {
16303		return fmt.Errorf("unexpected JSON type %v", value)
16304	}
16305
16306	var sv *DescribeClustersOutput
16307	if *v == nil {
16308		sv = &DescribeClustersOutput{}
16309	} else {
16310		sv = *v
16311	}
16312
16313	for key, value := range shape {
16314		switch key {
16315		case "clusters":
16316			if err := awsAwsjson11_deserializeDocumentClusters(&sv.Clusters, value); err != nil {
16317				return err
16318			}
16319
16320		case "failures":
16321			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16322				return err
16323			}
16324
16325		default:
16326			_, _ = key, value
16327
16328		}
16329	}
16330	*v = sv
16331	return nil
16332}
16333
16334func awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(v **DescribeContainerInstancesOutput, value interface{}) error {
16335	if v == nil {
16336		return fmt.Errorf("unexpected nil of type %T", v)
16337	}
16338	if value == nil {
16339		return nil
16340	}
16341
16342	shape, ok := value.(map[string]interface{})
16343	if !ok {
16344		return fmt.Errorf("unexpected JSON type %v", value)
16345	}
16346
16347	var sv *DescribeContainerInstancesOutput
16348	if *v == nil {
16349		sv = &DescribeContainerInstancesOutput{}
16350	} else {
16351		sv = *v
16352	}
16353
16354	for key, value := range shape {
16355		switch key {
16356		case "containerInstances":
16357			if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil {
16358				return err
16359			}
16360
16361		case "failures":
16362			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16363				return err
16364			}
16365
16366		default:
16367			_, _ = key, value
16368
16369		}
16370	}
16371	*v = sv
16372	return nil
16373}
16374
16375func awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(v **DescribeServicesOutput, value interface{}) error {
16376	if v == nil {
16377		return fmt.Errorf("unexpected nil of type %T", v)
16378	}
16379	if value == nil {
16380		return nil
16381	}
16382
16383	shape, ok := value.(map[string]interface{})
16384	if !ok {
16385		return fmt.Errorf("unexpected JSON type %v", value)
16386	}
16387
16388	var sv *DescribeServicesOutput
16389	if *v == nil {
16390		sv = &DescribeServicesOutput{}
16391	} else {
16392		sv = *v
16393	}
16394
16395	for key, value := range shape {
16396		switch key {
16397		case "failures":
16398			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16399				return err
16400			}
16401
16402		case "services":
16403			if err := awsAwsjson11_deserializeDocumentServices(&sv.Services, value); err != nil {
16404				return err
16405			}
16406
16407		default:
16408			_, _ = key, value
16409
16410		}
16411	}
16412	*v = sv
16413	return nil
16414}
16415
16416func awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(v **DescribeTaskDefinitionOutput, value interface{}) error {
16417	if v == nil {
16418		return fmt.Errorf("unexpected nil of type %T", v)
16419	}
16420	if value == nil {
16421		return nil
16422	}
16423
16424	shape, ok := value.(map[string]interface{})
16425	if !ok {
16426		return fmt.Errorf("unexpected JSON type %v", value)
16427	}
16428
16429	var sv *DescribeTaskDefinitionOutput
16430	if *v == nil {
16431		sv = &DescribeTaskDefinitionOutput{}
16432	} else {
16433		sv = *v
16434	}
16435
16436	for key, value := range shape {
16437		switch key {
16438		case "tags":
16439			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16440				return err
16441			}
16442
16443		case "taskDefinition":
16444			if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
16445				return err
16446			}
16447
16448		default:
16449			_, _ = key, value
16450
16451		}
16452	}
16453	*v = sv
16454	return nil
16455}
16456
16457func awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(v **DescribeTaskSetsOutput, value interface{}) error {
16458	if v == nil {
16459		return fmt.Errorf("unexpected nil of type %T", v)
16460	}
16461	if value == nil {
16462		return nil
16463	}
16464
16465	shape, ok := value.(map[string]interface{})
16466	if !ok {
16467		return fmt.Errorf("unexpected JSON type %v", value)
16468	}
16469
16470	var sv *DescribeTaskSetsOutput
16471	if *v == nil {
16472		sv = &DescribeTaskSetsOutput{}
16473	} else {
16474		sv = *v
16475	}
16476
16477	for key, value := range shape {
16478		switch key {
16479		case "failures":
16480			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16481				return err
16482			}
16483
16484		case "taskSets":
16485			if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil {
16486				return err
16487			}
16488
16489		default:
16490			_, _ = key, value
16491
16492		}
16493	}
16494	*v = sv
16495	return nil
16496}
16497
16498func awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(v **DescribeTasksOutput, value interface{}) error {
16499	if v == nil {
16500		return fmt.Errorf("unexpected nil of type %T", v)
16501	}
16502	if value == nil {
16503		return nil
16504	}
16505
16506	shape, ok := value.(map[string]interface{})
16507	if !ok {
16508		return fmt.Errorf("unexpected JSON type %v", value)
16509	}
16510
16511	var sv *DescribeTasksOutput
16512	if *v == nil {
16513		sv = &DescribeTasksOutput{}
16514	} else {
16515		sv = *v
16516	}
16517
16518	for key, value := range shape {
16519		switch key {
16520		case "failures":
16521			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
16522				return err
16523			}
16524
16525		case "tasks":
16526			if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
16527				return err
16528			}
16529
16530		default:
16531			_, _ = key, value
16532
16533		}
16534	}
16535	*v = sv
16536	return nil
16537}
16538
16539func awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(v **DiscoverPollEndpointOutput, value interface{}) error {
16540	if v == nil {
16541		return fmt.Errorf("unexpected nil of type %T", v)
16542	}
16543	if value == nil {
16544		return nil
16545	}
16546
16547	shape, ok := value.(map[string]interface{})
16548	if !ok {
16549		return fmt.Errorf("unexpected JSON type %v", value)
16550	}
16551
16552	var sv *DiscoverPollEndpointOutput
16553	if *v == nil {
16554		sv = &DiscoverPollEndpointOutput{}
16555	} else {
16556		sv = *v
16557	}
16558
16559	for key, value := range shape {
16560		switch key {
16561		case "endpoint":
16562			if value != nil {
16563				jtv, ok := value.(string)
16564				if !ok {
16565					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16566				}
16567				sv.Endpoint = ptr.String(jtv)
16568			}
16569
16570		case "telemetryEndpoint":
16571			if value != nil {
16572				jtv, ok := value.(string)
16573				if !ok {
16574					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16575				}
16576				sv.TelemetryEndpoint = ptr.String(jtv)
16577			}
16578
16579		default:
16580			_, _ = key, value
16581
16582		}
16583	}
16584	*v = sv
16585	return nil
16586}
16587
16588func awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(v **ExecuteCommandOutput, value interface{}) error {
16589	if v == nil {
16590		return fmt.Errorf("unexpected nil of type %T", v)
16591	}
16592	if value == nil {
16593		return nil
16594	}
16595
16596	shape, ok := value.(map[string]interface{})
16597	if !ok {
16598		return fmt.Errorf("unexpected JSON type %v", value)
16599	}
16600
16601	var sv *ExecuteCommandOutput
16602	if *v == nil {
16603		sv = &ExecuteCommandOutput{}
16604	} else {
16605		sv = *v
16606	}
16607
16608	for key, value := range shape {
16609		switch key {
16610		case "clusterArn":
16611			if value != nil {
16612				jtv, ok := value.(string)
16613				if !ok {
16614					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16615				}
16616				sv.ClusterArn = ptr.String(jtv)
16617			}
16618
16619		case "containerArn":
16620			if value != nil {
16621				jtv, ok := value.(string)
16622				if !ok {
16623					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16624				}
16625				sv.ContainerArn = ptr.String(jtv)
16626			}
16627
16628		case "containerName":
16629			if value != nil {
16630				jtv, ok := value.(string)
16631				if !ok {
16632					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16633				}
16634				sv.ContainerName = ptr.String(jtv)
16635			}
16636
16637		case "interactive":
16638			if value != nil {
16639				jtv, ok := value.(bool)
16640				if !ok {
16641					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
16642				}
16643				sv.Interactive = jtv
16644			}
16645
16646		case "session":
16647			if err := awsAwsjson11_deserializeDocumentSession(&sv.Session, value); err != nil {
16648				return err
16649			}
16650
16651		case "taskArn":
16652			if value != nil {
16653				jtv, ok := value.(string)
16654				if !ok {
16655					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16656				}
16657				sv.TaskArn = ptr.String(jtv)
16658			}
16659
16660		default:
16661			_, _ = key, value
16662
16663		}
16664	}
16665	*v = sv
16666	return nil
16667}
16668
16669func awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(v **ListAccountSettingsOutput, value interface{}) error {
16670	if v == nil {
16671		return fmt.Errorf("unexpected nil of type %T", v)
16672	}
16673	if value == nil {
16674		return nil
16675	}
16676
16677	shape, ok := value.(map[string]interface{})
16678	if !ok {
16679		return fmt.Errorf("unexpected JSON type %v", value)
16680	}
16681
16682	var sv *ListAccountSettingsOutput
16683	if *v == nil {
16684		sv = &ListAccountSettingsOutput{}
16685	} else {
16686		sv = *v
16687	}
16688
16689	for key, value := range shape {
16690		switch key {
16691		case "nextToken":
16692			if value != nil {
16693				jtv, ok := value.(string)
16694				if !ok {
16695					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16696				}
16697				sv.NextToken = ptr.String(jtv)
16698			}
16699
16700		case "settings":
16701			if err := awsAwsjson11_deserializeDocumentSettings(&sv.Settings, value); err != nil {
16702				return err
16703			}
16704
16705		default:
16706			_, _ = key, value
16707
16708		}
16709	}
16710	*v = sv
16711	return nil
16712}
16713
16714func awsAwsjson11_deserializeOpDocumentListAttributesOutput(v **ListAttributesOutput, value interface{}) error {
16715	if v == nil {
16716		return fmt.Errorf("unexpected nil of type %T", v)
16717	}
16718	if value == nil {
16719		return nil
16720	}
16721
16722	shape, ok := value.(map[string]interface{})
16723	if !ok {
16724		return fmt.Errorf("unexpected JSON type %v", value)
16725	}
16726
16727	var sv *ListAttributesOutput
16728	if *v == nil {
16729		sv = &ListAttributesOutput{}
16730	} else {
16731		sv = *v
16732	}
16733
16734	for key, value := range shape {
16735		switch key {
16736		case "attributes":
16737			if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
16738				return err
16739			}
16740
16741		case "nextToken":
16742			if value != nil {
16743				jtv, ok := value.(string)
16744				if !ok {
16745					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16746				}
16747				sv.NextToken = ptr.String(jtv)
16748			}
16749
16750		default:
16751			_, _ = key, value
16752
16753		}
16754	}
16755	*v = sv
16756	return nil
16757}
16758
16759func awsAwsjson11_deserializeOpDocumentListClustersOutput(v **ListClustersOutput, value interface{}) error {
16760	if v == nil {
16761		return fmt.Errorf("unexpected nil of type %T", v)
16762	}
16763	if value == nil {
16764		return nil
16765	}
16766
16767	shape, ok := value.(map[string]interface{})
16768	if !ok {
16769		return fmt.Errorf("unexpected JSON type %v", value)
16770	}
16771
16772	var sv *ListClustersOutput
16773	if *v == nil {
16774		sv = &ListClustersOutput{}
16775	} else {
16776		sv = *v
16777	}
16778
16779	for key, value := range shape {
16780		switch key {
16781		case "clusterArns":
16782			if err := awsAwsjson11_deserializeDocumentStringList(&sv.ClusterArns, value); err != nil {
16783				return err
16784			}
16785
16786		case "nextToken":
16787			if value != nil {
16788				jtv, ok := value.(string)
16789				if !ok {
16790					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16791				}
16792				sv.NextToken = ptr.String(jtv)
16793			}
16794
16795		default:
16796			_, _ = key, value
16797
16798		}
16799	}
16800	*v = sv
16801	return nil
16802}
16803
16804func awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(v **ListContainerInstancesOutput, value interface{}) error {
16805	if v == nil {
16806		return fmt.Errorf("unexpected nil of type %T", v)
16807	}
16808	if value == nil {
16809		return nil
16810	}
16811
16812	shape, ok := value.(map[string]interface{})
16813	if !ok {
16814		return fmt.Errorf("unexpected JSON type %v", value)
16815	}
16816
16817	var sv *ListContainerInstancesOutput
16818	if *v == nil {
16819		sv = &ListContainerInstancesOutput{}
16820	} else {
16821		sv = *v
16822	}
16823
16824	for key, value := range shape {
16825		switch key {
16826		case "containerInstanceArns":
16827			if err := awsAwsjson11_deserializeDocumentStringList(&sv.ContainerInstanceArns, value); err != nil {
16828				return err
16829			}
16830
16831		case "nextToken":
16832			if value != nil {
16833				jtv, ok := value.(string)
16834				if !ok {
16835					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16836				}
16837				sv.NextToken = ptr.String(jtv)
16838			}
16839
16840		default:
16841			_, _ = key, value
16842
16843		}
16844	}
16845	*v = sv
16846	return nil
16847}
16848
16849func awsAwsjson11_deserializeOpDocumentListServicesOutput(v **ListServicesOutput, value interface{}) error {
16850	if v == nil {
16851		return fmt.Errorf("unexpected nil of type %T", v)
16852	}
16853	if value == nil {
16854		return nil
16855	}
16856
16857	shape, ok := value.(map[string]interface{})
16858	if !ok {
16859		return fmt.Errorf("unexpected JSON type %v", value)
16860	}
16861
16862	var sv *ListServicesOutput
16863	if *v == nil {
16864		sv = &ListServicesOutput{}
16865	} else {
16866		sv = *v
16867	}
16868
16869	for key, value := range shape {
16870		switch key {
16871		case "nextToken":
16872			if value != nil {
16873				jtv, ok := value.(string)
16874				if !ok {
16875					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16876				}
16877				sv.NextToken = ptr.String(jtv)
16878			}
16879
16880		case "serviceArns":
16881			if err := awsAwsjson11_deserializeDocumentStringList(&sv.ServiceArns, value); err != nil {
16882				return err
16883			}
16884
16885		default:
16886			_, _ = key, value
16887
16888		}
16889	}
16890	*v = sv
16891	return nil
16892}
16893
16894func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
16895	if v == nil {
16896		return fmt.Errorf("unexpected nil of type %T", v)
16897	}
16898	if value == nil {
16899		return nil
16900	}
16901
16902	shape, ok := value.(map[string]interface{})
16903	if !ok {
16904		return fmt.Errorf("unexpected JSON type %v", value)
16905	}
16906
16907	var sv *ListTagsForResourceOutput
16908	if *v == nil {
16909		sv = &ListTagsForResourceOutput{}
16910	} else {
16911		sv = *v
16912	}
16913
16914	for key, value := range shape {
16915		switch key {
16916		case "tags":
16917			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16918				return err
16919			}
16920
16921		default:
16922			_, _ = key, value
16923
16924		}
16925	}
16926	*v = sv
16927	return nil
16928}
16929
16930func awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(v **ListTaskDefinitionFamiliesOutput, value interface{}) error {
16931	if v == nil {
16932		return fmt.Errorf("unexpected nil of type %T", v)
16933	}
16934	if value == nil {
16935		return nil
16936	}
16937
16938	shape, ok := value.(map[string]interface{})
16939	if !ok {
16940		return fmt.Errorf("unexpected JSON type %v", value)
16941	}
16942
16943	var sv *ListTaskDefinitionFamiliesOutput
16944	if *v == nil {
16945		sv = &ListTaskDefinitionFamiliesOutput{}
16946	} else {
16947		sv = *v
16948	}
16949
16950	for key, value := range shape {
16951		switch key {
16952		case "families":
16953			if err := awsAwsjson11_deserializeDocumentStringList(&sv.Families, value); err != nil {
16954				return err
16955			}
16956
16957		case "nextToken":
16958			if value != nil {
16959				jtv, ok := value.(string)
16960				if !ok {
16961					return fmt.Errorf("expected String to be of type string, got %T instead", value)
16962				}
16963				sv.NextToken = ptr.String(jtv)
16964			}
16965
16966		default:
16967			_, _ = key, value
16968
16969		}
16970	}
16971	*v = sv
16972	return nil
16973}
16974
16975func awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(v **ListTaskDefinitionsOutput, value interface{}) error {
16976	if v == nil {
16977		return fmt.Errorf("unexpected nil of type %T", v)
16978	}
16979	if value == nil {
16980		return nil
16981	}
16982
16983	shape, ok := value.(map[string]interface{})
16984	if !ok {
16985		return fmt.Errorf("unexpected JSON type %v", value)
16986	}
16987
16988	var sv *ListTaskDefinitionsOutput
16989	if *v == nil {
16990		sv = &ListTaskDefinitionsOutput{}
16991	} else {
16992		sv = *v
16993	}
16994
16995	for key, value := range shape {
16996		switch key {
16997		case "nextToken":
16998			if value != nil {
16999				jtv, ok := value.(string)
17000				if !ok {
17001					return fmt.Errorf("expected String to be of type string, got %T instead", value)
17002				}
17003				sv.NextToken = ptr.String(jtv)
17004			}
17005
17006		case "taskDefinitionArns":
17007			if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskDefinitionArns, value); err != nil {
17008				return err
17009			}
17010
17011		default:
17012			_, _ = key, value
17013
17014		}
17015	}
17016	*v = sv
17017	return nil
17018}
17019
17020func awsAwsjson11_deserializeOpDocumentListTasksOutput(v **ListTasksOutput, value interface{}) error {
17021	if v == nil {
17022		return fmt.Errorf("unexpected nil of type %T", v)
17023	}
17024	if value == nil {
17025		return nil
17026	}
17027
17028	shape, ok := value.(map[string]interface{})
17029	if !ok {
17030		return fmt.Errorf("unexpected JSON type %v", value)
17031	}
17032
17033	var sv *ListTasksOutput
17034	if *v == nil {
17035		sv = &ListTasksOutput{}
17036	} else {
17037		sv = *v
17038	}
17039
17040	for key, value := range shape {
17041		switch key {
17042		case "nextToken":
17043			if value != nil {
17044				jtv, ok := value.(string)
17045				if !ok {
17046					return fmt.Errorf("expected String to be of type string, got %T instead", value)
17047				}
17048				sv.NextToken = ptr.String(jtv)
17049			}
17050
17051		case "taskArns":
17052			if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskArns, value); err != nil {
17053				return err
17054			}
17055
17056		default:
17057			_, _ = key, value
17058
17059		}
17060	}
17061	*v = sv
17062	return nil
17063}
17064
17065func awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(v **PutAccountSettingDefaultOutput, value interface{}) error {
17066	if v == nil {
17067		return fmt.Errorf("unexpected nil of type %T", v)
17068	}
17069	if value == nil {
17070		return nil
17071	}
17072
17073	shape, ok := value.(map[string]interface{})
17074	if !ok {
17075		return fmt.Errorf("unexpected JSON type %v", value)
17076	}
17077
17078	var sv *PutAccountSettingDefaultOutput
17079	if *v == nil {
17080		sv = &PutAccountSettingDefaultOutput{}
17081	} else {
17082		sv = *v
17083	}
17084
17085	for key, value := range shape {
17086		switch key {
17087		case "setting":
17088			if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
17089				return err
17090			}
17091
17092		default:
17093			_, _ = key, value
17094
17095		}
17096	}
17097	*v = sv
17098	return nil
17099}
17100
17101func awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(v **PutAccountSettingOutput, value interface{}) error {
17102	if v == nil {
17103		return fmt.Errorf("unexpected nil of type %T", v)
17104	}
17105	if value == nil {
17106		return nil
17107	}
17108
17109	shape, ok := value.(map[string]interface{})
17110	if !ok {
17111		return fmt.Errorf("unexpected JSON type %v", value)
17112	}
17113
17114	var sv *PutAccountSettingOutput
17115	if *v == nil {
17116		sv = &PutAccountSettingOutput{}
17117	} else {
17118		sv = *v
17119	}
17120
17121	for key, value := range shape {
17122		switch key {
17123		case "setting":
17124			if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil {
17125				return err
17126			}
17127
17128		default:
17129			_, _ = key, value
17130
17131		}
17132	}
17133	*v = sv
17134	return nil
17135}
17136
17137func awsAwsjson11_deserializeOpDocumentPutAttributesOutput(v **PutAttributesOutput, value interface{}) error {
17138	if v == nil {
17139		return fmt.Errorf("unexpected nil of type %T", v)
17140	}
17141	if value == nil {
17142		return nil
17143	}
17144
17145	shape, ok := value.(map[string]interface{})
17146	if !ok {
17147		return fmt.Errorf("unexpected JSON type %v", value)
17148	}
17149
17150	var sv *PutAttributesOutput
17151	if *v == nil {
17152		sv = &PutAttributesOutput{}
17153	} else {
17154		sv = *v
17155	}
17156
17157	for key, value := range shape {
17158		switch key {
17159		case "attributes":
17160			if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
17161				return err
17162			}
17163
17164		default:
17165			_, _ = key, value
17166
17167		}
17168	}
17169	*v = sv
17170	return nil
17171}
17172
17173func awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(v **PutClusterCapacityProvidersOutput, value interface{}) error {
17174	if v == nil {
17175		return fmt.Errorf("unexpected nil of type %T", v)
17176	}
17177	if value == nil {
17178		return nil
17179	}
17180
17181	shape, ok := value.(map[string]interface{})
17182	if !ok {
17183		return fmt.Errorf("unexpected JSON type %v", value)
17184	}
17185
17186	var sv *PutClusterCapacityProvidersOutput
17187	if *v == nil {
17188		sv = &PutClusterCapacityProvidersOutput{}
17189	} else {
17190		sv = *v
17191	}
17192
17193	for key, value := range shape {
17194		switch key {
17195		case "cluster":
17196			if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
17197				return err
17198			}
17199
17200		default:
17201			_, _ = key, value
17202
17203		}
17204	}
17205	*v = sv
17206	return nil
17207}
17208
17209func awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(v **RegisterContainerInstanceOutput, value interface{}) error {
17210	if v == nil {
17211		return fmt.Errorf("unexpected nil of type %T", v)
17212	}
17213	if value == nil {
17214		return nil
17215	}
17216
17217	shape, ok := value.(map[string]interface{})
17218	if !ok {
17219		return fmt.Errorf("unexpected JSON type %v", value)
17220	}
17221
17222	var sv *RegisterContainerInstanceOutput
17223	if *v == nil {
17224		sv = &RegisterContainerInstanceOutput{}
17225	} else {
17226		sv = *v
17227	}
17228
17229	for key, value := range shape {
17230		switch key {
17231		case "containerInstance":
17232			if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
17233				return err
17234			}
17235
17236		default:
17237			_, _ = key, value
17238
17239		}
17240	}
17241	*v = sv
17242	return nil
17243}
17244
17245func awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(v **RegisterTaskDefinitionOutput, value interface{}) error {
17246	if v == nil {
17247		return fmt.Errorf("unexpected nil of type %T", v)
17248	}
17249	if value == nil {
17250		return nil
17251	}
17252
17253	shape, ok := value.(map[string]interface{})
17254	if !ok {
17255		return fmt.Errorf("unexpected JSON type %v", value)
17256	}
17257
17258	var sv *RegisterTaskDefinitionOutput
17259	if *v == nil {
17260		sv = &RegisterTaskDefinitionOutput{}
17261	} else {
17262		sv = *v
17263	}
17264
17265	for key, value := range shape {
17266		switch key {
17267		case "tags":
17268			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
17269				return err
17270			}
17271
17272		case "taskDefinition":
17273			if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil {
17274				return err
17275			}
17276
17277		default:
17278			_, _ = key, value
17279
17280		}
17281	}
17282	*v = sv
17283	return nil
17284}
17285
17286func awsAwsjson11_deserializeOpDocumentRunTaskOutput(v **RunTaskOutput, value interface{}) error {
17287	if v == nil {
17288		return fmt.Errorf("unexpected nil of type %T", v)
17289	}
17290	if value == nil {
17291		return nil
17292	}
17293
17294	shape, ok := value.(map[string]interface{})
17295	if !ok {
17296		return fmt.Errorf("unexpected JSON type %v", value)
17297	}
17298
17299	var sv *RunTaskOutput
17300	if *v == nil {
17301		sv = &RunTaskOutput{}
17302	} else {
17303		sv = *v
17304	}
17305
17306	for key, value := range shape {
17307		switch key {
17308		case "failures":
17309			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
17310				return err
17311			}
17312
17313		case "tasks":
17314			if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
17315				return err
17316			}
17317
17318		default:
17319			_, _ = key, value
17320
17321		}
17322	}
17323	*v = sv
17324	return nil
17325}
17326
17327func awsAwsjson11_deserializeOpDocumentStartTaskOutput(v **StartTaskOutput, value interface{}) error {
17328	if v == nil {
17329		return fmt.Errorf("unexpected nil of type %T", v)
17330	}
17331	if value == nil {
17332		return nil
17333	}
17334
17335	shape, ok := value.(map[string]interface{})
17336	if !ok {
17337		return fmt.Errorf("unexpected JSON type %v", value)
17338	}
17339
17340	var sv *StartTaskOutput
17341	if *v == nil {
17342		sv = &StartTaskOutput{}
17343	} else {
17344		sv = *v
17345	}
17346
17347	for key, value := range shape {
17348		switch key {
17349		case "failures":
17350			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
17351				return err
17352			}
17353
17354		case "tasks":
17355			if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil {
17356				return err
17357			}
17358
17359		default:
17360			_, _ = key, value
17361
17362		}
17363	}
17364	*v = sv
17365	return nil
17366}
17367
17368func awsAwsjson11_deserializeOpDocumentStopTaskOutput(v **StopTaskOutput, value interface{}) error {
17369	if v == nil {
17370		return fmt.Errorf("unexpected nil of type %T", v)
17371	}
17372	if value == nil {
17373		return nil
17374	}
17375
17376	shape, ok := value.(map[string]interface{})
17377	if !ok {
17378		return fmt.Errorf("unexpected JSON type %v", value)
17379	}
17380
17381	var sv *StopTaskOutput
17382	if *v == nil {
17383		sv = &StopTaskOutput{}
17384	} else {
17385		sv = *v
17386	}
17387
17388	for key, value := range shape {
17389		switch key {
17390		case "task":
17391			if err := awsAwsjson11_deserializeDocumentTask(&sv.Task, value); err != nil {
17392				return err
17393			}
17394
17395		default:
17396			_, _ = key, value
17397
17398		}
17399	}
17400	*v = sv
17401	return nil
17402}
17403
17404func awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(v **SubmitAttachmentStateChangesOutput, value interface{}) error {
17405	if v == nil {
17406		return fmt.Errorf("unexpected nil of type %T", v)
17407	}
17408	if value == nil {
17409		return nil
17410	}
17411
17412	shape, ok := value.(map[string]interface{})
17413	if !ok {
17414		return fmt.Errorf("unexpected JSON type %v", value)
17415	}
17416
17417	var sv *SubmitAttachmentStateChangesOutput
17418	if *v == nil {
17419		sv = &SubmitAttachmentStateChangesOutput{}
17420	} else {
17421		sv = *v
17422	}
17423
17424	for key, value := range shape {
17425		switch key {
17426		case "acknowledgment":
17427			if value != nil {
17428				jtv, ok := value.(string)
17429				if !ok {
17430					return fmt.Errorf("expected String to be of type string, got %T instead", value)
17431				}
17432				sv.Acknowledgment = ptr.String(jtv)
17433			}
17434
17435		default:
17436			_, _ = key, value
17437
17438		}
17439	}
17440	*v = sv
17441	return nil
17442}
17443
17444func awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(v **SubmitContainerStateChangeOutput, value interface{}) error {
17445	if v == nil {
17446		return fmt.Errorf("unexpected nil of type %T", v)
17447	}
17448	if value == nil {
17449		return nil
17450	}
17451
17452	shape, ok := value.(map[string]interface{})
17453	if !ok {
17454		return fmt.Errorf("unexpected JSON type %v", value)
17455	}
17456
17457	var sv *SubmitContainerStateChangeOutput
17458	if *v == nil {
17459		sv = &SubmitContainerStateChangeOutput{}
17460	} else {
17461		sv = *v
17462	}
17463
17464	for key, value := range shape {
17465		switch key {
17466		case "acknowledgment":
17467			if value != nil {
17468				jtv, ok := value.(string)
17469				if !ok {
17470					return fmt.Errorf("expected String to be of type string, got %T instead", value)
17471				}
17472				sv.Acknowledgment = ptr.String(jtv)
17473			}
17474
17475		default:
17476			_, _ = key, value
17477
17478		}
17479	}
17480	*v = sv
17481	return nil
17482}
17483
17484func awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(v **SubmitTaskStateChangeOutput, value interface{}) error {
17485	if v == nil {
17486		return fmt.Errorf("unexpected nil of type %T", v)
17487	}
17488	if value == nil {
17489		return nil
17490	}
17491
17492	shape, ok := value.(map[string]interface{})
17493	if !ok {
17494		return fmt.Errorf("unexpected JSON type %v", value)
17495	}
17496
17497	var sv *SubmitTaskStateChangeOutput
17498	if *v == nil {
17499		sv = &SubmitTaskStateChangeOutput{}
17500	} else {
17501		sv = *v
17502	}
17503
17504	for key, value := range shape {
17505		switch key {
17506		case "acknowledgment":
17507			if value != nil {
17508				jtv, ok := value.(string)
17509				if !ok {
17510					return fmt.Errorf("expected String to be of type string, got %T instead", value)
17511				}
17512				sv.Acknowledgment = ptr.String(jtv)
17513			}
17514
17515		default:
17516			_, _ = key, value
17517
17518		}
17519	}
17520	*v = sv
17521	return nil
17522}
17523
17524func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
17525	if v == nil {
17526		return fmt.Errorf("unexpected nil of type %T", v)
17527	}
17528	if value == nil {
17529		return nil
17530	}
17531
17532	shape, ok := value.(map[string]interface{})
17533	if !ok {
17534		return fmt.Errorf("unexpected JSON type %v", value)
17535	}
17536
17537	var sv *TagResourceOutput
17538	if *v == nil {
17539		sv = &TagResourceOutput{}
17540	} else {
17541		sv = *v
17542	}
17543
17544	for key, value := range shape {
17545		switch key {
17546		default:
17547			_, _ = key, value
17548
17549		}
17550	}
17551	*v = sv
17552	return nil
17553}
17554
17555func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
17556	if v == nil {
17557		return fmt.Errorf("unexpected nil of type %T", v)
17558	}
17559	if value == nil {
17560		return nil
17561	}
17562
17563	shape, ok := value.(map[string]interface{})
17564	if !ok {
17565		return fmt.Errorf("unexpected JSON type %v", value)
17566	}
17567
17568	var sv *UntagResourceOutput
17569	if *v == nil {
17570		sv = &UntagResourceOutput{}
17571	} else {
17572		sv = *v
17573	}
17574
17575	for key, value := range shape {
17576		switch key {
17577		default:
17578			_, _ = key, value
17579
17580		}
17581	}
17582	*v = sv
17583	return nil
17584}
17585
17586func awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(v **UpdateCapacityProviderOutput, value interface{}) error {
17587	if v == nil {
17588		return fmt.Errorf("unexpected nil of type %T", v)
17589	}
17590	if value == nil {
17591		return nil
17592	}
17593
17594	shape, ok := value.(map[string]interface{})
17595	if !ok {
17596		return fmt.Errorf("unexpected JSON type %v", value)
17597	}
17598
17599	var sv *UpdateCapacityProviderOutput
17600	if *v == nil {
17601		sv = &UpdateCapacityProviderOutput{}
17602	} else {
17603		sv = *v
17604	}
17605
17606	for key, value := range shape {
17607		switch key {
17608		case "capacityProvider":
17609			if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil {
17610				return err
17611			}
17612
17613		default:
17614			_, _ = key, value
17615
17616		}
17617	}
17618	*v = sv
17619	return nil
17620}
17621
17622func awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(v **UpdateClusterOutput, value interface{}) error {
17623	if v == nil {
17624		return fmt.Errorf("unexpected nil of type %T", v)
17625	}
17626	if value == nil {
17627		return nil
17628	}
17629
17630	shape, ok := value.(map[string]interface{})
17631	if !ok {
17632		return fmt.Errorf("unexpected JSON type %v", value)
17633	}
17634
17635	var sv *UpdateClusterOutput
17636	if *v == nil {
17637		sv = &UpdateClusterOutput{}
17638	} else {
17639		sv = *v
17640	}
17641
17642	for key, value := range shape {
17643		switch key {
17644		case "cluster":
17645			if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
17646				return err
17647			}
17648
17649		default:
17650			_, _ = key, value
17651
17652		}
17653	}
17654	*v = sv
17655	return nil
17656}
17657
17658func awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(v **UpdateClusterSettingsOutput, value interface{}) error {
17659	if v == nil {
17660		return fmt.Errorf("unexpected nil of type %T", v)
17661	}
17662	if value == nil {
17663		return nil
17664	}
17665
17666	shape, ok := value.(map[string]interface{})
17667	if !ok {
17668		return fmt.Errorf("unexpected JSON type %v", value)
17669	}
17670
17671	var sv *UpdateClusterSettingsOutput
17672	if *v == nil {
17673		sv = &UpdateClusterSettingsOutput{}
17674	} else {
17675		sv = *v
17676	}
17677
17678	for key, value := range shape {
17679		switch key {
17680		case "cluster":
17681			if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
17682				return err
17683			}
17684
17685		default:
17686			_, _ = key, value
17687
17688		}
17689	}
17690	*v = sv
17691	return nil
17692}
17693
17694func awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(v **UpdateContainerAgentOutput, value interface{}) error {
17695	if v == nil {
17696		return fmt.Errorf("unexpected nil of type %T", v)
17697	}
17698	if value == nil {
17699		return nil
17700	}
17701
17702	shape, ok := value.(map[string]interface{})
17703	if !ok {
17704		return fmt.Errorf("unexpected JSON type %v", value)
17705	}
17706
17707	var sv *UpdateContainerAgentOutput
17708	if *v == nil {
17709		sv = &UpdateContainerAgentOutput{}
17710	} else {
17711		sv = *v
17712	}
17713
17714	for key, value := range shape {
17715		switch key {
17716		case "containerInstance":
17717			if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil {
17718				return err
17719			}
17720
17721		default:
17722			_, _ = key, value
17723
17724		}
17725	}
17726	*v = sv
17727	return nil
17728}
17729
17730func awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(v **UpdateContainerInstancesStateOutput, value interface{}) error {
17731	if v == nil {
17732		return fmt.Errorf("unexpected nil of type %T", v)
17733	}
17734	if value == nil {
17735		return nil
17736	}
17737
17738	shape, ok := value.(map[string]interface{})
17739	if !ok {
17740		return fmt.Errorf("unexpected JSON type %v", value)
17741	}
17742
17743	var sv *UpdateContainerInstancesStateOutput
17744	if *v == nil {
17745		sv = &UpdateContainerInstancesStateOutput{}
17746	} else {
17747		sv = *v
17748	}
17749
17750	for key, value := range shape {
17751		switch key {
17752		case "containerInstances":
17753			if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil {
17754				return err
17755			}
17756
17757		case "failures":
17758			if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil {
17759				return err
17760			}
17761
17762		default:
17763			_, _ = key, value
17764
17765		}
17766	}
17767	*v = sv
17768	return nil
17769}
17770
17771func awsAwsjson11_deserializeOpDocumentUpdateServiceOutput(v **UpdateServiceOutput, value interface{}) error {
17772	if v == nil {
17773		return fmt.Errorf("unexpected nil of type %T", v)
17774	}
17775	if value == nil {
17776		return nil
17777	}
17778
17779	shape, ok := value.(map[string]interface{})
17780	if !ok {
17781		return fmt.Errorf("unexpected JSON type %v", value)
17782	}
17783
17784	var sv *UpdateServiceOutput
17785	if *v == nil {
17786		sv = &UpdateServiceOutput{}
17787	} else {
17788		sv = *v
17789	}
17790
17791	for key, value := range shape {
17792		switch key {
17793		case "service":
17794			if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil {
17795				return err
17796			}
17797
17798		default:
17799			_, _ = key, value
17800
17801		}
17802	}
17803	*v = sv
17804	return nil
17805}
17806
17807func awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(v **UpdateServicePrimaryTaskSetOutput, value interface{}) error {
17808	if v == nil {
17809		return fmt.Errorf("unexpected nil of type %T", v)
17810	}
17811	if value == nil {
17812		return nil
17813	}
17814
17815	shape, ok := value.(map[string]interface{})
17816	if !ok {
17817		return fmt.Errorf("unexpected JSON type %v", value)
17818	}
17819
17820	var sv *UpdateServicePrimaryTaskSetOutput
17821	if *v == nil {
17822		sv = &UpdateServicePrimaryTaskSetOutput{}
17823	} else {
17824		sv = *v
17825	}
17826
17827	for key, value := range shape {
17828		switch key {
17829		case "taskSet":
17830			if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
17831				return err
17832			}
17833
17834		default:
17835			_, _ = key, value
17836
17837		}
17838	}
17839	*v = sv
17840	return nil
17841}
17842
17843func awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(v **UpdateTaskSetOutput, value interface{}) error {
17844	if v == nil {
17845		return fmt.Errorf("unexpected nil of type %T", v)
17846	}
17847	if value == nil {
17848		return nil
17849	}
17850
17851	shape, ok := value.(map[string]interface{})
17852	if !ok {
17853		return fmt.Errorf("unexpected JSON type %v", value)
17854	}
17855
17856	var sv *UpdateTaskSetOutput
17857	if *v == nil {
17858		sv = &UpdateTaskSetOutput{}
17859	} else {
17860		sv = *v
17861	}
17862
17863	for key, value := range shape {
17864		switch key {
17865		case "taskSet":
17866			if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil {
17867				return err
17868			}
17869
17870		default:
17871			_, _ = key, value
17872
17873		}
17874	}
17875	*v = sv
17876	return nil
17877}
17878