1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package globalaccelerator
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/globalaccelerator/types"
12	smithy "github.com/aws/smithy-go"
13	smithyio "github.com/aws/smithy-go/io"
14	"github.com/aws/smithy-go/middleware"
15	"github.com/aws/smithy-go/ptr"
16	smithytime "github.com/aws/smithy-go/time"
17	smithyhttp "github.com/aws/smithy-go/transport/http"
18	"io"
19	"io/ioutil"
20	"strings"
21)
22
23type awsAwsjson11_deserializeOpAddCustomRoutingEndpoints struct {
24}
25
26func (*awsAwsjson11_deserializeOpAddCustomRoutingEndpoints) ID() string {
27	return "OperationDeserializer"
28}
29
30func (m *awsAwsjson11_deserializeOpAddCustomRoutingEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32) {
33	out, metadata, err = next.HandleDeserialize(ctx, in)
34	if err != nil {
35		return out, metadata, err
36	}
37
38	response, ok := out.RawResponse.(*smithyhttp.Response)
39	if !ok {
40		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
41	}
42
43	if response.StatusCode < 200 || response.StatusCode >= 300 {
44		return out, metadata, awsAwsjson11_deserializeOpErrorAddCustomRoutingEndpoints(response, &metadata)
45	}
46	output := &AddCustomRoutingEndpointsOutput{}
47	out.Result = output
48
49	var buff [1024]byte
50	ringBuffer := smithyio.NewRingBuffer(buff[:])
51
52	body := io.TeeReader(response.Body, ringBuffer)
53	decoder := json.NewDecoder(body)
54	decoder.UseNumber()
55	var shape interface{}
56	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
57		var snapshot bytes.Buffer
58		io.Copy(&snapshot, ringBuffer)
59		err = &smithy.DeserializationError{
60			Err:      fmt.Errorf("failed to decode response body, %w", err),
61			Snapshot: snapshot.Bytes(),
62		}
63		return out, metadata, err
64	}
65
66	err = awsAwsjson11_deserializeOpDocumentAddCustomRoutingEndpointsOutput(&output, shape)
67	if err != nil {
68		var snapshot bytes.Buffer
69		io.Copy(&snapshot, ringBuffer)
70		err = &smithy.DeserializationError{
71			Err:      fmt.Errorf("failed to decode response body, %w", err),
72			Snapshot: snapshot.Bytes(),
73		}
74		return out, metadata, err
75	}
76
77	return out, metadata, err
78}
79
80func awsAwsjson11_deserializeOpErrorAddCustomRoutingEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
81	var errorBuffer bytes.Buffer
82	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
83		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
84	}
85	errorBody := bytes.NewReader(errorBuffer.Bytes())
86
87	errorCode := "UnknownError"
88	errorMessage := errorCode
89
90	code := response.Header.Get("X-Amzn-ErrorType")
91	if len(code) != 0 {
92		errorCode = restjson.SanitizeErrorCode(code)
93	}
94
95	var buff [1024]byte
96	ringBuffer := smithyio.NewRingBuffer(buff[:])
97
98	body := io.TeeReader(errorBody, ringBuffer)
99	decoder := json.NewDecoder(body)
100	decoder.UseNumber()
101	code, message, err := restjson.GetErrorInfo(decoder)
102	if err != nil {
103		var snapshot bytes.Buffer
104		io.Copy(&snapshot, ringBuffer)
105		err = &smithy.DeserializationError{
106			Err:      fmt.Errorf("failed to decode response body, %w", err),
107			Snapshot: snapshot.Bytes(),
108		}
109		return err
110	}
111
112	errorBody.Seek(0, io.SeekStart)
113	if len(code) != 0 {
114		errorCode = restjson.SanitizeErrorCode(code)
115	}
116	if len(message) != 0 {
117		errorMessage = message
118	}
119
120	switch {
121	case strings.EqualFold("AccessDeniedException", errorCode):
122		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
123
124	case strings.EqualFold("ConflictException", errorCode):
125		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
126
127	case strings.EqualFold("EndpointAlreadyExistsException", errorCode):
128		return awsAwsjson11_deserializeErrorEndpointAlreadyExistsException(response, errorBody)
129
130	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
131		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
132
133	case strings.EqualFold("InternalServiceErrorException", errorCode):
134		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
135
136	case strings.EqualFold("InvalidArgumentException", errorCode):
137		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
138
139	case strings.EqualFold("LimitExceededException", errorCode):
140		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
141
142	default:
143		genericError := &smithy.GenericAPIError{
144			Code:    errorCode,
145			Message: errorMessage,
146		}
147		return genericError
148
149	}
150}
151
152type awsAwsjson11_deserializeOpAdvertiseByoipCidr struct {
153}
154
155func (*awsAwsjson11_deserializeOpAdvertiseByoipCidr) ID() string {
156	return "OperationDeserializer"
157}
158
159func (m *awsAwsjson11_deserializeOpAdvertiseByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
160	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
161) {
162	out, metadata, err = next.HandleDeserialize(ctx, in)
163	if err != nil {
164		return out, metadata, err
165	}
166
167	response, ok := out.RawResponse.(*smithyhttp.Response)
168	if !ok {
169		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
170	}
171
172	if response.StatusCode < 200 || response.StatusCode >= 300 {
173		return out, metadata, awsAwsjson11_deserializeOpErrorAdvertiseByoipCidr(response, &metadata)
174	}
175	output := &AdvertiseByoipCidrOutput{}
176	out.Result = output
177
178	var buff [1024]byte
179	ringBuffer := smithyio.NewRingBuffer(buff[:])
180
181	body := io.TeeReader(response.Body, ringBuffer)
182	decoder := json.NewDecoder(body)
183	decoder.UseNumber()
184	var shape interface{}
185	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
186		var snapshot bytes.Buffer
187		io.Copy(&snapshot, ringBuffer)
188		err = &smithy.DeserializationError{
189			Err:      fmt.Errorf("failed to decode response body, %w", err),
190			Snapshot: snapshot.Bytes(),
191		}
192		return out, metadata, err
193	}
194
195	err = awsAwsjson11_deserializeOpDocumentAdvertiseByoipCidrOutput(&output, shape)
196	if err != nil {
197		var snapshot bytes.Buffer
198		io.Copy(&snapshot, ringBuffer)
199		err = &smithy.DeserializationError{
200			Err:      fmt.Errorf("failed to decode response body, %w", err),
201			Snapshot: snapshot.Bytes(),
202		}
203		return out, metadata, err
204	}
205
206	return out, metadata, err
207}
208
209func awsAwsjson11_deserializeOpErrorAdvertiseByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
210	var errorBuffer bytes.Buffer
211	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
212		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
213	}
214	errorBody := bytes.NewReader(errorBuffer.Bytes())
215
216	errorCode := "UnknownError"
217	errorMessage := errorCode
218
219	code := response.Header.Get("X-Amzn-ErrorType")
220	if len(code) != 0 {
221		errorCode = restjson.SanitizeErrorCode(code)
222	}
223
224	var buff [1024]byte
225	ringBuffer := smithyio.NewRingBuffer(buff[:])
226
227	body := io.TeeReader(errorBody, ringBuffer)
228	decoder := json.NewDecoder(body)
229	decoder.UseNumber()
230	code, message, err := restjson.GetErrorInfo(decoder)
231	if err != nil {
232		var snapshot bytes.Buffer
233		io.Copy(&snapshot, ringBuffer)
234		err = &smithy.DeserializationError{
235			Err:      fmt.Errorf("failed to decode response body, %w", err),
236			Snapshot: snapshot.Bytes(),
237		}
238		return err
239	}
240
241	errorBody.Seek(0, io.SeekStart)
242	if len(code) != 0 {
243		errorCode = restjson.SanitizeErrorCode(code)
244	}
245	if len(message) != 0 {
246		errorMessage = message
247	}
248
249	switch {
250	case strings.EqualFold("AccessDeniedException", errorCode):
251		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
252
253	case strings.EqualFold("ByoipCidrNotFoundException", errorCode):
254		return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody)
255
256	case strings.EqualFold("IncorrectCidrStateException", errorCode):
257		return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody)
258
259	case strings.EqualFold("InternalServiceErrorException", errorCode):
260		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
261
262	case strings.EqualFold("InvalidArgumentException", errorCode):
263		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
264
265	default:
266		genericError := &smithy.GenericAPIError{
267			Code:    errorCode,
268			Message: errorMessage,
269		}
270		return genericError
271
272	}
273}
274
275type awsAwsjson11_deserializeOpAllowCustomRoutingTraffic struct {
276}
277
278func (*awsAwsjson11_deserializeOpAllowCustomRoutingTraffic) ID() string {
279	return "OperationDeserializer"
280}
281
282func (m *awsAwsjson11_deserializeOpAllowCustomRoutingTraffic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
283	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
284) {
285	out, metadata, err = next.HandleDeserialize(ctx, in)
286	if err != nil {
287		return out, metadata, err
288	}
289
290	response, ok := out.RawResponse.(*smithyhttp.Response)
291	if !ok {
292		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
293	}
294
295	if response.StatusCode < 200 || response.StatusCode >= 300 {
296		return out, metadata, awsAwsjson11_deserializeOpErrorAllowCustomRoutingTraffic(response, &metadata)
297	}
298	output := &AllowCustomRoutingTrafficOutput{}
299	out.Result = output
300
301	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
302		return out, metadata, &smithy.DeserializationError{
303			Err: fmt.Errorf("failed to discard response body, %w", err),
304		}
305	}
306
307	return out, metadata, err
308}
309
310func awsAwsjson11_deserializeOpErrorAllowCustomRoutingTraffic(response *smithyhttp.Response, metadata *middleware.Metadata) error {
311	var errorBuffer bytes.Buffer
312	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
313		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
314	}
315	errorBody := bytes.NewReader(errorBuffer.Bytes())
316
317	errorCode := "UnknownError"
318	errorMessage := errorCode
319
320	code := response.Header.Get("X-Amzn-ErrorType")
321	if len(code) != 0 {
322		errorCode = restjson.SanitizeErrorCode(code)
323	}
324
325	var buff [1024]byte
326	ringBuffer := smithyio.NewRingBuffer(buff[:])
327
328	body := io.TeeReader(errorBody, ringBuffer)
329	decoder := json.NewDecoder(body)
330	decoder.UseNumber()
331	code, message, err := restjson.GetErrorInfo(decoder)
332	if err != nil {
333		var snapshot bytes.Buffer
334		io.Copy(&snapshot, ringBuffer)
335		err = &smithy.DeserializationError{
336			Err:      fmt.Errorf("failed to decode response body, %w", err),
337			Snapshot: snapshot.Bytes(),
338		}
339		return err
340	}
341
342	errorBody.Seek(0, io.SeekStart)
343	if len(code) != 0 {
344		errorCode = restjson.SanitizeErrorCode(code)
345	}
346	if len(message) != 0 {
347		errorMessage = message
348	}
349
350	switch {
351	case strings.EqualFold("InternalServiceErrorException", errorCode):
352		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
353
354	case strings.EqualFold("InvalidArgumentException", errorCode):
355		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
356
357	default:
358		genericError := &smithy.GenericAPIError{
359			Code:    errorCode,
360			Message: errorMessage,
361		}
362		return genericError
363
364	}
365}
366
367type awsAwsjson11_deserializeOpCreateAccelerator struct {
368}
369
370func (*awsAwsjson11_deserializeOpCreateAccelerator) ID() string {
371	return "OperationDeserializer"
372}
373
374func (m *awsAwsjson11_deserializeOpCreateAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
375	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
376) {
377	out, metadata, err = next.HandleDeserialize(ctx, in)
378	if err != nil {
379		return out, metadata, err
380	}
381
382	response, ok := out.RawResponse.(*smithyhttp.Response)
383	if !ok {
384		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
385	}
386
387	if response.StatusCode < 200 || response.StatusCode >= 300 {
388		return out, metadata, awsAwsjson11_deserializeOpErrorCreateAccelerator(response, &metadata)
389	}
390	output := &CreateAcceleratorOutput{}
391	out.Result = output
392
393	var buff [1024]byte
394	ringBuffer := smithyio.NewRingBuffer(buff[:])
395
396	body := io.TeeReader(response.Body, ringBuffer)
397	decoder := json.NewDecoder(body)
398	decoder.UseNumber()
399	var shape interface{}
400	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
401		var snapshot bytes.Buffer
402		io.Copy(&snapshot, ringBuffer)
403		err = &smithy.DeserializationError{
404			Err:      fmt.Errorf("failed to decode response body, %w", err),
405			Snapshot: snapshot.Bytes(),
406		}
407		return out, metadata, err
408	}
409
410	err = awsAwsjson11_deserializeOpDocumentCreateAcceleratorOutput(&output, shape)
411	if err != nil {
412		var snapshot bytes.Buffer
413		io.Copy(&snapshot, ringBuffer)
414		err = &smithy.DeserializationError{
415			Err:      fmt.Errorf("failed to decode response body, %w", err),
416			Snapshot: snapshot.Bytes(),
417		}
418		return out, metadata, err
419	}
420
421	return out, metadata, err
422}
423
424func awsAwsjson11_deserializeOpErrorCreateAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
425	var errorBuffer bytes.Buffer
426	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
427		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
428	}
429	errorBody := bytes.NewReader(errorBuffer.Bytes())
430
431	errorCode := "UnknownError"
432	errorMessage := errorCode
433
434	code := response.Header.Get("X-Amzn-ErrorType")
435	if len(code) != 0 {
436		errorCode = restjson.SanitizeErrorCode(code)
437	}
438
439	var buff [1024]byte
440	ringBuffer := smithyio.NewRingBuffer(buff[:])
441
442	body := io.TeeReader(errorBody, ringBuffer)
443	decoder := json.NewDecoder(body)
444	decoder.UseNumber()
445	code, message, err := restjson.GetErrorInfo(decoder)
446	if err != nil {
447		var snapshot bytes.Buffer
448		io.Copy(&snapshot, ringBuffer)
449		err = &smithy.DeserializationError{
450			Err:      fmt.Errorf("failed to decode response body, %w", err),
451			Snapshot: snapshot.Bytes(),
452		}
453		return err
454	}
455
456	errorBody.Seek(0, io.SeekStart)
457	if len(code) != 0 {
458		errorCode = restjson.SanitizeErrorCode(code)
459	}
460	if len(message) != 0 {
461		errorMessage = message
462	}
463
464	switch {
465	case strings.EqualFold("InternalServiceErrorException", errorCode):
466		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
467
468	case strings.EqualFold("InvalidArgumentException", errorCode):
469		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
470
471	case strings.EqualFold("LimitExceededException", errorCode):
472		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
473
474	default:
475		genericError := &smithy.GenericAPIError{
476			Code:    errorCode,
477			Message: errorMessage,
478		}
479		return genericError
480
481	}
482}
483
484type awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator struct {
485}
486
487func (*awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator) ID() string {
488	return "OperationDeserializer"
489}
490
491func (m *awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
492	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
493) {
494	out, metadata, err = next.HandleDeserialize(ctx, in)
495	if err != nil {
496		return out, metadata, err
497	}
498
499	response, ok := out.RawResponse.(*smithyhttp.Response)
500	if !ok {
501		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
502	}
503
504	if response.StatusCode < 200 || response.StatusCode >= 300 {
505		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingAccelerator(response, &metadata)
506	}
507	output := &CreateCustomRoutingAcceleratorOutput{}
508	out.Result = output
509
510	var buff [1024]byte
511	ringBuffer := smithyio.NewRingBuffer(buff[:])
512
513	body := io.TeeReader(response.Body, ringBuffer)
514	decoder := json.NewDecoder(body)
515	decoder.UseNumber()
516	var shape interface{}
517	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
518		var snapshot bytes.Buffer
519		io.Copy(&snapshot, ringBuffer)
520		err = &smithy.DeserializationError{
521			Err:      fmt.Errorf("failed to decode response body, %w", err),
522			Snapshot: snapshot.Bytes(),
523		}
524		return out, metadata, err
525	}
526
527	err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingAcceleratorOutput(&output, shape)
528	if err != nil {
529		var snapshot bytes.Buffer
530		io.Copy(&snapshot, ringBuffer)
531		err = &smithy.DeserializationError{
532			Err:      fmt.Errorf("failed to decode response body, %w", err),
533			Snapshot: snapshot.Bytes(),
534		}
535		return out, metadata, err
536	}
537
538	return out, metadata, err
539}
540
541func awsAwsjson11_deserializeOpErrorCreateCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
542	var errorBuffer bytes.Buffer
543	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
544		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
545	}
546	errorBody := bytes.NewReader(errorBuffer.Bytes())
547
548	errorCode := "UnknownError"
549	errorMessage := errorCode
550
551	code := response.Header.Get("X-Amzn-ErrorType")
552	if len(code) != 0 {
553		errorCode = restjson.SanitizeErrorCode(code)
554	}
555
556	var buff [1024]byte
557	ringBuffer := smithyio.NewRingBuffer(buff[:])
558
559	body := io.TeeReader(errorBody, ringBuffer)
560	decoder := json.NewDecoder(body)
561	decoder.UseNumber()
562	code, message, err := restjson.GetErrorInfo(decoder)
563	if err != nil {
564		var snapshot bytes.Buffer
565		io.Copy(&snapshot, ringBuffer)
566		err = &smithy.DeserializationError{
567			Err:      fmt.Errorf("failed to decode response body, %w", err),
568			Snapshot: snapshot.Bytes(),
569		}
570		return err
571	}
572
573	errorBody.Seek(0, io.SeekStart)
574	if len(code) != 0 {
575		errorCode = restjson.SanitizeErrorCode(code)
576	}
577	if len(message) != 0 {
578		errorMessage = message
579	}
580
581	switch {
582	case strings.EqualFold("AccessDeniedException", errorCode):
583		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
584
585	case strings.EqualFold("InternalServiceErrorException", errorCode):
586		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
587
588	case strings.EqualFold("InvalidArgumentException", errorCode):
589		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
590
591	case strings.EqualFold("LimitExceededException", errorCode):
592		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
593
594	default:
595		genericError := &smithy.GenericAPIError{
596			Code:    errorCode,
597			Message: errorMessage,
598		}
599		return genericError
600
601	}
602}
603
604type awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup struct {
605}
606
607func (*awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup) ID() string {
608	return "OperationDeserializer"
609}
610
611func (m *awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
612	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
613) {
614	out, metadata, err = next.HandleDeserialize(ctx, in)
615	if err != nil {
616		return out, metadata, err
617	}
618
619	response, ok := out.RawResponse.(*smithyhttp.Response)
620	if !ok {
621		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
622	}
623
624	if response.StatusCode < 200 || response.StatusCode >= 300 {
625		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingEndpointGroup(response, &metadata)
626	}
627	output := &CreateCustomRoutingEndpointGroupOutput{}
628	out.Result = output
629
630	var buff [1024]byte
631	ringBuffer := smithyio.NewRingBuffer(buff[:])
632
633	body := io.TeeReader(response.Body, ringBuffer)
634	decoder := json.NewDecoder(body)
635	decoder.UseNumber()
636	var shape interface{}
637	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
638		var snapshot bytes.Buffer
639		io.Copy(&snapshot, ringBuffer)
640		err = &smithy.DeserializationError{
641			Err:      fmt.Errorf("failed to decode response body, %w", err),
642			Snapshot: snapshot.Bytes(),
643		}
644		return out, metadata, err
645	}
646
647	err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingEndpointGroupOutput(&output, shape)
648	if err != nil {
649		var snapshot bytes.Buffer
650		io.Copy(&snapshot, ringBuffer)
651		err = &smithy.DeserializationError{
652			Err:      fmt.Errorf("failed to decode response body, %w", err),
653			Snapshot: snapshot.Bytes(),
654		}
655		return out, metadata, err
656	}
657
658	return out, metadata, err
659}
660
661func awsAwsjson11_deserializeOpErrorCreateCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
662	var errorBuffer bytes.Buffer
663	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
664		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
665	}
666	errorBody := bytes.NewReader(errorBuffer.Bytes())
667
668	errorCode := "UnknownError"
669	errorMessage := errorCode
670
671	code := response.Header.Get("X-Amzn-ErrorType")
672	if len(code) != 0 {
673		errorCode = restjson.SanitizeErrorCode(code)
674	}
675
676	var buff [1024]byte
677	ringBuffer := smithyio.NewRingBuffer(buff[:])
678
679	body := io.TeeReader(errorBody, ringBuffer)
680	decoder := json.NewDecoder(body)
681	decoder.UseNumber()
682	code, message, err := restjson.GetErrorInfo(decoder)
683	if err != nil {
684		var snapshot bytes.Buffer
685		io.Copy(&snapshot, ringBuffer)
686		err = &smithy.DeserializationError{
687			Err:      fmt.Errorf("failed to decode response body, %w", err),
688			Snapshot: snapshot.Bytes(),
689		}
690		return err
691	}
692
693	errorBody.Seek(0, io.SeekStart)
694	if len(code) != 0 {
695		errorCode = restjson.SanitizeErrorCode(code)
696	}
697	if len(message) != 0 {
698		errorMessage = message
699	}
700
701	switch {
702	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
703		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
704
705	case strings.EqualFold("AccessDeniedException", errorCode):
706		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
707
708	case strings.EqualFold("EndpointGroupAlreadyExistsException", errorCode):
709		return awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response, errorBody)
710
711	case strings.EqualFold("InternalServiceErrorException", errorCode):
712		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
713
714	case strings.EqualFold("InvalidArgumentException", errorCode):
715		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
716
717	case strings.EqualFold("InvalidPortRangeException", errorCode):
718		return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody)
719
720	case strings.EqualFold("LimitExceededException", errorCode):
721		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
722
723	case strings.EqualFold("ListenerNotFoundException", errorCode):
724		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
725
726	default:
727		genericError := &smithy.GenericAPIError{
728			Code:    errorCode,
729			Message: errorMessage,
730		}
731		return genericError
732
733	}
734}
735
736type awsAwsjson11_deserializeOpCreateCustomRoutingListener struct {
737}
738
739func (*awsAwsjson11_deserializeOpCreateCustomRoutingListener) ID() string {
740	return "OperationDeserializer"
741}
742
743func (m *awsAwsjson11_deserializeOpCreateCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
744	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
745) {
746	out, metadata, err = next.HandleDeserialize(ctx, in)
747	if err != nil {
748		return out, metadata, err
749	}
750
751	response, ok := out.RawResponse.(*smithyhttp.Response)
752	if !ok {
753		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
754	}
755
756	if response.StatusCode < 200 || response.StatusCode >= 300 {
757		return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingListener(response, &metadata)
758	}
759	output := &CreateCustomRoutingListenerOutput{}
760	out.Result = output
761
762	var buff [1024]byte
763	ringBuffer := smithyio.NewRingBuffer(buff[:])
764
765	body := io.TeeReader(response.Body, ringBuffer)
766	decoder := json.NewDecoder(body)
767	decoder.UseNumber()
768	var shape interface{}
769	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
770		var snapshot bytes.Buffer
771		io.Copy(&snapshot, ringBuffer)
772		err = &smithy.DeserializationError{
773			Err:      fmt.Errorf("failed to decode response body, %w", err),
774			Snapshot: snapshot.Bytes(),
775		}
776		return out, metadata, err
777	}
778
779	err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingListenerOutput(&output, shape)
780	if err != nil {
781		var snapshot bytes.Buffer
782		io.Copy(&snapshot, ringBuffer)
783		err = &smithy.DeserializationError{
784			Err:      fmt.Errorf("failed to decode response body, %w", err),
785			Snapshot: snapshot.Bytes(),
786		}
787		return out, metadata, err
788	}
789
790	return out, metadata, err
791}
792
793func awsAwsjson11_deserializeOpErrorCreateCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
794	var errorBuffer bytes.Buffer
795	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
796		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
797	}
798	errorBody := bytes.NewReader(errorBuffer.Bytes())
799
800	errorCode := "UnknownError"
801	errorMessage := errorCode
802
803	code := response.Header.Get("X-Amzn-ErrorType")
804	if len(code) != 0 {
805		errorCode = restjson.SanitizeErrorCode(code)
806	}
807
808	var buff [1024]byte
809	ringBuffer := smithyio.NewRingBuffer(buff[:])
810
811	body := io.TeeReader(errorBody, ringBuffer)
812	decoder := json.NewDecoder(body)
813	decoder.UseNumber()
814	code, message, err := restjson.GetErrorInfo(decoder)
815	if err != nil {
816		var snapshot bytes.Buffer
817		io.Copy(&snapshot, ringBuffer)
818		err = &smithy.DeserializationError{
819			Err:      fmt.Errorf("failed to decode response body, %w", err),
820			Snapshot: snapshot.Bytes(),
821		}
822		return err
823	}
824
825	errorBody.Seek(0, io.SeekStart)
826	if len(code) != 0 {
827		errorCode = restjson.SanitizeErrorCode(code)
828	}
829	if len(message) != 0 {
830		errorMessage = message
831	}
832
833	switch {
834	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
835		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
836
837	case strings.EqualFold("InternalServiceErrorException", errorCode):
838		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
839
840	case strings.EqualFold("InvalidArgumentException", errorCode):
841		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
842
843	case strings.EqualFold("InvalidPortRangeException", errorCode):
844		return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody)
845
846	case strings.EqualFold("LimitExceededException", errorCode):
847		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
848
849	default:
850		genericError := &smithy.GenericAPIError{
851			Code:    errorCode,
852			Message: errorMessage,
853		}
854		return genericError
855
856	}
857}
858
859type awsAwsjson11_deserializeOpCreateEndpointGroup struct {
860}
861
862func (*awsAwsjson11_deserializeOpCreateEndpointGroup) ID() string {
863	return "OperationDeserializer"
864}
865
866func (m *awsAwsjson11_deserializeOpCreateEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
867	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
868) {
869	out, metadata, err = next.HandleDeserialize(ctx, in)
870	if err != nil {
871		return out, metadata, err
872	}
873
874	response, ok := out.RawResponse.(*smithyhttp.Response)
875	if !ok {
876		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
877	}
878
879	if response.StatusCode < 200 || response.StatusCode >= 300 {
880		return out, metadata, awsAwsjson11_deserializeOpErrorCreateEndpointGroup(response, &metadata)
881	}
882	output := &CreateEndpointGroupOutput{}
883	out.Result = output
884
885	var buff [1024]byte
886	ringBuffer := smithyio.NewRingBuffer(buff[:])
887
888	body := io.TeeReader(response.Body, ringBuffer)
889	decoder := json.NewDecoder(body)
890	decoder.UseNumber()
891	var shape interface{}
892	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
893		var snapshot bytes.Buffer
894		io.Copy(&snapshot, ringBuffer)
895		err = &smithy.DeserializationError{
896			Err:      fmt.Errorf("failed to decode response body, %w", err),
897			Snapshot: snapshot.Bytes(),
898		}
899		return out, metadata, err
900	}
901
902	err = awsAwsjson11_deserializeOpDocumentCreateEndpointGroupOutput(&output, shape)
903	if err != nil {
904		var snapshot bytes.Buffer
905		io.Copy(&snapshot, ringBuffer)
906		err = &smithy.DeserializationError{
907			Err:      fmt.Errorf("failed to decode response body, %w", err),
908			Snapshot: snapshot.Bytes(),
909		}
910		return out, metadata, err
911	}
912
913	return out, metadata, err
914}
915
916func awsAwsjson11_deserializeOpErrorCreateEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
917	var errorBuffer bytes.Buffer
918	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
919		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
920	}
921	errorBody := bytes.NewReader(errorBuffer.Bytes())
922
923	errorCode := "UnknownError"
924	errorMessage := errorCode
925
926	code := response.Header.Get("X-Amzn-ErrorType")
927	if len(code) != 0 {
928		errorCode = restjson.SanitizeErrorCode(code)
929	}
930
931	var buff [1024]byte
932	ringBuffer := smithyio.NewRingBuffer(buff[:])
933
934	body := io.TeeReader(errorBody, ringBuffer)
935	decoder := json.NewDecoder(body)
936	decoder.UseNumber()
937	code, message, err := restjson.GetErrorInfo(decoder)
938	if err != nil {
939		var snapshot bytes.Buffer
940		io.Copy(&snapshot, ringBuffer)
941		err = &smithy.DeserializationError{
942			Err:      fmt.Errorf("failed to decode response body, %w", err),
943			Snapshot: snapshot.Bytes(),
944		}
945		return err
946	}
947
948	errorBody.Seek(0, io.SeekStart)
949	if len(code) != 0 {
950		errorCode = restjson.SanitizeErrorCode(code)
951	}
952	if len(message) != 0 {
953		errorMessage = message
954	}
955
956	switch {
957	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
958		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
959
960	case strings.EqualFold("AccessDeniedException", errorCode):
961		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
962
963	case strings.EqualFold("EndpointGroupAlreadyExistsException", errorCode):
964		return awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response, errorBody)
965
966	case strings.EqualFold("InternalServiceErrorException", errorCode):
967		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
968
969	case strings.EqualFold("InvalidArgumentException", errorCode):
970		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
971
972	case strings.EqualFold("LimitExceededException", errorCode):
973		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
974
975	case strings.EqualFold("ListenerNotFoundException", errorCode):
976		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
977
978	default:
979		genericError := &smithy.GenericAPIError{
980			Code:    errorCode,
981			Message: errorMessage,
982		}
983		return genericError
984
985	}
986}
987
988type awsAwsjson11_deserializeOpCreateListener struct {
989}
990
991func (*awsAwsjson11_deserializeOpCreateListener) ID() string {
992	return "OperationDeserializer"
993}
994
995func (m *awsAwsjson11_deserializeOpCreateListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
996	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
997) {
998	out, metadata, err = next.HandleDeserialize(ctx, in)
999	if err != nil {
1000		return out, metadata, err
1001	}
1002
1003	response, ok := out.RawResponse.(*smithyhttp.Response)
1004	if !ok {
1005		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1006	}
1007
1008	if response.StatusCode < 200 || response.StatusCode >= 300 {
1009		return out, metadata, awsAwsjson11_deserializeOpErrorCreateListener(response, &metadata)
1010	}
1011	output := &CreateListenerOutput{}
1012	out.Result = output
1013
1014	var buff [1024]byte
1015	ringBuffer := smithyio.NewRingBuffer(buff[:])
1016
1017	body := io.TeeReader(response.Body, ringBuffer)
1018	decoder := json.NewDecoder(body)
1019	decoder.UseNumber()
1020	var shape interface{}
1021	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1022		var snapshot bytes.Buffer
1023		io.Copy(&snapshot, ringBuffer)
1024		err = &smithy.DeserializationError{
1025			Err:      fmt.Errorf("failed to decode response body, %w", err),
1026			Snapshot: snapshot.Bytes(),
1027		}
1028		return out, metadata, err
1029	}
1030
1031	err = awsAwsjson11_deserializeOpDocumentCreateListenerOutput(&output, shape)
1032	if err != nil {
1033		var snapshot bytes.Buffer
1034		io.Copy(&snapshot, ringBuffer)
1035		err = &smithy.DeserializationError{
1036			Err:      fmt.Errorf("failed to decode response body, %w", err),
1037			Snapshot: snapshot.Bytes(),
1038		}
1039		return out, metadata, err
1040	}
1041
1042	return out, metadata, err
1043}
1044
1045func awsAwsjson11_deserializeOpErrorCreateListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1046	var errorBuffer bytes.Buffer
1047	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1048		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1049	}
1050	errorBody := bytes.NewReader(errorBuffer.Bytes())
1051
1052	errorCode := "UnknownError"
1053	errorMessage := errorCode
1054
1055	code := response.Header.Get("X-Amzn-ErrorType")
1056	if len(code) != 0 {
1057		errorCode = restjson.SanitizeErrorCode(code)
1058	}
1059
1060	var buff [1024]byte
1061	ringBuffer := smithyio.NewRingBuffer(buff[:])
1062
1063	body := io.TeeReader(errorBody, ringBuffer)
1064	decoder := json.NewDecoder(body)
1065	decoder.UseNumber()
1066	code, message, err := restjson.GetErrorInfo(decoder)
1067	if err != nil {
1068		var snapshot bytes.Buffer
1069		io.Copy(&snapshot, ringBuffer)
1070		err = &smithy.DeserializationError{
1071			Err:      fmt.Errorf("failed to decode response body, %w", err),
1072			Snapshot: snapshot.Bytes(),
1073		}
1074		return err
1075	}
1076
1077	errorBody.Seek(0, io.SeekStart)
1078	if len(code) != 0 {
1079		errorCode = restjson.SanitizeErrorCode(code)
1080	}
1081	if len(message) != 0 {
1082		errorMessage = message
1083	}
1084
1085	switch {
1086	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
1087		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
1088
1089	case strings.EqualFold("InternalServiceErrorException", errorCode):
1090		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1091
1092	case strings.EqualFold("InvalidArgumentException", errorCode):
1093		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1094
1095	case strings.EqualFold("InvalidPortRangeException", errorCode):
1096		return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody)
1097
1098	case strings.EqualFold("LimitExceededException", errorCode):
1099		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1100
1101	default:
1102		genericError := &smithy.GenericAPIError{
1103			Code:    errorCode,
1104			Message: errorMessage,
1105		}
1106		return genericError
1107
1108	}
1109}
1110
1111type awsAwsjson11_deserializeOpDeleteAccelerator struct {
1112}
1113
1114func (*awsAwsjson11_deserializeOpDeleteAccelerator) ID() string {
1115	return "OperationDeserializer"
1116}
1117
1118func (m *awsAwsjson11_deserializeOpDeleteAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1119	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1120) {
1121	out, metadata, err = next.HandleDeserialize(ctx, in)
1122	if err != nil {
1123		return out, metadata, err
1124	}
1125
1126	response, ok := out.RawResponse.(*smithyhttp.Response)
1127	if !ok {
1128		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1129	}
1130
1131	if response.StatusCode < 200 || response.StatusCode >= 300 {
1132		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccelerator(response, &metadata)
1133	}
1134	output := &DeleteAcceleratorOutput{}
1135	out.Result = output
1136
1137	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1138		return out, metadata, &smithy.DeserializationError{
1139			Err: fmt.Errorf("failed to discard response body, %w", err),
1140		}
1141	}
1142
1143	return out, metadata, err
1144}
1145
1146func awsAwsjson11_deserializeOpErrorDeleteAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1147	var errorBuffer bytes.Buffer
1148	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1149		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1150	}
1151	errorBody := bytes.NewReader(errorBuffer.Bytes())
1152
1153	errorCode := "UnknownError"
1154	errorMessage := errorCode
1155
1156	code := response.Header.Get("X-Amzn-ErrorType")
1157	if len(code) != 0 {
1158		errorCode = restjson.SanitizeErrorCode(code)
1159	}
1160
1161	var buff [1024]byte
1162	ringBuffer := smithyio.NewRingBuffer(buff[:])
1163
1164	body := io.TeeReader(errorBody, ringBuffer)
1165	decoder := json.NewDecoder(body)
1166	decoder.UseNumber()
1167	code, message, err := restjson.GetErrorInfo(decoder)
1168	if err != nil {
1169		var snapshot bytes.Buffer
1170		io.Copy(&snapshot, ringBuffer)
1171		err = &smithy.DeserializationError{
1172			Err:      fmt.Errorf("failed to decode response body, %w", err),
1173			Snapshot: snapshot.Bytes(),
1174		}
1175		return err
1176	}
1177
1178	errorBody.Seek(0, io.SeekStart)
1179	if len(code) != 0 {
1180		errorCode = restjson.SanitizeErrorCode(code)
1181	}
1182	if len(message) != 0 {
1183		errorMessage = message
1184	}
1185
1186	switch {
1187	case strings.EqualFold("AcceleratorNotDisabledException", errorCode):
1188		return awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response, errorBody)
1189
1190	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
1191		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
1192
1193	case strings.EqualFold("AssociatedListenerFoundException", errorCode):
1194		return awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response, errorBody)
1195
1196	case strings.EqualFold("InternalServiceErrorException", errorCode):
1197		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1198
1199	case strings.EqualFold("InvalidArgumentException", errorCode):
1200		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1201
1202	default:
1203		genericError := &smithy.GenericAPIError{
1204			Code:    errorCode,
1205			Message: errorMessage,
1206		}
1207		return genericError
1208
1209	}
1210}
1211
1212type awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator struct {
1213}
1214
1215func (*awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator) ID() string {
1216	return "OperationDeserializer"
1217}
1218
1219func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1220	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1221) {
1222	out, metadata, err = next.HandleDeserialize(ctx, in)
1223	if err != nil {
1224		return out, metadata, err
1225	}
1226
1227	response, ok := out.RawResponse.(*smithyhttp.Response)
1228	if !ok {
1229		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1230	}
1231
1232	if response.StatusCode < 200 || response.StatusCode >= 300 {
1233		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingAccelerator(response, &metadata)
1234	}
1235	output := &DeleteCustomRoutingAcceleratorOutput{}
1236	out.Result = output
1237
1238	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1239		return out, metadata, &smithy.DeserializationError{
1240			Err: fmt.Errorf("failed to discard response body, %w", err),
1241		}
1242	}
1243
1244	return out, metadata, err
1245}
1246
1247func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1248	var errorBuffer bytes.Buffer
1249	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1250		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1251	}
1252	errorBody := bytes.NewReader(errorBuffer.Bytes())
1253
1254	errorCode := "UnknownError"
1255	errorMessage := errorCode
1256
1257	code := response.Header.Get("X-Amzn-ErrorType")
1258	if len(code) != 0 {
1259		errorCode = restjson.SanitizeErrorCode(code)
1260	}
1261
1262	var buff [1024]byte
1263	ringBuffer := smithyio.NewRingBuffer(buff[:])
1264
1265	body := io.TeeReader(errorBody, ringBuffer)
1266	decoder := json.NewDecoder(body)
1267	decoder.UseNumber()
1268	code, message, err := restjson.GetErrorInfo(decoder)
1269	if err != nil {
1270		var snapshot bytes.Buffer
1271		io.Copy(&snapshot, ringBuffer)
1272		err = &smithy.DeserializationError{
1273			Err:      fmt.Errorf("failed to decode response body, %w", err),
1274			Snapshot: snapshot.Bytes(),
1275		}
1276		return err
1277	}
1278
1279	errorBody.Seek(0, io.SeekStart)
1280	if len(code) != 0 {
1281		errorCode = restjson.SanitizeErrorCode(code)
1282	}
1283	if len(message) != 0 {
1284		errorMessage = message
1285	}
1286
1287	switch {
1288	case strings.EqualFold("AcceleratorNotDisabledException", errorCode):
1289		return awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response, errorBody)
1290
1291	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
1292		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
1293
1294	case strings.EqualFold("AssociatedListenerFoundException", errorCode):
1295		return awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response, errorBody)
1296
1297	case strings.EqualFold("InternalServiceErrorException", errorCode):
1298		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1299
1300	case strings.EqualFold("InvalidArgumentException", errorCode):
1301		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1302
1303	default:
1304		genericError := &smithy.GenericAPIError{
1305			Code:    errorCode,
1306			Message: errorMessage,
1307		}
1308		return genericError
1309
1310	}
1311}
1312
1313type awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup struct {
1314}
1315
1316func (*awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup) ID() string {
1317	return "OperationDeserializer"
1318}
1319
1320func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1321	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	out, metadata, err = next.HandleDeserialize(ctx, in)
1324	if err != nil {
1325		return out, metadata, err
1326	}
1327
1328	response, ok := out.RawResponse.(*smithyhttp.Response)
1329	if !ok {
1330		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1331	}
1332
1333	if response.StatusCode < 200 || response.StatusCode >= 300 {
1334		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingEndpointGroup(response, &metadata)
1335	}
1336	output := &DeleteCustomRoutingEndpointGroupOutput{}
1337	out.Result = output
1338
1339	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1340		return out, metadata, &smithy.DeserializationError{
1341			Err: fmt.Errorf("failed to discard response body, %w", err),
1342		}
1343	}
1344
1345	return out, metadata, err
1346}
1347
1348func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1349	var errorBuffer bytes.Buffer
1350	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1351		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1352	}
1353	errorBody := bytes.NewReader(errorBuffer.Bytes())
1354
1355	errorCode := "UnknownError"
1356	errorMessage := errorCode
1357
1358	code := response.Header.Get("X-Amzn-ErrorType")
1359	if len(code) != 0 {
1360		errorCode = restjson.SanitizeErrorCode(code)
1361	}
1362
1363	var buff [1024]byte
1364	ringBuffer := smithyio.NewRingBuffer(buff[:])
1365
1366	body := io.TeeReader(errorBody, ringBuffer)
1367	decoder := json.NewDecoder(body)
1368	decoder.UseNumber()
1369	code, message, err := restjson.GetErrorInfo(decoder)
1370	if err != nil {
1371		var snapshot bytes.Buffer
1372		io.Copy(&snapshot, ringBuffer)
1373		err = &smithy.DeserializationError{
1374			Err:      fmt.Errorf("failed to decode response body, %w", err),
1375			Snapshot: snapshot.Bytes(),
1376		}
1377		return err
1378	}
1379
1380	errorBody.Seek(0, io.SeekStart)
1381	if len(code) != 0 {
1382		errorCode = restjson.SanitizeErrorCode(code)
1383	}
1384	if len(message) != 0 {
1385		errorMessage = message
1386	}
1387
1388	switch {
1389	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
1390		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
1391
1392	case strings.EqualFold("InternalServiceErrorException", errorCode):
1393		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1394
1395	case strings.EqualFold("InvalidArgumentException", errorCode):
1396		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1397
1398	default:
1399		genericError := &smithy.GenericAPIError{
1400			Code:    errorCode,
1401			Message: errorMessage,
1402		}
1403		return genericError
1404
1405	}
1406}
1407
1408type awsAwsjson11_deserializeOpDeleteCustomRoutingListener struct {
1409}
1410
1411func (*awsAwsjson11_deserializeOpDeleteCustomRoutingListener) ID() string {
1412	return "OperationDeserializer"
1413}
1414
1415func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1416	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1417) {
1418	out, metadata, err = next.HandleDeserialize(ctx, in)
1419	if err != nil {
1420		return out, metadata, err
1421	}
1422
1423	response, ok := out.RawResponse.(*smithyhttp.Response)
1424	if !ok {
1425		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1426	}
1427
1428	if response.StatusCode < 200 || response.StatusCode >= 300 {
1429		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingListener(response, &metadata)
1430	}
1431	output := &DeleteCustomRoutingListenerOutput{}
1432	out.Result = output
1433
1434	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1435		return out, metadata, &smithy.DeserializationError{
1436			Err: fmt.Errorf("failed to discard response body, %w", err),
1437		}
1438	}
1439
1440	return out, metadata, err
1441}
1442
1443func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1444	var errorBuffer bytes.Buffer
1445	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1446		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1447	}
1448	errorBody := bytes.NewReader(errorBuffer.Bytes())
1449
1450	errorCode := "UnknownError"
1451	errorMessage := errorCode
1452
1453	code := response.Header.Get("X-Amzn-ErrorType")
1454	if len(code) != 0 {
1455		errorCode = restjson.SanitizeErrorCode(code)
1456	}
1457
1458	var buff [1024]byte
1459	ringBuffer := smithyio.NewRingBuffer(buff[:])
1460
1461	body := io.TeeReader(errorBody, ringBuffer)
1462	decoder := json.NewDecoder(body)
1463	decoder.UseNumber()
1464	code, message, err := restjson.GetErrorInfo(decoder)
1465	if err != nil {
1466		var snapshot bytes.Buffer
1467		io.Copy(&snapshot, ringBuffer)
1468		err = &smithy.DeserializationError{
1469			Err:      fmt.Errorf("failed to decode response body, %w", err),
1470			Snapshot: snapshot.Bytes(),
1471		}
1472		return err
1473	}
1474
1475	errorBody.Seek(0, io.SeekStart)
1476	if len(code) != 0 {
1477		errorCode = restjson.SanitizeErrorCode(code)
1478	}
1479	if len(message) != 0 {
1480		errorMessage = message
1481	}
1482
1483	switch {
1484	case strings.EqualFold("AssociatedEndpointGroupFoundException", errorCode):
1485		return awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response, errorBody)
1486
1487	case strings.EqualFold("InternalServiceErrorException", errorCode):
1488		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1489
1490	case strings.EqualFold("InvalidArgumentException", errorCode):
1491		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1492
1493	case strings.EqualFold("ListenerNotFoundException", errorCode):
1494		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
1495
1496	default:
1497		genericError := &smithy.GenericAPIError{
1498			Code:    errorCode,
1499			Message: errorMessage,
1500		}
1501		return genericError
1502
1503	}
1504}
1505
1506type awsAwsjson11_deserializeOpDeleteEndpointGroup struct {
1507}
1508
1509func (*awsAwsjson11_deserializeOpDeleteEndpointGroup) ID() string {
1510	return "OperationDeserializer"
1511}
1512
1513func (m *awsAwsjson11_deserializeOpDeleteEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1514	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1515) {
1516	out, metadata, err = next.HandleDeserialize(ctx, in)
1517	if err != nil {
1518		return out, metadata, err
1519	}
1520
1521	response, ok := out.RawResponse.(*smithyhttp.Response)
1522	if !ok {
1523		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1524	}
1525
1526	if response.StatusCode < 200 || response.StatusCode >= 300 {
1527		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteEndpointGroup(response, &metadata)
1528	}
1529	output := &DeleteEndpointGroupOutput{}
1530	out.Result = output
1531
1532	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1533		return out, metadata, &smithy.DeserializationError{
1534			Err: fmt.Errorf("failed to discard response body, %w", err),
1535		}
1536	}
1537
1538	return out, metadata, err
1539}
1540
1541func awsAwsjson11_deserializeOpErrorDeleteEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1542	var errorBuffer bytes.Buffer
1543	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1544		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1545	}
1546	errorBody := bytes.NewReader(errorBuffer.Bytes())
1547
1548	errorCode := "UnknownError"
1549	errorMessage := errorCode
1550
1551	code := response.Header.Get("X-Amzn-ErrorType")
1552	if len(code) != 0 {
1553		errorCode = restjson.SanitizeErrorCode(code)
1554	}
1555
1556	var buff [1024]byte
1557	ringBuffer := smithyio.NewRingBuffer(buff[:])
1558
1559	body := io.TeeReader(errorBody, ringBuffer)
1560	decoder := json.NewDecoder(body)
1561	decoder.UseNumber()
1562	code, message, err := restjson.GetErrorInfo(decoder)
1563	if err != nil {
1564		var snapshot bytes.Buffer
1565		io.Copy(&snapshot, ringBuffer)
1566		err = &smithy.DeserializationError{
1567			Err:      fmt.Errorf("failed to decode response body, %w", err),
1568			Snapshot: snapshot.Bytes(),
1569		}
1570		return err
1571	}
1572
1573	errorBody.Seek(0, io.SeekStart)
1574	if len(code) != 0 {
1575		errorCode = restjson.SanitizeErrorCode(code)
1576	}
1577	if len(message) != 0 {
1578		errorMessage = message
1579	}
1580
1581	switch {
1582	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
1583		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
1584
1585	case strings.EqualFold("InternalServiceErrorException", errorCode):
1586		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1587
1588	case strings.EqualFold("InvalidArgumentException", errorCode):
1589		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1590
1591	default:
1592		genericError := &smithy.GenericAPIError{
1593			Code:    errorCode,
1594			Message: errorMessage,
1595		}
1596		return genericError
1597
1598	}
1599}
1600
1601type awsAwsjson11_deserializeOpDeleteListener struct {
1602}
1603
1604func (*awsAwsjson11_deserializeOpDeleteListener) ID() string {
1605	return "OperationDeserializer"
1606}
1607
1608func (m *awsAwsjson11_deserializeOpDeleteListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1609	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1610) {
1611	out, metadata, err = next.HandleDeserialize(ctx, in)
1612	if err != nil {
1613		return out, metadata, err
1614	}
1615
1616	response, ok := out.RawResponse.(*smithyhttp.Response)
1617	if !ok {
1618		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1619	}
1620
1621	if response.StatusCode < 200 || response.StatusCode >= 300 {
1622		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteListener(response, &metadata)
1623	}
1624	output := &DeleteListenerOutput{}
1625	out.Result = output
1626
1627	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1628		return out, metadata, &smithy.DeserializationError{
1629			Err: fmt.Errorf("failed to discard response body, %w", err),
1630		}
1631	}
1632
1633	return out, metadata, err
1634}
1635
1636func awsAwsjson11_deserializeOpErrorDeleteListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1637	var errorBuffer bytes.Buffer
1638	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1639		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1640	}
1641	errorBody := bytes.NewReader(errorBuffer.Bytes())
1642
1643	errorCode := "UnknownError"
1644	errorMessage := errorCode
1645
1646	code := response.Header.Get("X-Amzn-ErrorType")
1647	if len(code) != 0 {
1648		errorCode = restjson.SanitizeErrorCode(code)
1649	}
1650
1651	var buff [1024]byte
1652	ringBuffer := smithyio.NewRingBuffer(buff[:])
1653
1654	body := io.TeeReader(errorBody, ringBuffer)
1655	decoder := json.NewDecoder(body)
1656	decoder.UseNumber()
1657	code, message, err := restjson.GetErrorInfo(decoder)
1658	if err != nil {
1659		var snapshot bytes.Buffer
1660		io.Copy(&snapshot, ringBuffer)
1661		err = &smithy.DeserializationError{
1662			Err:      fmt.Errorf("failed to decode response body, %w", err),
1663			Snapshot: snapshot.Bytes(),
1664		}
1665		return err
1666	}
1667
1668	errorBody.Seek(0, io.SeekStart)
1669	if len(code) != 0 {
1670		errorCode = restjson.SanitizeErrorCode(code)
1671	}
1672	if len(message) != 0 {
1673		errorMessage = message
1674	}
1675
1676	switch {
1677	case strings.EqualFold("AssociatedEndpointGroupFoundException", errorCode):
1678		return awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response, errorBody)
1679
1680	case strings.EqualFold("InternalServiceErrorException", errorCode):
1681		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1682
1683	case strings.EqualFold("InvalidArgumentException", errorCode):
1684		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1685
1686	case strings.EqualFold("ListenerNotFoundException", errorCode):
1687		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
1688
1689	default:
1690		genericError := &smithy.GenericAPIError{
1691			Code:    errorCode,
1692			Message: errorMessage,
1693		}
1694		return genericError
1695
1696	}
1697}
1698
1699type awsAwsjson11_deserializeOpDenyCustomRoutingTraffic struct {
1700}
1701
1702func (*awsAwsjson11_deserializeOpDenyCustomRoutingTraffic) ID() string {
1703	return "OperationDeserializer"
1704}
1705
1706func (m *awsAwsjson11_deserializeOpDenyCustomRoutingTraffic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1707	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1708) {
1709	out, metadata, err = next.HandleDeserialize(ctx, in)
1710	if err != nil {
1711		return out, metadata, err
1712	}
1713
1714	response, ok := out.RawResponse.(*smithyhttp.Response)
1715	if !ok {
1716		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1717	}
1718
1719	if response.StatusCode < 200 || response.StatusCode >= 300 {
1720		return out, metadata, awsAwsjson11_deserializeOpErrorDenyCustomRoutingTraffic(response, &metadata)
1721	}
1722	output := &DenyCustomRoutingTrafficOutput{}
1723	out.Result = output
1724
1725	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1726		return out, metadata, &smithy.DeserializationError{
1727			Err: fmt.Errorf("failed to discard response body, %w", err),
1728		}
1729	}
1730
1731	return out, metadata, err
1732}
1733
1734func awsAwsjson11_deserializeOpErrorDenyCustomRoutingTraffic(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1735	var errorBuffer bytes.Buffer
1736	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1737		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1738	}
1739	errorBody := bytes.NewReader(errorBuffer.Bytes())
1740
1741	errorCode := "UnknownError"
1742	errorMessage := errorCode
1743
1744	code := response.Header.Get("X-Amzn-ErrorType")
1745	if len(code) != 0 {
1746		errorCode = restjson.SanitizeErrorCode(code)
1747	}
1748
1749	var buff [1024]byte
1750	ringBuffer := smithyio.NewRingBuffer(buff[:])
1751
1752	body := io.TeeReader(errorBody, ringBuffer)
1753	decoder := json.NewDecoder(body)
1754	decoder.UseNumber()
1755	code, message, err := restjson.GetErrorInfo(decoder)
1756	if err != nil {
1757		var snapshot bytes.Buffer
1758		io.Copy(&snapshot, ringBuffer)
1759		err = &smithy.DeserializationError{
1760			Err:      fmt.Errorf("failed to decode response body, %w", err),
1761			Snapshot: snapshot.Bytes(),
1762		}
1763		return err
1764	}
1765
1766	errorBody.Seek(0, io.SeekStart)
1767	if len(code) != 0 {
1768		errorCode = restjson.SanitizeErrorCode(code)
1769	}
1770	if len(message) != 0 {
1771		errorMessage = message
1772	}
1773
1774	switch {
1775	case strings.EqualFold("InternalServiceErrorException", errorCode):
1776		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1777
1778	case strings.EqualFold("InvalidArgumentException", errorCode):
1779		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1780
1781	default:
1782		genericError := &smithy.GenericAPIError{
1783			Code:    errorCode,
1784			Message: errorMessage,
1785		}
1786		return genericError
1787
1788	}
1789}
1790
1791type awsAwsjson11_deserializeOpDeprovisionByoipCidr struct {
1792}
1793
1794func (*awsAwsjson11_deserializeOpDeprovisionByoipCidr) ID() string {
1795	return "OperationDeserializer"
1796}
1797
1798func (m *awsAwsjson11_deserializeOpDeprovisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1799	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1800) {
1801	out, metadata, err = next.HandleDeserialize(ctx, in)
1802	if err != nil {
1803		return out, metadata, err
1804	}
1805
1806	response, ok := out.RawResponse.(*smithyhttp.Response)
1807	if !ok {
1808		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1809	}
1810
1811	if response.StatusCode < 200 || response.StatusCode >= 300 {
1812		return out, metadata, awsAwsjson11_deserializeOpErrorDeprovisionByoipCidr(response, &metadata)
1813	}
1814	output := &DeprovisionByoipCidrOutput{}
1815	out.Result = output
1816
1817	var buff [1024]byte
1818	ringBuffer := smithyio.NewRingBuffer(buff[:])
1819
1820	body := io.TeeReader(response.Body, ringBuffer)
1821	decoder := json.NewDecoder(body)
1822	decoder.UseNumber()
1823	var shape interface{}
1824	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1825		var snapshot bytes.Buffer
1826		io.Copy(&snapshot, ringBuffer)
1827		err = &smithy.DeserializationError{
1828			Err:      fmt.Errorf("failed to decode response body, %w", err),
1829			Snapshot: snapshot.Bytes(),
1830		}
1831		return out, metadata, err
1832	}
1833
1834	err = awsAwsjson11_deserializeOpDocumentDeprovisionByoipCidrOutput(&output, shape)
1835	if err != nil {
1836		var snapshot bytes.Buffer
1837		io.Copy(&snapshot, ringBuffer)
1838		err = &smithy.DeserializationError{
1839			Err:      fmt.Errorf("failed to decode response body, %w", err),
1840			Snapshot: snapshot.Bytes(),
1841		}
1842		return out, metadata, err
1843	}
1844
1845	return out, metadata, err
1846}
1847
1848func awsAwsjson11_deserializeOpErrorDeprovisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1849	var errorBuffer bytes.Buffer
1850	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1851		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1852	}
1853	errorBody := bytes.NewReader(errorBuffer.Bytes())
1854
1855	errorCode := "UnknownError"
1856	errorMessage := errorCode
1857
1858	code := response.Header.Get("X-Amzn-ErrorType")
1859	if len(code) != 0 {
1860		errorCode = restjson.SanitizeErrorCode(code)
1861	}
1862
1863	var buff [1024]byte
1864	ringBuffer := smithyio.NewRingBuffer(buff[:])
1865
1866	body := io.TeeReader(errorBody, ringBuffer)
1867	decoder := json.NewDecoder(body)
1868	decoder.UseNumber()
1869	code, message, err := restjson.GetErrorInfo(decoder)
1870	if err != nil {
1871		var snapshot bytes.Buffer
1872		io.Copy(&snapshot, ringBuffer)
1873		err = &smithy.DeserializationError{
1874			Err:      fmt.Errorf("failed to decode response body, %w", err),
1875			Snapshot: snapshot.Bytes(),
1876		}
1877		return err
1878	}
1879
1880	errorBody.Seek(0, io.SeekStart)
1881	if len(code) != 0 {
1882		errorCode = restjson.SanitizeErrorCode(code)
1883	}
1884	if len(message) != 0 {
1885		errorMessage = message
1886	}
1887
1888	switch {
1889	case strings.EqualFold("AccessDeniedException", errorCode):
1890		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1891
1892	case strings.EqualFold("ByoipCidrNotFoundException", errorCode):
1893		return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody)
1894
1895	case strings.EqualFold("IncorrectCidrStateException", errorCode):
1896		return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody)
1897
1898	case strings.EqualFold("InternalServiceErrorException", errorCode):
1899		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1900
1901	case strings.EqualFold("InvalidArgumentException", errorCode):
1902		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
1903
1904	default:
1905		genericError := &smithy.GenericAPIError{
1906			Code:    errorCode,
1907			Message: errorMessage,
1908		}
1909		return genericError
1910
1911	}
1912}
1913
1914type awsAwsjson11_deserializeOpDescribeAccelerator struct {
1915}
1916
1917func (*awsAwsjson11_deserializeOpDescribeAccelerator) ID() string {
1918	return "OperationDeserializer"
1919}
1920
1921func (m *awsAwsjson11_deserializeOpDescribeAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1922	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1923) {
1924	out, metadata, err = next.HandleDeserialize(ctx, in)
1925	if err != nil {
1926		return out, metadata, err
1927	}
1928
1929	response, ok := out.RawResponse.(*smithyhttp.Response)
1930	if !ok {
1931		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1932	}
1933
1934	if response.StatusCode < 200 || response.StatusCode >= 300 {
1935		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccelerator(response, &metadata)
1936	}
1937	output := &DescribeAcceleratorOutput{}
1938	out.Result = output
1939
1940	var buff [1024]byte
1941	ringBuffer := smithyio.NewRingBuffer(buff[:])
1942
1943	body := io.TeeReader(response.Body, ringBuffer)
1944	decoder := json.NewDecoder(body)
1945	decoder.UseNumber()
1946	var shape interface{}
1947	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1948		var snapshot bytes.Buffer
1949		io.Copy(&snapshot, ringBuffer)
1950		err = &smithy.DeserializationError{
1951			Err:      fmt.Errorf("failed to decode response body, %w", err),
1952			Snapshot: snapshot.Bytes(),
1953		}
1954		return out, metadata, err
1955	}
1956
1957	err = awsAwsjson11_deserializeOpDocumentDescribeAcceleratorOutput(&output, shape)
1958	if err != nil {
1959		var snapshot bytes.Buffer
1960		io.Copy(&snapshot, ringBuffer)
1961		err = &smithy.DeserializationError{
1962			Err:      fmt.Errorf("failed to decode response body, %w", err),
1963			Snapshot: snapshot.Bytes(),
1964		}
1965		return out, metadata, err
1966	}
1967
1968	return out, metadata, err
1969}
1970
1971func awsAwsjson11_deserializeOpErrorDescribeAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1972	var errorBuffer bytes.Buffer
1973	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1974		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1975	}
1976	errorBody := bytes.NewReader(errorBuffer.Bytes())
1977
1978	errorCode := "UnknownError"
1979	errorMessage := errorCode
1980
1981	code := response.Header.Get("X-Amzn-ErrorType")
1982	if len(code) != 0 {
1983		errorCode = restjson.SanitizeErrorCode(code)
1984	}
1985
1986	var buff [1024]byte
1987	ringBuffer := smithyio.NewRingBuffer(buff[:])
1988
1989	body := io.TeeReader(errorBody, ringBuffer)
1990	decoder := json.NewDecoder(body)
1991	decoder.UseNumber()
1992	code, message, err := restjson.GetErrorInfo(decoder)
1993	if err != nil {
1994		var snapshot bytes.Buffer
1995		io.Copy(&snapshot, ringBuffer)
1996		err = &smithy.DeserializationError{
1997			Err:      fmt.Errorf("failed to decode response body, %w", err),
1998			Snapshot: snapshot.Bytes(),
1999		}
2000		return err
2001	}
2002
2003	errorBody.Seek(0, io.SeekStart)
2004	if len(code) != 0 {
2005		errorCode = restjson.SanitizeErrorCode(code)
2006	}
2007	if len(message) != 0 {
2008		errorMessage = message
2009	}
2010
2011	switch {
2012	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
2013		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
2014
2015	case strings.EqualFold("InternalServiceErrorException", errorCode):
2016		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2017
2018	case strings.EqualFold("InvalidArgumentException", errorCode):
2019		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2020
2021	default:
2022		genericError := &smithy.GenericAPIError{
2023			Code:    errorCode,
2024			Message: errorMessage,
2025		}
2026		return genericError
2027
2028	}
2029}
2030
2031type awsAwsjson11_deserializeOpDescribeAcceleratorAttributes struct {
2032}
2033
2034func (*awsAwsjson11_deserializeOpDescribeAcceleratorAttributes) ID() string {
2035	return "OperationDeserializer"
2036}
2037
2038func (m *awsAwsjson11_deserializeOpDescribeAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2039	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2040) {
2041	out, metadata, err = next.HandleDeserialize(ctx, in)
2042	if err != nil {
2043		return out, metadata, err
2044	}
2045
2046	response, ok := out.RawResponse.(*smithyhttp.Response)
2047	if !ok {
2048		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2049	}
2050
2051	if response.StatusCode < 200 || response.StatusCode >= 300 {
2052		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAcceleratorAttributes(response, &metadata)
2053	}
2054	output := &DescribeAcceleratorAttributesOutput{}
2055	out.Result = output
2056
2057	var buff [1024]byte
2058	ringBuffer := smithyio.NewRingBuffer(buff[:])
2059
2060	body := io.TeeReader(response.Body, ringBuffer)
2061	decoder := json.NewDecoder(body)
2062	decoder.UseNumber()
2063	var shape interface{}
2064	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2065		var snapshot bytes.Buffer
2066		io.Copy(&snapshot, ringBuffer)
2067		err = &smithy.DeserializationError{
2068			Err:      fmt.Errorf("failed to decode response body, %w", err),
2069			Snapshot: snapshot.Bytes(),
2070		}
2071		return out, metadata, err
2072	}
2073
2074	err = awsAwsjson11_deserializeOpDocumentDescribeAcceleratorAttributesOutput(&output, shape)
2075	if err != nil {
2076		var snapshot bytes.Buffer
2077		io.Copy(&snapshot, ringBuffer)
2078		err = &smithy.DeserializationError{
2079			Err:      fmt.Errorf("failed to decode response body, %w", err),
2080			Snapshot: snapshot.Bytes(),
2081		}
2082		return out, metadata, err
2083	}
2084
2085	return out, metadata, err
2086}
2087
2088func awsAwsjson11_deserializeOpErrorDescribeAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2089	var errorBuffer bytes.Buffer
2090	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2091		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2092	}
2093	errorBody := bytes.NewReader(errorBuffer.Bytes())
2094
2095	errorCode := "UnknownError"
2096	errorMessage := errorCode
2097
2098	code := response.Header.Get("X-Amzn-ErrorType")
2099	if len(code) != 0 {
2100		errorCode = restjson.SanitizeErrorCode(code)
2101	}
2102
2103	var buff [1024]byte
2104	ringBuffer := smithyio.NewRingBuffer(buff[:])
2105
2106	body := io.TeeReader(errorBody, ringBuffer)
2107	decoder := json.NewDecoder(body)
2108	decoder.UseNumber()
2109	code, message, err := restjson.GetErrorInfo(decoder)
2110	if err != nil {
2111		var snapshot bytes.Buffer
2112		io.Copy(&snapshot, ringBuffer)
2113		err = &smithy.DeserializationError{
2114			Err:      fmt.Errorf("failed to decode response body, %w", err),
2115			Snapshot: snapshot.Bytes(),
2116		}
2117		return err
2118	}
2119
2120	errorBody.Seek(0, io.SeekStart)
2121	if len(code) != 0 {
2122		errorCode = restjson.SanitizeErrorCode(code)
2123	}
2124	if len(message) != 0 {
2125		errorMessage = message
2126	}
2127
2128	switch {
2129	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
2130		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
2131
2132	case strings.EqualFold("InternalServiceErrorException", errorCode):
2133		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2134
2135	case strings.EqualFold("InvalidArgumentException", errorCode):
2136		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2137
2138	default:
2139		genericError := &smithy.GenericAPIError{
2140			Code:    errorCode,
2141			Message: errorMessage,
2142		}
2143		return genericError
2144
2145	}
2146}
2147
2148type awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator struct {
2149}
2150
2151func (*awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator) ID() string {
2152	return "OperationDeserializer"
2153}
2154
2155func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2156	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2157) {
2158	out, metadata, err = next.HandleDeserialize(ctx, in)
2159	if err != nil {
2160		return out, metadata, err
2161	}
2162
2163	response, ok := out.RawResponse.(*smithyhttp.Response)
2164	if !ok {
2165		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2166	}
2167
2168	if response.StatusCode < 200 || response.StatusCode >= 300 {
2169		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAccelerator(response, &metadata)
2170	}
2171	output := &DescribeCustomRoutingAcceleratorOutput{}
2172	out.Result = output
2173
2174	var buff [1024]byte
2175	ringBuffer := smithyio.NewRingBuffer(buff[:])
2176
2177	body := io.TeeReader(response.Body, ringBuffer)
2178	decoder := json.NewDecoder(body)
2179	decoder.UseNumber()
2180	var shape interface{}
2181	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2182		var snapshot bytes.Buffer
2183		io.Copy(&snapshot, ringBuffer)
2184		err = &smithy.DeserializationError{
2185			Err:      fmt.Errorf("failed to decode response body, %w", err),
2186			Snapshot: snapshot.Bytes(),
2187		}
2188		return out, metadata, err
2189	}
2190
2191	err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorOutput(&output, shape)
2192	if err != nil {
2193		var snapshot bytes.Buffer
2194		io.Copy(&snapshot, ringBuffer)
2195		err = &smithy.DeserializationError{
2196			Err:      fmt.Errorf("failed to decode response body, %w", err),
2197			Snapshot: snapshot.Bytes(),
2198		}
2199		return out, metadata, err
2200	}
2201
2202	return out, metadata, err
2203}
2204
2205func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2206	var errorBuffer bytes.Buffer
2207	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2208		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2209	}
2210	errorBody := bytes.NewReader(errorBuffer.Bytes())
2211
2212	errorCode := "UnknownError"
2213	errorMessage := errorCode
2214
2215	code := response.Header.Get("X-Amzn-ErrorType")
2216	if len(code) != 0 {
2217		errorCode = restjson.SanitizeErrorCode(code)
2218	}
2219
2220	var buff [1024]byte
2221	ringBuffer := smithyio.NewRingBuffer(buff[:])
2222
2223	body := io.TeeReader(errorBody, ringBuffer)
2224	decoder := json.NewDecoder(body)
2225	decoder.UseNumber()
2226	code, message, err := restjson.GetErrorInfo(decoder)
2227	if err != nil {
2228		var snapshot bytes.Buffer
2229		io.Copy(&snapshot, ringBuffer)
2230		err = &smithy.DeserializationError{
2231			Err:      fmt.Errorf("failed to decode response body, %w", err),
2232			Snapshot: snapshot.Bytes(),
2233		}
2234		return err
2235	}
2236
2237	errorBody.Seek(0, io.SeekStart)
2238	if len(code) != 0 {
2239		errorCode = restjson.SanitizeErrorCode(code)
2240	}
2241	if len(message) != 0 {
2242		errorMessage = message
2243	}
2244
2245	switch {
2246	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
2247		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
2248
2249	case strings.EqualFold("InternalServiceErrorException", errorCode):
2250		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2251
2252	case strings.EqualFold("InvalidArgumentException", errorCode):
2253		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2254
2255	default:
2256		genericError := &smithy.GenericAPIError{
2257			Code:    errorCode,
2258			Message: errorMessage,
2259		}
2260		return genericError
2261
2262	}
2263}
2264
2265type awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes struct {
2266}
2267
2268func (*awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes) ID() string {
2269	return "OperationDeserializer"
2270}
2271
2272func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2273	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2274) {
2275	out, metadata, err = next.HandleDeserialize(ctx, in)
2276	if err != nil {
2277		return out, metadata, err
2278	}
2279
2280	response, ok := out.RawResponse.(*smithyhttp.Response)
2281	if !ok {
2282		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2283	}
2284
2285	if response.StatusCode < 200 || response.StatusCode >= 300 {
2286		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAcceleratorAttributes(response, &metadata)
2287	}
2288	output := &DescribeCustomRoutingAcceleratorAttributesOutput{}
2289	out.Result = output
2290
2291	var buff [1024]byte
2292	ringBuffer := smithyio.NewRingBuffer(buff[:])
2293
2294	body := io.TeeReader(response.Body, ringBuffer)
2295	decoder := json.NewDecoder(body)
2296	decoder.UseNumber()
2297	var shape interface{}
2298	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2299		var snapshot bytes.Buffer
2300		io.Copy(&snapshot, ringBuffer)
2301		err = &smithy.DeserializationError{
2302			Err:      fmt.Errorf("failed to decode response body, %w", err),
2303			Snapshot: snapshot.Bytes(),
2304		}
2305		return out, metadata, err
2306	}
2307
2308	err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorAttributesOutput(&output, shape)
2309	if err != nil {
2310		var snapshot bytes.Buffer
2311		io.Copy(&snapshot, ringBuffer)
2312		err = &smithy.DeserializationError{
2313			Err:      fmt.Errorf("failed to decode response body, %w", err),
2314			Snapshot: snapshot.Bytes(),
2315		}
2316		return out, metadata, err
2317	}
2318
2319	return out, metadata, err
2320}
2321
2322func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2323	var errorBuffer bytes.Buffer
2324	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2325		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2326	}
2327	errorBody := bytes.NewReader(errorBuffer.Bytes())
2328
2329	errorCode := "UnknownError"
2330	errorMessage := errorCode
2331
2332	code := response.Header.Get("X-Amzn-ErrorType")
2333	if len(code) != 0 {
2334		errorCode = restjson.SanitizeErrorCode(code)
2335	}
2336
2337	var buff [1024]byte
2338	ringBuffer := smithyio.NewRingBuffer(buff[:])
2339
2340	body := io.TeeReader(errorBody, ringBuffer)
2341	decoder := json.NewDecoder(body)
2342	decoder.UseNumber()
2343	code, message, err := restjson.GetErrorInfo(decoder)
2344	if err != nil {
2345		var snapshot bytes.Buffer
2346		io.Copy(&snapshot, ringBuffer)
2347		err = &smithy.DeserializationError{
2348			Err:      fmt.Errorf("failed to decode response body, %w", err),
2349			Snapshot: snapshot.Bytes(),
2350		}
2351		return err
2352	}
2353
2354	errorBody.Seek(0, io.SeekStart)
2355	if len(code) != 0 {
2356		errorCode = restjson.SanitizeErrorCode(code)
2357	}
2358	if len(message) != 0 {
2359		errorMessage = message
2360	}
2361
2362	switch {
2363	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
2364		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
2365
2366	case strings.EqualFold("InternalServiceErrorException", errorCode):
2367		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2368
2369	case strings.EqualFold("InvalidArgumentException", errorCode):
2370		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2371
2372	default:
2373		genericError := &smithy.GenericAPIError{
2374			Code:    errorCode,
2375			Message: errorMessage,
2376		}
2377		return genericError
2378
2379	}
2380}
2381
2382type awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup struct {
2383}
2384
2385func (*awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup) ID() string {
2386	return "OperationDeserializer"
2387}
2388
2389func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2390	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2391) {
2392	out, metadata, err = next.HandleDeserialize(ctx, in)
2393	if err != nil {
2394		return out, metadata, err
2395	}
2396
2397	response, ok := out.RawResponse.(*smithyhttp.Response)
2398	if !ok {
2399		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2400	}
2401
2402	if response.StatusCode < 200 || response.StatusCode >= 300 {
2403		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingEndpointGroup(response, &metadata)
2404	}
2405	output := &DescribeCustomRoutingEndpointGroupOutput{}
2406	out.Result = output
2407
2408	var buff [1024]byte
2409	ringBuffer := smithyio.NewRingBuffer(buff[:])
2410
2411	body := io.TeeReader(response.Body, ringBuffer)
2412	decoder := json.NewDecoder(body)
2413	decoder.UseNumber()
2414	var shape interface{}
2415	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2416		var snapshot bytes.Buffer
2417		io.Copy(&snapshot, ringBuffer)
2418		err = &smithy.DeserializationError{
2419			Err:      fmt.Errorf("failed to decode response body, %w", err),
2420			Snapshot: snapshot.Bytes(),
2421		}
2422		return out, metadata, err
2423	}
2424
2425	err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingEndpointGroupOutput(&output, shape)
2426	if err != nil {
2427		var snapshot bytes.Buffer
2428		io.Copy(&snapshot, ringBuffer)
2429		err = &smithy.DeserializationError{
2430			Err:      fmt.Errorf("failed to decode response body, %w", err),
2431			Snapshot: snapshot.Bytes(),
2432		}
2433		return out, metadata, err
2434	}
2435
2436	return out, metadata, err
2437}
2438
2439func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2440	var errorBuffer bytes.Buffer
2441	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2442		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2443	}
2444	errorBody := bytes.NewReader(errorBuffer.Bytes())
2445
2446	errorCode := "UnknownError"
2447	errorMessage := errorCode
2448
2449	code := response.Header.Get("X-Amzn-ErrorType")
2450	if len(code) != 0 {
2451		errorCode = restjson.SanitizeErrorCode(code)
2452	}
2453
2454	var buff [1024]byte
2455	ringBuffer := smithyio.NewRingBuffer(buff[:])
2456
2457	body := io.TeeReader(errorBody, ringBuffer)
2458	decoder := json.NewDecoder(body)
2459	decoder.UseNumber()
2460	code, message, err := restjson.GetErrorInfo(decoder)
2461	if err != nil {
2462		var snapshot bytes.Buffer
2463		io.Copy(&snapshot, ringBuffer)
2464		err = &smithy.DeserializationError{
2465			Err:      fmt.Errorf("failed to decode response body, %w", err),
2466			Snapshot: snapshot.Bytes(),
2467		}
2468		return err
2469	}
2470
2471	errorBody.Seek(0, io.SeekStart)
2472	if len(code) != 0 {
2473		errorCode = restjson.SanitizeErrorCode(code)
2474	}
2475	if len(message) != 0 {
2476		errorMessage = message
2477	}
2478
2479	switch {
2480	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
2481		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
2482
2483	case strings.EqualFold("InternalServiceErrorException", errorCode):
2484		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2485
2486	case strings.EqualFold("InvalidArgumentException", errorCode):
2487		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2488
2489	default:
2490		genericError := &smithy.GenericAPIError{
2491			Code:    errorCode,
2492			Message: errorMessage,
2493		}
2494		return genericError
2495
2496	}
2497}
2498
2499type awsAwsjson11_deserializeOpDescribeCustomRoutingListener struct {
2500}
2501
2502func (*awsAwsjson11_deserializeOpDescribeCustomRoutingListener) ID() string {
2503	return "OperationDeserializer"
2504}
2505
2506func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2507	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2508) {
2509	out, metadata, err = next.HandleDeserialize(ctx, in)
2510	if err != nil {
2511		return out, metadata, err
2512	}
2513
2514	response, ok := out.RawResponse.(*smithyhttp.Response)
2515	if !ok {
2516		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2517	}
2518
2519	if response.StatusCode < 200 || response.StatusCode >= 300 {
2520		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingListener(response, &metadata)
2521	}
2522	output := &DescribeCustomRoutingListenerOutput{}
2523	out.Result = output
2524
2525	var buff [1024]byte
2526	ringBuffer := smithyio.NewRingBuffer(buff[:])
2527
2528	body := io.TeeReader(response.Body, ringBuffer)
2529	decoder := json.NewDecoder(body)
2530	decoder.UseNumber()
2531	var shape interface{}
2532	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2533		var snapshot bytes.Buffer
2534		io.Copy(&snapshot, ringBuffer)
2535		err = &smithy.DeserializationError{
2536			Err:      fmt.Errorf("failed to decode response body, %w", err),
2537			Snapshot: snapshot.Bytes(),
2538		}
2539		return out, metadata, err
2540	}
2541
2542	err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingListenerOutput(&output, shape)
2543	if err != nil {
2544		var snapshot bytes.Buffer
2545		io.Copy(&snapshot, ringBuffer)
2546		err = &smithy.DeserializationError{
2547			Err:      fmt.Errorf("failed to decode response body, %w", err),
2548			Snapshot: snapshot.Bytes(),
2549		}
2550		return out, metadata, err
2551	}
2552
2553	return out, metadata, err
2554}
2555
2556func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2557	var errorBuffer bytes.Buffer
2558	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2559		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2560	}
2561	errorBody := bytes.NewReader(errorBuffer.Bytes())
2562
2563	errorCode := "UnknownError"
2564	errorMessage := errorCode
2565
2566	code := response.Header.Get("X-Amzn-ErrorType")
2567	if len(code) != 0 {
2568		errorCode = restjson.SanitizeErrorCode(code)
2569	}
2570
2571	var buff [1024]byte
2572	ringBuffer := smithyio.NewRingBuffer(buff[:])
2573
2574	body := io.TeeReader(errorBody, ringBuffer)
2575	decoder := json.NewDecoder(body)
2576	decoder.UseNumber()
2577	code, message, err := restjson.GetErrorInfo(decoder)
2578	if err != nil {
2579		var snapshot bytes.Buffer
2580		io.Copy(&snapshot, ringBuffer)
2581		err = &smithy.DeserializationError{
2582			Err:      fmt.Errorf("failed to decode response body, %w", err),
2583			Snapshot: snapshot.Bytes(),
2584		}
2585		return err
2586	}
2587
2588	errorBody.Seek(0, io.SeekStart)
2589	if len(code) != 0 {
2590		errorCode = restjson.SanitizeErrorCode(code)
2591	}
2592	if len(message) != 0 {
2593		errorMessage = message
2594	}
2595
2596	switch {
2597	case strings.EqualFold("InternalServiceErrorException", errorCode):
2598		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2599
2600	case strings.EqualFold("InvalidArgumentException", errorCode):
2601		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2602
2603	case strings.EqualFold("ListenerNotFoundException", errorCode):
2604		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
2605
2606	default:
2607		genericError := &smithy.GenericAPIError{
2608			Code:    errorCode,
2609			Message: errorMessage,
2610		}
2611		return genericError
2612
2613	}
2614}
2615
2616type awsAwsjson11_deserializeOpDescribeEndpointGroup struct {
2617}
2618
2619func (*awsAwsjson11_deserializeOpDescribeEndpointGroup) ID() string {
2620	return "OperationDeserializer"
2621}
2622
2623func (m *awsAwsjson11_deserializeOpDescribeEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2624	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2625) {
2626	out, metadata, err = next.HandleDeserialize(ctx, in)
2627	if err != nil {
2628		return out, metadata, err
2629	}
2630
2631	response, ok := out.RawResponse.(*smithyhttp.Response)
2632	if !ok {
2633		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2634	}
2635
2636	if response.StatusCode < 200 || response.StatusCode >= 300 {
2637		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEndpointGroup(response, &metadata)
2638	}
2639	output := &DescribeEndpointGroupOutput{}
2640	out.Result = output
2641
2642	var buff [1024]byte
2643	ringBuffer := smithyio.NewRingBuffer(buff[:])
2644
2645	body := io.TeeReader(response.Body, ringBuffer)
2646	decoder := json.NewDecoder(body)
2647	decoder.UseNumber()
2648	var shape interface{}
2649	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2650		var snapshot bytes.Buffer
2651		io.Copy(&snapshot, ringBuffer)
2652		err = &smithy.DeserializationError{
2653			Err:      fmt.Errorf("failed to decode response body, %w", err),
2654			Snapshot: snapshot.Bytes(),
2655		}
2656		return out, metadata, err
2657	}
2658
2659	err = awsAwsjson11_deserializeOpDocumentDescribeEndpointGroupOutput(&output, shape)
2660	if err != nil {
2661		var snapshot bytes.Buffer
2662		io.Copy(&snapshot, ringBuffer)
2663		err = &smithy.DeserializationError{
2664			Err:      fmt.Errorf("failed to decode response body, %w", err),
2665			Snapshot: snapshot.Bytes(),
2666		}
2667		return out, metadata, err
2668	}
2669
2670	return out, metadata, err
2671}
2672
2673func awsAwsjson11_deserializeOpErrorDescribeEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2674	var errorBuffer bytes.Buffer
2675	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2676		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2677	}
2678	errorBody := bytes.NewReader(errorBuffer.Bytes())
2679
2680	errorCode := "UnknownError"
2681	errorMessage := errorCode
2682
2683	code := response.Header.Get("X-Amzn-ErrorType")
2684	if len(code) != 0 {
2685		errorCode = restjson.SanitizeErrorCode(code)
2686	}
2687
2688	var buff [1024]byte
2689	ringBuffer := smithyio.NewRingBuffer(buff[:])
2690
2691	body := io.TeeReader(errorBody, ringBuffer)
2692	decoder := json.NewDecoder(body)
2693	decoder.UseNumber()
2694	code, message, err := restjson.GetErrorInfo(decoder)
2695	if err != nil {
2696		var snapshot bytes.Buffer
2697		io.Copy(&snapshot, ringBuffer)
2698		err = &smithy.DeserializationError{
2699			Err:      fmt.Errorf("failed to decode response body, %w", err),
2700			Snapshot: snapshot.Bytes(),
2701		}
2702		return err
2703	}
2704
2705	errorBody.Seek(0, io.SeekStart)
2706	if len(code) != 0 {
2707		errorCode = restjson.SanitizeErrorCode(code)
2708	}
2709	if len(message) != 0 {
2710		errorMessage = message
2711	}
2712
2713	switch {
2714	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
2715		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
2716
2717	case strings.EqualFold("InternalServiceErrorException", errorCode):
2718		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2719
2720	case strings.EqualFold("InvalidArgumentException", errorCode):
2721		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2722
2723	default:
2724		genericError := &smithy.GenericAPIError{
2725			Code:    errorCode,
2726			Message: errorMessage,
2727		}
2728		return genericError
2729
2730	}
2731}
2732
2733type awsAwsjson11_deserializeOpDescribeListener struct {
2734}
2735
2736func (*awsAwsjson11_deserializeOpDescribeListener) ID() string {
2737	return "OperationDeserializer"
2738}
2739
2740func (m *awsAwsjson11_deserializeOpDescribeListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2741	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2742) {
2743	out, metadata, err = next.HandleDeserialize(ctx, in)
2744	if err != nil {
2745		return out, metadata, err
2746	}
2747
2748	response, ok := out.RawResponse.(*smithyhttp.Response)
2749	if !ok {
2750		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2751	}
2752
2753	if response.StatusCode < 200 || response.StatusCode >= 300 {
2754		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeListener(response, &metadata)
2755	}
2756	output := &DescribeListenerOutput{}
2757	out.Result = output
2758
2759	var buff [1024]byte
2760	ringBuffer := smithyio.NewRingBuffer(buff[:])
2761
2762	body := io.TeeReader(response.Body, ringBuffer)
2763	decoder := json.NewDecoder(body)
2764	decoder.UseNumber()
2765	var shape interface{}
2766	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2767		var snapshot bytes.Buffer
2768		io.Copy(&snapshot, ringBuffer)
2769		err = &smithy.DeserializationError{
2770			Err:      fmt.Errorf("failed to decode response body, %w", err),
2771			Snapshot: snapshot.Bytes(),
2772		}
2773		return out, metadata, err
2774	}
2775
2776	err = awsAwsjson11_deserializeOpDocumentDescribeListenerOutput(&output, shape)
2777	if err != nil {
2778		var snapshot bytes.Buffer
2779		io.Copy(&snapshot, ringBuffer)
2780		err = &smithy.DeserializationError{
2781			Err:      fmt.Errorf("failed to decode response body, %w", err),
2782			Snapshot: snapshot.Bytes(),
2783		}
2784		return out, metadata, err
2785	}
2786
2787	return out, metadata, err
2788}
2789
2790func awsAwsjson11_deserializeOpErrorDescribeListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2791	var errorBuffer bytes.Buffer
2792	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2793		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2794	}
2795	errorBody := bytes.NewReader(errorBuffer.Bytes())
2796
2797	errorCode := "UnknownError"
2798	errorMessage := errorCode
2799
2800	code := response.Header.Get("X-Amzn-ErrorType")
2801	if len(code) != 0 {
2802		errorCode = restjson.SanitizeErrorCode(code)
2803	}
2804
2805	var buff [1024]byte
2806	ringBuffer := smithyio.NewRingBuffer(buff[:])
2807
2808	body := io.TeeReader(errorBody, ringBuffer)
2809	decoder := json.NewDecoder(body)
2810	decoder.UseNumber()
2811	code, message, err := restjson.GetErrorInfo(decoder)
2812	if err != nil {
2813		var snapshot bytes.Buffer
2814		io.Copy(&snapshot, ringBuffer)
2815		err = &smithy.DeserializationError{
2816			Err:      fmt.Errorf("failed to decode response body, %w", err),
2817			Snapshot: snapshot.Bytes(),
2818		}
2819		return err
2820	}
2821
2822	errorBody.Seek(0, io.SeekStart)
2823	if len(code) != 0 {
2824		errorCode = restjson.SanitizeErrorCode(code)
2825	}
2826	if len(message) != 0 {
2827		errorMessage = message
2828	}
2829
2830	switch {
2831	case strings.EqualFold("InternalServiceErrorException", errorCode):
2832		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2833
2834	case strings.EqualFold("InvalidArgumentException", errorCode):
2835		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2836
2837	case strings.EqualFold("ListenerNotFoundException", errorCode):
2838		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
2839
2840	default:
2841		genericError := &smithy.GenericAPIError{
2842			Code:    errorCode,
2843			Message: errorMessage,
2844		}
2845		return genericError
2846
2847	}
2848}
2849
2850type awsAwsjson11_deserializeOpListAccelerators struct {
2851}
2852
2853func (*awsAwsjson11_deserializeOpListAccelerators) ID() string {
2854	return "OperationDeserializer"
2855}
2856
2857func (m *awsAwsjson11_deserializeOpListAccelerators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2858	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2859) {
2860	out, metadata, err = next.HandleDeserialize(ctx, in)
2861	if err != nil {
2862		return out, metadata, err
2863	}
2864
2865	response, ok := out.RawResponse.(*smithyhttp.Response)
2866	if !ok {
2867		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2868	}
2869
2870	if response.StatusCode < 200 || response.StatusCode >= 300 {
2871		return out, metadata, awsAwsjson11_deserializeOpErrorListAccelerators(response, &metadata)
2872	}
2873	output := &ListAcceleratorsOutput{}
2874	out.Result = output
2875
2876	var buff [1024]byte
2877	ringBuffer := smithyio.NewRingBuffer(buff[:])
2878
2879	body := io.TeeReader(response.Body, ringBuffer)
2880	decoder := json.NewDecoder(body)
2881	decoder.UseNumber()
2882	var shape interface{}
2883	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2884		var snapshot bytes.Buffer
2885		io.Copy(&snapshot, ringBuffer)
2886		err = &smithy.DeserializationError{
2887			Err:      fmt.Errorf("failed to decode response body, %w", err),
2888			Snapshot: snapshot.Bytes(),
2889		}
2890		return out, metadata, err
2891	}
2892
2893	err = awsAwsjson11_deserializeOpDocumentListAcceleratorsOutput(&output, shape)
2894	if err != nil {
2895		var snapshot bytes.Buffer
2896		io.Copy(&snapshot, ringBuffer)
2897		err = &smithy.DeserializationError{
2898			Err:      fmt.Errorf("failed to decode response body, %w", err),
2899			Snapshot: snapshot.Bytes(),
2900		}
2901		return out, metadata, err
2902	}
2903
2904	return out, metadata, err
2905}
2906
2907func awsAwsjson11_deserializeOpErrorListAccelerators(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2908	var errorBuffer bytes.Buffer
2909	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2910		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2911	}
2912	errorBody := bytes.NewReader(errorBuffer.Bytes())
2913
2914	errorCode := "UnknownError"
2915	errorMessage := errorCode
2916
2917	code := response.Header.Get("X-Amzn-ErrorType")
2918	if len(code) != 0 {
2919		errorCode = restjson.SanitizeErrorCode(code)
2920	}
2921
2922	var buff [1024]byte
2923	ringBuffer := smithyio.NewRingBuffer(buff[:])
2924
2925	body := io.TeeReader(errorBody, ringBuffer)
2926	decoder := json.NewDecoder(body)
2927	decoder.UseNumber()
2928	code, message, err := restjson.GetErrorInfo(decoder)
2929	if err != nil {
2930		var snapshot bytes.Buffer
2931		io.Copy(&snapshot, ringBuffer)
2932		err = &smithy.DeserializationError{
2933			Err:      fmt.Errorf("failed to decode response body, %w", err),
2934			Snapshot: snapshot.Bytes(),
2935		}
2936		return err
2937	}
2938
2939	errorBody.Seek(0, io.SeekStart)
2940	if len(code) != 0 {
2941		errorCode = restjson.SanitizeErrorCode(code)
2942	}
2943	if len(message) != 0 {
2944		errorMessage = message
2945	}
2946
2947	switch {
2948	case strings.EqualFold("InternalServiceErrorException", errorCode):
2949		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2950
2951	case strings.EqualFold("InvalidArgumentException", errorCode):
2952		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
2953
2954	case strings.EqualFold("InvalidNextTokenException", errorCode):
2955		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
2956
2957	default:
2958		genericError := &smithy.GenericAPIError{
2959			Code:    errorCode,
2960			Message: errorMessage,
2961		}
2962		return genericError
2963
2964	}
2965}
2966
2967type awsAwsjson11_deserializeOpListByoipCidrs struct {
2968}
2969
2970func (*awsAwsjson11_deserializeOpListByoipCidrs) ID() string {
2971	return "OperationDeserializer"
2972}
2973
2974func (m *awsAwsjson11_deserializeOpListByoipCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2975	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2976) {
2977	out, metadata, err = next.HandleDeserialize(ctx, in)
2978	if err != nil {
2979		return out, metadata, err
2980	}
2981
2982	response, ok := out.RawResponse.(*smithyhttp.Response)
2983	if !ok {
2984		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2985	}
2986
2987	if response.StatusCode < 200 || response.StatusCode >= 300 {
2988		return out, metadata, awsAwsjson11_deserializeOpErrorListByoipCidrs(response, &metadata)
2989	}
2990	output := &ListByoipCidrsOutput{}
2991	out.Result = output
2992
2993	var buff [1024]byte
2994	ringBuffer := smithyio.NewRingBuffer(buff[:])
2995
2996	body := io.TeeReader(response.Body, ringBuffer)
2997	decoder := json.NewDecoder(body)
2998	decoder.UseNumber()
2999	var shape interface{}
3000	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3001		var snapshot bytes.Buffer
3002		io.Copy(&snapshot, ringBuffer)
3003		err = &smithy.DeserializationError{
3004			Err:      fmt.Errorf("failed to decode response body, %w", err),
3005			Snapshot: snapshot.Bytes(),
3006		}
3007		return out, metadata, err
3008	}
3009
3010	err = awsAwsjson11_deserializeOpDocumentListByoipCidrsOutput(&output, shape)
3011	if err != nil {
3012		var snapshot bytes.Buffer
3013		io.Copy(&snapshot, ringBuffer)
3014		err = &smithy.DeserializationError{
3015			Err:      fmt.Errorf("failed to decode response body, %w", err),
3016			Snapshot: snapshot.Bytes(),
3017		}
3018		return out, metadata, err
3019	}
3020
3021	return out, metadata, err
3022}
3023
3024func awsAwsjson11_deserializeOpErrorListByoipCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3025	var errorBuffer bytes.Buffer
3026	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3027		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3028	}
3029	errorBody := bytes.NewReader(errorBuffer.Bytes())
3030
3031	errorCode := "UnknownError"
3032	errorMessage := errorCode
3033
3034	code := response.Header.Get("X-Amzn-ErrorType")
3035	if len(code) != 0 {
3036		errorCode = restjson.SanitizeErrorCode(code)
3037	}
3038
3039	var buff [1024]byte
3040	ringBuffer := smithyio.NewRingBuffer(buff[:])
3041
3042	body := io.TeeReader(errorBody, ringBuffer)
3043	decoder := json.NewDecoder(body)
3044	decoder.UseNumber()
3045	code, message, err := restjson.GetErrorInfo(decoder)
3046	if err != nil {
3047		var snapshot bytes.Buffer
3048		io.Copy(&snapshot, ringBuffer)
3049		err = &smithy.DeserializationError{
3050			Err:      fmt.Errorf("failed to decode response body, %w", err),
3051			Snapshot: snapshot.Bytes(),
3052		}
3053		return err
3054	}
3055
3056	errorBody.Seek(0, io.SeekStart)
3057	if len(code) != 0 {
3058		errorCode = restjson.SanitizeErrorCode(code)
3059	}
3060	if len(message) != 0 {
3061		errorMessage = message
3062	}
3063
3064	switch {
3065	case strings.EqualFold("AccessDeniedException", errorCode):
3066		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3067
3068	case strings.EqualFold("InternalServiceErrorException", errorCode):
3069		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3070
3071	case strings.EqualFold("InvalidArgumentException", errorCode):
3072		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3073
3074	case strings.EqualFold("InvalidNextTokenException", errorCode):
3075		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3076
3077	default:
3078		genericError := &smithy.GenericAPIError{
3079			Code:    errorCode,
3080			Message: errorMessage,
3081		}
3082		return genericError
3083
3084	}
3085}
3086
3087type awsAwsjson11_deserializeOpListCustomRoutingAccelerators struct {
3088}
3089
3090func (*awsAwsjson11_deserializeOpListCustomRoutingAccelerators) ID() string {
3091	return "OperationDeserializer"
3092}
3093
3094func (m *awsAwsjson11_deserializeOpListCustomRoutingAccelerators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3095	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3096) {
3097	out, metadata, err = next.HandleDeserialize(ctx, in)
3098	if err != nil {
3099		return out, metadata, err
3100	}
3101
3102	response, ok := out.RawResponse.(*smithyhttp.Response)
3103	if !ok {
3104		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3105	}
3106
3107	if response.StatusCode < 200 || response.StatusCode >= 300 {
3108		return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingAccelerators(response, &metadata)
3109	}
3110	output := &ListCustomRoutingAcceleratorsOutput{}
3111	out.Result = output
3112
3113	var buff [1024]byte
3114	ringBuffer := smithyio.NewRingBuffer(buff[:])
3115
3116	body := io.TeeReader(response.Body, ringBuffer)
3117	decoder := json.NewDecoder(body)
3118	decoder.UseNumber()
3119	var shape interface{}
3120	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3121		var snapshot bytes.Buffer
3122		io.Copy(&snapshot, ringBuffer)
3123		err = &smithy.DeserializationError{
3124			Err:      fmt.Errorf("failed to decode response body, %w", err),
3125			Snapshot: snapshot.Bytes(),
3126		}
3127		return out, metadata, err
3128	}
3129
3130	err = awsAwsjson11_deserializeOpDocumentListCustomRoutingAcceleratorsOutput(&output, shape)
3131	if err != nil {
3132		var snapshot bytes.Buffer
3133		io.Copy(&snapshot, ringBuffer)
3134		err = &smithy.DeserializationError{
3135			Err:      fmt.Errorf("failed to decode response body, %w", err),
3136			Snapshot: snapshot.Bytes(),
3137		}
3138		return out, metadata, err
3139	}
3140
3141	return out, metadata, err
3142}
3143
3144func awsAwsjson11_deserializeOpErrorListCustomRoutingAccelerators(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3145	var errorBuffer bytes.Buffer
3146	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3147		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3148	}
3149	errorBody := bytes.NewReader(errorBuffer.Bytes())
3150
3151	errorCode := "UnknownError"
3152	errorMessage := errorCode
3153
3154	code := response.Header.Get("X-Amzn-ErrorType")
3155	if len(code) != 0 {
3156		errorCode = restjson.SanitizeErrorCode(code)
3157	}
3158
3159	var buff [1024]byte
3160	ringBuffer := smithyio.NewRingBuffer(buff[:])
3161
3162	body := io.TeeReader(errorBody, ringBuffer)
3163	decoder := json.NewDecoder(body)
3164	decoder.UseNumber()
3165	code, message, err := restjson.GetErrorInfo(decoder)
3166	if err != nil {
3167		var snapshot bytes.Buffer
3168		io.Copy(&snapshot, ringBuffer)
3169		err = &smithy.DeserializationError{
3170			Err:      fmt.Errorf("failed to decode response body, %w", err),
3171			Snapshot: snapshot.Bytes(),
3172		}
3173		return err
3174	}
3175
3176	errorBody.Seek(0, io.SeekStart)
3177	if len(code) != 0 {
3178		errorCode = restjson.SanitizeErrorCode(code)
3179	}
3180	if len(message) != 0 {
3181		errorMessage = message
3182	}
3183
3184	switch {
3185	case strings.EqualFold("InternalServiceErrorException", errorCode):
3186		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3187
3188	case strings.EqualFold("InvalidArgumentException", errorCode):
3189		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3190
3191	case strings.EqualFold("InvalidNextTokenException", errorCode):
3192		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3193
3194	default:
3195		genericError := &smithy.GenericAPIError{
3196			Code:    errorCode,
3197			Message: errorMessage,
3198		}
3199		return genericError
3200
3201	}
3202}
3203
3204type awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups struct {
3205}
3206
3207func (*awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups) ID() string {
3208	return "OperationDeserializer"
3209}
3210
3211func (m *awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3212	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3213) {
3214	out, metadata, err = next.HandleDeserialize(ctx, in)
3215	if err != nil {
3216		return out, metadata, err
3217	}
3218
3219	response, ok := out.RawResponse.(*smithyhttp.Response)
3220	if !ok {
3221		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3222	}
3223
3224	if response.StatusCode < 200 || response.StatusCode >= 300 {
3225		return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingEndpointGroups(response, &metadata)
3226	}
3227	output := &ListCustomRoutingEndpointGroupsOutput{}
3228	out.Result = output
3229
3230	var buff [1024]byte
3231	ringBuffer := smithyio.NewRingBuffer(buff[:])
3232
3233	body := io.TeeReader(response.Body, ringBuffer)
3234	decoder := json.NewDecoder(body)
3235	decoder.UseNumber()
3236	var shape interface{}
3237	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3238		var snapshot bytes.Buffer
3239		io.Copy(&snapshot, ringBuffer)
3240		err = &smithy.DeserializationError{
3241			Err:      fmt.Errorf("failed to decode response body, %w", err),
3242			Snapshot: snapshot.Bytes(),
3243		}
3244		return out, metadata, err
3245	}
3246
3247	err = awsAwsjson11_deserializeOpDocumentListCustomRoutingEndpointGroupsOutput(&output, shape)
3248	if err != nil {
3249		var snapshot bytes.Buffer
3250		io.Copy(&snapshot, ringBuffer)
3251		err = &smithy.DeserializationError{
3252			Err:      fmt.Errorf("failed to decode response body, %w", err),
3253			Snapshot: snapshot.Bytes(),
3254		}
3255		return out, metadata, err
3256	}
3257
3258	return out, metadata, err
3259}
3260
3261func awsAwsjson11_deserializeOpErrorListCustomRoutingEndpointGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3262	var errorBuffer bytes.Buffer
3263	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3264		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3265	}
3266	errorBody := bytes.NewReader(errorBuffer.Bytes())
3267
3268	errorCode := "UnknownError"
3269	errorMessage := errorCode
3270
3271	code := response.Header.Get("X-Amzn-ErrorType")
3272	if len(code) != 0 {
3273		errorCode = restjson.SanitizeErrorCode(code)
3274	}
3275
3276	var buff [1024]byte
3277	ringBuffer := smithyio.NewRingBuffer(buff[:])
3278
3279	body := io.TeeReader(errorBody, ringBuffer)
3280	decoder := json.NewDecoder(body)
3281	decoder.UseNumber()
3282	code, message, err := restjson.GetErrorInfo(decoder)
3283	if err != nil {
3284		var snapshot bytes.Buffer
3285		io.Copy(&snapshot, ringBuffer)
3286		err = &smithy.DeserializationError{
3287			Err:      fmt.Errorf("failed to decode response body, %w", err),
3288			Snapshot: snapshot.Bytes(),
3289		}
3290		return err
3291	}
3292
3293	errorBody.Seek(0, io.SeekStart)
3294	if len(code) != 0 {
3295		errorCode = restjson.SanitizeErrorCode(code)
3296	}
3297	if len(message) != 0 {
3298		errorMessage = message
3299	}
3300
3301	switch {
3302	case strings.EqualFold("InternalServiceErrorException", errorCode):
3303		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3304
3305	case strings.EqualFold("InvalidArgumentException", errorCode):
3306		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3307
3308	case strings.EqualFold("InvalidNextTokenException", errorCode):
3309		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3310
3311	case strings.EqualFold("ListenerNotFoundException", errorCode):
3312		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
3313
3314	default:
3315		genericError := &smithy.GenericAPIError{
3316			Code:    errorCode,
3317			Message: errorMessage,
3318		}
3319		return genericError
3320
3321	}
3322}
3323
3324type awsAwsjson11_deserializeOpListCustomRoutingListeners struct {
3325}
3326
3327func (*awsAwsjson11_deserializeOpListCustomRoutingListeners) ID() string {
3328	return "OperationDeserializer"
3329}
3330
3331func (m *awsAwsjson11_deserializeOpListCustomRoutingListeners) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3332	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3333) {
3334	out, metadata, err = next.HandleDeserialize(ctx, in)
3335	if err != nil {
3336		return out, metadata, err
3337	}
3338
3339	response, ok := out.RawResponse.(*smithyhttp.Response)
3340	if !ok {
3341		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3342	}
3343
3344	if response.StatusCode < 200 || response.StatusCode >= 300 {
3345		return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingListeners(response, &metadata)
3346	}
3347	output := &ListCustomRoutingListenersOutput{}
3348	out.Result = output
3349
3350	var buff [1024]byte
3351	ringBuffer := smithyio.NewRingBuffer(buff[:])
3352
3353	body := io.TeeReader(response.Body, ringBuffer)
3354	decoder := json.NewDecoder(body)
3355	decoder.UseNumber()
3356	var shape interface{}
3357	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3358		var snapshot bytes.Buffer
3359		io.Copy(&snapshot, ringBuffer)
3360		err = &smithy.DeserializationError{
3361			Err:      fmt.Errorf("failed to decode response body, %w", err),
3362			Snapshot: snapshot.Bytes(),
3363		}
3364		return out, metadata, err
3365	}
3366
3367	err = awsAwsjson11_deserializeOpDocumentListCustomRoutingListenersOutput(&output, shape)
3368	if err != nil {
3369		var snapshot bytes.Buffer
3370		io.Copy(&snapshot, ringBuffer)
3371		err = &smithy.DeserializationError{
3372			Err:      fmt.Errorf("failed to decode response body, %w", err),
3373			Snapshot: snapshot.Bytes(),
3374		}
3375		return out, metadata, err
3376	}
3377
3378	return out, metadata, err
3379}
3380
3381func awsAwsjson11_deserializeOpErrorListCustomRoutingListeners(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3382	var errorBuffer bytes.Buffer
3383	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3384		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3385	}
3386	errorBody := bytes.NewReader(errorBuffer.Bytes())
3387
3388	errorCode := "UnknownError"
3389	errorMessage := errorCode
3390
3391	code := response.Header.Get("X-Amzn-ErrorType")
3392	if len(code) != 0 {
3393		errorCode = restjson.SanitizeErrorCode(code)
3394	}
3395
3396	var buff [1024]byte
3397	ringBuffer := smithyio.NewRingBuffer(buff[:])
3398
3399	body := io.TeeReader(errorBody, ringBuffer)
3400	decoder := json.NewDecoder(body)
3401	decoder.UseNumber()
3402	code, message, err := restjson.GetErrorInfo(decoder)
3403	if err != nil {
3404		var snapshot bytes.Buffer
3405		io.Copy(&snapshot, ringBuffer)
3406		err = &smithy.DeserializationError{
3407			Err:      fmt.Errorf("failed to decode response body, %w", err),
3408			Snapshot: snapshot.Bytes(),
3409		}
3410		return err
3411	}
3412
3413	errorBody.Seek(0, io.SeekStart)
3414	if len(code) != 0 {
3415		errorCode = restjson.SanitizeErrorCode(code)
3416	}
3417	if len(message) != 0 {
3418		errorMessage = message
3419	}
3420
3421	switch {
3422	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
3423		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
3424
3425	case strings.EqualFold("InternalServiceErrorException", errorCode):
3426		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3427
3428	case strings.EqualFold("InvalidArgumentException", errorCode):
3429		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3430
3431	case strings.EqualFold("InvalidNextTokenException", errorCode):
3432		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3433
3434	default:
3435		genericError := &smithy.GenericAPIError{
3436			Code:    errorCode,
3437			Message: errorMessage,
3438		}
3439		return genericError
3440
3441	}
3442}
3443
3444type awsAwsjson11_deserializeOpListCustomRoutingPortMappings struct {
3445}
3446
3447func (*awsAwsjson11_deserializeOpListCustomRoutingPortMappings) ID() string {
3448	return "OperationDeserializer"
3449}
3450
3451func (m *awsAwsjson11_deserializeOpListCustomRoutingPortMappings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3452	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3453) {
3454	out, metadata, err = next.HandleDeserialize(ctx, in)
3455	if err != nil {
3456		return out, metadata, err
3457	}
3458
3459	response, ok := out.RawResponse.(*smithyhttp.Response)
3460	if !ok {
3461		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3462	}
3463
3464	if response.StatusCode < 200 || response.StatusCode >= 300 {
3465		return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappings(response, &metadata)
3466	}
3467	output := &ListCustomRoutingPortMappingsOutput{}
3468	out.Result = output
3469
3470	var buff [1024]byte
3471	ringBuffer := smithyio.NewRingBuffer(buff[:])
3472
3473	body := io.TeeReader(response.Body, ringBuffer)
3474	decoder := json.NewDecoder(body)
3475	decoder.UseNumber()
3476	var shape interface{}
3477	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3478		var snapshot bytes.Buffer
3479		io.Copy(&snapshot, ringBuffer)
3480		err = &smithy.DeserializationError{
3481			Err:      fmt.Errorf("failed to decode response body, %w", err),
3482			Snapshot: snapshot.Bytes(),
3483		}
3484		return out, metadata, err
3485	}
3486
3487	err = awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsOutput(&output, shape)
3488	if err != nil {
3489		var snapshot bytes.Buffer
3490		io.Copy(&snapshot, ringBuffer)
3491		err = &smithy.DeserializationError{
3492			Err:      fmt.Errorf("failed to decode response body, %w", err),
3493			Snapshot: snapshot.Bytes(),
3494		}
3495		return out, metadata, err
3496	}
3497
3498	return out, metadata, err
3499}
3500
3501func awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3502	var errorBuffer bytes.Buffer
3503	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3504		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3505	}
3506	errorBody := bytes.NewReader(errorBuffer.Bytes())
3507
3508	errorCode := "UnknownError"
3509	errorMessage := errorCode
3510
3511	code := response.Header.Get("X-Amzn-ErrorType")
3512	if len(code) != 0 {
3513		errorCode = restjson.SanitizeErrorCode(code)
3514	}
3515
3516	var buff [1024]byte
3517	ringBuffer := smithyio.NewRingBuffer(buff[:])
3518
3519	body := io.TeeReader(errorBody, ringBuffer)
3520	decoder := json.NewDecoder(body)
3521	decoder.UseNumber()
3522	code, message, err := restjson.GetErrorInfo(decoder)
3523	if err != nil {
3524		var snapshot bytes.Buffer
3525		io.Copy(&snapshot, ringBuffer)
3526		err = &smithy.DeserializationError{
3527			Err:      fmt.Errorf("failed to decode response body, %w", err),
3528			Snapshot: snapshot.Bytes(),
3529		}
3530		return err
3531	}
3532
3533	errorBody.Seek(0, io.SeekStart)
3534	if len(code) != 0 {
3535		errorCode = restjson.SanitizeErrorCode(code)
3536	}
3537	if len(message) != 0 {
3538		errorMessage = message
3539	}
3540
3541	switch {
3542	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
3543		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
3544
3545	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
3546		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
3547
3548	case strings.EqualFold("InternalServiceErrorException", errorCode):
3549		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3550
3551	case strings.EqualFold("InvalidArgumentException", errorCode):
3552		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3553
3554	case strings.EqualFold("InvalidNextTokenException", errorCode):
3555		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3556
3557	default:
3558		genericError := &smithy.GenericAPIError{
3559			Code:    errorCode,
3560			Message: errorMessage,
3561		}
3562		return genericError
3563
3564	}
3565}
3566
3567type awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination struct {
3568}
3569
3570func (*awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination) ID() string {
3571	return "OperationDeserializer"
3572}
3573
3574func (m *awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3575	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3576) {
3577	out, metadata, err = next.HandleDeserialize(ctx, in)
3578	if err != nil {
3579		return out, metadata, err
3580	}
3581
3582	response, ok := out.RawResponse.(*smithyhttp.Response)
3583	if !ok {
3584		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3585	}
3586
3587	if response.StatusCode < 200 || response.StatusCode >= 300 {
3588		return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappingsByDestination(response, &metadata)
3589	}
3590	output := &ListCustomRoutingPortMappingsByDestinationOutput{}
3591	out.Result = output
3592
3593	var buff [1024]byte
3594	ringBuffer := smithyio.NewRingBuffer(buff[:])
3595
3596	body := io.TeeReader(response.Body, ringBuffer)
3597	decoder := json.NewDecoder(body)
3598	decoder.UseNumber()
3599	var shape interface{}
3600	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3601		var snapshot bytes.Buffer
3602		io.Copy(&snapshot, ringBuffer)
3603		err = &smithy.DeserializationError{
3604			Err:      fmt.Errorf("failed to decode response body, %w", err),
3605			Snapshot: snapshot.Bytes(),
3606		}
3607		return out, metadata, err
3608	}
3609
3610	err = awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsByDestinationOutput(&output, shape)
3611	if err != nil {
3612		var snapshot bytes.Buffer
3613		io.Copy(&snapshot, ringBuffer)
3614		err = &smithy.DeserializationError{
3615			Err:      fmt.Errorf("failed to decode response body, %w", err),
3616			Snapshot: snapshot.Bytes(),
3617		}
3618		return out, metadata, err
3619	}
3620
3621	return out, metadata, err
3622}
3623
3624func awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappingsByDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3625	var errorBuffer bytes.Buffer
3626	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3627		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3628	}
3629	errorBody := bytes.NewReader(errorBuffer.Bytes())
3630
3631	errorCode := "UnknownError"
3632	errorMessage := errorCode
3633
3634	code := response.Header.Get("X-Amzn-ErrorType")
3635	if len(code) != 0 {
3636		errorCode = restjson.SanitizeErrorCode(code)
3637	}
3638
3639	var buff [1024]byte
3640	ringBuffer := smithyio.NewRingBuffer(buff[:])
3641
3642	body := io.TeeReader(errorBody, ringBuffer)
3643	decoder := json.NewDecoder(body)
3644	decoder.UseNumber()
3645	code, message, err := restjson.GetErrorInfo(decoder)
3646	if err != nil {
3647		var snapshot bytes.Buffer
3648		io.Copy(&snapshot, ringBuffer)
3649		err = &smithy.DeserializationError{
3650			Err:      fmt.Errorf("failed to decode response body, %w", err),
3651			Snapshot: snapshot.Bytes(),
3652		}
3653		return err
3654	}
3655
3656	errorBody.Seek(0, io.SeekStart)
3657	if len(code) != 0 {
3658		errorCode = restjson.SanitizeErrorCode(code)
3659	}
3660	if len(message) != 0 {
3661		errorMessage = message
3662	}
3663
3664	switch {
3665	case strings.EqualFold("EndpointNotFoundException", errorCode):
3666		return awsAwsjson11_deserializeErrorEndpointNotFoundException(response, errorBody)
3667
3668	case strings.EqualFold("InternalServiceErrorException", errorCode):
3669		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3670
3671	case strings.EqualFold("InvalidArgumentException", errorCode):
3672		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3673
3674	case strings.EqualFold("InvalidNextTokenException", errorCode):
3675		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3676
3677	default:
3678		genericError := &smithy.GenericAPIError{
3679			Code:    errorCode,
3680			Message: errorMessage,
3681		}
3682		return genericError
3683
3684	}
3685}
3686
3687type awsAwsjson11_deserializeOpListEndpointGroups struct {
3688}
3689
3690func (*awsAwsjson11_deserializeOpListEndpointGroups) ID() string {
3691	return "OperationDeserializer"
3692}
3693
3694func (m *awsAwsjson11_deserializeOpListEndpointGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3695	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3696) {
3697	out, metadata, err = next.HandleDeserialize(ctx, in)
3698	if err != nil {
3699		return out, metadata, err
3700	}
3701
3702	response, ok := out.RawResponse.(*smithyhttp.Response)
3703	if !ok {
3704		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3705	}
3706
3707	if response.StatusCode < 200 || response.StatusCode >= 300 {
3708		return out, metadata, awsAwsjson11_deserializeOpErrorListEndpointGroups(response, &metadata)
3709	}
3710	output := &ListEndpointGroupsOutput{}
3711	out.Result = output
3712
3713	var buff [1024]byte
3714	ringBuffer := smithyio.NewRingBuffer(buff[:])
3715
3716	body := io.TeeReader(response.Body, ringBuffer)
3717	decoder := json.NewDecoder(body)
3718	decoder.UseNumber()
3719	var shape interface{}
3720	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3721		var snapshot bytes.Buffer
3722		io.Copy(&snapshot, ringBuffer)
3723		err = &smithy.DeserializationError{
3724			Err:      fmt.Errorf("failed to decode response body, %w", err),
3725			Snapshot: snapshot.Bytes(),
3726		}
3727		return out, metadata, err
3728	}
3729
3730	err = awsAwsjson11_deserializeOpDocumentListEndpointGroupsOutput(&output, shape)
3731	if err != nil {
3732		var snapshot bytes.Buffer
3733		io.Copy(&snapshot, ringBuffer)
3734		err = &smithy.DeserializationError{
3735			Err:      fmt.Errorf("failed to decode response body, %w", err),
3736			Snapshot: snapshot.Bytes(),
3737		}
3738		return out, metadata, err
3739	}
3740
3741	return out, metadata, err
3742}
3743
3744func awsAwsjson11_deserializeOpErrorListEndpointGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3745	var errorBuffer bytes.Buffer
3746	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3747		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3748	}
3749	errorBody := bytes.NewReader(errorBuffer.Bytes())
3750
3751	errorCode := "UnknownError"
3752	errorMessage := errorCode
3753
3754	code := response.Header.Get("X-Amzn-ErrorType")
3755	if len(code) != 0 {
3756		errorCode = restjson.SanitizeErrorCode(code)
3757	}
3758
3759	var buff [1024]byte
3760	ringBuffer := smithyio.NewRingBuffer(buff[:])
3761
3762	body := io.TeeReader(errorBody, ringBuffer)
3763	decoder := json.NewDecoder(body)
3764	decoder.UseNumber()
3765	code, message, err := restjson.GetErrorInfo(decoder)
3766	if err != nil {
3767		var snapshot bytes.Buffer
3768		io.Copy(&snapshot, ringBuffer)
3769		err = &smithy.DeserializationError{
3770			Err:      fmt.Errorf("failed to decode response body, %w", err),
3771			Snapshot: snapshot.Bytes(),
3772		}
3773		return err
3774	}
3775
3776	errorBody.Seek(0, io.SeekStart)
3777	if len(code) != 0 {
3778		errorCode = restjson.SanitizeErrorCode(code)
3779	}
3780	if len(message) != 0 {
3781		errorMessage = message
3782	}
3783
3784	switch {
3785	case strings.EqualFold("InternalServiceErrorException", errorCode):
3786		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3787
3788	case strings.EqualFold("InvalidArgumentException", errorCode):
3789		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3790
3791	case strings.EqualFold("InvalidNextTokenException", errorCode):
3792		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3793
3794	case strings.EqualFold("ListenerNotFoundException", errorCode):
3795		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
3796
3797	default:
3798		genericError := &smithy.GenericAPIError{
3799			Code:    errorCode,
3800			Message: errorMessage,
3801		}
3802		return genericError
3803
3804	}
3805}
3806
3807type awsAwsjson11_deserializeOpListListeners struct {
3808}
3809
3810func (*awsAwsjson11_deserializeOpListListeners) ID() string {
3811	return "OperationDeserializer"
3812}
3813
3814func (m *awsAwsjson11_deserializeOpListListeners) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3815	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3816) {
3817	out, metadata, err = next.HandleDeserialize(ctx, in)
3818	if err != nil {
3819		return out, metadata, err
3820	}
3821
3822	response, ok := out.RawResponse.(*smithyhttp.Response)
3823	if !ok {
3824		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3825	}
3826
3827	if response.StatusCode < 200 || response.StatusCode >= 300 {
3828		return out, metadata, awsAwsjson11_deserializeOpErrorListListeners(response, &metadata)
3829	}
3830	output := &ListListenersOutput{}
3831	out.Result = output
3832
3833	var buff [1024]byte
3834	ringBuffer := smithyio.NewRingBuffer(buff[:])
3835
3836	body := io.TeeReader(response.Body, ringBuffer)
3837	decoder := json.NewDecoder(body)
3838	decoder.UseNumber()
3839	var shape interface{}
3840	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3841		var snapshot bytes.Buffer
3842		io.Copy(&snapshot, ringBuffer)
3843		err = &smithy.DeserializationError{
3844			Err:      fmt.Errorf("failed to decode response body, %w", err),
3845			Snapshot: snapshot.Bytes(),
3846		}
3847		return out, metadata, err
3848	}
3849
3850	err = awsAwsjson11_deserializeOpDocumentListListenersOutput(&output, shape)
3851	if err != nil {
3852		var snapshot bytes.Buffer
3853		io.Copy(&snapshot, ringBuffer)
3854		err = &smithy.DeserializationError{
3855			Err:      fmt.Errorf("failed to decode response body, %w", err),
3856			Snapshot: snapshot.Bytes(),
3857		}
3858		return out, metadata, err
3859	}
3860
3861	return out, metadata, err
3862}
3863
3864func awsAwsjson11_deserializeOpErrorListListeners(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3865	var errorBuffer bytes.Buffer
3866	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3867		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3868	}
3869	errorBody := bytes.NewReader(errorBuffer.Bytes())
3870
3871	errorCode := "UnknownError"
3872	errorMessage := errorCode
3873
3874	code := response.Header.Get("X-Amzn-ErrorType")
3875	if len(code) != 0 {
3876		errorCode = restjson.SanitizeErrorCode(code)
3877	}
3878
3879	var buff [1024]byte
3880	ringBuffer := smithyio.NewRingBuffer(buff[:])
3881
3882	body := io.TeeReader(errorBody, ringBuffer)
3883	decoder := json.NewDecoder(body)
3884	decoder.UseNumber()
3885	code, message, err := restjson.GetErrorInfo(decoder)
3886	if err != nil {
3887		var snapshot bytes.Buffer
3888		io.Copy(&snapshot, ringBuffer)
3889		err = &smithy.DeserializationError{
3890			Err:      fmt.Errorf("failed to decode response body, %w", err),
3891			Snapshot: snapshot.Bytes(),
3892		}
3893		return err
3894	}
3895
3896	errorBody.Seek(0, io.SeekStart)
3897	if len(code) != 0 {
3898		errorCode = restjson.SanitizeErrorCode(code)
3899	}
3900	if len(message) != 0 {
3901		errorMessage = message
3902	}
3903
3904	switch {
3905	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
3906		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
3907
3908	case strings.EqualFold("InternalServiceErrorException", errorCode):
3909		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3910
3911	case strings.EqualFold("InvalidArgumentException", errorCode):
3912		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
3913
3914	case strings.EqualFold("InvalidNextTokenException", errorCode):
3915		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
3916
3917	default:
3918		genericError := &smithy.GenericAPIError{
3919			Code:    errorCode,
3920			Message: errorMessage,
3921		}
3922		return genericError
3923
3924	}
3925}
3926
3927type awsAwsjson11_deserializeOpListTagsForResource struct {
3928}
3929
3930func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
3931	return "OperationDeserializer"
3932}
3933
3934func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3935	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3936) {
3937	out, metadata, err = next.HandleDeserialize(ctx, in)
3938	if err != nil {
3939		return out, metadata, err
3940	}
3941
3942	response, ok := out.RawResponse.(*smithyhttp.Response)
3943	if !ok {
3944		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3945	}
3946
3947	if response.StatusCode < 200 || response.StatusCode >= 300 {
3948		return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
3949	}
3950	output := &ListTagsForResourceOutput{}
3951	out.Result = output
3952
3953	var buff [1024]byte
3954	ringBuffer := smithyio.NewRingBuffer(buff[:])
3955
3956	body := io.TeeReader(response.Body, ringBuffer)
3957	decoder := json.NewDecoder(body)
3958	decoder.UseNumber()
3959	var shape interface{}
3960	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3961		var snapshot bytes.Buffer
3962		io.Copy(&snapshot, ringBuffer)
3963		err = &smithy.DeserializationError{
3964			Err:      fmt.Errorf("failed to decode response body, %w", err),
3965			Snapshot: snapshot.Bytes(),
3966		}
3967		return out, metadata, err
3968	}
3969
3970	err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
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 out, metadata, err
3979	}
3980
3981	return out, metadata, err
3982}
3983
3984func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3985	var errorBuffer bytes.Buffer
3986	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3987		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3988	}
3989	errorBody := bytes.NewReader(errorBuffer.Bytes())
3990
3991	errorCode := "UnknownError"
3992	errorMessage := errorCode
3993
3994	code := response.Header.Get("X-Amzn-ErrorType")
3995	if len(code) != 0 {
3996		errorCode = restjson.SanitizeErrorCode(code)
3997	}
3998
3999	var buff [1024]byte
4000	ringBuffer := smithyio.NewRingBuffer(buff[:])
4001
4002	body := io.TeeReader(errorBody, ringBuffer)
4003	decoder := json.NewDecoder(body)
4004	decoder.UseNumber()
4005	code, message, err := restjson.GetErrorInfo(decoder)
4006	if err != nil {
4007		var snapshot bytes.Buffer
4008		io.Copy(&snapshot, ringBuffer)
4009		err = &smithy.DeserializationError{
4010			Err:      fmt.Errorf("failed to decode response body, %w", err),
4011			Snapshot: snapshot.Bytes(),
4012		}
4013		return err
4014	}
4015
4016	errorBody.Seek(0, io.SeekStart)
4017	if len(code) != 0 {
4018		errorCode = restjson.SanitizeErrorCode(code)
4019	}
4020	if len(message) != 0 {
4021		errorMessage = message
4022	}
4023
4024	switch {
4025	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4026		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4027
4028	case strings.EqualFold("InternalServiceErrorException", errorCode):
4029		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4030
4031	case strings.EqualFold("InvalidArgumentException", errorCode):
4032		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4033
4034	default:
4035		genericError := &smithy.GenericAPIError{
4036			Code:    errorCode,
4037			Message: errorMessage,
4038		}
4039		return genericError
4040
4041	}
4042}
4043
4044type awsAwsjson11_deserializeOpProvisionByoipCidr struct {
4045}
4046
4047func (*awsAwsjson11_deserializeOpProvisionByoipCidr) ID() string {
4048	return "OperationDeserializer"
4049}
4050
4051func (m *awsAwsjson11_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4052	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4053) {
4054	out, metadata, err = next.HandleDeserialize(ctx, in)
4055	if err != nil {
4056		return out, metadata, err
4057	}
4058
4059	response, ok := out.RawResponse.(*smithyhttp.Response)
4060	if !ok {
4061		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4062	}
4063
4064	if response.StatusCode < 200 || response.StatusCode >= 300 {
4065		return out, metadata, awsAwsjson11_deserializeOpErrorProvisionByoipCidr(response, &metadata)
4066	}
4067	output := &ProvisionByoipCidrOutput{}
4068	out.Result = output
4069
4070	var buff [1024]byte
4071	ringBuffer := smithyio.NewRingBuffer(buff[:])
4072
4073	body := io.TeeReader(response.Body, ringBuffer)
4074	decoder := json.NewDecoder(body)
4075	decoder.UseNumber()
4076	var shape interface{}
4077	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4078		var snapshot bytes.Buffer
4079		io.Copy(&snapshot, ringBuffer)
4080		err = &smithy.DeserializationError{
4081			Err:      fmt.Errorf("failed to decode response body, %w", err),
4082			Snapshot: snapshot.Bytes(),
4083		}
4084		return out, metadata, err
4085	}
4086
4087	err = awsAwsjson11_deserializeOpDocumentProvisionByoipCidrOutput(&output, shape)
4088	if err != nil {
4089		var snapshot bytes.Buffer
4090		io.Copy(&snapshot, ringBuffer)
4091		err = &smithy.DeserializationError{
4092			Err:      fmt.Errorf("failed to decode response body, %w", err),
4093			Snapshot: snapshot.Bytes(),
4094		}
4095		return out, metadata, err
4096	}
4097
4098	return out, metadata, err
4099}
4100
4101func awsAwsjson11_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4102	var errorBuffer bytes.Buffer
4103	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4104		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4105	}
4106	errorBody := bytes.NewReader(errorBuffer.Bytes())
4107
4108	errorCode := "UnknownError"
4109	errorMessage := errorCode
4110
4111	code := response.Header.Get("X-Amzn-ErrorType")
4112	if len(code) != 0 {
4113		errorCode = restjson.SanitizeErrorCode(code)
4114	}
4115
4116	var buff [1024]byte
4117	ringBuffer := smithyio.NewRingBuffer(buff[:])
4118
4119	body := io.TeeReader(errorBody, ringBuffer)
4120	decoder := json.NewDecoder(body)
4121	decoder.UseNumber()
4122	code, message, err := restjson.GetErrorInfo(decoder)
4123	if err != nil {
4124		var snapshot bytes.Buffer
4125		io.Copy(&snapshot, ringBuffer)
4126		err = &smithy.DeserializationError{
4127			Err:      fmt.Errorf("failed to decode response body, %w", err),
4128			Snapshot: snapshot.Bytes(),
4129		}
4130		return err
4131	}
4132
4133	errorBody.Seek(0, io.SeekStart)
4134	if len(code) != 0 {
4135		errorCode = restjson.SanitizeErrorCode(code)
4136	}
4137	if len(message) != 0 {
4138		errorMessage = message
4139	}
4140
4141	switch {
4142	case strings.EqualFold("AccessDeniedException", errorCode):
4143		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4144
4145	case strings.EqualFold("IncorrectCidrStateException", errorCode):
4146		return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody)
4147
4148	case strings.EqualFold("InternalServiceErrorException", errorCode):
4149		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4150
4151	case strings.EqualFold("InvalidArgumentException", errorCode):
4152		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4153
4154	case strings.EqualFold("LimitExceededException", errorCode):
4155		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
4156
4157	default:
4158		genericError := &smithy.GenericAPIError{
4159			Code:    errorCode,
4160			Message: errorMessage,
4161		}
4162		return genericError
4163
4164	}
4165}
4166
4167type awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints struct {
4168}
4169
4170func (*awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints) ID() string {
4171	return "OperationDeserializer"
4172}
4173
4174func (m *awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4175	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4176) {
4177	out, metadata, err = next.HandleDeserialize(ctx, in)
4178	if err != nil {
4179		return out, metadata, err
4180	}
4181
4182	response, ok := out.RawResponse.(*smithyhttp.Response)
4183	if !ok {
4184		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4185	}
4186
4187	if response.StatusCode < 200 || response.StatusCode >= 300 {
4188		return out, metadata, awsAwsjson11_deserializeOpErrorRemoveCustomRoutingEndpoints(response, &metadata)
4189	}
4190	output := &RemoveCustomRoutingEndpointsOutput{}
4191	out.Result = output
4192
4193	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
4194		return out, metadata, &smithy.DeserializationError{
4195			Err: fmt.Errorf("failed to discard response body, %w", err),
4196		}
4197	}
4198
4199	return out, metadata, err
4200}
4201
4202func awsAwsjson11_deserializeOpErrorRemoveCustomRoutingEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4203	var errorBuffer bytes.Buffer
4204	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4205		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4206	}
4207	errorBody := bytes.NewReader(errorBuffer.Bytes())
4208
4209	errorCode := "UnknownError"
4210	errorMessage := errorCode
4211
4212	code := response.Header.Get("X-Amzn-ErrorType")
4213	if len(code) != 0 {
4214		errorCode = restjson.SanitizeErrorCode(code)
4215	}
4216
4217	var buff [1024]byte
4218	ringBuffer := smithyio.NewRingBuffer(buff[:])
4219
4220	body := io.TeeReader(errorBody, ringBuffer)
4221	decoder := json.NewDecoder(body)
4222	decoder.UseNumber()
4223	code, message, err := restjson.GetErrorInfo(decoder)
4224	if err != nil {
4225		var snapshot bytes.Buffer
4226		io.Copy(&snapshot, ringBuffer)
4227		err = &smithy.DeserializationError{
4228			Err:      fmt.Errorf("failed to decode response body, %w", err),
4229			Snapshot: snapshot.Bytes(),
4230		}
4231		return err
4232	}
4233
4234	errorBody.Seek(0, io.SeekStart)
4235	if len(code) != 0 {
4236		errorCode = restjson.SanitizeErrorCode(code)
4237	}
4238	if len(message) != 0 {
4239		errorMessage = message
4240	}
4241
4242	switch {
4243	case strings.EqualFold("AccessDeniedException", errorCode):
4244		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4245
4246	case strings.EqualFold("ConflictException", errorCode):
4247		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
4248
4249	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
4250		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
4251
4252	case strings.EqualFold("EndpointNotFoundException", errorCode):
4253		return awsAwsjson11_deserializeErrorEndpointNotFoundException(response, errorBody)
4254
4255	case strings.EqualFold("InternalServiceErrorException", errorCode):
4256		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4257
4258	case strings.EqualFold("InvalidArgumentException", errorCode):
4259		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4260
4261	default:
4262		genericError := &smithy.GenericAPIError{
4263			Code:    errorCode,
4264			Message: errorMessage,
4265		}
4266		return genericError
4267
4268	}
4269}
4270
4271type awsAwsjson11_deserializeOpTagResource struct {
4272}
4273
4274func (*awsAwsjson11_deserializeOpTagResource) ID() string {
4275	return "OperationDeserializer"
4276}
4277
4278func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4279	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4280) {
4281	out, metadata, err = next.HandleDeserialize(ctx, in)
4282	if err != nil {
4283		return out, metadata, err
4284	}
4285
4286	response, ok := out.RawResponse.(*smithyhttp.Response)
4287	if !ok {
4288		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4289	}
4290
4291	if response.StatusCode < 200 || response.StatusCode >= 300 {
4292		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
4293	}
4294	output := &TagResourceOutput{}
4295	out.Result = output
4296
4297	var buff [1024]byte
4298	ringBuffer := smithyio.NewRingBuffer(buff[:])
4299
4300	body := io.TeeReader(response.Body, ringBuffer)
4301	decoder := json.NewDecoder(body)
4302	decoder.UseNumber()
4303	var shape interface{}
4304	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4305		var snapshot bytes.Buffer
4306		io.Copy(&snapshot, ringBuffer)
4307		err = &smithy.DeserializationError{
4308			Err:      fmt.Errorf("failed to decode response body, %w", err),
4309			Snapshot: snapshot.Bytes(),
4310		}
4311		return out, metadata, err
4312	}
4313
4314	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
4315	if err != nil {
4316		var snapshot bytes.Buffer
4317		io.Copy(&snapshot, ringBuffer)
4318		err = &smithy.DeserializationError{
4319			Err:      fmt.Errorf("failed to decode response body, %w", err),
4320			Snapshot: snapshot.Bytes(),
4321		}
4322		return out, metadata, err
4323	}
4324
4325	return out, metadata, err
4326}
4327
4328func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4329	var errorBuffer bytes.Buffer
4330	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4331		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4332	}
4333	errorBody := bytes.NewReader(errorBuffer.Bytes())
4334
4335	errorCode := "UnknownError"
4336	errorMessage := errorCode
4337
4338	code := response.Header.Get("X-Amzn-ErrorType")
4339	if len(code) != 0 {
4340		errorCode = restjson.SanitizeErrorCode(code)
4341	}
4342
4343	var buff [1024]byte
4344	ringBuffer := smithyio.NewRingBuffer(buff[:])
4345
4346	body := io.TeeReader(errorBody, ringBuffer)
4347	decoder := json.NewDecoder(body)
4348	decoder.UseNumber()
4349	code, message, err := restjson.GetErrorInfo(decoder)
4350	if err != nil {
4351		var snapshot bytes.Buffer
4352		io.Copy(&snapshot, ringBuffer)
4353		err = &smithy.DeserializationError{
4354			Err:      fmt.Errorf("failed to decode response body, %w", err),
4355			Snapshot: snapshot.Bytes(),
4356		}
4357		return err
4358	}
4359
4360	errorBody.Seek(0, io.SeekStart)
4361	if len(code) != 0 {
4362		errorCode = restjson.SanitizeErrorCode(code)
4363	}
4364	if len(message) != 0 {
4365		errorMessage = message
4366	}
4367
4368	switch {
4369	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4370		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4371
4372	case strings.EqualFold("InternalServiceErrorException", errorCode):
4373		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4374
4375	case strings.EqualFold("InvalidArgumentException", errorCode):
4376		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4377
4378	default:
4379		genericError := &smithy.GenericAPIError{
4380			Code:    errorCode,
4381			Message: errorMessage,
4382		}
4383		return genericError
4384
4385	}
4386}
4387
4388type awsAwsjson11_deserializeOpUntagResource struct {
4389}
4390
4391func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
4392	return "OperationDeserializer"
4393}
4394
4395func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4396	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4397) {
4398	out, metadata, err = next.HandleDeserialize(ctx, in)
4399	if err != nil {
4400		return out, metadata, err
4401	}
4402
4403	response, ok := out.RawResponse.(*smithyhttp.Response)
4404	if !ok {
4405		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4406	}
4407
4408	if response.StatusCode < 200 || response.StatusCode >= 300 {
4409		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
4410	}
4411	output := &UntagResourceOutput{}
4412	out.Result = output
4413
4414	var buff [1024]byte
4415	ringBuffer := smithyio.NewRingBuffer(buff[:])
4416
4417	body := io.TeeReader(response.Body, ringBuffer)
4418	decoder := json.NewDecoder(body)
4419	decoder.UseNumber()
4420	var shape interface{}
4421	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4422		var snapshot bytes.Buffer
4423		io.Copy(&snapshot, ringBuffer)
4424		err = &smithy.DeserializationError{
4425			Err:      fmt.Errorf("failed to decode response body, %w", err),
4426			Snapshot: snapshot.Bytes(),
4427		}
4428		return out, metadata, err
4429	}
4430
4431	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
4432	if err != nil {
4433		var snapshot bytes.Buffer
4434		io.Copy(&snapshot, ringBuffer)
4435		err = &smithy.DeserializationError{
4436			Err:      fmt.Errorf("failed to decode response body, %w", err),
4437			Snapshot: snapshot.Bytes(),
4438		}
4439		return out, metadata, err
4440	}
4441
4442	return out, metadata, err
4443}
4444
4445func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4446	var errorBuffer bytes.Buffer
4447	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4448		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4449	}
4450	errorBody := bytes.NewReader(errorBuffer.Bytes())
4451
4452	errorCode := "UnknownError"
4453	errorMessage := errorCode
4454
4455	code := response.Header.Get("X-Amzn-ErrorType")
4456	if len(code) != 0 {
4457		errorCode = restjson.SanitizeErrorCode(code)
4458	}
4459
4460	var buff [1024]byte
4461	ringBuffer := smithyio.NewRingBuffer(buff[:])
4462
4463	body := io.TeeReader(errorBody, ringBuffer)
4464	decoder := json.NewDecoder(body)
4465	decoder.UseNumber()
4466	code, message, err := restjson.GetErrorInfo(decoder)
4467	if err != nil {
4468		var snapshot bytes.Buffer
4469		io.Copy(&snapshot, ringBuffer)
4470		err = &smithy.DeserializationError{
4471			Err:      fmt.Errorf("failed to decode response body, %w", err),
4472			Snapshot: snapshot.Bytes(),
4473		}
4474		return err
4475	}
4476
4477	errorBody.Seek(0, io.SeekStart)
4478	if len(code) != 0 {
4479		errorCode = restjson.SanitizeErrorCode(code)
4480	}
4481	if len(message) != 0 {
4482		errorMessage = message
4483	}
4484
4485	switch {
4486	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4487		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4488
4489	case strings.EqualFold("InternalServiceErrorException", errorCode):
4490		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4491
4492	case strings.EqualFold("InvalidArgumentException", errorCode):
4493		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4494
4495	default:
4496		genericError := &smithy.GenericAPIError{
4497			Code:    errorCode,
4498			Message: errorMessage,
4499		}
4500		return genericError
4501
4502	}
4503}
4504
4505type awsAwsjson11_deserializeOpUpdateAccelerator struct {
4506}
4507
4508func (*awsAwsjson11_deserializeOpUpdateAccelerator) ID() string {
4509	return "OperationDeserializer"
4510}
4511
4512func (m *awsAwsjson11_deserializeOpUpdateAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4513	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4514) {
4515	out, metadata, err = next.HandleDeserialize(ctx, in)
4516	if err != nil {
4517		return out, metadata, err
4518	}
4519
4520	response, ok := out.RawResponse.(*smithyhttp.Response)
4521	if !ok {
4522		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4523	}
4524
4525	if response.StatusCode < 200 || response.StatusCode >= 300 {
4526		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAccelerator(response, &metadata)
4527	}
4528	output := &UpdateAcceleratorOutput{}
4529	out.Result = output
4530
4531	var buff [1024]byte
4532	ringBuffer := smithyio.NewRingBuffer(buff[:])
4533
4534	body := io.TeeReader(response.Body, ringBuffer)
4535	decoder := json.NewDecoder(body)
4536	decoder.UseNumber()
4537	var shape interface{}
4538	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4539		var snapshot bytes.Buffer
4540		io.Copy(&snapshot, ringBuffer)
4541		err = &smithy.DeserializationError{
4542			Err:      fmt.Errorf("failed to decode response body, %w", err),
4543			Snapshot: snapshot.Bytes(),
4544		}
4545		return out, metadata, err
4546	}
4547
4548	err = awsAwsjson11_deserializeOpDocumentUpdateAcceleratorOutput(&output, shape)
4549	if err != nil {
4550		var snapshot bytes.Buffer
4551		io.Copy(&snapshot, ringBuffer)
4552		err = &smithy.DeserializationError{
4553			Err:      fmt.Errorf("failed to decode response body, %w", err),
4554			Snapshot: snapshot.Bytes(),
4555		}
4556		return out, metadata, err
4557	}
4558
4559	return out, metadata, err
4560}
4561
4562func awsAwsjson11_deserializeOpErrorUpdateAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4563	var errorBuffer bytes.Buffer
4564	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4565		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4566	}
4567	errorBody := bytes.NewReader(errorBuffer.Bytes())
4568
4569	errorCode := "UnknownError"
4570	errorMessage := errorCode
4571
4572	code := response.Header.Get("X-Amzn-ErrorType")
4573	if len(code) != 0 {
4574		errorCode = restjson.SanitizeErrorCode(code)
4575	}
4576
4577	var buff [1024]byte
4578	ringBuffer := smithyio.NewRingBuffer(buff[:])
4579
4580	body := io.TeeReader(errorBody, ringBuffer)
4581	decoder := json.NewDecoder(body)
4582	decoder.UseNumber()
4583	code, message, err := restjson.GetErrorInfo(decoder)
4584	if err != nil {
4585		var snapshot bytes.Buffer
4586		io.Copy(&snapshot, ringBuffer)
4587		err = &smithy.DeserializationError{
4588			Err:      fmt.Errorf("failed to decode response body, %w", err),
4589			Snapshot: snapshot.Bytes(),
4590		}
4591		return err
4592	}
4593
4594	errorBody.Seek(0, io.SeekStart)
4595	if len(code) != 0 {
4596		errorCode = restjson.SanitizeErrorCode(code)
4597	}
4598	if len(message) != 0 {
4599		errorMessage = message
4600	}
4601
4602	switch {
4603	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4604		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4605
4606	case strings.EqualFold("InternalServiceErrorException", errorCode):
4607		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4608
4609	case strings.EqualFold("InvalidArgumentException", errorCode):
4610		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4611
4612	default:
4613		genericError := &smithy.GenericAPIError{
4614			Code:    errorCode,
4615			Message: errorMessage,
4616		}
4617		return genericError
4618
4619	}
4620}
4621
4622type awsAwsjson11_deserializeOpUpdateAcceleratorAttributes struct {
4623}
4624
4625func (*awsAwsjson11_deserializeOpUpdateAcceleratorAttributes) ID() string {
4626	return "OperationDeserializer"
4627}
4628
4629func (m *awsAwsjson11_deserializeOpUpdateAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4630	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4631) {
4632	out, metadata, err = next.HandleDeserialize(ctx, in)
4633	if err != nil {
4634		return out, metadata, err
4635	}
4636
4637	response, ok := out.RawResponse.(*smithyhttp.Response)
4638	if !ok {
4639		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4640	}
4641
4642	if response.StatusCode < 200 || response.StatusCode >= 300 {
4643		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAcceleratorAttributes(response, &metadata)
4644	}
4645	output := &UpdateAcceleratorAttributesOutput{}
4646	out.Result = output
4647
4648	var buff [1024]byte
4649	ringBuffer := smithyio.NewRingBuffer(buff[:])
4650
4651	body := io.TeeReader(response.Body, ringBuffer)
4652	decoder := json.NewDecoder(body)
4653	decoder.UseNumber()
4654	var shape interface{}
4655	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4656		var snapshot bytes.Buffer
4657		io.Copy(&snapshot, ringBuffer)
4658		err = &smithy.DeserializationError{
4659			Err:      fmt.Errorf("failed to decode response body, %w", err),
4660			Snapshot: snapshot.Bytes(),
4661		}
4662		return out, metadata, err
4663	}
4664
4665	err = awsAwsjson11_deserializeOpDocumentUpdateAcceleratorAttributesOutput(&output, shape)
4666	if err != nil {
4667		var snapshot bytes.Buffer
4668		io.Copy(&snapshot, ringBuffer)
4669		err = &smithy.DeserializationError{
4670			Err:      fmt.Errorf("failed to decode response body, %w", err),
4671			Snapshot: snapshot.Bytes(),
4672		}
4673		return out, metadata, err
4674	}
4675
4676	return out, metadata, err
4677}
4678
4679func awsAwsjson11_deserializeOpErrorUpdateAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4680	var errorBuffer bytes.Buffer
4681	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4682		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4683	}
4684	errorBody := bytes.NewReader(errorBuffer.Bytes())
4685
4686	errorCode := "UnknownError"
4687	errorMessage := errorCode
4688
4689	code := response.Header.Get("X-Amzn-ErrorType")
4690	if len(code) != 0 {
4691		errorCode = restjson.SanitizeErrorCode(code)
4692	}
4693
4694	var buff [1024]byte
4695	ringBuffer := smithyio.NewRingBuffer(buff[:])
4696
4697	body := io.TeeReader(errorBody, ringBuffer)
4698	decoder := json.NewDecoder(body)
4699	decoder.UseNumber()
4700	code, message, err := restjson.GetErrorInfo(decoder)
4701	if err != nil {
4702		var snapshot bytes.Buffer
4703		io.Copy(&snapshot, ringBuffer)
4704		err = &smithy.DeserializationError{
4705			Err:      fmt.Errorf("failed to decode response body, %w", err),
4706			Snapshot: snapshot.Bytes(),
4707		}
4708		return err
4709	}
4710
4711	errorBody.Seek(0, io.SeekStart)
4712	if len(code) != 0 {
4713		errorCode = restjson.SanitizeErrorCode(code)
4714	}
4715	if len(message) != 0 {
4716		errorMessage = message
4717	}
4718
4719	switch {
4720	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4721		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4722
4723	case strings.EqualFold("AccessDeniedException", errorCode):
4724		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4725
4726	case strings.EqualFold("InternalServiceErrorException", errorCode):
4727		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4728
4729	case strings.EqualFold("InvalidArgumentException", errorCode):
4730		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4731
4732	default:
4733		genericError := &smithy.GenericAPIError{
4734			Code:    errorCode,
4735			Message: errorMessage,
4736		}
4737		return genericError
4738
4739	}
4740}
4741
4742type awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator struct {
4743}
4744
4745func (*awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator) ID() string {
4746	return "OperationDeserializer"
4747}
4748
4749func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4750	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4751) {
4752	out, metadata, err = next.HandleDeserialize(ctx, in)
4753	if err != nil {
4754		return out, metadata, err
4755	}
4756
4757	response, ok := out.RawResponse.(*smithyhttp.Response)
4758	if !ok {
4759		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4760	}
4761
4762	if response.StatusCode < 200 || response.StatusCode >= 300 {
4763		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAccelerator(response, &metadata)
4764	}
4765	output := &UpdateCustomRoutingAcceleratorOutput{}
4766	out.Result = output
4767
4768	var buff [1024]byte
4769	ringBuffer := smithyio.NewRingBuffer(buff[:])
4770
4771	body := io.TeeReader(response.Body, ringBuffer)
4772	decoder := json.NewDecoder(body)
4773	decoder.UseNumber()
4774	var shape interface{}
4775	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4776		var snapshot bytes.Buffer
4777		io.Copy(&snapshot, ringBuffer)
4778		err = &smithy.DeserializationError{
4779			Err:      fmt.Errorf("failed to decode response body, %w", err),
4780			Snapshot: snapshot.Bytes(),
4781		}
4782		return out, metadata, err
4783	}
4784
4785	err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorOutput(&output, shape)
4786	if err != nil {
4787		var snapshot bytes.Buffer
4788		io.Copy(&snapshot, ringBuffer)
4789		err = &smithy.DeserializationError{
4790			Err:      fmt.Errorf("failed to decode response body, %w", err),
4791			Snapshot: snapshot.Bytes(),
4792		}
4793		return out, metadata, err
4794	}
4795
4796	return out, metadata, err
4797}
4798
4799func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4800	var errorBuffer bytes.Buffer
4801	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4802		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4803	}
4804	errorBody := bytes.NewReader(errorBuffer.Bytes())
4805
4806	errorCode := "UnknownError"
4807	errorMessage := errorCode
4808
4809	code := response.Header.Get("X-Amzn-ErrorType")
4810	if len(code) != 0 {
4811		errorCode = restjson.SanitizeErrorCode(code)
4812	}
4813
4814	var buff [1024]byte
4815	ringBuffer := smithyio.NewRingBuffer(buff[:])
4816
4817	body := io.TeeReader(errorBody, ringBuffer)
4818	decoder := json.NewDecoder(body)
4819	decoder.UseNumber()
4820	code, message, err := restjson.GetErrorInfo(decoder)
4821	if err != nil {
4822		var snapshot bytes.Buffer
4823		io.Copy(&snapshot, ringBuffer)
4824		err = &smithy.DeserializationError{
4825			Err:      fmt.Errorf("failed to decode response body, %w", err),
4826			Snapshot: snapshot.Bytes(),
4827		}
4828		return err
4829	}
4830
4831	errorBody.Seek(0, io.SeekStart)
4832	if len(code) != 0 {
4833		errorCode = restjson.SanitizeErrorCode(code)
4834	}
4835	if len(message) != 0 {
4836		errorMessage = message
4837	}
4838
4839	switch {
4840	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4841		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4842
4843	case strings.EqualFold("InternalServiceErrorException", errorCode):
4844		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4845
4846	case strings.EqualFold("InvalidArgumentException", errorCode):
4847		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4848
4849	default:
4850		genericError := &smithy.GenericAPIError{
4851			Code:    errorCode,
4852			Message: errorMessage,
4853		}
4854		return genericError
4855
4856	}
4857}
4858
4859type awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes struct {
4860}
4861
4862func (*awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes) ID() string {
4863	return "OperationDeserializer"
4864}
4865
4866func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4867	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4868) {
4869	out, metadata, err = next.HandleDeserialize(ctx, in)
4870	if err != nil {
4871		return out, metadata, err
4872	}
4873
4874	response, ok := out.RawResponse.(*smithyhttp.Response)
4875	if !ok {
4876		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4877	}
4878
4879	if response.StatusCode < 200 || response.StatusCode >= 300 {
4880		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAcceleratorAttributes(response, &metadata)
4881	}
4882	output := &UpdateCustomRoutingAcceleratorAttributesOutput{}
4883	out.Result = output
4884
4885	var buff [1024]byte
4886	ringBuffer := smithyio.NewRingBuffer(buff[:])
4887
4888	body := io.TeeReader(response.Body, ringBuffer)
4889	decoder := json.NewDecoder(body)
4890	decoder.UseNumber()
4891	var shape interface{}
4892	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4893		var snapshot bytes.Buffer
4894		io.Copy(&snapshot, ringBuffer)
4895		err = &smithy.DeserializationError{
4896			Err:      fmt.Errorf("failed to decode response body, %w", err),
4897			Snapshot: snapshot.Bytes(),
4898		}
4899		return out, metadata, err
4900	}
4901
4902	err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorAttributesOutput(&output, shape)
4903	if err != nil {
4904		var snapshot bytes.Buffer
4905		io.Copy(&snapshot, ringBuffer)
4906		err = &smithy.DeserializationError{
4907			Err:      fmt.Errorf("failed to decode response body, %w", err),
4908			Snapshot: snapshot.Bytes(),
4909		}
4910		return out, metadata, err
4911	}
4912
4913	return out, metadata, err
4914}
4915
4916func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4917	var errorBuffer bytes.Buffer
4918	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4919		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4920	}
4921	errorBody := bytes.NewReader(errorBuffer.Bytes())
4922
4923	errorCode := "UnknownError"
4924	errorMessage := errorCode
4925
4926	code := response.Header.Get("X-Amzn-ErrorType")
4927	if len(code) != 0 {
4928		errorCode = restjson.SanitizeErrorCode(code)
4929	}
4930
4931	var buff [1024]byte
4932	ringBuffer := smithyio.NewRingBuffer(buff[:])
4933
4934	body := io.TeeReader(errorBody, ringBuffer)
4935	decoder := json.NewDecoder(body)
4936	decoder.UseNumber()
4937	code, message, err := restjson.GetErrorInfo(decoder)
4938	if err != nil {
4939		var snapshot bytes.Buffer
4940		io.Copy(&snapshot, ringBuffer)
4941		err = &smithy.DeserializationError{
4942			Err:      fmt.Errorf("failed to decode response body, %w", err),
4943			Snapshot: snapshot.Bytes(),
4944		}
4945		return err
4946	}
4947
4948	errorBody.Seek(0, io.SeekStart)
4949	if len(code) != 0 {
4950		errorCode = restjson.SanitizeErrorCode(code)
4951	}
4952	if len(message) != 0 {
4953		errorMessage = message
4954	}
4955
4956	switch {
4957	case strings.EqualFold("AcceleratorNotFoundException", errorCode):
4958		return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody)
4959
4960	case strings.EqualFold("AccessDeniedException", errorCode):
4961		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4962
4963	case strings.EqualFold("InternalServiceErrorException", errorCode):
4964		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4965
4966	case strings.EqualFold("InvalidArgumentException", errorCode):
4967		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
4968
4969	default:
4970		genericError := &smithy.GenericAPIError{
4971			Code:    errorCode,
4972			Message: errorMessage,
4973		}
4974		return genericError
4975
4976	}
4977}
4978
4979type awsAwsjson11_deserializeOpUpdateCustomRoutingListener struct {
4980}
4981
4982func (*awsAwsjson11_deserializeOpUpdateCustomRoutingListener) ID() string {
4983	return "OperationDeserializer"
4984}
4985
4986func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4987	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4988) {
4989	out, metadata, err = next.HandleDeserialize(ctx, in)
4990	if err != nil {
4991		return out, metadata, err
4992	}
4993
4994	response, ok := out.RawResponse.(*smithyhttp.Response)
4995	if !ok {
4996		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4997	}
4998
4999	if response.StatusCode < 200 || response.StatusCode >= 300 {
5000		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingListener(response, &metadata)
5001	}
5002	output := &UpdateCustomRoutingListenerOutput{}
5003	out.Result = output
5004
5005	var buff [1024]byte
5006	ringBuffer := smithyio.NewRingBuffer(buff[:])
5007
5008	body := io.TeeReader(response.Body, ringBuffer)
5009	decoder := json.NewDecoder(body)
5010	decoder.UseNumber()
5011	var shape interface{}
5012	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5013		var snapshot bytes.Buffer
5014		io.Copy(&snapshot, ringBuffer)
5015		err = &smithy.DeserializationError{
5016			Err:      fmt.Errorf("failed to decode response body, %w", err),
5017			Snapshot: snapshot.Bytes(),
5018		}
5019		return out, metadata, err
5020	}
5021
5022	err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingListenerOutput(&output, shape)
5023	if err != nil {
5024		var snapshot bytes.Buffer
5025		io.Copy(&snapshot, ringBuffer)
5026		err = &smithy.DeserializationError{
5027			Err:      fmt.Errorf("failed to decode response body, %w", err),
5028			Snapshot: snapshot.Bytes(),
5029		}
5030		return out, metadata, err
5031	}
5032
5033	return out, metadata, err
5034}
5035
5036func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5037	var errorBuffer bytes.Buffer
5038	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5039		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5040	}
5041	errorBody := bytes.NewReader(errorBuffer.Bytes())
5042
5043	errorCode := "UnknownError"
5044	errorMessage := errorCode
5045
5046	code := response.Header.Get("X-Amzn-ErrorType")
5047	if len(code) != 0 {
5048		errorCode = restjson.SanitizeErrorCode(code)
5049	}
5050
5051	var buff [1024]byte
5052	ringBuffer := smithyio.NewRingBuffer(buff[:])
5053
5054	body := io.TeeReader(errorBody, ringBuffer)
5055	decoder := json.NewDecoder(body)
5056	decoder.UseNumber()
5057	code, message, err := restjson.GetErrorInfo(decoder)
5058	if err != nil {
5059		var snapshot bytes.Buffer
5060		io.Copy(&snapshot, ringBuffer)
5061		err = &smithy.DeserializationError{
5062			Err:      fmt.Errorf("failed to decode response body, %w", err),
5063			Snapshot: snapshot.Bytes(),
5064		}
5065		return err
5066	}
5067
5068	errorBody.Seek(0, io.SeekStart)
5069	if len(code) != 0 {
5070		errorCode = restjson.SanitizeErrorCode(code)
5071	}
5072	if len(message) != 0 {
5073		errorMessage = message
5074	}
5075
5076	switch {
5077	case strings.EqualFold("InternalServiceErrorException", errorCode):
5078		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5079
5080	case strings.EqualFold("InvalidArgumentException", errorCode):
5081		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
5082
5083	case strings.EqualFold("InvalidPortRangeException", errorCode):
5084		return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody)
5085
5086	case strings.EqualFold("LimitExceededException", errorCode):
5087		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
5088
5089	case strings.EqualFold("ListenerNotFoundException", errorCode):
5090		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
5091
5092	default:
5093		genericError := &smithy.GenericAPIError{
5094			Code:    errorCode,
5095			Message: errorMessage,
5096		}
5097		return genericError
5098
5099	}
5100}
5101
5102type awsAwsjson11_deserializeOpUpdateEndpointGroup struct {
5103}
5104
5105func (*awsAwsjson11_deserializeOpUpdateEndpointGroup) ID() string {
5106	return "OperationDeserializer"
5107}
5108
5109func (m *awsAwsjson11_deserializeOpUpdateEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5110	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5111) {
5112	out, metadata, err = next.HandleDeserialize(ctx, in)
5113	if err != nil {
5114		return out, metadata, err
5115	}
5116
5117	response, ok := out.RawResponse.(*smithyhttp.Response)
5118	if !ok {
5119		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5120	}
5121
5122	if response.StatusCode < 200 || response.StatusCode >= 300 {
5123		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateEndpointGroup(response, &metadata)
5124	}
5125	output := &UpdateEndpointGroupOutput{}
5126	out.Result = output
5127
5128	var buff [1024]byte
5129	ringBuffer := smithyio.NewRingBuffer(buff[:])
5130
5131	body := io.TeeReader(response.Body, ringBuffer)
5132	decoder := json.NewDecoder(body)
5133	decoder.UseNumber()
5134	var shape interface{}
5135	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5136		var snapshot bytes.Buffer
5137		io.Copy(&snapshot, ringBuffer)
5138		err = &smithy.DeserializationError{
5139			Err:      fmt.Errorf("failed to decode response body, %w", err),
5140			Snapshot: snapshot.Bytes(),
5141		}
5142		return out, metadata, err
5143	}
5144
5145	err = awsAwsjson11_deserializeOpDocumentUpdateEndpointGroupOutput(&output, shape)
5146	if err != nil {
5147		var snapshot bytes.Buffer
5148		io.Copy(&snapshot, ringBuffer)
5149		err = &smithy.DeserializationError{
5150			Err:      fmt.Errorf("failed to decode response body, %w", err),
5151			Snapshot: snapshot.Bytes(),
5152		}
5153		return out, metadata, err
5154	}
5155
5156	return out, metadata, err
5157}
5158
5159func awsAwsjson11_deserializeOpErrorUpdateEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5160	var errorBuffer bytes.Buffer
5161	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5162		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5163	}
5164	errorBody := bytes.NewReader(errorBuffer.Bytes())
5165
5166	errorCode := "UnknownError"
5167	errorMessage := errorCode
5168
5169	code := response.Header.Get("X-Amzn-ErrorType")
5170	if len(code) != 0 {
5171		errorCode = restjson.SanitizeErrorCode(code)
5172	}
5173
5174	var buff [1024]byte
5175	ringBuffer := smithyio.NewRingBuffer(buff[:])
5176
5177	body := io.TeeReader(errorBody, ringBuffer)
5178	decoder := json.NewDecoder(body)
5179	decoder.UseNumber()
5180	code, message, err := restjson.GetErrorInfo(decoder)
5181	if err != nil {
5182		var snapshot bytes.Buffer
5183		io.Copy(&snapshot, ringBuffer)
5184		err = &smithy.DeserializationError{
5185			Err:      fmt.Errorf("failed to decode response body, %w", err),
5186			Snapshot: snapshot.Bytes(),
5187		}
5188		return err
5189	}
5190
5191	errorBody.Seek(0, io.SeekStart)
5192	if len(code) != 0 {
5193		errorCode = restjson.SanitizeErrorCode(code)
5194	}
5195	if len(message) != 0 {
5196		errorMessage = message
5197	}
5198
5199	switch {
5200	case strings.EqualFold("AccessDeniedException", errorCode):
5201		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5202
5203	case strings.EqualFold("EndpointGroupNotFoundException", errorCode):
5204		return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody)
5205
5206	case strings.EqualFold("InternalServiceErrorException", errorCode):
5207		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5208
5209	case strings.EqualFold("InvalidArgumentException", errorCode):
5210		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
5211
5212	case strings.EqualFold("LimitExceededException", errorCode):
5213		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
5214
5215	default:
5216		genericError := &smithy.GenericAPIError{
5217			Code:    errorCode,
5218			Message: errorMessage,
5219		}
5220		return genericError
5221
5222	}
5223}
5224
5225type awsAwsjson11_deserializeOpUpdateListener struct {
5226}
5227
5228func (*awsAwsjson11_deserializeOpUpdateListener) ID() string {
5229	return "OperationDeserializer"
5230}
5231
5232func (m *awsAwsjson11_deserializeOpUpdateListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5233	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5234) {
5235	out, metadata, err = next.HandleDeserialize(ctx, in)
5236	if err != nil {
5237		return out, metadata, err
5238	}
5239
5240	response, ok := out.RawResponse.(*smithyhttp.Response)
5241	if !ok {
5242		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5243	}
5244
5245	if response.StatusCode < 200 || response.StatusCode >= 300 {
5246		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateListener(response, &metadata)
5247	}
5248	output := &UpdateListenerOutput{}
5249	out.Result = output
5250
5251	var buff [1024]byte
5252	ringBuffer := smithyio.NewRingBuffer(buff[:])
5253
5254	body := io.TeeReader(response.Body, ringBuffer)
5255	decoder := json.NewDecoder(body)
5256	decoder.UseNumber()
5257	var shape interface{}
5258	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5259		var snapshot bytes.Buffer
5260		io.Copy(&snapshot, ringBuffer)
5261		err = &smithy.DeserializationError{
5262			Err:      fmt.Errorf("failed to decode response body, %w", err),
5263			Snapshot: snapshot.Bytes(),
5264		}
5265		return out, metadata, err
5266	}
5267
5268	err = awsAwsjson11_deserializeOpDocumentUpdateListenerOutput(&output, shape)
5269	if err != nil {
5270		var snapshot bytes.Buffer
5271		io.Copy(&snapshot, ringBuffer)
5272		err = &smithy.DeserializationError{
5273			Err:      fmt.Errorf("failed to decode response body, %w", err),
5274			Snapshot: snapshot.Bytes(),
5275		}
5276		return out, metadata, err
5277	}
5278
5279	return out, metadata, err
5280}
5281
5282func awsAwsjson11_deserializeOpErrorUpdateListener(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5283	var errorBuffer bytes.Buffer
5284	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5285		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5286	}
5287	errorBody := bytes.NewReader(errorBuffer.Bytes())
5288
5289	errorCode := "UnknownError"
5290	errorMessage := errorCode
5291
5292	code := response.Header.Get("X-Amzn-ErrorType")
5293	if len(code) != 0 {
5294		errorCode = restjson.SanitizeErrorCode(code)
5295	}
5296
5297	var buff [1024]byte
5298	ringBuffer := smithyio.NewRingBuffer(buff[:])
5299
5300	body := io.TeeReader(errorBody, ringBuffer)
5301	decoder := json.NewDecoder(body)
5302	decoder.UseNumber()
5303	code, message, err := restjson.GetErrorInfo(decoder)
5304	if err != nil {
5305		var snapshot bytes.Buffer
5306		io.Copy(&snapshot, ringBuffer)
5307		err = &smithy.DeserializationError{
5308			Err:      fmt.Errorf("failed to decode response body, %w", err),
5309			Snapshot: snapshot.Bytes(),
5310		}
5311		return err
5312	}
5313
5314	errorBody.Seek(0, io.SeekStart)
5315	if len(code) != 0 {
5316		errorCode = restjson.SanitizeErrorCode(code)
5317	}
5318	if len(message) != 0 {
5319		errorMessage = message
5320	}
5321
5322	switch {
5323	case strings.EqualFold("InternalServiceErrorException", errorCode):
5324		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5325
5326	case strings.EqualFold("InvalidArgumentException", errorCode):
5327		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
5328
5329	case strings.EqualFold("InvalidPortRangeException", errorCode):
5330		return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody)
5331
5332	case strings.EqualFold("LimitExceededException", errorCode):
5333		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
5334
5335	case strings.EqualFold("ListenerNotFoundException", errorCode):
5336		return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody)
5337
5338	default:
5339		genericError := &smithy.GenericAPIError{
5340			Code:    errorCode,
5341			Message: errorMessage,
5342		}
5343		return genericError
5344
5345	}
5346}
5347
5348type awsAwsjson11_deserializeOpWithdrawByoipCidr struct {
5349}
5350
5351func (*awsAwsjson11_deserializeOpWithdrawByoipCidr) ID() string {
5352	return "OperationDeserializer"
5353}
5354
5355func (m *awsAwsjson11_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5356	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5357) {
5358	out, metadata, err = next.HandleDeserialize(ctx, in)
5359	if err != nil {
5360		return out, metadata, err
5361	}
5362
5363	response, ok := out.RawResponse.(*smithyhttp.Response)
5364	if !ok {
5365		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5366	}
5367
5368	if response.StatusCode < 200 || response.StatusCode >= 300 {
5369		return out, metadata, awsAwsjson11_deserializeOpErrorWithdrawByoipCidr(response, &metadata)
5370	}
5371	output := &WithdrawByoipCidrOutput{}
5372	out.Result = output
5373
5374	var buff [1024]byte
5375	ringBuffer := smithyio.NewRingBuffer(buff[:])
5376
5377	body := io.TeeReader(response.Body, ringBuffer)
5378	decoder := json.NewDecoder(body)
5379	decoder.UseNumber()
5380	var shape interface{}
5381	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5382		var snapshot bytes.Buffer
5383		io.Copy(&snapshot, ringBuffer)
5384		err = &smithy.DeserializationError{
5385			Err:      fmt.Errorf("failed to decode response body, %w", err),
5386			Snapshot: snapshot.Bytes(),
5387		}
5388		return out, metadata, err
5389	}
5390
5391	err = awsAwsjson11_deserializeOpDocumentWithdrawByoipCidrOutput(&output, shape)
5392	if err != nil {
5393		var snapshot bytes.Buffer
5394		io.Copy(&snapshot, ringBuffer)
5395		err = &smithy.DeserializationError{
5396			Err:      fmt.Errorf("failed to decode response body, %w", err),
5397			Snapshot: snapshot.Bytes(),
5398		}
5399		return out, metadata, err
5400	}
5401
5402	return out, metadata, err
5403}
5404
5405func awsAwsjson11_deserializeOpErrorWithdrawByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5406	var errorBuffer bytes.Buffer
5407	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5408		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5409	}
5410	errorBody := bytes.NewReader(errorBuffer.Bytes())
5411
5412	errorCode := "UnknownError"
5413	errorMessage := errorCode
5414
5415	code := response.Header.Get("X-Amzn-ErrorType")
5416	if len(code) != 0 {
5417		errorCode = restjson.SanitizeErrorCode(code)
5418	}
5419
5420	var buff [1024]byte
5421	ringBuffer := smithyio.NewRingBuffer(buff[:])
5422
5423	body := io.TeeReader(errorBody, ringBuffer)
5424	decoder := json.NewDecoder(body)
5425	decoder.UseNumber()
5426	code, message, err := restjson.GetErrorInfo(decoder)
5427	if err != nil {
5428		var snapshot bytes.Buffer
5429		io.Copy(&snapshot, ringBuffer)
5430		err = &smithy.DeserializationError{
5431			Err:      fmt.Errorf("failed to decode response body, %w", err),
5432			Snapshot: snapshot.Bytes(),
5433		}
5434		return err
5435	}
5436
5437	errorBody.Seek(0, io.SeekStart)
5438	if len(code) != 0 {
5439		errorCode = restjson.SanitizeErrorCode(code)
5440	}
5441	if len(message) != 0 {
5442		errorMessage = message
5443	}
5444
5445	switch {
5446	case strings.EqualFold("AccessDeniedException", errorCode):
5447		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5448
5449	case strings.EqualFold("ByoipCidrNotFoundException", errorCode):
5450		return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody)
5451
5452	case strings.EqualFold("IncorrectCidrStateException", errorCode):
5453		return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody)
5454
5455	case strings.EqualFold("InternalServiceErrorException", errorCode):
5456		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5457
5458	case strings.EqualFold("InvalidArgumentException", errorCode):
5459		return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody)
5460
5461	default:
5462		genericError := &smithy.GenericAPIError{
5463			Code:    errorCode,
5464			Message: errorMessage,
5465		}
5466		return genericError
5467
5468	}
5469}
5470
5471func awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5472	var buff [1024]byte
5473	ringBuffer := smithyio.NewRingBuffer(buff[:])
5474
5475	body := io.TeeReader(errorBody, ringBuffer)
5476	decoder := json.NewDecoder(body)
5477	decoder.UseNumber()
5478	var shape interface{}
5479	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5480		var snapshot bytes.Buffer
5481		io.Copy(&snapshot, ringBuffer)
5482		err = &smithy.DeserializationError{
5483			Err:      fmt.Errorf("failed to decode response body, %w", err),
5484			Snapshot: snapshot.Bytes(),
5485		}
5486		return err
5487	}
5488
5489	output := &types.AcceleratorNotDisabledException{}
5490	err := awsAwsjson11_deserializeDocumentAcceleratorNotDisabledException(&output, shape)
5491
5492	if err != nil {
5493		var snapshot bytes.Buffer
5494		io.Copy(&snapshot, ringBuffer)
5495		err = &smithy.DeserializationError{
5496			Err:      fmt.Errorf("failed to decode response body, %w", err),
5497			Snapshot: snapshot.Bytes(),
5498		}
5499		return err
5500	}
5501
5502	errorBody.Seek(0, io.SeekStart)
5503	return output
5504}
5505
5506func awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5507	var buff [1024]byte
5508	ringBuffer := smithyio.NewRingBuffer(buff[:])
5509
5510	body := io.TeeReader(errorBody, ringBuffer)
5511	decoder := json.NewDecoder(body)
5512	decoder.UseNumber()
5513	var shape interface{}
5514	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5515		var snapshot bytes.Buffer
5516		io.Copy(&snapshot, ringBuffer)
5517		err = &smithy.DeserializationError{
5518			Err:      fmt.Errorf("failed to decode response body, %w", err),
5519			Snapshot: snapshot.Bytes(),
5520		}
5521		return err
5522	}
5523
5524	output := &types.AcceleratorNotFoundException{}
5525	err := awsAwsjson11_deserializeDocumentAcceleratorNotFoundException(&output, shape)
5526
5527	if err != nil {
5528		var snapshot bytes.Buffer
5529		io.Copy(&snapshot, ringBuffer)
5530		err = &smithy.DeserializationError{
5531			Err:      fmt.Errorf("failed to decode response body, %w", err),
5532			Snapshot: snapshot.Bytes(),
5533		}
5534		return err
5535	}
5536
5537	errorBody.Seek(0, io.SeekStart)
5538	return output
5539}
5540
5541func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5542	var buff [1024]byte
5543	ringBuffer := smithyio.NewRingBuffer(buff[:])
5544
5545	body := io.TeeReader(errorBody, ringBuffer)
5546	decoder := json.NewDecoder(body)
5547	decoder.UseNumber()
5548	var shape interface{}
5549	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5550		var snapshot bytes.Buffer
5551		io.Copy(&snapshot, ringBuffer)
5552		err = &smithy.DeserializationError{
5553			Err:      fmt.Errorf("failed to decode response body, %w", err),
5554			Snapshot: snapshot.Bytes(),
5555		}
5556		return err
5557	}
5558
5559	output := &types.AccessDeniedException{}
5560	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
5561
5562	if err != nil {
5563		var snapshot bytes.Buffer
5564		io.Copy(&snapshot, ringBuffer)
5565		err = &smithy.DeserializationError{
5566			Err:      fmt.Errorf("failed to decode response body, %w", err),
5567			Snapshot: snapshot.Bytes(),
5568		}
5569		return err
5570	}
5571
5572	errorBody.Seek(0, io.SeekStart)
5573	return output
5574}
5575
5576func awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5577	var buff [1024]byte
5578	ringBuffer := smithyio.NewRingBuffer(buff[:])
5579
5580	body := io.TeeReader(errorBody, ringBuffer)
5581	decoder := json.NewDecoder(body)
5582	decoder.UseNumber()
5583	var shape interface{}
5584	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5585		var snapshot bytes.Buffer
5586		io.Copy(&snapshot, ringBuffer)
5587		err = &smithy.DeserializationError{
5588			Err:      fmt.Errorf("failed to decode response body, %w", err),
5589			Snapshot: snapshot.Bytes(),
5590		}
5591		return err
5592	}
5593
5594	output := &types.AssociatedEndpointGroupFoundException{}
5595	err := awsAwsjson11_deserializeDocumentAssociatedEndpointGroupFoundException(&output, shape)
5596
5597	if err != nil {
5598		var snapshot bytes.Buffer
5599		io.Copy(&snapshot, ringBuffer)
5600		err = &smithy.DeserializationError{
5601			Err:      fmt.Errorf("failed to decode response body, %w", err),
5602			Snapshot: snapshot.Bytes(),
5603		}
5604		return err
5605	}
5606
5607	errorBody.Seek(0, io.SeekStart)
5608	return output
5609}
5610
5611func awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5612	var buff [1024]byte
5613	ringBuffer := smithyio.NewRingBuffer(buff[:])
5614
5615	body := io.TeeReader(errorBody, ringBuffer)
5616	decoder := json.NewDecoder(body)
5617	decoder.UseNumber()
5618	var shape interface{}
5619	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5620		var snapshot bytes.Buffer
5621		io.Copy(&snapshot, ringBuffer)
5622		err = &smithy.DeserializationError{
5623			Err:      fmt.Errorf("failed to decode response body, %w", err),
5624			Snapshot: snapshot.Bytes(),
5625		}
5626		return err
5627	}
5628
5629	output := &types.AssociatedListenerFoundException{}
5630	err := awsAwsjson11_deserializeDocumentAssociatedListenerFoundException(&output, shape)
5631
5632	if err != nil {
5633		var snapshot bytes.Buffer
5634		io.Copy(&snapshot, ringBuffer)
5635		err = &smithy.DeserializationError{
5636			Err:      fmt.Errorf("failed to decode response body, %w", err),
5637			Snapshot: snapshot.Bytes(),
5638		}
5639		return err
5640	}
5641
5642	errorBody.Seek(0, io.SeekStart)
5643	return output
5644}
5645
5646func awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5647	var buff [1024]byte
5648	ringBuffer := smithyio.NewRingBuffer(buff[:])
5649
5650	body := io.TeeReader(errorBody, ringBuffer)
5651	decoder := json.NewDecoder(body)
5652	decoder.UseNumber()
5653	var shape interface{}
5654	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5655		var snapshot bytes.Buffer
5656		io.Copy(&snapshot, ringBuffer)
5657		err = &smithy.DeserializationError{
5658			Err:      fmt.Errorf("failed to decode response body, %w", err),
5659			Snapshot: snapshot.Bytes(),
5660		}
5661		return err
5662	}
5663
5664	output := &types.ByoipCidrNotFoundException{}
5665	err := awsAwsjson11_deserializeDocumentByoipCidrNotFoundException(&output, shape)
5666
5667	if err != nil {
5668		var snapshot bytes.Buffer
5669		io.Copy(&snapshot, ringBuffer)
5670		err = &smithy.DeserializationError{
5671			Err:      fmt.Errorf("failed to decode response body, %w", err),
5672			Snapshot: snapshot.Bytes(),
5673		}
5674		return err
5675	}
5676
5677	errorBody.Seek(0, io.SeekStart)
5678	return output
5679}
5680
5681func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5682	var buff [1024]byte
5683	ringBuffer := smithyio.NewRingBuffer(buff[:])
5684
5685	body := io.TeeReader(errorBody, ringBuffer)
5686	decoder := json.NewDecoder(body)
5687	decoder.UseNumber()
5688	var shape interface{}
5689	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5690		var snapshot bytes.Buffer
5691		io.Copy(&snapshot, ringBuffer)
5692		err = &smithy.DeserializationError{
5693			Err:      fmt.Errorf("failed to decode response body, %w", err),
5694			Snapshot: snapshot.Bytes(),
5695		}
5696		return err
5697	}
5698
5699	output := &types.ConflictException{}
5700	err := awsAwsjson11_deserializeDocumentConflictException(&output, shape)
5701
5702	if err != nil {
5703		var snapshot bytes.Buffer
5704		io.Copy(&snapshot, ringBuffer)
5705		err = &smithy.DeserializationError{
5706			Err:      fmt.Errorf("failed to decode response body, %w", err),
5707			Snapshot: snapshot.Bytes(),
5708		}
5709		return err
5710	}
5711
5712	errorBody.Seek(0, io.SeekStart)
5713	return output
5714}
5715
5716func awsAwsjson11_deserializeErrorEndpointAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5717	var buff [1024]byte
5718	ringBuffer := smithyio.NewRingBuffer(buff[:])
5719
5720	body := io.TeeReader(errorBody, ringBuffer)
5721	decoder := json.NewDecoder(body)
5722	decoder.UseNumber()
5723	var shape interface{}
5724	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5725		var snapshot bytes.Buffer
5726		io.Copy(&snapshot, ringBuffer)
5727		err = &smithy.DeserializationError{
5728			Err:      fmt.Errorf("failed to decode response body, %w", err),
5729			Snapshot: snapshot.Bytes(),
5730		}
5731		return err
5732	}
5733
5734	output := &types.EndpointAlreadyExistsException{}
5735	err := awsAwsjson11_deserializeDocumentEndpointAlreadyExistsException(&output, shape)
5736
5737	if err != nil {
5738		var snapshot bytes.Buffer
5739		io.Copy(&snapshot, ringBuffer)
5740		err = &smithy.DeserializationError{
5741			Err:      fmt.Errorf("failed to decode response body, %w", err),
5742			Snapshot: snapshot.Bytes(),
5743		}
5744		return err
5745	}
5746
5747	errorBody.Seek(0, io.SeekStart)
5748	return output
5749}
5750
5751func awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5752	var buff [1024]byte
5753	ringBuffer := smithyio.NewRingBuffer(buff[:])
5754
5755	body := io.TeeReader(errorBody, ringBuffer)
5756	decoder := json.NewDecoder(body)
5757	decoder.UseNumber()
5758	var shape interface{}
5759	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5760		var snapshot bytes.Buffer
5761		io.Copy(&snapshot, ringBuffer)
5762		err = &smithy.DeserializationError{
5763			Err:      fmt.Errorf("failed to decode response body, %w", err),
5764			Snapshot: snapshot.Bytes(),
5765		}
5766		return err
5767	}
5768
5769	output := &types.EndpointGroupAlreadyExistsException{}
5770	err := awsAwsjson11_deserializeDocumentEndpointGroupAlreadyExistsException(&output, shape)
5771
5772	if err != nil {
5773		var snapshot bytes.Buffer
5774		io.Copy(&snapshot, ringBuffer)
5775		err = &smithy.DeserializationError{
5776			Err:      fmt.Errorf("failed to decode response body, %w", err),
5777			Snapshot: snapshot.Bytes(),
5778		}
5779		return err
5780	}
5781
5782	errorBody.Seek(0, io.SeekStart)
5783	return output
5784}
5785
5786func awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5787	var buff [1024]byte
5788	ringBuffer := smithyio.NewRingBuffer(buff[:])
5789
5790	body := io.TeeReader(errorBody, ringBuffer)
5791	decoder := json.NewDecoder(body)
5792	decoder.UseNumber()
5793	var shape interface{}
5794	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5795		var snapshot bytes.Buffer
5796		io.Copy(&snapshot, ringBuffer)
5797		err = &smithy.DeserializationError{
5798			Err:      fmt.Errorf("failed to decode response body, %w", err),
5799			Snapshot: snapshot.Bytes(),
5800		}
5801		return err
5802	}
5803
5804	output := &types.EndpointGroupNotFoundException{}
5805	err := awsAwsjson11_deserializeDocumentEndpointGroupNotFoundException(&output, shape)
5806
5807	if err != nil {
5808		var snapshot bytes.Buffer
5809		io.Copy(&snapshot, ringBuffer)
5810		err = &smithy.DeserializationError{
5811			Err:      fmt.Errorf("failed to decode response body, %w", err),
5812			Snapshot: snapshot.Bytes(),
5813		}
5814		return err
5815	}
5816
5817	errorBody.Seek(0, io.SeekStart)
5818	return output
5819}
5820
5821func awsAwsjson11_deserializeErrorEndpointNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5822	var buff [1024]byte
5823	ringBuffer := smithyio.NewRingBuffer(buff[:])
5824
5825	body := io.TeeReader(errorBody, ringBuffer)
5826	decoder := json.NewDecoder(body)
5827	decoder.UseNumber()
5828	var shape interface{}
5829	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5830		var snapshot bytes.Buffer
5831		io.Copy(&snapshot, ringBuffer)
5832		err = &smithy.DeserializationError{
5833			Err:      fmt.Errorf("failed to decode response body, %w", err),
5834			Snapshot: snapshot.Bytes(),
5835		}
5836		return err
5837	}
5838
5839	output := &types.EndpointNotFoundException{}
5840	err := awsAwsjson11_deserializeDocumentEndpointNotFoundException(&output, shape)
5841
5842	if err != nil {
5843		var snapshot bytes.Buffer
5844		io.Copy(&snapshot, ringBuffer)
5845		err = &smithy.DeserializationError{
5846			Err:      fmt.Errorf("failed to decode response body, %w", err),
5847			Snapshot: snapshot.Bytes(),
5848		}
5849		return err
5850	}
5851
5852	errorBody.Seek(0, io.SeekStart)
5853	return output
5854}
5855
5856func awsAwsjson11_deserializeErrorIncorrectCidrStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5857	var buff [1024]byte
5858	ringBuffer := smithyio.NewRingBuffer(buff[:])
5859
5860	body := io.TeeReader(errorBody, ringBuffer)
5861	decoder := json.NewDecoder(body)
5862	decoder.UseNumber()
5863	var shape interface{}
5864	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5865		var snapshot bytes.Buffer
5866		io.Copy(&snapshot, ringBuffer)
5867		err = &smithy.DeserializationError{
5868			Err:      fmt.Errorf("failed to decode response body, %w", err),
5869			Snapshot: snapshot.Bytes(),
5870		}
5871		return err
5872	}
5873
5874	output := &types.IncorrectCidrStateException{}
5875	err := awsAwsjson11_deserializeDocumentIncorrectCidrStateException(&output, shape)
5876
5877	if err != nil {
5878		var snapshot bytes.Buffer
5879		io.Copy(&snapshot, ringBuffer)
5880		err = &smithy.DeserializationError{
5881			Err:      fmt.Errorf("failed to decode response body, %w", err),
5882			Snapshot: snapshot.Bytes(),
5883		}
5884		return err
5885	}
5886
5887	errorBody.Seek(0, io.SeekStart)
5888	return output
5889}
5890
5891func awsAwsjson11_deserializeErrorInternalServiceErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5892	var buff [1024]byte
5893	ringBuffer := smithyio.NewRingBuffer(buff[:])
5894
5895	body := io.TeeReader(errorBody, ringBuffer)
5896	decoder := json.NewDecoder(body)
5897	decoder.UseNumber()
5898	var shape interface{}
5899	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5900		var snapshot bytes.Buffer
5901		io.Copy(&snapshot, ringBuffer)
5902		err = &smithy.DeserializationError{
5903			Err:      fmt.Errorf("failed to decode response body, %w", err),
5904			Snapshot: snapshot.Bytes(),
5905		}
5906		return err
5907	}
5908
5909	output := &types.InternalServiceErrorException{}
5910	err := awsAwsjson11_deserializeDocumentInternalServiceErrorException(&output, shape)
5911
5912	if err != nil {
5913		var snapshot bytes.Buffer
5914		io.Copy(&snapshot, ringBuffer)
5915		err = &smithy.DeserializationError{
5916			Err:      fmt.Errorf("failed to decode response body, %w", err),
5917			Snapshot: snapshot.Bytes(),
5918		}
5919		return err
5920	}
5921
5922	errorBody.Seek(0, io.SeekStart)
5923	return output
5924}
5925
5926func awsAwsjson11_deserializeErrorInvalidArgumentException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5927	var buff [1024]byte
5928	ringBuffer := smithyio.NewRingBuffer(buff[:])
5929
5930	body := io.TeeReader(errorBody, ringBuffer)
5931	decoder := json.NewDecoder(body)
5932	decoder.UseNumber()
5933	var shape interface{}
5934	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5935		var snapshot bytes.Buffer
5936		io.Copy(&snapshot, ringBuffer)
5937		err = &smithy.DeserializationError{
5938			Err:      fmt.Errorf("failed to decode response body, %w", err),
5939			Snapshot: snapshot.Bytes(),
5940		}
5941		return err
5942	}
5943
5944	output := &types.InvalidArgumentException{}
5945	err := awsAwsjson11_deserializeDocumentInvalidArgumentException(&output, shape)
5946
5947	if err != nil {
5948		var snapshot bytes.Buffer
5949		io.Copy(&snapshot, ringBuffer)
5950		err = &smithy.DeserializationError{
5951			Err:      fmt.Errorf("failed to decode response body, %w", err),
5952			Snapshot: snapshot.Bytes(),
5953		}
5954		return err
5955	}
5956
5957	errorBody.Seek(0, io.SeekStart)
5958	return output
5959}
5960
5961func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5962	var buff [1024]byte
5963	ringBuffer := smithyio.NewRingBuffer(buff[:])
5964
5965	body := io.TeeReader(errorBody, ringBuffer)
5966	decoder := json.NewDecoder(body)
5967	decoder.UseNumber()
5968	var shape interface{}
5969	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5970		var snapshot bytes.Buffer
5971		io.Copy(&snapshot, ringBuffer)
5972		err = &smithy.DeserializationError{
5973			Err:      fmt.Errorf("failed to decode response body, %w", err),
5974			Snapshot: snapshot.Bytes(),
5975		}
5976		return err
5977	}
5978
5979	output := &types.InvalidNextTokenException{}
5980	err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape)
5981
5982	if err != nil {
5983		var snapshot bytes.Buffer
5984		io.Copy(&snapshot, ringBuffer)
5985		err = &smithy.DeserializationError{
5986			Err:      fmt.Errorf("failed to decode response body, %w", err),
5987			Snapshot: snapshot.Bytes(),
5988		}
5989		return err
5990	}
5991
5992	errorBody.Seek(0, io.SeekStart)
5993	return output
5994}
5995
5996func awsAwsjson11_deserializeErrorInvalidPortRangeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
5997	var buff [1024]byte
5998	ringBuffer := smithyio.NewRingBuffer(buff[:])
5999
6000	body := io.TeeReader(errorBody, ringBuffer)
6001	decoder := json.NewDecoder(body)
6002	decoder.UseNumber()
6003	var shape interface{}
6004	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6005		var snapshot bytes.Buffer
6006		io.Copy(&snapshot, ringBuffer)
6007		err = &smithy.DeserializationError{
6008			Err:      fmt.Errorf("failed to decode response body, %w", err),
6009			Snapshot: snapshot.Bytes(),
6010		}
6011		return err
6012	}
6013
6014	output := &types.InvalidPortRangeException{}
6015	err := awsAwsjson11_deserializeDocumentInvalidPortRangeException(&output, shape)
6016
6017	if err != nil {
6018		var snapshot bytes.Buffer
6019		io.Copy(&snapshot, ringBuffer)
6020		err = &smithy.DeserializationError{
6021			Err:      fmt.Errorf("failed to decode response body, %w", err),
6022			Snapshot: snapshot.Bytes(),
6023		}
6024		return err
6025	}
6026
6027	errorBody.Seek(0, io.SeekStart)
6028	return output
6029}
6030
6031func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6032	var buff [1024]byte
6033	ringBuffer := smithyio.NewRingBuffer(buff[:])
6034
6035	body := io.TeeReader(errorBody, ringBuffer)
6036	decoder := json.NewDecoder(body)
6037	decoder.UseNumber()
6038	var shape interface{}
6039	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6040		var snapshot bytes.Buffer
6041		io.Copy(&snapshot, ringBuffer)
6042		err = &smithy.DeserializationError{
6043			Err:      fmt.Errorf("failed to decode response body, %w", err),
6044			Snapshot: snapshot.Bytes(),
6045		}
6046		return err
6047	}
6048
6049	output := &types.LimitExceededException{}
6050	err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
6051
6052	if err != nil {
6053		var snapshot bytes.Buffer
6054		io.Copy(&snapshot, ringBuffer)
6055		err = &smithy.DeserializationError{
6056			Err:      fmt.Errorf("failed to decode response body, %w", err),
6057			Snapshot: snapshot.Bytes(),
6058		}
6059		return err
6060	}
6061
6062	errorBody.Seek(0, io.SeekStart)
6063	return output
6064}
6065
6066func awsAwsjson11_deserializeErrorListenerNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6067	var buff [1024]byte
6068	ringBuffer := smithyio.NewRingBuffer(buff[:])
6069
6070	body := io.TeeReader(errorBody, ringBuffer)
6071	decoder := json.NewDecoder(body)
6072	decoder.UseNumber()
6073	var shape interface{}
6074	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6075		var snapshot bytes.Buffer
6076		io.Copy(&snapshot, ringBuffer)
6077		err = &smithy.DeserializationError{
6078			Err:      fmt.Errorf("failed to decode response body, %w", err),
6079			Snapshot: snapshot.Bytes(),
6080		}
6081		return err
6082	}
6083
6084	output := &types.ListenerNotFoundException{}
6085	err := awsAwsjson11_deserializeDocumentListenerNotFoundException(&output, shape)
6086
6087	if err != nil {
6088		var snapshot bytes.Buffer
6089		io.Copy(&snapshot, ringBuffer)
6090		err = &smithy.DeserializationError{
6091			Err:      fmt.Errorf("failed to decode response body, %w", err),
6092			Snapshot: snapshot.Bytes(),
6093		}
6094		return err
6095	}
6096
6097	errorBody.Seek(0, io.SeekStart)
6098	return output
6099}
6100
6101func awsAwsjson11_deserializeDocumentAccelerator(v **types.Accelerator, value interface{}) error {
6102	if v == nil {
6103		return fmt.Errorf("unexpected nil of type %T", v)
6104	}
6105	if value == nil {
6106		return nil
6107	}
6108
6109	shape, ok := value.(map[string]interface{})
6110	if !ok {
6111		return fmt.Errorf("unexpected JSON type %v", value)
6112	}
6113
6114	var sv *types.Accelerator
6115	if *v == nil {
6116		sv = &types.Accelerator{}
6117	} else {
6118		sv = *v
6119	}
6120
6121	for key, value := range shape {
6122		switch key {
6123		case "AcceleratorArn":
6124			if value != nil {
6125				jtv, ok := value.(string)
6126				if !ok {
6127					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6128				}
6129				sv.AcceleratorArn = ptr.String(jtv)
6130			}
6131
6132		case "CreatedTime":
6133			if value != nil {
6134				jtv, ok := value.(json.Number)
6135				if !ok {
6136					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
6137				}
6138				f64, err := jtv.Float64()
6139				if err != nil {
6140					return err
6141				}
6142				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
6143			}
6144
6145		case "DnsName":
6146			if value != nil {
6147				jtv, ok := value.(string)
6148				if !ok {
6149					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6150				}
6151				sv.DnsName = ptr.String(jtv)
6152			}
6153
6154		case "Enabled":
6155			if value != nil {
6156				jtv, ok := value.(bool)
6157				if !ok {
6158					return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
6159				}
6160				sv.Enabled = ptr.Bool(jtv)
6161			}
6162
6163		case "IpAddressType":
6164			if value != nil {
6165				jtv, ok := value.(string)
6166				if !ok {
6167					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
6168				}
6169				sv.IpAddressType = types.IpAddressType(jtv)
6170			}
6171
6172		case "IpSets":
6173			if err := awsAwsjson11_deserializeDocumentIpSets(&sv.IpSets, value); err != nil {
6174				return err
6175			}
6176
6177		case "LastModifiedTime":
6178			if value != nil {
6179				jtv, ok := value.(json.Number)
6180				if !ok {
6181					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
6182				}
6183				f64, err := jtv.Float64()
6184				if err != nil {
6185					return err
6186				}
6187				sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
6188			}
6189
6190		case "Name":
6191			if value != nil {
6192				jtv, ok := value.(string)
6193				if !ok {
6194					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6195				}
6196				sv.Name = ptr.String(jtv)
6197			}
6198
6199		case "Status":
6200			if value != nil {
6201				jtv, ok := value.(string)
6202				if !ok {
6203					return fmt.Errorf("expected AcceleratorStatus to be of type string, got %T instead", value)
6204				}
6205				sv.Status = types.AcceleratorStatus(jtv)
6206			}
6207
6208		default:
6209			_, _ = key, value
6210
6211		}
6212	}
6213	*v = sv
6214	return nil
6215}
6216
6217func awsAwsjson11_deserializeDocumentAcceleratorAttributes(v **types.AcceleratorAttributes, value interface{}) error {
6218	if v == nil {
6219		return fmt.Errorf("unexpected nil of type %T", v)
6220	}
6221	if value == nil {
6222		return nil
6223	}
6224
6225	shape, ok := value.(map[string]interface{})
6226	if !ok {
6227		return fmt.Errorf("unexpected JSON type %v", value)
6228	}
6229
6230	var sv *types.AcceleratorAttributes
6231	if *v == nil {
6232		sv = &types.AcceleratorAttributes{}
6233	} else {
6234		sv = *v
6235	}
6236
6237	for key, value := range shape {
6238		switch key {
6239		case "FlowLogsEnabled":
6240			if value != nil {
6241				jtv, ok := value.(bool)
6242				if !ok {
6243					return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
6244				}
6245				sv.FlowLogsEnabled = ptr.Bool(jtv)
6246			}
6247
6248		case "FlowLogsS3Bucket":
6249			if value != nil {
6250				jtv, ok := value.(string)
6251				if !ok {
6252					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6253				}
6254				sv.FlowLogsS3Bucket = ptr.String(jtv)
6255			}
6256
6257		case "FlowLogsS3Prefix":
6258			if value != nil {
6259				jtv, ok := value.(string)
6260				if !ok {
6261					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6262				}
6263				sv.FlowLogsS3Prefix = ptr.String(jtv)
6264			}
6265
6266		default:
6267			_, _ = key, value
6268
6269		}
6270	}
6271	*v = sv
6272	return nil
6273}
6274
6275func awsAwsjson11_deserializeDocumentAcceleratorNotDisabledException(v **types.AcceleratorNotDisabledException, value interface{}) error {
6276	if v == nil {
6277		return fmt.Errorf("unexpected nil of type %T", v)
6278	}
6279	if value == nil {
6280		return nil
6281	}
6282
6283	shape, ok := value.(map[string]interface{})
6284	if !ok {
6285		return fmt.Errorf("unexpected JSON type %v", value)
6286	}
6287
6288	var sv *types.AcceleratorNotDisabledException
6289	if *v == nil {
6290		sv = &types.AcceleratorNotDisabledException{}
6291	} else {
6292		sv = *v
6293	}
6294
6295	for key, value := range shape {
6296		switch key {
6297		case "Message":
6298			if value != nil {
6299				jtv, ok := value.(string)
6300				if !ok {
6301					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6302				}
6303				sv.Message = ptr.String(jtv)
6304			}
6305
6306		default:
6307			_, _ = key, value
6308
6309		}
6310	}
6311	*v = sv
6312	return nil
6313}
6314
6315func awsAwsjson11_deserializeDocumentAcceleratorNotFoundException(v **types.AcceleratorNotFoundException, value interface{}) error {
6316	if v == nil {
6317		return fmt.Errorf("unexpected nil of type %T", v)
6318	}
6319	if value == nil {
6320		return nil
6321	}
6322
6323	shape, ok := value.(map[string]interface{})
6324	if !ok {
6325		return fmt.Errorf("unexpected JSON type %v", value)
6326	}
6327
6328	var sv *types.AcceleratorNotFoundException
6329	if *v == nil {
6330		sv = &types.AcceleratorNotFoundException{}
6331	} else {
6332		sv = *v
6333	}
6334
6335	for key, value := range shape {
6336		switch key {
6337		case "Message":
6338			if value != nil {
6339				jtv, ok := value.(string)
6340				if !ok {
6341					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6342				}
6343				sv.Message = ptr.String(jtv)
6344			}
6345
6346		default:
6347			_, _ = key, value
6348
6349		}
6350	}
6351	*v = sv
6352	return nil
6353}
6354
6355func awsAwsjson11_deserializeDocumentAccelerators(v *[]types.Accelerator, value interface{}) error {
6356	if v == nil {
6357		return fmt.Errorf("unexpected nil of type %T", v)
6358	}
6359	if value == nil {
6360		return nil
6361	}
6362
6363	shape, ok := value.([]interface{})
6364	if !ok {
6365		return fmt.Errorf("unexpected JSON type %v", value)
6366	}
6367
6368	var cv []types.Accelerator
6369	if *v == nil {
6370		cv = []types.Accelerator{}
6371	} else {
6372		cv = *v
6373	}
6374
6375	for _, value := range shape {
6376		var col types.Accelerator
6377		destAddr := &col
6378		if err := awsAwsjson11_deserializeDocumentAccelerator(&destAddr, value); err != nil {
6379			return err
6380		}
6381		col = *destAddr
6382		cv = append(cv, col)
6383
6384	}
6385	*v = cv
6386	return nil
6387}
6388
6389func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
6390	if v == nil {
6391		return fmt.Errorf("unexpected nil of type %T", v)
6392	}
6393	if value == nil {
6394		return nil
6395	}
6396
6397	shape, ok := value.(map[string]interface{})
6398	if !ok {
6399		return fmt.Errorf("unexpected JSON type %v", value)
6400	}
6401
6402	var sv *types.AccessDeniedException
6403	if *v == nil {
6404		sv = &types.AccessDeniedException{}
6405	} else {
6406		sv = *v
6407	}
6408
6409	for key, value := range shape {
6410		switch key {
6411		case "Message":
6412			if value != nil {
6413				jtv, ok := value.(string)
6414				if !ok {
6415					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6416				}
6417				sv.Message = ptr.String(jtv)
6418			}
6419
6420		default:
6421			_, _ = key, value
6422
6423		}
6424	}
6425	*v = sv
6426	return nil
6427}
6428
6429func awsAwsjson11_deserializeDocumentAssociatedEndpointGroupFoundException(v **types.AssociatedEndpointGroupFoundException, value interface{}) error {
6430	if v == nil {
6431		return fmt.Errorf("unexpected nil of type %T", v)
6432	}
6433	if value == nil {
6434		return nil
6435	}
6436
6437	shape, ok := value.(map[string]interface{})
6438	if !ok {
6439		return fmt.Errorf("unexpected JSON type %v", value)
6440	}
6441
6442	var sv *types.AssociatedEndpointGroupFoundException
6443	if *v == nil {
6444		sv = &types.AssociatedEndpointGroupFoundException{}
6445	} else {
6446		sv = *v
6447	}
6448
6449	for key, value := range shape {
6450		switch key {
6451		case "Message":
6452			if value != nil {
6453				jtv, ok := value.(string)
6454				if !ok {
6455					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6456				}
6457				sv.Message = ptr.String(jtv)
6458			}
6459
6460		default:
6461			_, _ = key, value
6462
6463		}
6464	}
6465	*v = sv
6466	return nil
6467}
6468
6469func awsAwsjson11_deserializeDocumentAssociatedListenerFoundException(v **types.AssociatedListenerFoundException, value interface{}) error {
6470	if v == nil {
6471		return fmt.Errorf("unexpected nil of type %T", v)
6472	}
6473	if value == nil {
6474		return nil
6475	}
6476
6477	shape, ok := value.(map[string]interface{})
6478	if !ok {
6479		return fmt.Errorf("unexpected JSON type %v", value)
6480	}
6481
6482	var sv *types.AssociatedListenerFoundException
6483	if *v == nil {
6484		sv = &types.AssociatedListenerFoundException{}
6485	} else {
6486		sv = *v
6487	}
6488
6489	for key, value := range shape {
6490		switch key {
6491		case "Message":
6492			if value != nil {
6493				jtv, ok := value.(string)
6494				if !ok {
6495					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6496				}
6497				sv.Message = ptr.String(jtv)
6498			}
6499
6500		default:
6501			_, _ = key, value
6502
6503		}
6504	}
6505	*v = sv
6506	return nil
6507}
6508
6509func awsAwsjson11_deserializeDocumentByoipCidr(v **types.ByoipCidr, value interface{}) error {
6510	if v == nil {
6511		return fmt.Errorf("unexpected nil of type %T", v)
6512	}
6513	if value == nil {
6514		return nil
6515	}
6516
6517	shape, ok := value.(map[string]interface{})
6518	if !ok {
6519		return fmt.Errorf("unexpected JSON type %v", value)
6520	}
6521
6522	var sv *types.ByoipCidr
6523	if *v == nil {
6524		sv = &types.ByoipCidr{}
6525	} else {
6526		sv = *v
6527	}
6528
6529	for key, value := range shape {
6530		switch key {
6531		case "Cidr":
6532			if value != nil {
6533				jtv, ok := value.(string)
6534				if !ok {
6535					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6536				}
6537				sv.Cidr = ptr.String(jtv)
6538			}
6539
6540		case "Events":
6541			if err := awsAwsjson11_deserializeDocumentByoipCidrEvents(&sv.Events, value); err != nil {
6542				return err
6543			}
6544
6545		case "State":
6546			if value != nil {
6547				jtv, ok := value.(string)
6548				if !ok {
6549					return fmt.Errorf("expected ByoipCidrState to be of type string, got %T instead", value)
6550				}
6551				sv.State = types.ByoipCidrState(jtv)
6552			}
6553
6554		default:
6555			_, _ = key, value
6556
6557		}
6558	}
6559	*v = sv
6560	return nil
6561}
6562
6563func awsAwsjson11_deserializeDocumentByoipCidrEvent(v **types.ByoipCidrEvent, value interface{}) error {
6564	if v == nil {
6565		return fmt.Errorf("unexpected nil of type %T", v)
6566	}
6567	if value == nil {
6568		return nil
6569	}
6570
6571	shape, ok := value.(map[string]interface{})
6572	if !ok {
6573		return fmt.Errorf("unexpected JSON type %v", value)
6574	}
6575
6576	var sv *types.ByoipCidrEvent
6577	if *v == nil {
6578		sv = &types.ByoipCidrEvent{}
6579	} else {
6580		sv = *v
6581	}
6582
6583	for key, value := range shape {
6584		switch key {
6585		case "Message":
6586			if value != nil {
6587				jtv, ok := value.(string)
6588				if !ok {
6589					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6590				}
6591				sv.Message = ptr.String(jtv)
6592			}
6593
6594		case "Timestamp":
6595			if value != nil {
6596				jtv, ok := value.(json.Number)
6597				if !ok {
6598					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
6599				}
6600				f64, err := jtv.Float64()
6601				if err != nil {
6602					return err
6603				}
6604				sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
6605			}
6606
6607		default:
6608			_, _ = key, value
6609
6610		}
6611	}
6612	*v = sv
6613	return nil
6614}
6615
6616func awsAwsjson11_deserializeDocumentByoipCidrEvents(v *[]types.ByoipCidrEvent, value interface{}) error {
6617	if v == nil {
6618		return fmt.Errorf("unexpected nil of type %T", v)
6619	}
6620	if value == nil {
6621		return nil
6622	}
6623
6624	shape, ok := value.([]interface{})
6625	if !ok {
6626		return fmt.Errorf("unexpected JSON type %v", value)
6627	}
6628
6629	var cv []types.ByoipCidrEvent
6630	if *v == nil {
6631		cv = []types.ByoipCidrEvent{}
6632	} else {
6633		cv = *v
6634	}
6635
6636	for _, value := range shape {
6637		var col types.ByoipCidrEvent
6638		destAddr := &col
6639		if err := awsAwsjson11_deserializeDocumentByoipCidrEvent(&destAddr, value); err != nil {
6640			return err
6641		}
6642		col = *destAddr
6643		cv = append(cv, col)
6644
6645	}
6646	*v = cv
6647	return nil
6648}
6649
6650func awsAwsjson11_deserializeDocumentByoipCidrNotFoundException(v **types.ByoipCidrNotFoundException, value interface{}) error {
6651	if v == nil {
6652		return fmt.Errorf("unexpected nil of type %T", v)
6653	}
6654	if value == nil {
6655		return nil
6656	}
6657
6658	shape, ok := value.(map[string]interface{})
6659	if !ok {
6660		return fmt.Errorf("unexpected JSON type %v", value)
6661	}
6662
6663	var sv *types.ByoipCidrNotFoundException
6664	if *v == nil {
6665		sv = &types.ByoipCidrNotFoundException{}
6666	} else {
6667		sv = *v
6668	}
6669
6670	for key, value := range shape {
6671		switch key {
6672		case "Message":
6673			if value != nil {
6674				jtv, ok := value.(string)
6675				if !ok {
6676					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6677				}
6678				sv.Message = ptr.String(jtv)
6679			}
6680
6681		default:
6682			_, _ = key, value
6683
6684		}
6685	}
6686	*v = sv
6687	return nil
6688}
6689
6690func awsAwsjson11_deserializeDocumentByoipCidrs(v *[]types.ByoipCidr, value interface{}) error {
6691	if v == nil {
6692		return fmt.Errorf("unexpected nil of type %T", v)
6693	}
6694	if value == nil {
6695		return nil
6696	}
6697
6698	shape, ok := value.([]interface{})
6699	if !ok {
6700		return fmt.Errorf("unexpected JSON type %v", value)
6701	}
6702
6703	var cv []types.ByoipCidr
6704	if *v == nil {
6705		cv = []types.ByoipCidr{}
6706	} else {
6707		cv = *v
6708	}
6709
6710	for _, value := range shape {
6711		var col types.ByoipCidr
6712		destAddr := &col
6713		if err := awsAwsjson11_deserializeDocumentByoipCidr(&destAddr, value); err != nil {
6714			return err
6715		}
6716		col = *destAddr
6717		cv = append(cv, col)
6718
6719	}
6720	*v = cv
6721	return nil
6722}
6723
6724func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error {
6725	if v == nil {
6726		return fmt.Errorf("unexpected nil of type %T", v)
6727	}
6728	if value == nil {
6729		return nil
6730	}
6731
6732	shape, ok := value.(map[string]interface{})
6733	if !ok {
6734		return fmt.Errorf("unexpected JSON type %v", value)
6735	}
6736
6737	var sv *types.ConflictException
6738	if *v == nil {
6739		sv = &types.ConflictException{}
6740	} else {
6741		sv = *v
6742	}
6743
6744	for key, value := range shape {
6745		switch key {
6746		case "Message":
6747			if value != nil {
6748				jtv, ok := value.(string)
6749				if !ok {
6750					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
6751				}
6752				sv.Message = ptr.String(jtv)
6753			}
6754
6755		default:
6756			_, _ = key, value
6757
6758		}
6759	}
6760	*v = sv
6761	return nil
6762}
6763
6764func awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(v **types.CustomRoutingAccelerator, value interface{}) error {
6765	if v == nil {
6766		return fmt.Errorf("unexpected nil of type %T", v)
6767	}
6768	if value == nil {
6769		return nil
6770	}
6771
6772	shape, ok := value.(map[string]interface{})
6773	if !ok {
6774		return fmt.Errorf("unexpected JSON type %v", value)
6775	}
6776
6777	var sv *types.CustomRoutingAccelerator
6778	if *v == nil {
6779		sv = &types.CustomRoutingAccelerator{}
6780	} else {
6781		sv = *v
6782	}
6783
6784	for key, value := range shape {
6785		switch key {
6786		case "AcceleratorArn":
6787			if value != nil {
6788				jtv, ok := value.(string)
6789				if !ok {
6790					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6791				}
6792				sv.AcceleratorArn = ptr.String(jtv)
6793			}
6794
6795		case "CreatedTime":
6796			if value != nil {
6797				jtv, ok := value.(json.Number)
6798				if !ok {
6799					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
6800				}
6801				f64, err := jtv.Float64()
6802				if err != nil {
6803					return err
6804				}
6805				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
6806			}
6807
6808		case "DnsName":
6809			if value != nil {
6810				jtv, ok := value.(string)
6811				if !ok {
6812					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6813				}
6814				sv.DnsName = ptr.String(jtv)
6815			}
6816
6817		case "Enabled":
6818			if value != nil {
6819				jtv, ok := value.(bool)
6820				if !ok {
6821					return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
6822				}
6823				sv.Enabled = ptr.Bool(jtv)
6824			}
6825
6826		case "IpAddressType":
6827			if value != nil {
6828				jtv, ok := value.(string)
6829				if !ok {
6830					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
6831				}
6832				sv.IpAddressType = types.IpAddressType(jtv)
6833			}
6834
6835		case "IpSets":
6836			if err := awsAwsjson11_deserializeDocumentIpSets(&sv.IpSets, value); err != nil {
6837				return err
6838			}
6839
6840		case "LastModifiedTime":
6841			if value != nil {
6842				jtv, ok := value.(json.Number)
6843				if !ok {
6844					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
6845				}
6846				f64, err := jtv.Float64()
6847				if err != nil {
6848					return err
6849				}
6850				sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
6851			}
6852
6853		case "Name":
6854			if value != nil {
6855				jtv, ok := value.(string)
6856				if !ok {
6857					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6858				}
6859				sv.Name = ptr.String(jtv)
6860			}
6861
6862		case "Status":
6863			if value != nil {
6864				jtv, ok := value.(string)
6865				if !ok {
6866					return fmt.Errorf("expected CustomRoutingAcceleratorStatus to be of type string, got %T instead", value)
6867				}
6868				sv.Status = types.CustomRoutingAcceleratorStatus(jtv)
6869			}
6870
6871		default:
6872			_, _ = key, value
6873
6874		}
6875	}
6876	*v = sv
6877	return nil
6878}
6879
6880func awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(v **types.CustomRoutingAcceleratorAttributes, value interface{}) error {
6881	if v == nil {
6882		return fmt.Errorf("unexpected nil of type %T", v)
6883	}
6884	if value == nil {
6885		return nil
6886	}
6887
6888	shape, ok := value.(map[string]interface{})
6889	if !ok {
6890		return fmt.Errorf("unexpected JSON type %v", value)
6891	}
6892
6893	var sv *types.CustomRoutingAcceleratorAttributes
6894	if *v == nil {
6895		sv = &types.CustomRoutingAcceleratorAttributes{}
6896	} else {
6897		sv = *v
6898	}
6899
6900	for key, value := range shape {
6901		switch key {
6902		case "FlowLogsEnabled":
6903			if value != nil {
6904				jtv, ok := value.(bool)
6905				if !ok {
6906					return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
6907				}
6908				sv.FlowLogsEnabled = ptr.Bool(jtv)
6909			}
6910
6911		case "FlowLogsS3Bucket":
6912			if value != nil {
6913				jtv, ok := value.(string)
6914				if !ok {
6915					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6916				}
6917				sv.FlowLogsS3Bucket = ptr.String(jtv)
6918			}
6919
6920		case "FlowLogsS3Prefix":
6921			if value != nil {
6922				jtv, ok := value.(string)
6923				if !ok {
6924					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
6925				}
6926				sv.FlowLogsS3Prefix = ptr.String(jtv)
6927			}
6928
6929		default:
6930			_, _ = key, value
6931
6932		}
6933	}
6934	*v = sv
6935	return nil
6936}
6937
6938func awsAwsjson11_deserializeDocumentCustomRoutingAccelerators(v *[]types.CustomRoutingAccelerator, value interface{}) error {
6939	if v == nil {
6940		return fmt.Errorf("unexpected nil of type %T", v)
6941	}
6942	if value == nil {
6943		return nil
6944	}
6945
6946	shape, ok := value.([]interface{})
6947	if !ok {
6948		return fmt.Errorf("unexpected JSON type %v", value)
6949	}
6950
6951	var cv []types.CustomRoutingAccelerator
6952	if *v == nil {
6953		cv = []types.CustomRoutingAccelerator{}
6954	} else {
6955		cv = *v
6956	}
6957
6958	for _, value := range shape {
6959		var col types.CustomRoutingAccelerator
6960		destAddr := &col
6961		if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&destAddr, value); err != nil {
6962			return err
6963		}
6964		col = *destAddr
6965		cv = append(cv, col)
6966
6967	}
6968	*v = cv
6969	return nil
6970}
6971
6972func awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescription(v **types.CustomRoutingDestinationDescription, value interface{}) error {
6973	if v == nil {
6974		return fmt.Errorf("unexpected nil of type %T", v)
6975	}
6976	if value == nil {
6977		return nil
6978	}
6979
6980	shape, ok := value.(map[string]interface{})
6981	if !ok {
6982		return fmt.Errorf("unexpected JSON type %v", value)
6983	}
6984
6985	var sv *types.CustomRoutingDestinationDescription
6986	if *v == nil {
6987		sv = &types.CustomRoutingDestinationDescription{}
6988	} else {
6989		sv = *v
6990	}
6991
6992	for key, value := range shape {
6993		switch key {
6994		case "FromPort":
6995			if value != nil {
6996				jtv, ok := value.(json.Number)
6997				if !ok {
6998					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
6999				}
7000				i64, err := jtv.Int64()
7001				if err != nil {
7002					return err
7003				}
7004				sv.FromPort = ptr.Int32(int32(i64))
7005			}
7006
7007		case "Protocols":
7008			if err := awsAwsjson11_deserializeDocumentProtocols(&sv.Protocols, value); err != nil {
7009				return err
7010			}
7011
7012		case "ToPort":
7013			if value != nil {
7014				jtv, ok := value.(json.Number)
7015				if !ok {
7016					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
7017				}
7018				i64, err := jtv.Int64()
7019				if err != nil {
7020					return err
7021				}
7022				sv.ToPort = ptr.Int32(int32(i64))
7023			}
7024
7025		default:
7026			_, _ = key, value
7027
7028		}
7029	}
7030	*v = sv
7031	return nil
7032}
7033
7034func awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescriptions(v *[]types.CustomRoutingDestinationDescription, value interface{}) error {
7035	if v == nil {
7036		return fmt.Errorf("unexpected nil of type %T", v)
7037	}
7038	if value == nil {
7039		return nil
7040	}
7041
7042	shape, ok := value.([]interface{})
7043	if !ok {
7044		return fmt.Errorf("unexpected JSON type %v", value)
7045	}
7046
7047	var cv []types.CustomRoutingDestinationDescription
7048	if *v == nil {
7049		cv = []types.CustomRoutingDestinationDescription{}
7050	} else {
7051		cv = *v
7052	}
7053
7054	for _, value := range shape {
7055		var col types.CustomRoutingDestinationDescription
7056		destAddr := &col
7057		if err := awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescription(&destAddr, value); err != nil {
7058			return err
7059		}
7060		col = *destAddr
7061		cv = append(cv, col)
7062
7063	}
7064	*v = cv
7065	return nil
7066}
7067
7068func awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescription(v **types.CustomRoutingEndpointDescription, value interface{}) error {
7069	if v == nil {
7070		return fmt.Errorf("unexpected nil of type %T", v)
7071	}
7072	if value == nil {
7073		return nil
7074	}
7075
7076	shape, ok := value.(map[string]interface{})
7077	if !ok {
7078		return fmt.Errorf("unexpected JSON type %v", value)
7079	}
7080
7081	var sv *types.CustomRoutingEndpointDescription
7082	if *v == nil {
7083		sv = &types.CustomRoutingEndpointDescription{}
7084	} else {
7085		sv = *v
7086	}
7087
7088	for key, value := range shape {
7089		switch key {
7090		case "EndpointId":
7091			if value != nil {
7092				jtv, ok := value.(string)
7093				if !ok {
7094					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7095				}
7096				sv.EndpointId = ptr.String(jtv)
7097			}
7098
7099		default:
7100			_, _ = key, value
7101
7102		}
7103	}
7104	*v = sv
7105	return nil
7106}
7107
7108func awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(v *[]types.CustomRoutingEndpointDescription, value interface{}) error {
7109	if v == nil {
7110		return fmt.Errorf("unexpected nil of type %T", v)
7111	}
7112	if value == nil {
7113		return nil
7114	}
7115
7116	shape, ok := value.([]interface{})
7117	if !ok {
7118		return fmt.Errorf("unexpected JSON type %v", value)
7119	}
7120
7121	var cv []types.CustomRoutingEndpointDescription
7122	if *v == nil {
7123		cv = []types.CustomRoutingEndpointDescription{}
7124	} else {
7125		cv = *v
7126	}
7127
7128	for _, value := range shape {
7129		var col types.CustomRoutingEndpointDescription
7130		destAddr := &col
7131		if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescription(&destAddr, value); err != nil {
7132			return err
7133		}
7134		col = *destAddr
7135		cv = append(cv, col)
7136
7137	}
7138	*v = cv
7139	return nil
7140}
7141
7142func awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(v **types.CustomRoutingEndpointGroup, value interface{}) error {
7143	if v == nil {
7144		return fmt.Errorf("unexpected nil of type %T", v)
7145	}
7146	if value == nil {
7147		return nil
7148	}
7149
7150	shape, ok := value.(map[string]interface{})
7151	if !ok {
7152		return fmt.Errorf("unexpected JSON type %v", value)
7153	}
7154
7155	var sv *types.CustomRoutingEndpointGroup
7156	if *v == nil {
7157		sv = &types.CustomRoutingEndpointGroup{}
7158	} else {
7159		sv = *v
7160	}
7161
7162	for key, value := range shape {
7163		switch key {
7164		case "DestinationDescriptions":
7165			if err := awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescriptions(&sv.DestinationDescriptions, value); err != nil {
7166				return err
7167			}
7168
7169		case "EndpointDescriptions":
7170			if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil {
7171				return err
7172			}
7173
7174		case "EndpointGroupArn":
7175			if value != nil {
7176				jtv, ok := value.(string)
7177				if !ok {
7178					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7179				}
7180				sv.EndpointGroupArn = ptr.String(jtv)
7181			}
7182
7183		case "EndpointGroupRegion":
7184			if value != nil {
7185				jtv, ok := value.(string)
7186				if !ok {
7187					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7188				}
7189				sv.EndpointGroupRegion = ptr.String(jtv)
7190			}
7191
7192		default:
7193			_, _ = key, value
7194
7195		}
7196	}
7197	*v = sv
7198	return nil
7199}
7200
7201func awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroups(v *[]types.CustomRoutingEndpointGroup, 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.([]interface{})
7210	if !ok {
7211		return fmt.Errorf("unexpected JSON type %v", value)
7212	}
7213
7214	var cv []types.CustomRoutingEndpointGroup
7215	if *v == nil {
7216		cv = []types.CustomRoutingEndpointGroup{}
7217	} else {
7218		cv = *v
7219	}
7220
7221	for _, value := range shape {
7222		var col types.CustomRoutingEndpointGroup
7223		destAddr := &col
7224		if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&destAddr, value); err != nil {
7225			return err
7226		}
7227		col = *destAddr
7228		cv = append(cv, col)
7229
7230	}
7231	*v = cv
7232	return nil
7233}
7234
7235func awsAwsjson11_deserializeDocumentCustomRoutingListener(v **types.CustomRoutingListener, value interface{}) error {
7236	if v == nil {
7237		return fmt.Errorf("unexpected nil of type %T", v)
7238	}
7239	if value == nil {
7240		return nil
7241	}
7242
7243	shape, ok := value.(map[string]interface{})
7244	if !ok {
7245		return fmt.Errorf("unexpected JSON type %v", value)
7246	}
7247
7248	var sv *types.CustomRoutingListener
7249	if *v == nil {
7250		sv = &types.CustomRoutingListener{}
7251	} else {
7252		sv = *v
7253	}
7254
7255	for key, value := range shape {
7256		switch key {
7257		case "ListenerArn":
7258			if value != nil {
7259				jtv, ok := value.(string)
7260				if !ok {
7261					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7262				}
7263				sv.ListenerArn = ptr.String(jtv)
7264			}
7265
7266		case "PortRanges":
7267			if err := awsAwsjson11_deserializeDocumentPortRanges(&sv.PortRanges, value); err != nil {
7268				return err
7269			}
7270
7271		default:
7272			_, _ = key, value
7273
7274		}
7275	}
7276	*v = sv
7277	return nil
7278}
7279
7280func awsAwsjson11_deserializeDocumentCustomRoutingListeners(v *[]types.CustomRoutingListener, value interface{}) error {
7281	if v == nil {
7282		return fmt.Errorf("unexpected nil of type %T", v)
7283	}
7284	if value == nil {
7285		return nil
7286	}
7287
7288	shape, ok := value.([]interface{})
7289	if !ok {
7290		return fmt.Errorf("unexpected JSON type %v", value)
7291	}
7292
7293	var cv []types.CustomRoutingListener
7294	if *v == nil {
7295		cv = []types.CustomRoutingListener{}
7296	} else {
7297		cv = *v
7298	}
7299
7300	for _, value := range shape {
7301		var col types.CustomRoutingListener
7302		destAddr := &col
7303		if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&destAddr, value); err != nil {
7304			return err
7305		}
7306		col = *destAddr
7307		cv = append(cv, col)
7308
7309	}
7310	*v = cv
7311	return nil
7312}
7313
7314func awsAwsjson11_deserializeDocumentCustomRoutingProtocols(v *[]types.CustomRoutingProtocol, value interface{}) error {
7315	if v == nil {
7316		return fmt.Errorf("unexpected nil of type %T", v)
7317	}
7318	if value == nil {
7319		return nil
7320	}
7321
7322	shape, ok := value.([]interface{})
7323	if !ok {
7324		return fmt.Errorf("unexpected JSON type %v", value)
7325	}
7326
7327	var cv []types.CustomRoutingProtocol
7328	if *v == nil {
7329		cv = []types.CustomRoutingProtocol{}
7330	} else {
7331		cv = *v
7332	}
7333
7334	for _, value := range shape {
7335		var col types.CustomRoutingProtocol
7336		if value != nil {
7337			jtv, ok := value.(string)
7338			if !ok {
7339				return fmt.Errorf("expected CustomRoutingProtocol to be of type string, got %T instead", value)
7340			}
7341			col = types.CustomRoutingProtocol(jtv)
7342		}
7343		cv = append(cv, col)
7344
7345	}
7346	*v = cv
7347	return nil
7348}
7349
7350func awsAwsjson11_deserializeDocumentDestinationPortMapping(v **types.DestinationPortMapping, value interface{}) error {
7351	if v == nil {
7352		return fmt.Errorf("unexpected nil of type %T", v)
7353	}
7354	if value == nil {
7355		return nil
7356	}
7357
7358	shape, ok := value.(map[string]interface{})
7359	if !ok {
7360		return fmt.Errorf("unexpected JSON type %v", value)
7361	}
7362
7363	var sv *types.DestinationPortMapping
7364	if *v == nil {
7365		sv = &types.DestinationPortMapping{}
7366	} else {
7367		sv = *v
7368	}
7369
7370	for key, value := range shape {
7371		switch key {
7372		case "AcceleratorArn":
7373			if value != nil {
7374				jtv, ok := value.(string)
7375				if !ok {
7376					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7377				}
7378				sv.AcceleratorArn = ptr.String(jtv)
7379			}
7380
7381		case "AcceleratorSocketAddresses":
7382			if err := awsAwsjson11_deserializeDocumentSocketAddresses(&sv.AcceleratorSocketAddresses, value); err != nil {
7383				return err
7384			}
7385
7386		case "DestinationSocketAddress":
7387			if err := awsAwsjson11_deserializeDocumentSocketAddress(&sv.DestinationSocketAddress, value); err != nil {
7388				return err
7389			}
7390
7391		case "DestinationTrafficState":
7392			if value != nil {
7393				jtv, ok := value.(string)
7394				if !ok {
7395					return fmt.Errorf("expected CustomRoutingDestinationTrafficState to be of type string, got %T instead", value)
7396				}
7397				sv.DestinationTrafficState = types.CustomRoutingDestinationTrafficState(jtv)
7398			}
7399
7400		case "EndpointGroupArn":
7401			if value != nil {
7402				jtv, ok := value.(string)
7403				if !ok {
7404					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7405				}
7406				sv.EndpointGroupArn = ptr.String(jtv)
7407			}
7408
7409		case "EndpointGroupRegion":
7410			if value != nil {
7411				jtv, ok := value.(string)
7412				if !ok {
7413					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7414				}
7415				sv.EndpointGroupRegion = ptr.String(jtv)
7416			}
7417
7418		case "EndpointId":
7419			if value != nil {
7420				jtv, ok := value.(string)
7421				if !ok {
7422					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7423				}
7424				sv.EndpointId = ptr.String(jtv)
7425			}
7426
7427		case "IpAddressType":
7428			if value != nil {
7429				jtv, ok := value.(string)
7430				if !ok {
7431					return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value)
7432				}
7433				sv.IpAddressType = types.IpAddressType(jtv)
7434			}
7435
7436		default:
7437			_, _ = key, value
7438
7439		}
7440	}
7441	*v = sv
7442	return nil
7443}
7444
7445func awsAwsjson11_deserializeDocumentDestinationPortMappings(v *[]types.DestinationPortMapping, value interface{}) error {
7446	if v == nil {
7447		return fmt.Errorf("unexpected nil of type %T", v)
7448	}
7449	if value == nil {
7450		return nil
7451	}
7452
7453	shape, ok := value.([]interface{})
7454	if !ok {
7455		return fmt.Errorf("unexpected JSON type %v", value)
7456	}
7457
7458	var cv []types.DestinationPortMapping
7459	if *v == nil {
7460		cv = []types.DestinationPortMapping{}
7461	} else {
7462		cv = *v
7463	}
7464
7465	for _, value := range shape {
7466		var col types.DestinationPortMapping
7467		destAddr := &col
7468		if err := awsAwsjson11_deserializeDocumentDestinationPortMapping(&destAddr, value); err != nil {
7469			return err
7470		}
7471		col = *destAddr
7472		cv = append(cv, col)
7473
7474	}
7475	*v = cv
7476	return nil
7477}
7478
7479func awsAwsjson11_deserializeDocumentEndpointAlreadyExistsException(v **types.EndpointAlreadyExistsException, 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.(map[string]interface{})
7488	if !ok {
7489		return fmt.Errorf("unexpected JSON type %v", value)
7490	}
7491
7492	var sv *types.EndpointAlreadyExistsException
7493	if *v == nil {
7494		sv = &types.EndpointAlreadyExistsException{}
7495	} else {
7496		sv = *v
7497	}
7498
7499	for key, value := range shape {
7500		switch key {
7501		case "Message":
7502			if value != nil {
7503				jtv, ok := value.(string)
7504				if !ok {
7505					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7506				}
7507				sv.Message = ptr.String(jtv)
7508			}
7509
7510		default:
7511			_, _ = key, value
7512
7513		}
7514	}
7515	*v = sv
7516	return nil
7517}
7518
7519func awsAwsjson11_deserializeDocumentEndpointDescription(v **types.EndpointDescription, value interface{}) error {
7520	if v == nil {
7521		return fmt.Errorf("unexpected nil of type %T", v)
7522	}
7523	if value == nil {
7524		return nil
7525	}
7526
7527	shape, ok := value.(map[string]interface{})
7528	if !ok {
7529		return fmt.Errorf("unexpected JSON type %v", value)
7530	}
7531
7532	var sv *types.EndpointDescription
7533	if *v == nil {
7534		sv = &types.EndpointDescription{}
7535	} else {
7536		sv = *v
7537	}
7538
7539	for key, value := range shape {
7540		switch key {
7541		case "ClientIPPreservationEnabled":
7542			if value != nil {
7543				jtv, ok := value.(bool)
7544				if !ok {
7545					return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value)
7546				}
7547				sv.ClientIPPreservationEnabled = ptr.Bool(jtv)
7548			}
7549
7550		case "EndpointId":
7551			if value != nil {
7552				jtv, ok := value.(string)
7553				if !ok {
7554					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7555				}
7556				sv.EndpointId = ptr.String(jtv)
7557			}
7558
7559		case "HealthReason":
7560			if value != nil {
7561				jtv, ok := value.(string)
7562				if !ok {
7563					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7564				}
7565				sv.HealthReason = ptr.String(jtv)
7566			}
7567
7568		case "HealthState":
7569			if value != nil {
7570				jtv, ok := value.(string)
7571				if !ok {
7572					return fmt.Errorf("expected HealthState to be of type string, got %T instead", value)
7573				}
7574				sv.HealthState = types.HealthState(jtv)
7575			}
7576
7577		case "Weight":
7578			if value != nil {
7579				jtv, ok := value.(json.Number)
7580				if !ok {
7581					return fmt.Errorf("expected EndpointWeight to be json.Number, got %T instead", value)
7582				}
7583				i64, err := jtv.Int64()
7584				if err != nil {
7585					return err
7586				}
7587				sv.Weight = ptr.Int32(int32(i64))
7588			}
7589
7590		default:
7591			_, _ = key, value
7592
7593		}
7594	}
7595	*v = sv
7596	return nil
7597}
7598
7599func awsAwsjson11_deserializeDocumentEndpointDescriptions(v *[]types.EndpointDescription, value interface{}) error {
7600	if v == nil {
7601		return fmt.Errorf("unexpected nil of type %T", v)
7602	}
7603	if value == nil {
7604		return nil
7605	}
7606
7607	shape, ok := value.([]interface{})
7608	if !ok {
7609		return fmt.Errorf("unexpected JSON type %v", value)
7610	}
7611
7612	var cv []types.EndpointDescription
7613	if *v == nil {
7614		cv = []types.EndpointDescription{}
7615	} else {
7616		cv = *v
7617	}
7618
7619	for _, value := range shape {
7620		var col types.EndpointDescription
7621		destAddr := &col
7622		if err := awsAwsjson11_deserializeDocumentEndpointDescription(&destAddr, value); err != nil {
7623			return err
7624		}
7625		col = *destAddr
7626		cv = append(cv, col)
7627
7628	}
7629	*v = cv
7630	return nil
7631}
7632
7633func awsAwsjson11_deserializeDocumentEndpointGroup(v **types.EndpointGroup, value interface{}) error {
7634	if v == nil {
7635		return fmt.Errorf("unexpected nil of type %T", v)
7636	}
7637	if value == nil {
7638		return nil
7639	}
7640
7641	shape, ok := value.(map[string]interface{})
7642	if !ok {
7643		return fmt.Errorf("unexpected JSON type %v", value)
7644	}
7645
7646	var sv *types.EndpointGroup
7647	if *v == nil {
7648		sv = &types.EndpointGroup{}
7649	} else {
7650		sv = *v
7651	}
7652
7653	for key, value := range shape {
7654		switch key {
7655		case "EndpointDescriptions":
7656			if err := awsAwsjson11_deserializeDocumentEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil {
7657				return err
7658			}
7659
7660		case "EndpointGroupArn":
7661			if value != nil {
7662				jtv, ok := value.(string)
7663				if !ok {
7664					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7665				}
7666				sv.EndpointGroupArn = ptr.String(jtv)
7667			}
7668
7669		case "EndpointGroupRegion":
7670			if value != nil {
7671				jtv, ok := value.(string)
7672				if !ok {
7673					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
7674				}
7675				sv.EndpointGroupRegion = ptr.String(jtv)
7676			}
7677
7678		case "HealthCheckIntervalSeconds":
7679			if value != nil {
7680				jtv, ok := value.(json.Number)
7681				if !ok {
7682					return fmt.Errorf("expected HealthCheckIntervalSeconds to be json.Number, got %T instead", value)
7683				}
7684				i64, err := jtv.Int64()
7685				if err != nil {
7686					return err
7687				}
7688				sv.HealthCheckIntervalSeconds = ptr.Int32(int32(i64))
7689			}
7690
7691		case "HealthCheckPath":
7692			if value != nil {
7693				jtv, ok := value.(string)
7694				if !ok {
7695					return fmt.Errorf("expected HealthCheckPath to be of type string, got %T instead", value)
7696				}
7697				sv.HealthCheckPath = ptr.String(jtv)
7698			}
7699
7700		case "HealthCheckPort":
7701			if value != nil {
7702				jtv, ok := value.(json.Number)
7703				if !ok {
7704					return fmt.Errorf("expected HealthCheckPort to be json.Number, got %T instead", value)
7705				}
7706				i64, err := jtv.Int64()
7707				if err != nil {
7708					return err
7709				}
7710				sv.HealthCheckPort = ptr.Int32(int32(i64))
7711			}
7712
7713		case "HealthCheckProtocol":
7714			if value != nil {
7715				jtv, ok := value.(string)
7716				if !ok {
7717					return fmt.Errorf("expected HealthCheckProtocol to be of type string, got %T instead", value)
7718				}
7719				sv.HealthCheckProtocol = types.HealthCheckProtocol(jtv)
7720			}
7721
7722		case "PortOverrides":
7723			if err := awsAwsjson11_deserializeDocumentPortOverrides(&sv.PortOverrides, value); err != nil {
7724				return err
7725			}
7726
7727		case "ThresholdCount":
7728			if value != nil {
7729				jtv, ok := value.(json.Number)
7730				if !ok {
7731					return fmt.Errorf("expected ThresholdCount to be json.Number, got %T instead", value)
7732				}
7733				i64, err := jtv.Int64()
7734				if err != nil {
7735					return err
7736				}
7737				sv.ThresholdCount = ptr.Int32(int32(i64))
7738			}
7739
7740		case "TrafficDialPercentage":
7741			if value != nil {
7742				jtv, ok := value.(json.Number)
7743				if !ok {
7744					return fmt.Errorf("expected TrafficDialPercentage to be json.Number, got %T instead", value)
7745				}
7746				f64, err := jtv.Float64()
7747				if err != nil {
7748					return err
7749				}
7750				sv.TrafficDialPercentage = ptr.Float32(float32(f64))
7751			}
7752
7753		default:
7754			_, _ = key, value
7755
7756		}
7757	}
7758	*v = sv
7759	return nil
7760}
7761
7762func awsAwsjson11_deserializeDocumentEndpointGroupAlreadyExistsException(v **types.EndpointGroupAlreadyExistsException, value interface{}) error {
7763	if v == nil {
7764		return fmt.Errorf("unexpected nil of type %T", v)
7765	}
7766	if value == nil {
7767		return nil
7768	}
7769
7770	shape, ok := value.(map[string]interface{})
7771	if !ok {
7772		return fmt.Errorf("unexpected JSON type %v", value)
7773	}
7774
7775	var sv *types.EndpointGroupAlreadyExistsException
7776	if *v == nil {
7777		sv = &types.EndpointGroupAlreadyExistsException{}
7778	} else {
7779		sv = *v
7780	}
7781
7782	for key, value := range shape {
7783		switch key {
7784		case "Message":
7785			if value != nil {
7786				jtv, ok := value.(string)
7787				if !ok {
7788					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7789				}
7790				sv.Message = ptr.String(jtv)
7791			}
7792
7793		default:
7794			_, _ = key, value
7795
7796		}
7797	}
7798	*v = sv
7799	return nil
7800}
7801
7802func awsAwsjson11_deserializeDocumentEndpointGroupNotFoundException(v **types.EndpointGroupNotFoundException, value interface{}) error {
7803	if v == nil {
7804		return fmt.Errorf("unexpected nil of type %T", v)
7805	}
7806	if value == nil {
7807		return nil
7808	}
7809
7810	shape, ok := value.(map[string]interface{})
7811	if !ok {
7812		return fmt.Errorf("unexpected JSON type %v", value)
7813	}
7814
7815	var sv *types.EndpointGroupNotFoundException
7816	if *v == nil {
7817		sv = &types.EndpointGroupNotFoundException{}
7818	} else {
7819		sv = *v
7820	}
7821
7822	for key, value := range shape {
7823		switch key {
7824		case "Message":
7825			if value != nil {
7826				jtv, ok := value.(string)
7827				if !ok {
7828					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7829				}
7830				sv.Message = ptr.String(jtv)
7831			}
7832
7833		default:
7834			_, _ = key, value
7835
7836		}
7837	}
7838	*v = sv
7839	return nil
7840}
7841
7842func awsAwsjson11_deserializeDocumentEndpointGroups(v *[]types.EndpointGroup, value interface{}) error {
7843	if v == nil {
7844		return fmt.Errorf("unexpected nil of type %T", v)
7845	}
7846	if value == nil {
7847		return nil
7848	}
7849
7850	shape, ok := value.([]interface{})
7851	if !ok {
7852		return fmt.Errorf("unexpected JSON type %v", value)
7853	}
7854
7855	var cv []types.EndpointGroup
7856	if *v == nil {
7857		cv = []types.EndpointGroup{}
7858	} else {
7859		cv = *v
7860	}
7861
7862	for _, value := range shape {
7863		var col types.EndpointGroup
7864		destAddr := &col
7865		if err := awsAwsjson11_deserializeDocumentEndpointGroup(&destAddr, value); err != nil {
7866			return err
7867		}
7868		col = *destAddr
7869		cv = append(cv, col)
7870
7871	}
7872	*v = cv
7873	return nil
7874}
7875
7876func awsAwsjson11_deserializeDocumentEndpointNotFoundException(v **types.EndpointNotFoundException, value interface{}) error {
7877	if v == nil {
7878		return fmt.Errorf("unexpected nil of type %T", v)
7879	}
7880	if value == nil {
7881		return nil
7882	}
7883
7884	shape, ok := value.(map[string]interface{})
7885	if !ok {
7886		return fmt.Errorf("unexpected JSON type %v", value)
7887	}
7888
7889	var sv *types.EndpointNotFoundException
7890	if *v == nil {
7891		sv = &types.EndpointNotFoundException{}
7892	} else {
7893		sv = *v
7894	}
7895
7896	for key, value := range shape {
7897		switch key {
7898		case "Message":
7899			if value != nil {
7900				jtv, ok := value.(string)
7901				if !ok {
7902					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7903				}
7904				sv.Message = ptr.String(jtv)
7905			}
7906
7907		default:
7908			_, _ = key, value
7909
7910		}
7911	}
7912	*v = sv
7913	return nil
7914}
7915
7916func awsAwsjson11_deserializeDocumentIncorrectCidrStateException(v **types.IncorrectCidrStateException, value interface{}) error {
7917	if v == nil {
7918		return fmt.Errorf("unexpected nil of type %T", v)
7919	}
7920	if value == nil {
7921		return nil
7922	}
7923
7924	shape, ok := value.(map[string]interface{})
7925	if !ok {
7926		return fmt.Errorf("unexpected JSON type %v", value)
7927	}
7928
7929	var sv *types.IncorrectCidrStateException
7930	if *v == nil {
7931		sv = &types.IncorrectCidrStateException{}
7932	} else {
7933		sv = *v
7934	}
7935
7936	for key, value := range shape {
7937		switch key {
7938		case "Message":
7939			if value != nil {
7940				jtv, ok := value.(string)
7941				if !ok {
7942					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7943				}
7944				sv.Message = ptr.String(jtv)
7945			}
7946
7947		default:
7948			_, _ = key, value
7949
7950		}
7951	}
7952	*v = sv
7953	return nil
7954}
7955
7956func awsAwsjson11_deserializeDocumentInternalServiceErrorException(v **types.InternalServiceErrorException, value interface{}) error {
7957	if v == nil {
7958		return fmt.Errorf("unexpected nil of type %T", v)
7959	}
7960	if value == nil {
7961		return nil
7962	}
7963
7964	shape, ok := value.(map[string]interface{})
7965	if !ok {
7966		return fmt.Errorf("unexpected JSON type %v", value)
7967	}
7968
7969	var sv *types.InternalServiceErrorException
7970	if *v == nil {
7971		sv = &types.InternalServiceErrorException{}
7972	} else {
7973		sv = *v
7974	}
7975
7976	for key, value := range shape {
7977		switch key {
7978		case "Message":
7979			if value != nil {
7980				jtv, ok := value.(string)
7981				if !ok {
7982					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
7983				}
7984				sv.Message = ptr.String(jtv)
7985			}
7986
7987		default:
7988			_, _ = key, value
7989
7990		}
7991	}
7992	*v = sv
7993	return nil
7994}
7995
7996func awsAwsjson11_deserializeDocumentInvalidArgumentException(v **types.InvalidArgumentException, value interface{}) error {
7997	if v == nil {
7998		return fmt.Errorf("unexpected nil of type %T", v)
7999	}
8000	if value == nil {
8001		return nil
8002	}
8003
8004	shape, ok := value.(map[string]interface{})
8005	if !ok {
8006		return fmt.Errorf("unexpected JSON type %v", value)
8007	}
8008
8009	var sv *types.InvalidArgumentException
8010	if *v == nil {
8011		sv = &types.InvalidArgumentException{}
8012	} else {
8013		sv = *v
8014	}
8015
8016	for key, value := range shape {
8017		switch key {
8018		case "Message":
8019			if value != nil {
8020				jtv, ok := value.(string)
8021				if !ok {
8022					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
8023				}
8024				sv.Message = ptr.String(jtv)
8025			}
8026
8027		default:
8028			_, _ = key, value
8029
8030		}
8031	}
8032	*v = sv
8033	return nil
8034}
8035
8036func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error {
8037	if v == nil {
8038		return fmt.Errorf("unexpected nil of type %T", v)
8039	}
8040	if value == nil {
8041		return nil
8042	}
8043
8044	shape, ok := value.(map[string]interface{})
8045	if !ok {
8046		return fmt.Errorf("unexpected JSON type %v", value)
8047	}
8048
8049	var sv *types.InvalidNextTokenException
8050	if *v == nil {
8051		sv = &types.InvalidNextTokenException{}
8052	} else {
8053		sv = *v
8054	}
8055
8056	for key, value := range shape {
8057		switch key {
8058		case "Message":
8059			if value != nil {
8060				jtv, ok := value.(string)
8061				if !ok {
8062					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
8063				}
8064				sv.Message = ptr.String(jtv)
8065			}
8066
8067		default:
8068			_, _ = key, value
8069
8070		}
8071	}
8072	*v = sv
8073	return nil
8074}
8075
8076func awsAwsjson11_deserializeDocumentInvalidPortRangeException(v **types.InvalidPortRangeException, value interface{}) error {
8077	if v == nil {
8078		return fmt.Errorf("unexpected nil of type %T", v)
8079	}
8080	if value == nil {
8081		return nil
8082	}
8083
8084	shape, ok := value.(map[string]interface{})
8085	if !ok {
8086		return fmt.Errorf("unexpected JSON type %v", value)
8087	}
8088
8089	var sv *types.InvalidPortRangeException
8090	if *v == nil {
8091		sv = &types.InvalidPortRangeException{}
8092	} else {
8093		sv = *v
8094	}
8095
8096	for key, value := range shape {
8097		switch key {
8098		case "Message":
8099			if value != nil {
8100				jtv, ok := value.(string)
8101				if !ok {
8102					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
8103				}
8104				sv.Message = ptr.String(jtv)
8105			}
8106
8107		default:
8108			_, _ = key, value
8109
8110		}
8111	}
8112	*v = sv
8113	return nil
8114}
8115
8116func awsAwsjson11_deserializeDocumentIpAddresses(v *[]string, value interface{}) error {
8117	if v == nil {
8118		return fmt.Errorf("unexpected nil of type %T", v)
8119	}
8120	if value == nil {
8121		return nil
8122	}
8123
8124	shape, ok := value.([]interface{})
8125	if !ok {
8126		return fmt.Errorf("unexpected JSON type %v", value)
8127	}
8128
8129	var cv []string
8130	if *v == nil {
8131		cv = []string{}
8132	} else {
8133		cv = *v
8134	}
8135
8136	for _, value := range shape {
8137		var col string
8138		if value != nil {
8139			jtv, ok := value.(string)
8140			if !ok {
8141				return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value)
8142			}
8143			col = jtv
8144		}
8145		cv = append(cv, col)
8146
8147	}
8148	*v = cv
8149	return nil
8150}
8151
8152func awsAwsjson11_deserializeDocumentIpSet(v **types.IpSet, value interface{}) error {
8153	if v == nil {
8154		return fmt.Errorf("unexpected nil of type %T", v)
8155	}
8156	if value == nil {
8157		return nil
8158	}
8159
8160	shape, ok := value.(map[string]interface{})
8161	if !ok {
8162		return fmt.Errorf("unexpected JSON type %v", value)
8163	}
8164
8165	var sv *types.IpSet
8166	if *v == nil {
8167		sv = &types.IpSet{}
8168	} else {
8169		sv = *v
8170	}
8171
8172	for key, value := range shape {
8173		switch key {
8174		case "IpAddresses":
8175			if err := awsAwsjson11_deserializeDocumentIpAddresses(&sv.IpAddresses, value); err != nil {
8176				return err
8177			}
8178
8179		case "IpFamily":
8180			if value != nil {
8181				jtv, ok := value.(string)
8182				if !ok {
8183					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8184				}
8185				sv.IpFamily = ptr.String(jtv)
8186			}
8187
8188		default:
8189			_, _ = key, value
8190
8191		}
8192	}
8193	*v = sv
8194	return nil
8195}
8196
8197func awsAwsjson11_deserializeDocumentIpSets(v *[]types.IpSet, value interface{}) error {
8198	if v == nil {
8199		return fmt.Errorf("unexpected nil of type %T", v)
8200	}
8201	if value == nil {
8202		return nil
8203	}
8204
8205	shape, ok := value.([]interface{})
8206	if !ok {
8207		return fmt.Errorf("unexpected JSON type %v", value)
8208	}
8209
8210	var cv []types.IpSet
8211	if *v == nil {
8212		cv = []types.IpSet{}
8213	} else {
8214		cv = *v
8215	}
8216
8217	for _, value := range shape {
8218		var col types.IpSet
8219		destAddr := &col
8220		if err := awsAwsjson11_deserializeDocumentIpSet(&destAddr, value); err != nil {
8221			return err
8222		}
8223		col = *destAddr
8224		cv = append(cv, col)
8225
8226	}
8227	*v = cv
8228	return nil
8229}
8230
8231func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
8232	if v == nil {
8233		return fmt.Errorf("unexpected nil of type %T", v)
8234	}
8235	if value == nil {
8236		return nil
8237	}
8238
8239	shape, ok := value.(map[string]interface{})
8240	if !ok {
8241		return fmt.Errorf("unexpected JSON type %v", value)
8242	}
8243
8244	var sv *types.LimitExceededException
8245	if *v == nil {
8246		sv = &types.LimitExceededException{}
8247	} else {
8248		sv = *v
8249	}
8250
8251	for key, value := range shape {
8252		switch key {
8253		case "Message":
8254			if value != nil {
8255				jtv, ok := value.(string)
8256				if !ok {
8257					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
8258				}
8259				sv.Message = ptr.String(jtv)
8260			}
8261
8262		default:
8263			_, _ = key, value
8264
8265		}
8266	}
8267	*v = sv
8268	return nil
8269}
8270
8271func awsAwsjson11_deserializeDocumentListener(v **types.Listener, value interface{}) error {
8272	if v == nil {
8273		return fmt.Errorf("unexpected nil of type %T", v)
8274	}
8275	if value == nil {
8276		return nil
8277	}
8278
8279	shape, ok := value.(map[string]interface{})
8280	if !ok {
8281		return fmt.Errorf("unexpected JSON type %v", value)
8282	}
8283
8284	var sv *types.Listener
8285	if *v == nil {
8286		sv = &types.Listener{}
8287	} else {
8288		sv = *v
8289	}
8290
8291	for key, value := range shape {
8292		switch key {
8293		case "ClientAffinity":
8294			if value != nil {
8295				jtv, ok := value.(string)
8296				if !ok {
8297					return fmt.Errorf("expected ClientAffinity to be of type string, got %T instead", value)
8298				}
8299				sv.ClientAffinity = types.ClientAffinity(jtv)
8300			}
8301
8302		case "ListenerArn":
8303			if value != nil {
8304				jtv, ok := value.(string)
8305				if !ok {
8306					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8307				}
8308				sv.ListenerArn = ptr.String(jtv)
8309			}
8310
8311		case "PortRanges":
8312			if err := awsAwsjson11_deserializeDocumentPortRanges(&sv.PortRanges, value); err != nil {
8313				return err
8314			}
8315
8316		case "Protocol":
8317			if value != nil {
8318				jtv, ok := value.(string)
8319				if !ok {
8320					return fmt.Errorf("expected Protocol to be of type string, got %T instead", value)
8321				}
8322				sv.Protocol = types.Protocol(jtv)
8323			}
8324
8325		default:
8326			_, _ = key, value
8327
8328		}
8329	}
8330	*v = sv
8331	return nil
8332}
8333
8334func awsAwsjson11_deserializeDocumentListenerNotFoundException(v **types.ListenerNotFoundException, value interface{}) error {
8335	if v == nil {
8336		return fmt.Errorf("unexpected nil of type %T", v)
8337	}
8338	if value == nil {
8339		return nil
8340	}
8341
8342	shape, ok := value.(map[string]interface{})
8343	if !ok {
8344		return fmt.Errorf("unexpected JSON type %v", value)
8345	}
8346
8347	var sv *types.ListenerNotFoundException
8348	if *v == nil {
8349		sv = &types.ListenerNotFoundException{}
8350	} else {
8351		sv = *v
8352	}
8353
8354	for key, value := range shape {
8355		switch key {
8356		case "Message":
8357			if value != nil {
8358				jtv, ok := value.(string)
8359				if !ok {
8360					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
8361				}
8362				sv.Message = ptr.String(jtv)
8363			}
8364
8365		default:
8366			_, _ = key, value
8367
8368		}
8369	}
8370	*v = sv
8371	return nil
8372}
8373
8374func awsAwsjson11_deserializeDocumentListeners(v *[]types.Listener, value interface{}) error {
8375	if v == nil {
8376		return fmt.Errorf("unexpected nil of type %T", v)
8377	}
8378	if value == nil {
8379		return nil
8380	}
8381
8382	shape, ok := value.([]interface{})
8383	if !ok {
8384		return fmt.Errorf("unexpected JSON type %v", value)
8385	}
8386
8387	var cv []types.Listener
8388	if *v == nil {
8389		cv = []types.Listener{}
8390	} else {
8391		cv = *v
8392	}
8393
8394	for _, value := range shape {
8395		var col types.Listener
8396		destAddr := &col
8397		if err := awsAwsjson11_deserializeDocumentListener(&destAddr, value); err != nil {
8398			return err
8399		}
8400		col = *destAddr
8401		cv = append(cv, col)
8402
8403	}
8404	*v = cv
8405	return nil
8406}
8407
8408func awsAwsjson11_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error {
8409	if v == nil {
8410		return fmt.Errorf("unexpected nil of type %T", v)
8411	}
8412	if value == nil {
8413		return nil
8414	}
8415
8416	shape, ok := value.(map[string]interface{})
8417	if !ok {
8418		return fmt.Errorf("unexpected JSON type %v", value)
8419	}
8420
8421	var sv *types.PortMapping
8422	if *v == nil {
8423		sv = &types.PortMapping{}
8424	} else {
8425		sv = *v
8426	}
8427
8428	for key, value := range shape {
8429		switch key {
8430		case "AcceleratorPort":
8431			if value != nil {
8432				jtv, ok := value.(json.Number)
8433				if !ok {
8434					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8435				}
8436				i64, err := jtv.Int64()
8437				if err != nil {
8438					return err
8439				}
8440				sv.AcceleratorPort = ptr.Int32(int32(i64))
8441			}
8442
8443		case "DestinationSocketAddress":
8444			if err := awsAwsjson11_deserializeDocumentSocketAddress(&sv.DestinationSocketAddress, value); err != nil {
8445				return err
8446			}
8447
8448		case "DestinationTrafficState":
8449			if value != nil {
8450				jtv, ok := value.(string)
8451				if !ok {
8452					return fmt.Errorf("expected CustomRoutingDestinationTrafficState to be of type string, got %T instead", value)
8453				}
8454				sv.DestinationTrafficState = types.CustomRoutingDestinationTrafficState(jtv)
8455			}
8456
8457		case "EndpointGroupArn":
8458			if value != nil {
8459				jtv, ok := value.(string)
8460				if !ok {
8461					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8462				}
8463				sv.EndpointGroupArn = ptr.String(jtv)
8464			}
8465
8466		case "EndpointId":
8467			if value != nil {
8468				jtv, ok := value.(string)
8469				if !ok {
8470					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8471				}
8472				sv.EndpointId = ptr.String(jtv)
8473			}
8474
8475		case "Protocols":
8476			if err := awsAwsjson11_deserializeDocumentCustomRoutingProtocols(&sv.Protocols, value); err != nil {
8477				return err
8478			}
8479
8480		default:
8481			_, _ = key, value
8482
8483		}
8484	}
8485	*v = sv
8486	return nil
8487}
8488
8489func awsAwsjson11_deserializeDocumentPortMappings(v *[]types.PortMapping, value interface{}) error {
8490	if v == nil {
8491		return fmt.Errorf("unexpected nil of type %T", v)
8492	}
8493	if value == nil {
8494		return nil
8495	}
8496
8497	shape, ok := value.([]interface{})
8498	if !ok {
8499		return fmt.Errorf("unexpected JSON type %v", value)
8500	}
8501
8502	var cv []types.PortMapping
8503	if *v == nil {
8504		cv = []types.PortMapping{}
8505	} else {
8506		cv = *v
8507	}
8508
8509	for _, value := range shape {
8510		var col types.PortMapping
8511		destAddr := &col
8512		if err := awsAwsjson11_deserializeDocumentPortMapping(&destAddr, value); err != nil {
8513			return err
8514		}
8515		col = *destAddr
8516		cv = append(cv, col)
8517
8518	}
8519	*v = cv
8520	return nil
8521}
8522
8523func awsAwsjson11_deserializeDocumentPortOverride(v **types.PortOverride, value interface{}) error {
8524	if v == nil {
8525		return fmt.Errorf("unexpected nil of type %T", v)
8526	}
8527	if value == nil {
8528		return nil
8529	}
8530
8531	shape, ok := value.(map[string]interface{})
8532	if !ok {
8533		return fmt.Errorf("unexpected JSON type %v", value)
8534	}
8535
8536	var sv *types.PortOverride
8537	if *v == nil {
8538		sv = &types.PortOverride{}
8539	} else {
8540		sv = *v
8541	}
8542
8543	for key, value := range shape {
8544		switch key {
8545		case "EndpointPort":
8546			if value != nil {
8547				jtv, ok := value.(json.Number)
8548				if !ok {
8549					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8550				}
8551				i64, err := jtv.Int64()
8552				if err != nil {
8553					return err
8554				}
8555				sv.EndpointPort = ptr.Int32(int32(i64))
8556			}
8557
8558		case "ListenerPort":
8559			if value != nil {
8560				jtv, ok := value.(json.Number)
8561				if !ok {
8562					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8563				}
8564				i64, err := jtv.Int64()
8565				if err != nil {
8566					return err
8567				}
8568				sv.ListenerPort = ptr.Int32(int32(i64))
8569			}
8570
8571		default:
8572			_, _ = key, value
8573
8574		}
8575	}
8576	*v = sv
8577	return nil
8578}
8579
8580func awsAwsjson11_deserializeDocumentPortOverrides(v *[]types.PortOverride, value interface{}) error {
8581	if v == nil {
8582		return fmt.Errorf("unexpected nil of type %T", v)
8583	}
8584	if value == nil {
8585		return nil
8586	}
8587
8588	shape, ok := value.([]interface{})
8589	if !ok {
8590		return fmt.Errorf("unexpected JSON type %v", value)
8591	}
8592
8593	var cv []types.PortOverride
8594	if *v == nil {
8595		cv = []types.PortOverride{}
8596	} else {
8597		cv = *v
8598	}
8599
8600	for _, value := range shape {
8601		var col types.PortOverride
8602		destAddr := &col
8603		if err := awsAwsjson11_deserializeDocumentPortOverride(&destAddr, value); err != nil {
8604			return err
8605		}
8606		col = *destAddr
8607		cv = append(cv, col)
8608
8609	}
8610	*v = cv
8611	return nil
8612}
8613
8614func awsAwsjson11_deserializeDocumentPortRange(v **types.PortRange, value interface{}) error {
8615	if v == nil {
8616		return fmt.Errorf("unexpected nil of type %T", v)
8617	}
8618	if value == nil {
8619		return nil
8620	}
8621
8622	shape, ok := value.(map[string]interface{})
8623	if !ok {
8624		return fmt.Errorf("unexpected JSON type %v", value)
8625	}
8626
8627	var sv *types.PortRange
8628	if *v == nil {
8629		sv = &types.PortRange{}
8630	} else {
8631		sv = *v
8632	}
8633
8634	for key, value := range shape {
8635		switch key {
8636		case "FromPort":
8637			if value != nil {
8638				jtv, ok := value.(json.Number)
8639				if !ok {
8640					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8641				}
8642				i64, err := jtv.Int64()
8643				if err != nil {
8644					return err
8645				}
8646				sv.FromPort = ptr.Int32(int32(i64))
8647			}
8648
8649		case "ToPort":
8650			if value != nil {
8651				jtv, ok := value.(json.Number)
8652				if !ok {
8653					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8654				}
8655				i64, err := jtv.Int64()
8656				if err != nil {
8657					return err
8658				}
8659				sv.ToPort = ptr.Int32(int32(i64))
8660			}
8661
8662		default:
8663			_, _ = key, value
8664
8665		}
8666	}
8667	*v = sv
8668	return nil
8669}
8670
8671func awsAwsjson11_deserializeDocumentPortRanges(v *[]types.PortRange, value interface{}) error {
8672	if v == nil {
8673		return fmt.Errorf("unexpected nil of type %T", v)
8674	}
8675	if value == nil {
8676		return nil
8677	}
8678
8679	shape, ok := value.([]interface{})
8680	if !ok {
8681		return fmt.Errorf("unexpected JSON type %v", value)
8682	}
8683
8684	var cv []types.PortRange
8685	if *v == nil {
8686		cv = []types.PortRange{}
8687	} else {
8688		cv = *v
8689	}
8690
8691	for _, value := range shape {
8692		var col types.PortRange
8693		destAddr := &col
8694		if err := awsAwsjson11_deserializeDocumentPortRange(&destAddr, value); err != nil {
8695			return err
8696		}
8697		col = *destAddr
8698		cv = append(cv, col)
8699
8700	}
8701	*v = cv
8702	return nil
8703}
8704
8705func awsAwsjson11_deserializeDocumentProtocols(v *[]types.Protocol, value interface{}) error {
8706	if v == nil {
8707		return fmt.Errorf("unexpected nil of type %T", v)
8708	}
8709	if value == nil {
8710		return nil
8711	}
8712
8713	shape, ok := value.([]interface{})
8714	if !ok {
8715		return fmt.Errorf("unexpected JSON type %v", value)
8716	}
8717
8718	var cv []types.Protocol
8719	if *v == nil {
8720		cv = []types.Protocol{}
8721	} else {
8722		cv = *v
8723	}
8724
8725	for _, value := range shape {
8726		var col types.Protocol
8727		if value != nil {
8728			jtv, ok := value.(string)
8729			if !ok {
8730				return fmt.Errorf("expected Protocol to be of type string, got %T instead", value)
8731			}
8732			col = types.Protocol(jtv)
8733		}
8734		cv = append(cv, col)
8735
8736	}
8737	*v = cv
8738	return nil
8739}
8740
8741func awsAwsjson11_deserializeDocumentSocketAddress(v **types.SocketAddress, value interface{}) error {
8742	if v == nil {
8743		return fmt.Errorf("unexpected nil of type %T", v)
8744	}
8745	if value == nil {
8746		return nil
8747	}
8748
8749	shape, ok := value.(map[string]interface{})
8750	if !ok {
8751		return fmt.Errorf("unexpected JSON type %v", value)
8752	}
8753
8754	var sv *types.SocketAddress
8755	if *v == nil {
8756		sv = &types.SocketAddress{}
8757	} else {
8758		sv = *v
8759	}
8760
8761	for key, value := range shape {
8762		switch key {
8763		case "IpAddress":
8764			if value != nil {
8765				jtv, ok := value.(string)
8766				if !ok {
8767					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8768				}
8769				sv.IpAddress = ptr.String(jtv)
8770			}
8771
8772		case "Port":
8773			if value != nil {
8774				jtv, ok := value.(json.Number)
8775				if !ok {
8776					return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value)
8777				}
8778				i64, err := jtv.Int64()
8779				if err != nil {
8780					return err
8781				}
8782				sv.Port = ptr.Int32(int32(i64))
8783			}
8784
8785		default:
8786			_, _ = key, value
8787
8788		}
8789	}
8790	*v = sv
8791	return nil
8792}
8793
8794func awsAwsjson11_deserializeDocumentSocketAddresses(v *[]types.SocketAddress, value interface{}) error {
8795	if v == nil {
8796		return fmt.Errorf("unexpected nil of type %T", v)
8797	}
8798	if value == nil {
8799		return nil
8800	}
8801
8802	shape, ok := value.([]interface{})
8803	if !ok {
8804		return fmt.Errorf("unexpected JSON type %v", value)
8805	}
8806
8807	var cv []types.SocketAddress
8808	if *v == nil {
8809		cv = []types.SocketAddress{}
8810	} else {
8811		cv = *v
8812	}
8813
8814	for _, value := range shape {
8815		var col types.SocketAddress
8816		destAddr := &col
8817		if err := awsAwsjson11_deserializeDocumentSocketAddress(&destAddr, value); err != nil {
8818			return err
8819		}
8820		col = *destAddr
8821		cv = append(cv, col)
8822
8823	}
8824	*v = cv
8825	return nil
8826}
8827
8828func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
8829	if v == nil {
8830		return fmt.Errorf("unexpected nil of type %T", v)
8831	}
8832	if value == nil {
8833		return nil
8834	}
8835
8836	shape, ok := value.(map[string]interface{})
8837	if !ok {
8838		return fmt.Errorf("unexpected JSON type %v", value)
8839	}
8840
8841	var sv *types.Tag
8842	if *v == nil {
8843		sv = &types.Tag{}
8844	} else {
8845		sv = *v
8846	}
8847
8848	for key, value := range shape {
8849		switch key {
8850		case "Key":
8851			if value != nil {
8852				jtv, ok := value.(string)
8853				if !ok {
8854					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
8855				}
8856				sv.Key = ptr.String(jtv)
8857			}
8858
8859		case "Value":
8860			if value != nil {
8861				jtv, ok := value.(string)
8862				if !ok {
8863					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
8864				}
8865				sv.Value = ptr.String(jtv)
8866			}
8867
8868		default:
8869			_, _ = key, value
8870
8871		}
8872	}
8873	*v = sv
8874	return nil
8875}
8876
8877func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error {
8878	if v == nil {
8879		return fmt.Errorf("unexpected nil of type %T", v)
8880	}
8881	if value == nil {
8882		return nil
8883	}
8884
8885	shape, ok := value.([]interface{})
8886	if !ok {
8887		return fmt.Errorf("unexpected JSON type %v", value)
8888	}
8889
8890	var cv []types.Tag
8891	if *v == nil {
8892		cv = []types.Tag{}
8893	} else {
8894		cv = *v
8895	}
8896
8897	for _, value := range shape {
8898		var col types.Tag
8899		destAddr := &col
8900		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
8901			return err
8902		}
8903		col = *destAddr
8904		cv = append(cv, col)
8905
8906	}
8907	*v = cv
8908	return nil
8909}
8910
8911func awsAwsjson11_deserializeOpDocumentAddCustomRoutingEndpointsOutput(v **AddCustomRoutingEndpointsOutput, value interface{}) error {
8912	if v == nil {
8913		return fmt.Errorf("unexpected nil of type %T", v)
8914	}
8915	if value == nil {
8916		return nil
8917	}
8918
8919	shape, ok := value.(map[string]interface{})
8920	if !ok {
8921		return fmt.Errorf("unexpected JSON type %v", value)
8922	}
8923
8924	var sv *AddCustomRoutingEndpointsOutput
8925	if *v == nil {
8926		sv = &AddCustomRoutingEndpointsOutput{}
8927	} else {
8928		sv = *v
8929	}
8930
8931	for key, value := range shape {
8932		switch key {
8933		case "EndpointDescriptions":
8934			if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil {
8935				return err
8936			}
8937
8938		case "EndpointGroupArn":
8939			if value != nil {
8940				jtv, ok := value.(string)
8941				if !ok {
8942					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
8943				}
8944				sv.EndpointGroupArn = ptr.String(jtv)
8945			}
8946
8947		default:
8948			_, _ = key, value
8949
8950		}
8951	}
8952	*v = sv
8953	return nil
8954}
8955
8956func awsAwsjson11_deserializeOpDocumentAdvertiseByoipCidrOutput(v **AdvertiseByoipCidrOutput, value interface{}) error {
8957	if v == nil {
8958		return fmt.Errorf("unexpected nil of type %T", v)
8959	}
8960	if value == nil {
8961		return nil
8962	}
8963
8964	shape, ok := value.(map[string]interface{})
8965	if !ok {
8966		return fmt.Errorf("unexpected JSON type %v", value)
8967	}
8968
8969	var sv *AdvertiseByoipCidrOutput
8970	if *v == nil {
8971		sv = &AdvertiseByoipCidrOutput{}
8972	} else {
8973		sv = *v
8974	}
8975
8976	for key, value := range shape {
8977		switch key {
8978		case "ByoipCidr":
8979			if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil {
8980				return err
8981			}
8982
8983		default:
8984			_, _ = key, value
8985
8986		}
8987	}
8988	*v = sv
8989	return nil
8990}
8991
8992func awsAwsjson11_deserializeOpDocumentCreateAcceleratorOutput(v **CreateAcceleratorOutput, value interface{}) error {
8993	if v == nil {
8994		return fmt.Errorf("unexpected nil of type %T", v)
8995	}
8996	if value == nil {
8997		return nil
8998	}
8999
9000	shape, ok := value.(map[string]interface{})
9001	if !ok {
9002		return fmt.Errorf("unexpected JSON type %v", value)
9003	}
9004
9005	var sv *CreateAcceleratorOutput
9006	if *v == nil {
9007		sv = &CreateAcceleratorOutput{}
9008	} else {
9009		sv = *v
9010	}
9011
9012	for key, value := range shape {
9013		switch key {
9014		case "Accelerator":
9015			if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil {
9016				return err
9017			}
9018
9019		default:
9020			_, _ = key, value
9021
9022		}
9023	}
9024	*v = sv
9025	return nil
9026}
9027
9028func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingAcceleratorOutput(v **CreateCustomRoutingAcceleratorOutput, value interface{}) error {
9029	if v == nil {
9030		return fmt.Errorf("unexpected nil of type %T", v)
9031	}
9032	if value == nil {
9033		return nil
9034	}
9035
9036	shape, ok := value.(map[string]interface{})
9037	if !ok {
9038		return fmt.Errorf("unexpected JSON type %v", value)
9039	}
9040
9041	var sv *CreateCustomRoutingAcceleratorOutput
9042	if *v == nil {
9043		sv = &CreateCustomRoutingAcceleratorOutput{}
9044	} else {
9045		sv = *v
9046	}
9047
9048	for key, value := range shape {
9049		switch key {
9050		case "Accelerator":
9051			if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil {
9052				return err
9053			}
9054
9055		default:
9056			_, _ = key, value
9057
9058		}
9059	}
9060	*v = sv
9061	return nil
9062}
9063
9064func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingEndpointGroupOutput(v **CreateCustomRoutingEndpointGroupOutput, value interface{}) error {
9065	if v == nil {
9066		return fmt.Errorf("unexpected nil of type %T", v)
9067	}
9068	if value == nil {
9069		return nil
9070	}
9071
9072	shape, ok := value.(map[string]interface{})
9073	if !ok {
9074		return fmt.Errorf("unexpected JSON type %v", value)
9075	}
9076
9077	var sv *CreateCustomRoutingEndpointGroupOutput
9078	if *v == nil {
9079		sv = &CreateCustomRoutingEndpointGroupOutput{}
9080	} else {
9081		sv = *v
9082	}
9083
9084	for key, value := range shape {
9085		switch key {
9086		case "EndpointGroup":
9087			if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&sv.EndpointGroup, value); err != nil {
9088				return err
9089			}
9090
9091		default:
9092			_, _ = key, value
9093
9094		}
9095	}
9096	*v = sv
9097	return nil
9098}
9099
9100func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingListenerOutput(v **CreateCustomRoutingListenerOutput, value interface{}) error {
9101	if v == nil {
9102		return fmt.Errorf("unexpected nil of type %T", v)
9103	}
9104	if value == nil {
9105		return nil
9106	}
9107
9108	shape, ok := value.(map[string]interface{})
9109	if !ok {
9110		return fmt.Errorf("unexpected JSON type %v", value)
9111	}
9112
9113	var sv *CreateCustomRoutingListenerOutput
9114	if *v == nil {
9115		sv = &CreateCustomRoutingListenerOutput{}
9116	} else {
9117		sv = *v
9118	}
9119
9120	for key, value := range shape {
9121		switch key {
9122		case "Listener":
9123			if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil {
9124				return err
9125			}
9126
9127		default:
9128			_, _ = key, value
9129
9130		}
9131	}
9132	*v = sv
9133	return nil
9134}
9135
9136func awsAwsjson11_deserializeOpDocumentCreateEndpointGroupOutput(v **CreateEndpointGroupOutput, value interface{}) error {
9137	if v == nil {
9138		return fmt.Errorf("unexpected nil of type %T", v)
9139	}
9140	if value == nil {
9141		return nil
9142	}
9143
9144	shape, ok := value.(map[string]interface{})
9145	if !ok {
9146		return fmt.Errorf("unexpected JSON type %v", value)
9147	}
9148
9149	var sv *CreateEndpointGroupOutput
9150	if *v == nil {
9151		sv = &CreateEndpointGroupOutput{}
9152	} else {
9153		sv = *v
9154	}
9155
9156	for key, value := range shape {
9157		switch key {
9158		case "EndpointGroup":
9159			if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil {
9160				return err
9161			}
9162
9163		default:
9164			_, _ = key, value
9165
9166		}
9167	}
9168	*v = sv
9169	return nil
9170}
9171
9172func awsAwsjson11_deserializeOpDocumentCreateListenerOutput(v **CreateListenerOutput, value interface{}) error {
9173	if v == nil {
9174		return fmt.Errorf("unexpected nil of type %T", v)
9175	}
9176	if value == nil {
9177		return nil
9178	}
9179
9180	shape, ok := value.(map[string]interface{})
9181	if !ok {
9182		return fmt.Errorf("unexpected JSON type %v", value)
9183	}
9184
9185	var sv *CreateListenerOutput
9186	if *v == nil {
9187		sv = &CreateListenerOutput{}
9188	} else {
9189		sv = *v
9190	}
9191
9192	for key, value := range shape {
9193		switch key {
9194		case "Listener":
9195			if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil {
9196				return err
9197			}
9198
9199		default:
9200			_, _ = key, value
9201
9202		}
9203	}
9204	*v = sv
9205	return nil
9206}
9207
9208func awsAwsjson11_deserializeOpDocumentDeprovisionByoipCidrOutput(v **DeprovisionByoipCidrOutput, value interface{}) error {
9209	if v == nil {
9210		return fmt.Errorf("unexpected nil of type %T", v)
9211	}
9212	if value == nil {
9213		return nil
9214	}
9215
9216	shape, ok := value.(map[string]interface{})
9217	if !ok {
9218		return fmt.Errorf("unexpected JSON type %v", value)
9219	}
9220
9221	var sv *DeprovisionByoipCidrOutput
9222	if *v == nil {
9223		sv = &DeprovisionByoipCidrOutput{}
9224	} else {
9225		sv = *v
9226	}
9227
9228	for key, value := range shape {
9229		switch key {
9230		case "ByoipCidr":
9231			if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil {
9232				return err
9233			}
9234
9235		default:
9236			_, _ = key, value
9237
9238		}
9239	}
9240	*v = sv
9241	return nil
9242}
9243
9244func awsAwsjson11_deserializeOpDocumentDescribeAcceleratorAttributesOutput(v **DescribeAcceleratorAttributesOutput, value interface{}) error {
9245	if v == nil {
9246		return fmt.Errorf("unexpected nil of type %T", v)
9247	}
9248	if value == nil {
9249		return nil
9250	}
9251
9252	shape, ok := value.(map[string]interface{})
9253	if !ok {
9254		return fmt.Errorf("unexpected JSON type %v", value)
9255	}
9256
9257	var sv *DescribeAcceleratorAttributesOutput
9258	if *v == nil {
9259		sv = &DescribeAcceleratorAttributesOutput{}
9260	} else {
9261		sv = *v
9262	}
9263
9264	for key, value := range shape {
9265		switch key {
9266		case "AcceleratorAttributes":
9267			if err := awsAwsjson11_deserializeDocumentAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil {
9268				return err
9269			}
9270
9271		default:
9272			_, _ = key, value
9273
9274		}
9275	}
9276	*v = sv
9277	return nil
9278}
9279
9280func awsAwsjson11_deserializeOpDocumentDescribeAcceleratorOutput(v **DescribeAcceleratorOutput, value interface{}) error {
9281	if v == nil {
9282		return fmt.Errorf("unexpected nil of type %T", v)
9283	}
9284	if value == nil {
9285		return nil
9286	}
9287
9288	shape, ok := value.(map[string]interface{})
9289	if !ok {
9290		return fmt.Errorf("unexpected JSON type %v", value)
9291	}
9292
9293	var sv *DescribeAcceleratorOutput
9294	if *v == nil {
9295		sv = &DescribeAcceleratorOutput{}
9296	} else {
9297		sv = *v
9298	}
9299
9300	for key, value := range shape {
9301		switch key {
9302		case "Accelerator":
9303			if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil {
9304				return err
9305			}
9306
9307		default:
9308			_, _ = key, value
9309
9310		}
9311	}
9312	*v = sv
9313	return nil
9314}
9315
9316func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorAttributesOutput(v **DescribeCustomRoutingAcceleratorAttributesOutput, value interface{}) error {
9317	if v == nil {
9318		return fmt.Errorf("unexpected nil of type %T", v)
9319	}
9320	if value == nil {
9321		return nil
9322	}
9323
9324	shape, ok := value.(map[string]interface{})
9325	if !ok {
9326		return fmt.Errorf("unexpected JSON type %v", value)
9327	}
9328
9329	var sv *DescribeCustomRoutingAcceleratorAttributesOutput
9330	if *v == nil {
9331		sv = &DescribeCustomRoutingAcceleratorAttributesOutput{}
9332	} else {
9333		sv = *v
9334	}
9335
9336	for key, value := range shape {
9337		switch key {
9338		case "AcceleratorAttributes":
9339			if err := awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil {
9340				return err
9341			}
9342
9343		default:
9344			_, _ = key, value
9345
9346		}
9347	}
9348	*v = sv
9349	return nil
9350}
9351
9352func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorOutput(v **DescribeCustomRoutingAcceleratorOutput, value interface{}) error {
9353	if v == nil {
9354		return fmt.Errorf("unexpected nil of type %T", v)
9355	}
9356	if value == nil {
9357		return nil
9358	}
9359
9360	shape, ok := value.(map[string]interface{})
9361	if !ok {
9362		return fmt.Errorf("unexpected JSON type %v", value)
9363	}
9364
9365	var sv *DescribeCustomRoutingAcceleratorOutput
9366	if *v == nil {
9367		sv = &DescribeCustomRoutingAcceleratorOutput{}
9368	} else {
9369		sv = *v
9370	}
9371
9372	for key, value := range shape {
9373		switch key {
9374		case "Accelerator":
9375			if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil {
9376				return err
9377			}
9378
9379		default:
9380			_, _ = key, value
9381
9382		}
9383	}
9384	*v = sv
9385	return nil
9386}
9387
9388func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingEndpointGroupOutput(v **DescribeCustomRoutingEndpointGroupOutput, value interface{}) error {
9389	if v == nil {
9390		return fmt.Errorf("unexpected nil of type %T", v)
9391	}
9392	if value == nil {
9393		return nil
9394	}
9395
9396	shape, ok := value.(map[string]interface{})
9397	if !ok {
9398		return fmt.Errorf("unexpected JSON type %v", value)
9399	}
9400
9401	var sv *DescribeCustomRoutingEndpointGroupOutput
9402	if *v == nil {
9403		sv = &DescribeCustomRoutingEndpointGroupOutput{}
9404	} else {
9405		sv = *v
9406	}
9407
9408	for key, value := range shape {
9409		switch key {
9410		case "EndpointGroup":
9411			if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&sv.EndpointGroup, value); err != nil {
9412				return err
9413			}
9414
9415		default:
9416			_, _ = key, value
9417
9418		}
9419	}
9420	*v = sv
9421	return nil
9422}
9423
9424func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingListenerOutput(v **DescribeCustomRoutingListenerOutput, value interface{}) error {
9425	if v == nil {
9426		return fmt.Errorf("unexpected nil of type %T", v)
9427	}
9428	if value == nil {
9429		return nil
9430	}
9431
9432	shape, ok := value.(map[string]interface{})
9433	if !ok {
9434		return fmt.Errorf("unexpected JSON type %v", value)
9435	}
9436
9437	var sv *DescribeCustomRoutingListenerOutput
9438	if *v == nil {
9439		sv = &DescribeCustomRoutingListenerOutput{}
9440	} else {
9441		sv = *v
9442	}
9443
9444	for key, value := range shape {
9445		switch key {
9446		case "Listener":
9447			if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil {
9448				return err
9449			}
9450
9451		default:
9452			_, _ = key, value
9453
9454		}
9455	}
9456	*v = sv
9457	return nil
9458}
9459
9460func awsAwsjson11_deserializeOpDocumentDescribeEndpointGroupOutput(v **DescribeEndpointGroupOutput, value interface{}) error {
9461	if v == nil {
9462		return fmt.Errorf("unexpected nil of type %T", v)
9463	}
9464	if value == nil {
9465		return nil
9466	}
9467
9468	shape, ok := value.(map[string]interface{})
9469	if !ok {
9470		return fmt.Errorf("unexpected JSON type %v", value)
9471	}
9472
9473	var sv *DescribeEndpointGroupOutput
9474	if *v == nil {
9475		sv = &DescribeEndpointGroupOutput{}
9476	} else {
9477		sv = *v
9478	}
9479
9480	for key, value := range shape {
9481		switch key {
9482		case "EndpointGroup":
9483			if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil {
9484				return err
9485			}
9486
9487		default:
9488			_, _ = key, value
9489
9490		}
9491	}
9492	*v = sv
9493	return nil
9494}
9495
9496func awsAwsjson11_deserializeOpDocumentDescribeListenerOutput(v **DescribeListenerOutput, value interface{}) error {
9497	if v == nil {
9498		return fmt.Errorf("unexpected nil of type %T", v)
9499	}
9500	if value == nil {
9501		return nil
9502	}
9503
9504	shape, ok := value.(map[string]interface{})
9505	if !ok {
9506		return fmt.Errorf("unexpected JSON type %v", value)
9507	}
9508
9509	var sv *DescribeListenerOutput
9510	if *v == nil {
9511		sv = &DescribeListenerOutput{}
9512	} else {
9513		sv = *v
9514	}
9515
9516	for key, value := range shape {
9517		switch key {
9518		case "Listener":
9519			if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil {
9520				return err
9521			}
9522
9523		default:
9524			_, _ = key, value
9525
9526		}
9527	}
9528	*v = sv
9529	return nil
9530}
9531
9532func awsAwsjson11_deserializeOpDocumentListAcceleratorsOutput(v **ListAcceleratorsOutput, value interface{}) error {
9533	if v == nil {
9534		return fmt.Errorf("unexpected nil of type %T", v)
9535	}
9536	if value == nil {
9537		return nil
9538	}
9539
9540	shape, ok := value.(map[string]interface{})
9541	if !ok {
9542		return fmt.Errorf("unexpected JSON type %v", value)
9543	}
9544
9545	var sv *ListAcceleratorsOutput
9546	if *v == nil {
9547		sv = &ListAcceleratorsOutput{}
9548	} else {
9549		sv = *v
9550	}
9551
9552	for key, value := range shape {
9553		switch key {
9554		case "Accelerators":
9555			if err := awsAwsjson11_deserializeDocumentAccelerators(&sv.Accelerators, value); err != nil {
9556				return err
9557			}
9558
9559		case "NextToken":
9560			if value != nil {
9561				jtv, ok := value.(string)
9562				if !ok {
9563					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9564				}
9565				sv.NextToken = ptr.String(jtv)
9566			}
9567
9568		default:
9569			_, _ = key, value
9570
9571		}
9572	}
9573	*v = sv
9574	return nil
9575}
9576
9577func awsAwsjson11_deserializeOpDocumentListByoipCidrsOutput(v **ListByoipCidrsOutput, value interface{}) error {
9578	if v == nil {
9579		return fmt.Errorf("unexpected nil of type %T", v)
9580	}
9581	if value == nil {
9582		return nil
9583	}
9584
9585	shape, ok := value.(map[string]interface{})
9586	if !ok {
9587		return fmt.Errorf("unexpected JSON type %v", value)
9588	}
9589
9590	var sv *ListByoipCidrsOutput
9591	if *v == nil {
9592		sv = &ListByoipCidrsOutput{}
9593	} else {
9594		sv = *v
9595	}
9596
9597	for key, value := range shape {
9598		switch key {
9599		case "ByoipCidrs":
9600			if err := awsAwsjson11_deserializeDocumentByoipCidrs(&sv.ByoipCidrs, value); err != nil {
9601				return err
9602			}
9603
9604		case "NextToken":
9605			if value != nil {
9606				jtv, ok := value.(string)
9607				if !ok {
9608					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9609				}
9610				sv.NextToken = ptr.String(jtv)
9611			}
9612
9613		default:
9614			_, _ = key, value
9615
9616		}
9617	}
9618	*v = sv
9619	return nil
9620}
9621
9622func awsAwsjson11_deserializeOpDocumentListCustomRoutingAcceleratorsOutput(v **ListCustomRoutingAcceleratorsOutput, value interface{}) error {
9623	if v == nil {
9624		return fmt.Errorf("unexpected nil of type %T", v)
9625	}
9626	if value == nil {
9627		return nil
9628	}
9629
9630	shape, ok := value.(map[string]interface{})
9631	if !ok {
9632		return fmt.Errorf("unexpected JSON type %v", value)
9633	}
9634
9635	var sv *ListCustomRoutingAcceleratorsOutput
9636	if *v == nil {
9637		sv = &ListCustomRoutingAcceleratorsOutput{}
9638	} else {
9639		sv = *v
9640	}
9641
9642	for key, value := range shape {
9643		switch key {
9644		case "Accelerators":
9645			if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerators(&sv.Accelerators, value); err != nil {
9646				return err
9647			}
9648
9649		case "NextToken":
9650			if value != nil {
9651				jtv, ok := value.(string)
9652				if !ok {
9653					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9654				}
9655				sv.NextToken = ptr.String(jtv)
9656			}
9657
9658		default:
9659			_, _ = key, value
9660
9661		}
9662	}
9663	*v = sv
9664	return nil
9665}
9666
9667func awsAwsjson11_deserializeOpDocumentListCustomRoutingEndpointGroupsOutput(v **ListCustomRoutingEndpointGroupsOutput, value interface{}) error {
9668	if v == nil {
9669		return fmt.Errorf("unexpected nil of type %T", v)
9670	}
9671	if value == nil {
9672		return nil
9673	}
9674
9675	shape, ok := value.(map[string]interface{})
9676	if !ok {
9677		return fmt.Errorf("unexpected JSON type %v", value)
9678	}
9679
9680	var sv *ListCustomRoutingEndpointGroupsOutput
9681	if *v == nil {
9682		sv = &ListCustomRoutingEndpointGroupsOutput{}
9683	} else {
9684		sv = *v
9685	}
9686
9687	for key, value := range shape {
9688		switch key {
9689		case "EndpointGroups":
9690			if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroups(&sv.EndpointGroups, value); err != nil {
9691				return err
9692			}
9693
9694		case "NextToken":
9695			if value != nil {
9696				jtv, ok := value.(string)
9697				if !ok {
9698					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9699				}
9700				sv.NextToken = ptr.String(jtv)
9701			}
9702
9703		default:
9704			_, _ = key, value
9705
9706		}
9707	}
9708	*v = sv
9709	return nil
9710}
9711
9712func awsAwsjson11_deserializeOpDocumentListCustomRoutingListenersOutput(v **ListCustomRoutingListenersOutput, value interface{}) error {
9713	if v == nil {
9714		return fmt.Errorf("unexpected nil of type %T", v)
9715	}
9716	if value == nil {
9717		return nil
9718	}
9719
9720	shape, ok := value.(map[string]interface{})
9721	if !ok {
9722		return fmt.Errorf("unexpected JSON type %v", value)
9723	}
9724
9725	var sv *ListCustomRoutingListenersOutput
9726	if *v == nil {
9727		sv = &ListCustomRoutingListenersOutput{}
9728	} else {
9729		sv = *v
9730	}
9731
9732	for key, value := range shape {
9733		switch key {
9734		case "Listeners":
9735			if err := awsAwsjson11_deserializeDocumentCustomRoutingListeners(&sv.Listeners, value); err != nil {
9736				return err
9737			}
9738
9739		case "NextToken":
9740			if value != nil {
9741				jtv, ok := value.(string)
9742				if !ok {
9743					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9744				}
9745				sv.NextToken = ptr.String(jtv)
9746			}
9747
9748		default:
9749			_, _ = key, value
9750
9751		}
9752	}
9753	*v = sv
9754	return nil
9755}
9756
9757func awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsByDestinationOutput(v **ListCustomRoutingPortMappingsByDestinationOutput, value interface{}) error {
9758	if v == nil {
9759		return fmt.Errorf("unexpected nil of type %T", v)
9760	}
9761	if value == nil {
9762		return nil
9763	}
9764
9765	shape, ok := value.(map[string]interface{})
9766	if !ok {
9767		return fmt.Errorf("unexpected JSON type %v", value)
9768	}
9769
9770	var sv *ListCustomRoutingPortMappingsByDestinationOutput
9771	if *v == nil {
9772		sv = &ListCustomRoutingPortMappingsByDestinationOutput{}
9773	} else {
9774		sv = *v
9775	}
9776
9777	for key, value := range shape {
9778		switch key {
9779		case "DestinationPortMappings":
9780			if err := awsAwsjson11_deserializeDocumentDestinationPortMappings(&sv.DestinationPortMappings, value); err != nil {
9781				return err
9782			}
9783
9784		case "NextToken":
9785			if value != nil {
9786				jtv, ok := value.(string)
9787				if !ok {
9788					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9789				}
9790				sv.NextToken = ptr.String(jtv)
9791			}
9792
9793		default:
9794			_, _ = key, value
9795
9796		}
9797	}
9798	*v = sv
9799	return nil
9800}
9801
9802func awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsOutput(v **ListCustomRoutingPortMappingsOutput, value interface{}) error {
9803	if v == nil {
9804		return fmt.Errorf("unexpected nil of type %T", v)
9805	}
9806	if value == nil {
9807		return nil
9808	}
9809
9810	shape, ok := value.(map[string]interface{})
9811	if !ok {
9812		return fmt.Errorf("unexpected JSON type %v", value)
9813	}
9814
9815	var sv *ListCustomRoutingPortMappingsOutput
9816	if *v == nil {
9817		sv = &ListCustomRoutingPortMappingsOutput{}
9818	} else {
9819		sv = *v
9820	}
9821
9822	for key, value := range shape {
9823		switch key {
9824		case "NextToken":
9825			if value != nil {
9826				jtv, ok := value.(string)
9827				if !ok {
9828					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9829				}
9830				sv.NextToken = ptr.String(jtv)
9831			}
9832
9833		case "PortMappings":
9834			if err := awsAwsjson11_deserializeDocumentPortMappings(&sv.PortMappings, value); err != nil {
9835				return err
9836			}
9837
9838		default:
9839			_, _ = key, value
9840
9841		}
9842	}
9843	*v = sv
9844	return nil
9845}
9846
9847func awsAwsjson11_deserializeOpDocumentListEndpointGroupsOutput(v **ListEndpointGroupsOutput, value interface{}) error {
9848	if v == nil {
9849		return fmt.Errorf("unexpected nil of type %T", v)
9850	}
9851	if value == nil {
9852		return nil
9853	}
9854
9855	shape, ok := value.(map[string]interface{})
9856	if !ok {
9857		return fmt.Errorf("unexpected JSON type %v", value)
9858	}
9859
9860	var sv *ListEndpointGroupsOutput
9861	if *v == nil {
9862		sv = &ListEndpointGroupsOutput{}
9863	} else {
9864		sv = *v
9865	}
9866
9867	for key, value := range shape {
9868		switch key {
9869		case "EndpointGroups":
9870			if err := awsAwsjson11_deserializeDocumentEndpointGroups(&sv.EndpointGroups, value); err != nil {
9871				return err
9872			}
9873
9874		case "NextToken":
9875			if value != nil {
9876				jtv, ok := value.(string)
9877				if !ok {
9878					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9879				}
9880				sv.NextToken = ptr.String(jtv)
9881			}
9882
9883		default:
9884			_, _ = key, value
9885
9886		}
9887	}
9888	*v = sv
9889	return nil
9890}
9891
9892func awsAwsjson11_deserializeOpDocumentListListenersOutput(v **ListListenersOutput, value interface{}) error {
9893	if v == nil {
9894		return fmt.Errorf("unexpected nil of type %T", v)
9895	}
9896	if value == nil {
9897		return nil
9898	}
9899
9900	shape, ok := value.(map[string]interface{})
9901	if !ok {
9902		return fmt.Errorf("unexpected JSON type %v", value)
9903	}
9904
9905	var sv *ListListenersOutput
9906	if *v == nil {
9907		sv = &ListListenersOutput{}
9908	} else {
9909		sv = *v
9910	}
9911
9912	for key, value := range shape {
9913		switch key {
9914		case "Listeners":
9915			if err := awsAwsjson11_deserializeDocumentListeners(&sv.Listeners, value); err != nil {
9916				return err
9917			}
9918
9919		case "NextToken":
9920			if value != nil {
9921				jtv, ok := value.(string)
9922				if !ok {
9923					return fmt.Errorf("expected GenericString to be of type string, got %T instead", value)
9924				}
9925				sv.NextToken = ptr.String(jtv)
9926			}
9927
9928		default:
9929			_, _ = key, value
9930
9931		}
9932	}
9933	*v = sv
9934	return nil
9935}
9936
9937func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
9938	if v == nil {
9939		return fmt.Errorf("unexpected nil of type %T", v)
9940	}
9941	if value == nil {
9942		return nil
9943	}
9944
9945	shape, ok := value.(map[string]interface{})
9946	if !ok {
9947		return fmt.Errorf("unexpected JSON type %v", value)
9948	}
9949
9950	var sv *ListTagsForResourceOutput
9951	if *v == nil {
9952		sv = &ListTagsForResourceOutput{}
9953	} else {
9954		sv = *v
9955	}
9956
9957	for key, value := range shape {
9958		switch key {
9959		case "Tags":
9960			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
9961				return err
9962			}
9963
9964		default:
9965			_, _ = key, value
9966
9967		}
9968	}
9969	*v = sv
9970	return nil
9971}
9972
9973func awsAwsjson11_deserializeOpDocumentProvisionByoipCidrOutput(v **ProvisionByoipCidrOutput, value interface{}) error {
9974	if v == nil {
9975		return fmt.Errorf("unexpected nil of type %T", v)
9976	}
9977	if value == nil {
9978		return nil
9979	}
9980
9981	shape, ok := value.(map[string]interface{})
9982	if !ok {
9983		return fmt.Errorf("unexpected JSON type %v", value)
9984	}
9985
9986	var sv *ProvisionByoipCidrOutput
9987	if *v == nil {
9988		sv = &ProvisionByoipCidrOutput{}
9989	} else {
9990		sv = *v
9991	}
9992
9993	for key, value := range shape {
9994		switch key {
9995		case "ByoipCidr":
9996			if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil {
9997				return err
9998			}
9999
10000		default:
10001			_, _ = key, value
10002
10003		}
10004	}
10005	*v = sv
10006	return nil
10007}
10008
10009func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
10010	if v == nil {
10011		return fmt.Errorf("unexpected nil of type %T", v)
10012	}
10013	if value == nil {
10014		return nil
10015	}
10016
10017	shape, ok := value.(map[string]interface{})
10018	if !ok {
10019		return fmt.Errorf("unexpected JSON type %v", value)
10020	}
10021
10022	var sv *TagResourceOutput
10023	if *v == nil {
10024		sv = &TagResourceOutput{}
10025	} else {
10026		sv = *v
10027	}
10028
10029	for key, value := range shape {
10030		switch key {
10031		default:
10032			_, _ = key, value
10033
10034		}
10035	}
10036	*v = sv
10037	return nil
10038}
10039
10040func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, 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 *UntagResourceOutput
10054	if *v == nil {
10055		sv = &UntagResourceOutput{}
10056	} else {
10057		sv = *v
10058	}
10059
10060	for key, value := range shape {
10061		switch key {
10062		default:
10063			_, _ = key, value
10064
10065		}
10066	}
10067	*v = sv
10068	return nil
10069}
10070
10071func awsAwsjson11_deserializeOpDocumentUpdateAcceleratorAttributesOutput(v **UpdateAcceleratorAttributesOutput, value interface{}) error {
10072	if v == nil {
10073		return fmt.Errorf("unexpected nil of type %T", v)
10074	}
10075	if value == nil {
10076		return nil
10077	}
10078
10079	shape, ok := value.(map[string]interface{})
10080	if !ok {
10081		return fmt.Errorf("unexpected JSON type %v", value)
10082	}
10083
10084	var sv *UpdateAcceleratorAttributesOutput
10085	if *v == nil {
10086		sv = &UpdateAcceleratorAttributesOutput{}
10087	} else {
10088		sv = *v
10089	}
10090
10091	for key, value := range shape {
10092		switch key {
10093		case "AcceleratorAttributes":
10094			if err := awsAwsjson11_deserializeDocumentAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil {
10095				return err
10096			}
10097
10098		default:
10099			_, _ = key, value
10100
10101		}
10102	}
10103	*v = sv
10104	return nil
10105}
10106
10107func awsAwsjson11_deserializeOpDocumentUpdateAcceleratorOutput(v **UpdateAcceleratorOutput, value interface{}) error {
10108	if v == nil {
10109		return fmt.Errorf("unexpected nil of type %T", v)
10110	}
10111	if value == nil {
10112		return nil
10113	}
10114
10115	shape, ok := value.(map[string]interface{})
10116	if !ok {
10117		return fmt.Errorf("unexpected JSON type %v", value)
10118	}
10119
10120	var sv *UpdateAcceleratorOutput
10121	if *v == nil {
10122		sv = &UpdateAcceleratorOutput{}
10123	} else {
10124		sv = *v
10125	}
10126
10127	for key, value := range shape {
10128		switch key {
10129		case "Accelerator":
10130			if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil {
10131				return err
10132			}
10133
10134		default:
10135			_, _ = key, value
10136
10137		}
10138	}
10139	*v = sv
10140	return nil
10141}
10142
10143func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorAttributesOutput(v **UpdateCustomRoutingAcceleratorAttributesOutput, value interface{}) error {
10144	if v == nil {
10145		return fmt.Errorf("unexpected nil of type %T", v)
10146	}
10147	if value == nil {
10148		return nil
10149	}
10150
10151	shape, ok := value.(map[string]interface{})
10152	if !ok {
10153		return fmt.Errorf("unexpected JSON type %v", value)
10154	}
10155
10156	var sv *UpdateCustomRoutingAcceleratorAttributesOutput
10157	if *v == nil {
10158		sv = &UpdateCustomRoutingAcceleratorAttributesOutput{}
10159	} else {
10160		sv = *v
10161	}
10162
10163	for key, value := range shape {
10164		switch key {
10165		case "AcceleratorAttributes":
10166			if err := awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil {
10167				return err
10168			}
10169
10170		default:
10171			_, _ = key, value
10172
10173		}
10174	}
10175	*v = sv
10176	return nil
10177}
10178
10179func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorOutput(v **UpdateCustomRoutingAcceleratorOutput, value interface{}) error {
10180	if v == nil {
10181		return fmt.Errorf("unexpected nil of type %T", v)
10182	}
10183	if value == nil {
10184		return nil
10185	}
10186
10187	shape, ok := value.(map[string]interface{})
10188	if !ok {
10189		return fmt.Errorf("unexpected JSON type %v", value)
10190	}
10191
10192	var sv *UpdateCustomRoutingAcceleratorOutput
10193	if *v == nil {
10194		sv = &UpdateCustomRoutingAcceleratorOutput{}
10195	} else {
10196		sv = *v
10197	}
10198
10199	for key, value := range shape {
10200		switch key {
10201		case "Accelerator":
10202			if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil {
10203				return err
10204			}
10205
10206		default:
10207			_, _ = key, value
10208
10209		}
10210	}
10211	*v = sv
10212	return nil
10213}
10214
10215func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingListenerOutput(v **UpdateCustomRoutingListenerOutput, value interface{}) error {
10216	if v == nil {
10217		return fmt.Errorf("unexpected nil of type %T", v)
10218	}
10219	if value == nil {
10220		return nil
10221	}
10222
10223	shape, ok := value.(map[string]interface{})
10224	if !ok {
10225		return fmt.Errorf("unexpected JSON type %v", value)
10226	}
10227
10228	var sv *UpdateCustomRoutingListenerOutput
10229	if *v == nil {
10230		sv = &UpdateCustomRoutingListenerOutput{}
10231	} else {
10232		sv = *v
10233	}
10234
10235	for key, value := range shape {
10236		switch key {
10237		case "Listener":
10238			if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil {
10239				return err
10240			}
10241
10242		default:
10243			_, _ = key, value
10244
10245		}
10246	}
10247	*v = sv
10248	return nil
10249}
10250
10251func awsAwsjson11_deserializeOpDocumentUpdateEndpointGroupOutput(v **UpdateEndpointGroupOutput, value interface{}) error {
10252	if v == nil {
10253		return fmt.Errorf("unexpected nil of type %T", v)
10254	}
10255	if value == nil {
10256		return nil
10257	}
10258
10259	shape, ok := value.(map[string]interface{})
10260	if !ok {
10261		return fmt.Errorf("unexpected JSON type %v", value)
10262	}
10263
10264	var sv *UpdateEndpointGroupOutput
10265	if *v == nil {
10266		sv = &UpdateEndpointGroupOutput{}
10267	} else {
10268		sv = *v
10269	}
10270
10271	for key, value := range shape {
10272		switch key {
10273		case "EndpointGroup":
10274			if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil {
10275				return err
10276			}
10277
10278		default:
10279			_, _ = key, value
10280
10281		}
10282	}
10283	*v = sv
10284	return nil
10285}
10286
10287func awsAwsjson11_deserializeOpDocumentUpdateListenerOutput(v **UpdateListenerOutput, value interface{}) error {
10288	if v == nil {
10289		return fmt.Errorf("unexpected nil of type %T", v)
10290	}
10291	if value == nil {
10292		return nil
10293	}
10294
10295	shape, ok := value.(map[string]interface{})
10296	if !ok {
10297		return fmt.Errorf("unexpected JSON type %v", value)
10298	}
10299
10300	var sv *UpdateListenerOutput
10301	if *v == nil {
10302		sv = &UpdateListenerOutput{}
10303	} else {
10304		sv = *v
10305	}
10306
10307	for key, value := range shape {
10308		switch key {
10309		case "Listener":
10310			if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil {
10311				return err
10312			}
10313
10314		default:
10315			_, _ = key, value
10316
10317		}
10318	}
10319	*v = sv
10320	return nil
10321}
10322
10323func awsAwsjson11_deserializeOpDocumentWithdrawByoipCidrOutput(v **WithdrawByoipCidrOutput, value interface{}) error {
10324	if v == nil {
10325		return fmt.Errorf("unexpected nil of type %T", v)
10326	}
10327	if value == nil {
10328		return nil
10329	}
10330
10331	shape, ok := value.(map[string]interface{})
10332	if !ok {
10333		return fmt.Errorf("unexpected JSON type %v", value)
10334	}
10335
10336	var sv *WithdrawByoipCidrOutput
10337	if *v == nil {
10338		sv = &WithdrawByoipCidrOutput{}
10339	} else {
10340		sv = *v
10341	}
10342
10343	for key, value := range shape {
10344		switch key {
10345		case "ByoipCidr":
10346			if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil {
10347				return err
10348			}
10349
10350		default:
10351			_, _ = key, value
10352
10353		}
10354	}
10355	*v = sv
10356	return nil
10357}
10358