1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package route53resolver
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/route53resolver/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	smithyhttp "github.com/aws/smithy-go/transport/http"
17	"io"
18	"strings"
19)
20
21type awsAwsjson11_deserializeOpAssociateFirewallRuleGroup struct {
22}
23
24func (*awsAwsjson11_deserializeOpAssociateFirewallRuleGroup) ID() string {
25	return "OperationDeserializer"
26}
27
28func (m *awsAwsjson11_deserializeOpAssociateFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
29	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
30) {
31	out, metadata, err = next.HandleDeserialize(ctx, in)
32	if err != nil {
33		return out, metadata, err
34	}
35
36	response, ok := out.RawResponse.(*smithyhttp.Response)
37	if !ok {
38		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
39	}
40
41	if response.StatusCode < 200 || response.StatusCode >= 300 {
42		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateFirewallRuleGroup(response, &metadata)
43	}
44	output := &AssociateFirewallRuleGroupOutput{}
45	out.Result = output
46
47	var buff [1024]byte
48	ringBuffer := smithyio.NewRingBuffer(buff[:])
49
50	body := io.TeeReader(response.Body, ringBuffer)
51	decoder := json.NewDecoder(body)
52	decoder.UseNumber()
53	var shape interface{}
54	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
55		var snapshot bytes.Buffer
56		io.Copy(&snapshot, ringBuffer)
57		err = &smithy.DeserializationError{
58			Err:      fmt.Errorf("failed to decode response body, %w", err),
59			Snapshot: snapshot.Bytes(),
60		}
61		return out, metadata, err
62	}
63
64	err = awsAwsjson11_deserializeOpDocumentAssociateFirewallRuleGroupOutput(&output, shape)
65	if err != nil {
66		var snapshot bytes.Buffer
67		io.Copy(&snapshot, ringBuffer)
68		err = &smithy.DeserializationError{
69			Err:      fmt.Errorf("failed to decode response body, %w", err),
70			Snapshot: snapshot.Bytes(),
71		}
72		return out, metadata, err
73	}
74
75	return out, metadata, err
76}
77
78func awsAwsjson11_deserializeOpErrorAssociateFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
79	var errorBuffer bytes.Buffer
80	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
81		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
82	}
83	errorBody := bytes.NewReader(errorBuffer.Bytes())
84
85	errorCode := "UnknownError"
86	errorMessage := errorCode
87
88	code := response.Header.Get("X-Amzn-ErrorType")
89	if len(code) != 0 {
90		errorCode = restjson.SanitizeErrorCode(code)
91	}
92
93	var buff [1024]byte
94	ringBuffer := smithyio.NewRingBuffer(buff[:])
95
96	body := io.TeeReader(errorBody, ringBuffer)
97	decoder := json.NewDecoder(body)
98	decoder.UseNumber()
99	code, message, err := restjson.GetErrorInfo(decoder)
100	if err != nil {
101		var snapshot bytes.Buffer
102		io.Copy(&snapshot, ringBuffer)
103		err = &smithy.DeserializationError{
104			Err:      fmt.Errorf("failed to decode response body, %w", err),
105			Snapshot: snapshot.Bytes(),
106		}
107		return err
108	}
109
110	errorBody.Seek(0, io.SeekStart)
111	if len(code) != 0 {
112		errorCode = restjson.SanitizeErrorCode(code)
113	}
114	if len(message) != 0 {
115		errorMessage = message
116	}
117
118	switch {
119	case strings.EqualFold("AccessDeniedException", errorCode):
120		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
121
122	case strings.EqualFold("ConflictException", errorCode):
123		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
124
125	case strings.EqualFold("InternalServiceErrorException", errorCode):
126		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
127
128	case strings.EqualFold("LimitExceededException", errorCode):
129		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
130
131	case strings.EqualFold("ResourceNotFoundException", errorCode):
132		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
133
134	case strings.EqualFold("ThrottlingException", errorCode):
135		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
136
137	case strings.EqualFold("ValidationException", errorCode):
138		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
139
140	default:
141		genericError := &smithy.GenericAPIError{
142			Code:    errorCode,
143			Message: errorMessage,
144		}
145		return genericError
146
147	}
148}
149
150type awsAwsjson11_deserializeOpAssociateResolverEndpointIpAddress struct {
151}
152
153func (*awsAwsjson11_deserializeOpAssociateResolverEndpointIpAddress) ID() string {
154	return "OperationDeserializer"
155}
156
157func (m *awsAwsjson11_deserializeOpAssociateResolverEndpointIpAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
158	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
159) {
160	out, metadata, err = next.HandleDeserialize(ctx, in)
161	if err != nil {
162		return out, metadata, err
163	}
164
165	response, ok := out.RawResponse.(*smithyhttp.Response)
166	if !ok {
167		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
168	}
169
170	if response.StatusCode < 200 || response.StatusCode >= 300 {
171		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateResolverEndpointIpAddress(response, &metadata)
172	}
173	output := &AssociateResolverEndpointIpAddressOutput{}
174	out.Result = output
175
176	var buff [1024]byte
177	ringBuffer := smithyio.NewRingBuffer(buff[:])
178
179	body := io.TeeReader(response.Body, ringBuffer)
180	decoder := json.NewDecoder(body)
181	decoder.UseNumber()
182	var shape interface{}
183	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
184		var snapshot bytes.Buffer
185		io.Copy(&snapshot, ringBuffer)
186		err = &smithy.DeserializationError{
187			Err:      fmt.Errorf("failed to decode response body, %w", err),
188			Snapshot: snapshot.Bytes(),
189		}
190		return out, metadata, err
191	}
192
193	err = awsAwsjson11_deserializeOpDocumentAssociateResolverEndpointIpAddressOutput(&output, shape)
194	if err != nil {
195		var snapshot bytes.Buffer
196		io.Copy(&snapshot, ringBuffer)
197		err = &smithy.DeserializationError{
198			Err:      fmt.Errorf("failed to decode response body, %w", err),
199			Snapshot: snapshot.Bytes(),
200		}
201		return out, metadata, err
202	}
203
204	return out, metadata, err
205}
206
207func awsAwsjson11_deserializeOpErrorAssociateResolverEndpointIpAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
208	var errorBuffer bytes.Buffer
209	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
210		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
211	}
212	errorBody := bytes.NewReader(errorBuffer.Bytes())
213
214	errorCode := "UnknownError"
215	errorMessage := errorCode
216
217	code := response.Header.Get("X-Amzn-ErrorType")
218	if len(code) != 0 {
219		errorCode = restjson.SanitizeErrorCode(code)
220	}
221
222	var buff [1024]byte
223	ringBuffer := smithyio.NewRingBuffer(buff[:])
224
225	body := io.TeeReader(errorBody, ringBuffer)
226	decoder := json.NewDecoder(body)
227	decoder.UseNumber()
228	code, message, err := restjson.GetErrorInfo(decoder)
229	if err != nil {
230		var snapshot bytes.Buffer
231		io.Copy(&snapshot, ringBuffer)
232		err = &smithy.DeserializationError{
233			Err:      fmt.Errorf("failed to decode response body, %w", err),
234			Snapshot: snapshot.Bytes(),
235		}
236		return err
237	}
238
239	errorBody.Seek(0, io.SeekStart)
240	if len(code) != 0 {
241		errorCode = restjson.SanitizeErrorCode(code)
242	}
243	if len(message) != 0 {
244		errorMessage = message
245	}
246
247	switch {
248	case strings.EqualFold("InternalServiceErrorException", errorCode):
249		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
250
251	case strings.EqualFold("InvalidParameterException", errorCode):
252		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
253
254	case strings.EqualFold("InvalidRequestException", errorCode):
255		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
256
257	case strings.EqualFold("LimitExceededException", errorCode):
258		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
259
260	case strings.EqualFold("ResourceExistsException", errorCode):
261		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
262
263	case strings.EqualFold("ResourceNotFoundException", errorCode):
264		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
265
266	case strings.EqualFold("ThrottlingException", errorCode):
267		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
268
269	default:
270		genericError := &smithy.GenericAPIError{
271			Code:    errorCode,
272			Message: errorMessage,
273		}
274		return genericError
275
276	}
277}
278
279type awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig struct {
280}
281
282func (*awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig) ID() string {
283	return "OperationDeserializer"
284}
285
286func (m *awsAwsjson11_deserializeOpAssociateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
287	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
288) {
289	out, metadata, err = next.HandleDeserialize(ctx, in)
290	if err != nil {
291		return out, metadata, err
292	}
293
294	response, ok := out.RawResponse.(*smithyhttp.Response)
295	if !ok {
296		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
297	}
298
299	if response.StatusCode < 200 || response.StatusCode >= 300 {
300		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateResolverQueryLogConfig(response, &metadata)
301	}
302	output := &AssociateResolverQueryLogConfigOutput{}
303	out.Result = output
304
305	var buff [1024]byte
306	ringBuffer := smithyio.NewRingBuffer(buff[:])
307
308	body := io.TeeReader(response.Body, ringBuffer)
309	decoder := json.NewDecoder(body)
310	decoder.UseNumber()
311	var shape interface{}
312	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
313		var snapshot bytes.Buffer
314		io.Copy(&snapshot, ringBuffer)
315		err = &smithy.DeserializationError{
316			Err:      fmt.Errorf("failed to decode response body, %w", err),
317			Snapshot: snapshot.Bytes(),
318		}
319		return out, metadata, err
320	}
321
322	err = awsAwsjson11_deserializeOpDocumentAssociateResolverQueryLogConfigOutput(&output, shape)
323	if err != nil {
324		var snapshot bytes.Buffer
325		io.Copy(&snapshot, ringBuffer)
326		err = &smithy.DeserializationError{
327			Err:      fmt.Errorf("failed to decode response body, %w", err),
328			Snapshot: snapshot.Bytes(),
329		}
330		return out, metadata, err
331	}
332
333	return out, metadata, err
334}
335
336func awsAwsjson11_deserializeOpErrorAssociateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
337	var errorBuffer bytes.Buffer
338	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
339		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
340	}
341	errorBody := bytes.NewReader(errorBuffer.Bytes())
342
343	errorCode := "UnknownError"
344	errorMessage := errorCode
345
346	code := response.Header.Get("X-Amzn-ErrorType")
347	if len(code) != 0 {
348		errorCode = restjson.SanitizeErrorCode(code)
349	}
350
351	var buff [1024]byte
352	ringBuffer := smithyio.NewRingBuffer(buff[:])
353
354	body := io.TeeReader(errorBody, ringBuffer)
355	decoder := json.NewDecoder(body)
356	decoder.UseNumber()
357	code, message, err := restjson.GetErrorInfo(decoder)
358	if err != nil {
359		var snapshot bytes.Buffer
360		io.Copy(&snapshot, ringBuffer)
361		err = &smithy.DeserializationError{
362			Err:      fmt.Errorf("failed to decode response body, %w", err),
363			Snapshot: snapshot.Bytes(),
364		}
365		return err
366	}
367
368	errorBody.Seek(0, io.SeekStart)
369	if len(code) != 0 {
370		errorCode = restjson.SanitizeErrorCode(code)
371	}
372	if len(message) != 0 {
373		errorMessage = message
374	}
375
376	switch {
377	case strings.EqualFold("AccessDeniedException", errorCode):
378		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
379
380	case strings.EqualFold("InternalServiceErrorException", errorCode):
381		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
382
383	case strings.EqualFold("InvalidParameterException", errorCode):
384		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
385
386	case strings.EqualFold("InvalidRequestException", errorCode):
387		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
388
389	case strings.EqualFold("LimitExceededException", errorCode):
390		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
391
392	case strings.EqualFold("ResourceExistsException", errorCode):
393		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
394
395	case strings.EqualFold("ResourceNotFoundException", errorCode):
396		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
397
398	case strings.EqualFold("ThrottlingException", errorCode):
399		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
400
401	default:
402		genericError := &smithy.GenericAPIError{
403			Code:    errorCode,
404			Message: errorMessage,
405		}
406		return genericError
407
408	}
409}
410
411type awsAwsjson11_deserializeOpAssociateResolverRule struct {
412}
413
414func (*awsAwsjson11_deserializeOpAssociateResolverRule) ID() string {
415	return "OperationDeserializer"
416}
417
418func (m *awsAwsjson11_deserializeOpAssociateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
419	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
420) {
421	out, metadata, err = next.HandleDeserialize(ctx, in)
422	if err != nil {
423		return out, metadata, err
424	}
425
426	response, ok := out.RawResponse.(*smithyhttp.Response)
427	if !ok {
428		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
429	}
430
431	if response.StatusCode < 200 || response.StatusCode >= 300 {
432		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateResolverRule(response, &metadata)
433	}
434	output := &AssociateResolverRuleOutput{}
435	out.Result = output
436
437	var buff [1024]byte
438	ringBuffer := smithyio.NewRingBuffer(buff[:])
439
440	body := io.TeeReader(response.Body, ringBuffer)
441	decoder := json.NewDecoder(body)
442	decoder.UseNumber()
443	var shape interface{}
444	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
445		var snapshot bytes.Buffer
446		io.Copy(&snapshot, ringBuffer)
447		err = &smithy.DeserializationError{
448			Err:      fmt.Errorf("failed to decode response body, %w", err),
449			Snapshot: snapshot.Bytes(),
450		}
451		return out, metadata, err
452	}
453
454	err = awsAwsjson11_deserializeOpDocumentAssociateResolverRuleOutput(&output, shape)
455	if err != nil {
456		var snapshot bytes.Buffer
457		io.Copy(&snapshot, ringBuffer)
458		err = &smithy.DeserializationError{
459			Err:      fmt.Errorf("failed to decode response body, %w", err),
460			Snapshot: snapshot.Bytes(),
461		}
462		return out, metadata, err
463	}
464
465	return out, metadata, err
466}
467
468func awsAwsjson11_deserializeOpErrorAssociateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
469	var errorBuffer bytes.Buffer
470	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
471		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
472	}
473	errorBody := bytes.NewReader(errorBuffer.Bytes())
474
475	errorCode := "UnknownError"
476	errorMessage := errorCode
477
478	code := response.Header.Get("X-Amzn-ErrorType")
479	if len(code) != 0 {
480		errorCode = restjson.SanitizeErrorCode(code)
481	}
482
483	var buff [1024]byte
484	ringBuffer := smithyio.NewRingBuffer(buff[:])
485
486	body := io.TeeReader(errorBody, ringBuffer)
487	decoder := json.NewDecoder(body)
488	decoder.UseNumber()
489	code, message, err := restjson.GetErrorInfo(decoder)
490	if err != nil {
491		var snapshot bytes.Buffer
492		io.Copy(&snapshot, ringBuffer)
493		err = &smithy.DeserializationError{
494			Err:      fmt.Errorf("failed to decode response body, %w", err),
495			Snapshot: snapshot.Bytes(),
496		}
497		return err
498	}
499
500	errorBody.Seek(0, io.SeekStart)
501	if len(code) != 0 {
502		errorCode = restjson.SanitizeErrorCode(code)
503	}
504	if len(message) != 0 {
505		errorMessage = message
506	}
507
508	switch {
509	case strings.EqualFold("InternalServiceErrorException", errorCode):
510		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
511
512	case strings.EqualFold("InvalidParameterException", errorCode):
513		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
514
515	case strings.EqualFold("InvalidRequestException", errorCode):
516		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
517
518	case strings.EqualFold("LimitExceededException", errorCode):
519		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
520
521	case strings.EqualFold("ResourceExistsException", errorCode):
522		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
523
524	case strings.EqualFold("ResourceNotFoundException", errorCode):
525		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
526
527	case strings.EqualFold("ResourceUnavailableException", errorCode):
528		return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody)
529
530	case strings.EqualFold("ThrottlingException", errorCode):
531		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
532
533	default:
534		genericError := &smithy.GenericAPIError{
535			Code:    errorCode,
536			Message: errorMessage,
537		}
538		return genericError
539
540	}
541}
542
543type awsAwsjson11_deserializeOpCreateFirewallDomainList struct {
544}
545
546func (*awsAwsjson11_deserializeOpCreateFirewallDomainList) ID() string {
547	return "OperationDeserializer"
548}
549
550func (m *awsAwsjson11_deserializeOpCreateFirewallDomainList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
551	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
552) {
553	out, metadata, err = next.HandleDeserialize(ctx, in)
554	if err != nil {
555		return out, metadata, err
556	}
557
558	response, ok := out.RawResponse.(*smithyhttp.Response)
559	if !ok {
560		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
561	}
562
563	if response.StatusCode < 200 || response.StatusCode >= 300 {
564		return out, metadata, awsAwsjson11_deserializeOpErrorCreateFirewallDomainList(response, &metadata)
565	}
566	output := &CreateFirewallDomainListOutput{}
567	out.Result = output
568
569	var buff [1024]byte
570	ringBuffer := smithyio.NewRingBuffer(buff[:])
571
572	body := io.TeeReader(response.Body, ringBuffer)
573	decoder := json.NewDecoder(body)
574	decoder.UseNumber()
575	var shape interface{}
576	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
577		var snapshot bytes.Buffer
578		io.Copy(&snapshot, ringBuffer)
579		err = &smithy.DeserializationError{
580			Err:      fmt.Errorf("failed to decode response body, %w", err),
581			Snapshot: snapshot.Bytes(),
582		}
583		return out, metadata, err
584	}
585
586	err = awsAwsjson11_deserializeOpDocumentCreateFirewallDomainListOutput(&output, shape)
587	if err != nil {
588		var snapshot bytes.Buffer
589		io.Copy(&snapshot, ringBuffer)
590		err = &smithy.DeserializationError{
591			Err:      fmt.Errorf("failed to decode response body, %w", err),
592			Snapshot: snapshot.Bytes(),
593		}
594		return out, metadata, err
595	}
596
597	return out, metadata, err
598}
599
600func awsAwsjson11_deserializeOpErrorCreateFirewallDomainList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
601	var errorBuffer bytes.Buffer
602	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
603		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
604	}
605	errorBody := bytes.NewReader(errorBuffer.Bytes())
606
607	errorCode := "UnknownError"
608	errorMessage := errorCode
609
610	code := response.Header.Get("X-Amzn-ErrorType")
611	if len(code) != 0 {
612		errorCode = restjson.SanitizeErrorCode(code)
613	}
614
615	var buff [1024]byte
616	ringBuffer := smithyio.NewRingBuffer(buff[:])
617
618	body := io.TeeReader(errorBody, ringBuffer)
619	decoder := json.NewDecoder(body)
620	decoder.UseNumber()
621	code, message, err := restjson.GetErrorInfo(decoder)
622	if err != nil {
623		var snapshot bytes.Buffer
624		io.Copy(&snapshot, ringBuffer)
625		err = &smithy.DeserializationError{
626			Err:      fmt.Errorf("failed to decode response body, %w", err),
627			Snapshot: snapshot.Bytes(),
628		}
629		return err
630	}
631
632	errorBody.Seek(0, io.SeekStart)
633	if len(code) != 0 {
634		errorCode = restjson.SanitizeErrorCode(code)
635	}
636	if len(message) != 0 {
637		errorMessage = message
638	}
639
640	switch {
641	case strings.EqualFold("AccessDeniedException", errorCode):
642		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
643
644	case strings.EqualFold("InternalServiceErrorException", errorCode):
645		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
646
647	case strings.EqualFold("LimitExceededException", errorCode):
648		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
649
650	case strings.EqualFold("ThrottlingException", errorCode):
651		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
652
653	case strings.EqualFold("ValidationException", errorCode):
654		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
655
656	default:
657		genericError := &smithy.GenericAPIError{
658			Code:    errorCode,
659			Message: errorMessage,
660		}
661		return genericError
662
663	}
664}
665
666type awsAwsjson11_deserializeOpCreateFirewallRule struct {
667}
668
669func (*awsAwsjson11_deserializeOpCreateFirewallRule) ID() string {
670	return "OperationDeserializer"
671}
672
673func (m *awsAwsjson11_deserializeOpCreateFirewallRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
674	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
675) {
676	out, metadata, err = next.HandleDeserialize(ctx, in)
677	if err != nil {
678		return out, metadata, err
679	}
680
681	response, ok := out.RawResponse.(*smithyhttp.Response)
682	if !ok {
683		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
684	}
685
686	if response.StatusCode < 200 || response.StatusCode >= 300 {
687		return out, metadata, awsAwsjson11_deserializeOpErrorCreateFirewallRule(response, &metadata)
688	}
689	output := &CreateFirewallRuleOutput{}
690	out.Result = output
691
692	var buff [1024]byte
693	ringBuffer := smithyio.NewRingBuffer(buff[:])
694
695	body := io.TeeReader(response.Body, ringBuffer)
696	decoder := json.NewDecoder(body)
697	decoder.UseNumber()
698	var shape interface{}
699	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
700		var snapshot bytes.Buffer
701		io.Copy(&snapshot, ringBuffer)
702		err = &smithy.DeserializationError{
703			Err:      fmt.Errorf("failed to decode response body, %w", err),
704			Snapshot: snapshot.Bytes(),
705		}
706		return out, metadata, err
707	}
708
709	err = awsAwsjson11_deserializeOpDocumentCreateFirewallRuleOutput(&output, shape)
710	if err != nil {
711		var snapshot bytes.Buffer
712		io.Copy(&snapshot, ringBuffer)
713		err = &smithy.DeserializationError{
714			Err:      fmt.Errorf("failed to decode response body, %w", err),
715			Snapshot: snapshot.Bytes(),
716		}
717		return out, metadata, err
718	}
719
720	return out, metadata, err
721}
722
723func awsAwsjson11_deserializeOpErrorCreateFirewallRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
724	var errorBuffer bytes.Buffer
725	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
726		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
727	}
728	errorBody := bytes.NewReader(errorBuffer.Bytes())
729
730	errorCode := "UnknownError"
731	errorMessage := errorCode
732
733	code := response.Header.Get("X-Amzn-ErrorType")
734	if len(code) != 0 {
735		errorCode = restjson.SanitizeErrorCode(code)
736	}
737
738	var buff [1024]byte
739	ringBuffer := smithyio.NewRingBuffer(buff[:])
740
741	body := io.TeeReader(errorBody, ringBuffer)
742	decoder := json.NewDecoder(body)
743	decoder.UseNumber()
744	code, message, err := restjson.GetErrorInfo(decoder)
745	if err != nil {
746		var snapshot bytes.Buffer
747		io.Copy(&snapshot, ringBuffer)
748		err = &smithy.DeserializationError{
749			Err:      fmt.Errorf("failed to decode response body, %w", err),
750			Snapshot: snapshot.Bytes(),
751		}
752		return err
753	}
754
755	errorBody.Seek(0, io.SeekStart)
756	if len(code) != 0 {
757		errorCode = restjson.SanitizeErrorCode(code)
758	}
759	if len(message) != 0 {
760		errorMessage = message
761	}
762
763	switch {
764	case strings.EqualFold("AccessDeniedException", errorCode):
765		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
766
767	case strings.EqualFold("InternalServiceErrorException", errorCode):
768		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
769
770	case strings.EqualFold("LimitExceededException", errorCode):
771		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
772
773	case strings.EqualFold("ResourceNotFoundException", errorCode):
774		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
775
776	case strings.EqualFold("ThrottlingException", errorCode):
777		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
778
779	case strings.EqualFold("ValidationException", errorCode):
780		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
781
782	default:
783		genericError := &smithy.GenericAPIError{
784			Code:    errorCode,
785			Message: errorMessage,
786		}
787		return genericError
788
789	}
790}
791
792type awsAwsjson11_deserializeOpCreateFirewallRuleGroup struct {
793}
794
795func (*awsAwsjson11_deserializeOpCreateFirewallRuleGroup) ID() string {
796	return "OperationDeserializer"
797}
798
799func (m *awsAwsjson11_deserializeOpCreateFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
800	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
801) {
802	out, metadata, err = next.HandleDeserialize(ctx, in)
803	if err != nil {
804		return out, metadata, err
805	}
806
807	response, ok := out.RawResponse.(*smithyhttp.Response)
808	if !ok {
809		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
810	}
811
812	if response.StatusCode < 200 || response.StatusCode >= 300 {
813		return out, metadata, awsAwsjson11_deserializeOpErrorCreateFirewallRuleGroup(response, &metadata)
814	}
815	output := &CreateFirewallRuleGroupOutput{}
816	out.Result = output
817
818	var buff [1024]byte
819	ringBuffer := smithyio.NewRingBuffer(buff[:])
820
821	body := io.TeeReader(response.Body, ringBuffer)
822	decoder := json.NewDecoder(body)
823	decoder.UseNumber()
824	var shape interface{}
825	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
826		var snapshot bytes.Buffer
827		io.Copy(&snapshot, ringBuffer)
828		err = &smithy.DeserializationError{
829			Err:      fmt.Errorf("failed to decode response body, %w", err),
830			Snapshot: snapshot.Bytes(),
831		}
832		return out, metadata, err
833	}
834
835	err = awsAwsjson11_deserializeOpDocumentCreateFirewallRuleGroupOutput(&output, shape)
836	if err != nil {
837		var snapshot bytes.Buffer
838		io.Copy(&snapshot, ringBuffer)
839		err = &smithy.DeserializationError{
840			Err:      fmt.Errorf("failed to decode response body, %w", err),
841			Snapshot: snapshot.Bytes(),
842		}
843		return out, metadata, err
844	}
845
846	return out, metadata, err
847}
848
849func awsAwsjson11_deserializeOpErrorCreateFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
850	var errorBuffer bytes.Buffer
851	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
852		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
853	}
854	errorBody := bytes.NewReader(errorBuffer.Bytes())
855
856	errorCode := "UnknownError"
857	errorMessage := errorCode
858
859	code := response.Header.Get("X-Amzn-ErrorType")
860	if len(code) != 0 {
861		errorCode = restjson.SanitizeErrorCode(code)
862	}
863
864	var buff [1024]byte
865	ringBuffer := smithyio.NewRingBuffer(buff[:])
866
867	body := io.TeeReader(errorBody, ringBuffer)
868	decoder := json.NewDecoder(body)
869	decoder.UseNumber()
870	code, message, err := restjson.GetErrorInfo(decoder)
871	if err != nil {
872		var snapshot bytes.Buffer
873		io.Copy(&snapshot, ringBuffer)
874		err = &smithy.DeserializationError{
875			Err:      fmt.Errorf("failed to decode response body, %w", err),
876			Snapshot: snapshot.Bytes(),
877		}
878		return err
879	}
880
881	errorBody.Seek(0, io.SeekStart)
882	if len(code) != 0 {
883		errorCode = restjson.SanitizeErrorCode(code)
884	}
885	if len(message) != 0 {
886		errorMessage = message
887	}
888
889	switch {
890	case strings.EqualFold("AccessDeniedException", errorCode):
891		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
892
893	case strings.EqualFold("InternalServiceErrorException", errorCode):
894		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
895
896	case strings.EqualFold("LimitExceededException", errorCode):
897		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
898
899	case strings.EqualFold("ThrottlingException", errorCode):
900		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
901
902	case strings.EqualFold("ValidationException", errorCode):
903		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
904
905	default:
906		genericError := &smithy.GenericAPIError{
907			Code:    errorCode,
908			Message: errorMessage,
909		}
910		return genericError
911
912	}
913}
914
915type awsAwsjson11_deserializeOpCreateResolverEndpoint struct {
916}
917
918func (*awsAwsjson11_deserializeOpCreateResolverEndpoint) ID() string {
919	return "OperationDeserializer"
920}
921
922func (m *awsAwsjson11_deserializeOpCreateResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
923	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
924) {
925	out, metadata, err = next.HandleDeserialize(ctx, in)
926	if err != nil {
927		return out, metadata, err
928	}
929
930	response, ok := out.RawResponse.(*smithyhttp.Response)
931	if !ok {
932		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
933	}
934
935	if response.StatusCode < 200 || response.StatusCode >= 300 {
936		return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverEndpoint(response, &metadata)
937	}
938	output := &CreateResolverEndpointOutput{}
939	out.Result = output
940
941	var buff [1024]byte
942	ringBuffer := smithyio.NewRingBuffer(buff[:])
943
944	body := io.TeeReader(response.Body, ringBuffer)
945	decoder := json.NewDecoder(body)
946	decoder.UseNumber()
947	var shape interface{}
948	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
949		var snapshot bytes.Buffer
950		io.Copy(&snapshot, ringBuffer)
951		err = &smithy.DeserializationError{
952			Err:      fmt.Errorf("failed to decode response body, %w", err),
953			Snapshot: snapshot.Bytes(),
954		}
955		return out, metadata, err
956	}
957
958	err = awsAwsjson11_deserializeOpDocumentCreateResolverEndpointOutput(&output, shape)
959	if err != nil {
960		var snapshot bytes.Buffer
961		io.Copy(&snapshot, ringBuffer)
962		err = &smithy.DeserializationError{
963			Err:      fmt.Errorf("failed to decode response body, %w", err),
964			Snapshot: snapshot.Bytes(),
965		}
966		return out, metadata, err
967	}
968
969	return out, metadata, err
970}
971
972func awsAwsjson11_deserializeOpErrorCreateResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
973	var errorBuffer bytes.Buffer
974	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
975		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
976	}
977	errorBody := bytes.NewReader(errorBuffer.Bytes())
978
979	errorCode := "UnknownError"
980	errorMessage := errorCode
981
982	code := response.Header.Get("X-Amzn-ErrorType")
983	if len(code) != 0 {
984		errorCode = restjson.SanitizeErrorCode(code)
985	}
986
987	var buff [1024]byte
988	ringBuffer := smithyio.NewRingBuffer(buff[:])
989
990	body := io.TeeReader(errorBody, ringBuffer)
991	decoder := json.NewDecoder(body)
992	decoder.UseNumber()
993	code, message, err := restjson.GetErrorInfo(decoder)
994	if err != nil {
995		var snapshot bytes.Buffer
996		io.Copy(&snapshot, ringBuffer)
997		err = &smithy.DeserializationError{
998			Err:      fmt.Errorf("failed to decode response body, %w", err),
999			Snapshot: snapshot.Bytes(),
1000		}
1001		return err
1002	}
1003
1004	errorBody.Seek(0, io.SeekStart)
1005	if len(code) != 0 {
1006		errorCode = restjson.SanitizeErrorCode(code)
1007	}
1008	if len(message) != 0 {
1009		errorMessage = message
1010	}
1011
1012	switch {
1013	case strings.EqualFold("InternalServiceErrorException", errorCode):
1014		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1015
1016	case strings.EqualFold("InvalidParameterException", errorCode):
1017		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1018
1019	case strings.EqualFold("InvalidRequestException", errorCode):
1020		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
1021
1022	case strings.EqualFold("LimitExceededException", errorCode):
1023		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1024
1025	case strings.EqualFold("ResourceExistsException", errorCode):
1026		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
1027
1028	case strings.EqualFold("ResourceNotFoundException", errorCode):
1029		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1030
1031	case strings.EqualFold("ThrottlingException", errorCode):
1032		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1033
1034	default:
1035		genericError := &smithy.GenericAPIError{
1036			Code:    errorCode,
1037			Message: errorMessage,
1038		}
1039		return genericError
1040
1041	}
1042}
1043
1044type awsAwsjson11_deserializeOpCreateResolverQueryLogConfig struct {
1045}
1046
1047func (*awsAwsjson11_deserializeOpCreateResolverQueryLogConfig) ID() string {
1048	return "OperationDeserializer"
1049}
1050
1051func (m *awsAwsjson11_deserializeOpCreateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1052	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1053) {
1054	out, metadata, err = next.HandleDeserialize(ctx, in)
1055	if err != nil {
1056		return out, metadata, err
1057	}
1058
1059	response, ok := out.RawResponse.(*smithyhttp.Response)
1060	if !ok {
1061		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1062	}
1063
1064	if response.StatusCode < 200 || response.StatusCode >= 300 {
1065		return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverQueryLogConfig(response, &metadata)
1066	}
1067	output := &CreateResolverQueryLogConfigOutput{}
1068	out.Result = output
1069
1070	var buff [1024]byte
1071	ringBuffer := smithyio.NewRingBuffer(buff[:])
1072
1073	body := io.TeeReader(response.Body, ringBuffer)
1074	decoder := json.NewDecoder(body)
1075	decoder.UseNumber()
1076	var shape interface{}
1077	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1078		var snapshot bytes.Buffer
1079		io.Copy(&snapshot, ringBuffer)
1080		err = &smithy.DeserializationError{
1081			Err:      fmt.Errorf("failed to decode response body, %w", err),
1082			Snapshot: snapshot.Bytes(),
1083		}
1084		return out, metadata, err
1085	}
1086
1087	err = awsAwsjson11_deserializeOpDocumentCreateResolverQueryLogConfigOutput(&output, shape)
1088	if err != nil {
1089		var snapshot bytes.Buffer
1090		io.Copy(&snapshot, ringBuffer)
1091		err = &smithy.DeserializationError{
1092			Err:      fmt.Errorf("failed to decode response body, %w", err),
1093			Snapshot: snapshot.Bytes(),
1094		}
1095		return out, metadata, err
1096	}
1097
1098	return out, metadata, err
1099}
1100
1101func awsAwsjson11_deserializeOpErrorCreateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1102	var errorBuffer bytes.Buffer
1103	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1104		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1105	}
1106	errorBody := bytes.NewReader(errorBuffer.Bytes())
1107
1108	errorCode := "UnknownError"
1109	errorMessage := errorCode
1110
1111	code := response.Header.Get("X-Amzn-ErrorType")
1112	if len(code) != 0 {
1113		errorCode = restjson.SanitizeErrorCode(code)
1114	}
1115
1116	var buff [1024]byte
1117	ringBuffer := smithyio.NewRingBuffer(buff[:])
1118
1119	body := io.TeeReader(errorBody, ringBuffer)
1120	decoder := json.NewDecoder(body)
1121	decoder.UseNumber()
1122	code, message, err := restjson.GetErrorInfo(decoder)
1123	if err != nil {
1124		var snapshot bytes.Buffer
1125		io.Copy(&snapshot, ringBuffer)
1126		err = &smithy.DeserializationError{
1127			Err:      fmt.Errorf("failed to decode response body, %w", err),
1128			Snapshot: snapshot.Bytes(),
1129		}
1130		return err
1131	}
1132
1133	errorBody.Seek(0, io.SeekStart)
1134	if len(code) != 0 {
1135		errorCode = restjson.SanitizeErrorCode(code)
1136	}
1137	if len(message) != 0 {
1138		errorMessage = message
1139	}
1140
1141	switch {
1142	case strings.EqualFold("AccessDeniedException", errorCode):
1143		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1144
1145	case strings.EqualFold("InternalServiceErrorException", errorCode):
1146		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1147
1148	case strings.EqualFold("InvalidParameterException", errorCode):
1149		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1150
1151	case strings.EqualFold("InvalidRequestException", errorCode):
1152		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
1153
1154	case strings.EqualFold("LimitExceededException", errorCode):
1155		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1156
1157	case strings.EqualFold("ResourceExistsException", errorCode):
1158		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
1159
1160	case strings.EqualFold("ResourceNotFoundException", errorCode):
1161		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1162
1163	case strings.EqualFold("ThrottlingException", errorCode):
1164		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1165
1166	default:
1167		genericError := &smithy.GenericAPIError{
1168			Code:    errorCode,
1169			Message: errorMessage,
1170		}
1171		return genericError
1172
1173	}
1174}
1175
1176type awsAwsjson11_deserializeOpCreateResolverRule struct {
1177}
1178
1179func (*awsAwsjson11_deserializeOpCreateResolverRule) ID() string {
1180	return "OperationDeserializer"
1181}
1182
1183func (m *awsAwsjson11_deserializeOpCreateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1184	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1185) {
1186	out, metadata, err = next.HandleDeserialize(ctx, in)
1187	if err != nil {
1188		return out, metadata, err
1189	}
1190
1191	response, ok := out.RawResponse.(*smithyhttp.Response)
1192	if !ok {
1193		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1194	}
1195
1196	if response.StatusCode < 200 || response.StatusCode >= 300 {
1197		return out, metadata, awsAwsjson11_deserializeOpErrorCreateResolverRule(response, &metadata)
1198	}
1199	output := &CreateResolverRuleOutput{}
1200	out.Result = output
1201
1202	var buff [1024]byte
1203	ringBuffer := smithyio.NewRingBuffer(buff[:])
1204
1205	body := io.TeeReader(response.Body, ringBuffer)
1206	decoder := json.NewDecoder(body)
1207	decoder.UseNumber()
1208	var shape interface{}
1209	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1210		var snapshot bytes.Buffer
1211		io.Copy(&snapshot, ringBuffer)
1212		err = &smithy.DeserializationError{
1213			Err:      fmt.Errorf("failed to decode response body, %w", err),
1214			Snapshot: snapshot.Bytes(),
1215		}
1216		return out, metadata, err
1217	}
1218
1219	err = awsAwsjson11_deserializeOpDocumentCreateResolverRuleOutput(&output, shape)
1220	if err != nil {
1221		var snapshot bytes.Buffer
1222		io.Copy(&snapshot, ringBuffer)
1223		err = &smithy.DeserializationError{
1224			Err:      fmt.Errorf("failed to decode response body, %w", err),
1225			Snapshot: snapshot.Bytes(),
1226		}
1227		return out, metadata, err
1228	}
1229
1230	return out, metadata, err
1231}
1232
1233func awsAwsjson11_deserializeOpErrorCreateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1234	var errorBuffer bytes.Buffer
1235	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1236		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1237	}
1238	errorBody := bytes.NewReader(errorBuffer.Bytes())
1239
1240	errorCode := "UnknownError"
1241	errorMessage := errorCode
1242
1243	code := response.Header.Get("X-Amzn-ErrorType")
1244	if len(code) != 0 {
1245		errorCode = restjson.SanitizeErrorCode(code)
1246	}
1247
1248	var buff [1024]byte
1249	ringBuffer := smithyio.NewRingBuffer(buff[:])
1250
1251	body := io.TeeReader(errorBody, ringBuffer)
1252	decoder := json.NewDecoder(body)
1253	decoder.UseNumber()
1254	code, message, err := restjson.GetErrorInfo(decoder)
1255	if err != nil {
1256		var snapshot bytes.Buffer
1257		io.Copy(&snapshot, ringBuffer)
1258		err = &smithy.DeserializationError{
1259			Err:      fmt.Errorf("failed to decode response body, %w", err),
1260			Snapshot: snapshot.Bytes(),
1261		}
1262		return err
1263	}
1264
1265	errorBody.Seek(0, io.SeekStart)
1266	if len(code) != 0 {
1267		errorCode = restjson.SanitizeErrorCode(code)
1268	}
1269	if len(message) != 0 {
1270		errorMessage = message
1271	}
1272
1273	switch {
1274	case strings.EqualFold("InternalServiceErrorException", errorCode):
1275		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1276
1277	case strings.EqualFold("InvalidParameterException", errorCode):
1278		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1279
1280	case strings.EqualFold("InvalidRequestException", errorCode):
1281		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
1282
1283	case strings.EqualFold("LimitExceededException", errorCode):
1284		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1285
1286	case strings.EqualFold("ResourceExistsException", errorCode):
1287		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
1288
1289	case strings.EqualFold("ResourceNotFoundException", errorCode):
1290		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1291
1292	case strings.EqualFold("ResourceUnavailableException", errorCode):
1293		return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody)
1294
1295	case strings.EqualFold("ThrottlingException", errorCode):
1296		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1297
1298	default:
1299		genericError := &smithy.GenericAPIError{
1300			Code:    errorCode,
1301			Message: errorMessage,
1302		}
1303		return genericError
1304
1305	}
1306}
1307
1308type awsAwsjson11_deserializeOpDeleteFirewallDomainList struct {
1309}
1310
1311func (*awsAwsjson11_deserializeOpDeleteFirewallDomainList) ID() string {
1312	return "OperationDeserializer"
1313}
1314
1315func (m *awsAwsjson11_deserializeOpDeleteFirewallDomainList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1316	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1317) {
1318	out, metadata, err = next.HandleDeserialize(ctx, in)
1319	if err != nil {
1320		return out, metadata, err
1321	}
1322
1323	response, ok := out.RawResponse.(*smithyhttp.Response)
1324	if !ok {
1325		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1326	}
1327
1328	if response.StatusCode < 200 || response.StatusCode >= 300 {
1329		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFirewallDomainList(response, &metadata)
1330	}
1331	output := &DeleteFirewallDomainListOutput{}
1332	out.Result = output
1333
1334	var buff [1024]byte
1335	ringBuffer := smithyio.NewRingBuffer(buff[:])
1336
1337	body := io.TeeReader(response.Body, ringBuffer)
1338	decoder := json.NewDecoder(body)
1339	decoder.UseNumber()
1340	var shape interface{}
1341	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1342		var snapshot bytes.Buffer
1343		io.Copy(&snapshot, ringBuffer)
1344		err = &smithy.DeserializationError{
1345			Err:      fmt.Errorf("failed to decode response body, %w", err),
1346			Snapshot: snapshot.Bytes(),
1347		}
1348		return out, metadata, err
1349	}
1350
1351	err = awsAwsjson11_deserializeOpDocumentDeleteFirewallDomainListOutput(&output, shape)
1352	if err != nil {
1353		var snapshot bytes.Buffer
1354		io.Copy(&snapshot, ringBuffer)
1355		err = &smithy.DeserializationError{
1356			Err:      fmt.Errorf("failed to decode response body, %w", err),
1357			Snapshot: snapshot.Bytes(),
1358		}
1359		return out, metadata, err
1360	}
1361
1362	return out, metadata, err
1363}
1364
1365func awsAwsjson11_deserializeOpErrorDeleteFirewallDomainList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1366	var errorBuffer bytes.Buffer
1367	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1368		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1369	}
1370	errorBody := bytes.NewReader(errorBuffer.Bytes())
1371
1372	errorCode := "UnknownError"
1373	errorMessage := errorCode
1374
1375	code := response.Header.Get("X-Amzn-ErrorType")
1376	if len(code) != 0 {
1377		errorCode = restjson.SanitizeErrorCode(code)
1378	}
1379
1380	var buff [1024]byte
1381	ringBuffer := smithyio.NewRingBuffer(buff[:])
1382
1383	body := io.TeeReader(errorBody, ringBuffer)
1384	decoder := json.NewDecoder(body)
1385	decoder.UseNumber()
1386	code, message, err := restjson.GetErrorInfo(decoder)
1387	if err != nil {
1388		var snapshot bytes.Buffer
1389		io.Copy(&snapshot, ringBuffer)
1390		err = &smithy.DeserializationError{
1391			Err:      fmt.Errorf("failed to decode response body, %w", err),
1392			Snapshot: snapshot.Bytes(),
1393		}
1394		return err
1395	}
1396
1397	errorBody.Seek(0, io.SeekStart)
1398	if len(code) != 0 {
1399		errorCode = restjson.SanitizeErrorCode(code)
1400	}
1401	if len(message) != 0 {
1402		errorMessage = message
1403	}
1404
1405	switch {
1406	case strings.EqualFold("AccessDeniedException", errorCode):
1407		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1408
1409	case strings.EqualFold("ConflictException", errorCode):
1410		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
1411
1412	case strings.EqualFold("InternalServiceErrorException", errorCode):
1413		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1414
1415	case strings.EqualFold("ResourceNotFoundException", errorCode):
1416		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1417
1418	case strings.EqualFold("ThrottlingException", errorCode):
1419		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1420
1421	default:
1422		genericError := &smithy.GenericAPIError{
1423			Code:    errorCode,
1424			Message: errorMessage,
1425		}
1426		return genericError
1427
1428	}
1429}
1430
1431type awsAwsjson11_deserializeOpDeleteFirewallRule struct {
1432}
1433
1434func (*awsAwsjson11_deserializeOpDeleteFirewallRule) ID() string {
1435	return "OperationDeserializer"
1436}
1437
1438func (m *awsAwsjson11_deserializeOpDeleteFirewallRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1439	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1440) {
1441	out, metadata, err = next.HandleDeserialize(ctx, in)
1442	if err != nil {
1443		return out, metadata, err
1444	}
1445
1446	response, ok := out.RawResponse.(*smithyhttp.Response)
1447	if !ok {
1448		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1449	}
1450
1451	if response.StatusCode < 200 || response.StatusCode >= 300 {
1452		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFirewallRule(response, &metadata)
1453	}
1454	output := &DeleteFirewallRuleOutput{}
1455	out.Result = output
1456
1457	var buff [1024]byte
1458	ringBuffer := smithyio.NewRingBuffer(buff[:])
1459
1460	body := io.TeeReader(response.Body, ringBuffer)
1461	decoder := json.NewDecoder(body)
1462	decoder.UseNumber()
1463	var shape interface{}
1464	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1465		var snapshot bytes.Buffer
1466		io.Copy(&snapshot, ringBuffer)
1467		err = &smithy.DeserializationError{
1468			Err:      fmt.Errorf("failed to decode response body, %w", err),
1469			Snapshot: snapshot.Bytes(),
1470		}
1471		return out, metadata, err
1472	}
1473
1474	err = awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleOutput(&output, shape)
1475	if err != nil {
1476		var snapshot bytes.Buffer
1477		io.Copy(&snapshot, ringBuffer)
1478		err = &smithy.DeserializationError{
1479			Err:      fmt.Errorf("failed to decode response body, %w", err),
1480			Snapshot: snapshot.Bytes(),
1481		}
1482		return out, metadata, err
1483	}
1484
1485	return out, metadata, err
1486}
1487
1488func awsAwsjson11_deserializeOpErrorDeleteFirewallRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1489	var errorBuffer bytes.Buffer
1490	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1491		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1492	}
1493	errorBody := bytes.NewReader(errorBuffer.Bytes())
1494
1495	errorCode := "UnknownError"
1496	errorMessage := errorCode
1497
1498	code := response.Header.Get("X-Amzn-ErrorType")
1499	if len(code) != 0 {
1500		errorCode = restjson.SanitizeErrorCode(code)
1501	}
1502
1503	var buff [1024]byte
1504	ringBuffer := smithyio.NewRingBuffer(buff[:])
1505
1506	body := io.TeeReader(errorBody, ringBuffer)
1507	decoder := json.NewDecoder(body)
1508	decoder.UseNumber()
1509	code, message, err := restjson.GetErrorInfo(decoder)
1510	if err != nil {
1511		var snapshot bytes.Buffer
1512		io.Copy(&snapshot, ringBuffer)
1513		err = &smithy.DeserializationError{
1514			Err:      fmt.Errorf("failed to decode response body, %w", err),
1515			Snapshot: snapshot.Bytes(),
1516		}
1517		return err
1518	}
1519
1520	errorBody.Seek(0, io.SeekStart)
1521	if len(code) != 0 {
1522		errorCode = restjson.SanitizeErrorCode(code)
1523	}
1524	if len(message) != 0 {
1525		errorMessage = message
1526	}
1527
1528	switch {
1529	case strings.EqualFold("AccessDeniedException", errorCode):
1530		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1531
1532	case strings.EqualFold("InternalServiceErrorException", errorCode):
1533		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1534
1535	case strings.EqualFold("ResourceNotFoundException", errorCode):
1536		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1537
1538	case strings.EqualFold("ThrottlingException", errorCode):
1539		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1540
1541	default:
1542		genericError := &smithy.GenericAPIError{
1543			Code:    errorCode,
1544			Message: errorMessage,
1545		}
1546		return genericError
1547
1548	}
1549}
1550
1551type awsAwsjson11_deserializeOpDeleteFirewallRuleGroup struct {
1552}
1553
1554func (*awsAwsjson11_deserializeOpDeleteFirewallRuleGroup) ID() string {
1555	return "OperationDeserializer"
1556}
1557
1558func (m *awsAwsjson11_deserializeOpDeleteFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1559	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1560) {
1561	out, metadata, err = next.HandleDeserialize(ctx, in)
1562	if err != nil {
1563		return out, metadata, err
1564	}
1565
1566	response, ok := out.RawResponse.(*smithyhttp.Response)
1567	if !ok {
1568		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1569	}
1570
1571	if response.StatusCode < 200 || response.StatusCode >= 300 {
1572		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFirewallRuleGroup(response, &metadata)
1573	}
1574	output := &DeleteFirewallRuleGroupOutput{}
1575	out.Result = output
1576
1577	var buff [1024]byte
1578	ringBuffer := smithyio.NewRingBuffer(buff[:])
1579
1580	body := io.TeeReader(response.Body, ringBuffer)
1581	decoder := json.NewDecoder(body)
1582	decoder.UseNumber()
1583	var shape interface{}
1584	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1585		var snapshot bytes.Buffer
1586		io.Copy(&snapshot, ringBuffer)
1587		err = &smithy.DeserializationError{
1588			Err:      fmt.Errorf("failed to decode response body, %w", err),
1589			Snapshot: snapshot.Bytes(),
1590		}
1591		return out, metadata, err
1592	}
1593
1594	err = awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleGroupOutput(&output, shape)
1595	if err != nil {
1596		var snapshot bytes.Buffer
1597		io.Copy(&snapshot, ringBuffer)
1598		err = &smithy.DeserializationError{
1599			Err:      fmt.Errorf("failed to decode response body, %w", err),
1600			Snapshot: snapshot.Bytes(),
1601		}
1602		return out, metadata, err
1603	}
1604
1605	return out, metadata, err
1606}
1607
1608func awsAwsjson11_deserializeOpErrorDeleteFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1609	var errorBuffer bytes.Buffer
1610	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1611		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1612	}
1613	errorBody := bytes.NewReader(errorBuffer.Bytes())
1614
1615	errorCode := "UnknownError"
1616	errorMessage := errorCode
1617
1618	code := response.Header.Get("X-Amzn-ErrorType")
1619	if len(code) != 0 {
1620		errorCode = restjson.SanitizeErrorCode(code)
1621	}
1622
1623	var buff [1024]byte
1624	ringBuffer := smithyio.NewRingBuffer(buff[:])
1625
1626	body := io.TeeReader(errorBody, ringBuffer)
1627	decoder := json.NewDecoder(body)
1628	decoder.UseNumber()
1629	code, message, err := restjson.GetErrorInfo(decoder)
1630	if err != nil {
1631		var snapshot bytes.Buffer
1632		io.Copy(&snapshot, ringBuffer)
1633		err = &smithy.DeserializationError{
1634			Err:      fmt.Errorf("failed to decode response body, %w", err),
1635			Snapshot: snapshot.Bytes(),
1636		}
1637		return err
1638	}
1639
1640	errorBody.Seek(0, io.SeekStart)
1641	if len(code) != 0 {
1642		errorCode = restjson.SanitizeErrorCode(code)
1643	}
1644	if len(message) != 0 {
1645		errorMessage = message
1646	}
1647
1648	switch {
1649	case strings.EqualFold("AccessDeniedException", errorCode):
1650		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1651
1652	case strings.EqualFold("ConflictException", errorCode):
1653		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
1654
1655	case strings.EqualFold("InternalServiceErrorException", errorCode):
1656		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1657
1658	case strings.EqualFold("ResourceNotFoundException", errorCode):
1659		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1660
1661	case strings.EqualFold("ThrottlingException", errorCode):
1662		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1663
1664	case strings.EqualFold("ValidationException", errorCode):
1665		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
1666
1667	default:
1668		genericError := &smithy.GenericAPIError{
1669			Code:    errorCode,
1670			Message: errorMessage,
1671		}
1672		return genericError
1673
1674	}
1675}
1676
1677type awsAwsjson11_deserializeOpDeleteResolverEndpoint struct {
1678}
1679
1680func (*awsAwsjson11_deserializeOpDeleteResolverEndpoint) ID() string {
1681	return "OperationDeserializer"
1682}
1683
1684func (m *awsAwsjson11_deserializeOpDeleteResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1685	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1686) {
1687	out, metadata, err = next.HandleDeserialize(ctx, in)
1688	if err != nil {
1689		return out, metadata, err
1690	}
1691
1692	response, ok := out.RawResponse.(*smithyhttp.Response)
1693	if !ok {
1694		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1695	}
1696
1697	if response.StatusCode < 200 || response.StatusCode >= 300 {
1698		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverEndpoint(response, &metadata)
1699	}
1700	output := &DeleteResolverEndpointOutput{}
1701	out.Result = output
1702
1703	var buff [1024]byte
1704	ringBuffer := smithyio.NewRingBuffer(buff[:])
1705
1706	body := io.TeeReader(response.Body, ringBuffer)
1707	decoder := json.NewDecoder(body)
1708	decoder.UseNumber()
1709	var shape interface{}
1710	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1711		var snapshot bytes.Buffer
1712		io.Copy(&snapshot, ringBuffer)
1713		err = &smithy.DeserializationError{
1714			Err:      fmt.Errorf("failed to decode response body, %w", err),
1715			Snapshot: snapshot.Bytes(),
1716		}
1717		return out, metadata, err
1718	}
1719
1720	err = awsAwsjson11_deserializeOpDocumentDeleteResolverEndpointOutput(&output, shape)
1721	if err != nil {
1722		var snapshot bytes.Buffer
1723		io.Copy(&snapshot, ringBuffer)
1724		err = &smithy.DeserializationError{
1725			Err:      fmt.Errorf("failed to decode response body, %w", err),
1726			Snapshot: snapshot.Bytes(),
1727		}
1728		return out, metadata, err
1729	}
1730
1731	return out, metadata, err
1732}
1733
1734func awsAwsjson11_deserializeOpErrorDeleteResolverEndpoint(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("InvalidParameterException", errorCode):
1779		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1780
1781	case strings.EqualFold("InvalidRequestException", errorCode):
1782		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
1783
1784	case strings.EqualFold("ResourceNotFoundException", errorCode):
1785		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1786
1787	case strings.EqualFold("ThrottlingException", errorCode):
1788		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1789
1790	default:
1791		genericError := &smithy.GenericAPIError{
1792			Code:    errorCode,
1793			Message: errorMessage,
1794		}
1795		return genericError
1796
1797	}
1798}
1799
1800type awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig struct {
1801}
1802
1803func (*awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig) ID() string {
1804	return "OperationDeserializer"
1805}
1806
1807func (m *awsAwsjson11_deserializeOpDeleteResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1808	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1809) {
1810	out, metadata, err = next.HandleDeserialize(ctx, in)
1811	if err != nil {
1812		return out, metadata, err
1813	}
1814
1815	response, ok := out.RawResponse.(*smithyhttp.Response)
1816	if !ok {
1817		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1818	}
1819
1820	if response.StatusCode < 200 || response.StatusCode >= 300 {
1821		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverQueryLogConfig(response, &metadata)
1822	}
1823	output := &DeleteResolverQueryLogConfigOutput{}
1824	out.Result = output
1825
1826	var buff [1024]byte
1827	ringBuffer := smithyio.NewRingBuffer(buff[:])
1828
1829	body := io.TeeReader(response.Body, ringBuffer)
1830	decoder := json.NewDecoder(body)
1831	decoder.UseNumber()
1832	var shape interface{}
1833	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1834		var snapshot bytes.Buffer
1835		io.Copy(&snapshot, ringBuffer)
1836		err = &smithy.DeserializationError{
1837			Err:      fmt.Errorf("failed to decode response body, %w", err),
1838			Snapshot: snapshot.Bytes(),
1839		}
1840		return out, metadata, err
1841	}
1842
1843	err = awsAwsjson11_deserializeOpDocumentDeleteResolverQueryLogConfigOutput(&output, shape)
1844	if err != nil {
1845		var snapshot bytes.Buffer
1846		io.Copy(&snapshot, ringBuffer)
1847		err = &smithy.DeserializationError{
1848			Err:      fmt.Errorf("failed to decode response body, %w", err),
1849			Snapshot: snapshot.Bytes(),
1850		}
1851		return out, metadata, err
1852	}
1853
1854	return out, metadata, err
1855}
1856
1857func awsAwsjson11_deserializeOpErrorDeleteResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1858	var errorBuffer bytes.Buffer
1859	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1860		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1861	}
1862	errorBody := bytes.NewReader(errorBuffer.Bytes())
1863
1864	errorCode := "UnknownError"
1865	errorMessage := errorCode
1866
1867	code := response.Header.Get("X-Amzn-ErrorType")
1868	if len(code) != 0 {
1869		errorCode = restjson.SanitizeErrorCode(code)
1870	}
1871
1872	var buff [1024]byte
1873	ringBuffer := smithyio.NewRingBuffer(buff[:])
1874
1875	body := io.TeeReader(errorBody, ringBuffer)
1876	decoder := json.NewDecoder(body)
1877	decoder.UseNumber()
1878	code, message, err := restjson.GetErrorInfo(decoder)
1879	if err != nil {
1880		var snapshot bytes.Buffer
1881		io.Copy(&snapshot, ringBuffer)
1882		err = &smithy.DeserializationError{
1883			Err:      fmt.Errorf("failed to decode response body, %w", err),
1884			Snapshot: snapshot.Bytes(),
1885		}
1886		return err
1887	}
1888
1889	errorBody.Seek(0, io.SeekStart)
1890	if len(code) != 0 {
1891		errorCode = restjson.SanitizeErrorCode(code)
1892	}
1893	if len(message) != 0 {
1894		errorMessage = message
1895	}
1896
1897	switch {
1898	case strings.EqualFold("AccessDeniedException", errorCode):
1899		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1900
1901	case strings.EqualFold("InternalServiceErrorException", errorCode):
1902		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
1903
1904	case strings.EqualFold("InvalidParameterException", errorCode):
1905		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
1906
1907	case strings.EqualFold("InvalidRequestException", errorCode):
1908		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
1909
1910	case strings.EqualFold("ResourceNotFoundException", errorCode):
1911		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1912
1913	case strings.EqualFold("ThrottlingException", errorCode):
1914		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
1915
1916	default:
1917		genericError := &smithy.GenericAPIError{
1918			Code:    errorCode,
1919			Message: errorMessage,
1920		}
1921		return genericError
1922
1923	}
1924}
1925
1926type awsAwsjson11_deserializeOpDeleteResolverRule struct {
1927}
1928
1929func (*awsAwsjson11_deserializeOpDeleteResolverRule) ID() string {
1930	return "OperationDeserializer"
1931}
1932
1933func (m *awsAwsjson11_deserializeOpDeleteResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1934	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1935) {
1936	out, metadata, err = next.HandleDeserialize(ctx, in)
1937	if err != nil {
1938		return out, metadata, err
1939	}
1940
1941	response, ok := out.RawResponse.(*smithyhttp.Response)
1942	if !ok {
1943		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1944	}
1945
1946	if response.StatusCode < 200 || response.StatusCode >= 300 {
1947		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResolverRule(response, &metadata)
1948	}
1949	output := &DeleteResolverRuleOutput{}
1950	out.Result = output
1951
1952	var buff [1024]byte
1953	ringBuffer := smithyio.NewRingBuffer(buff[:])
1954
1955	body := io.TeeReader(response.Body, ringBuffer)
1956	decoder := json.NewDecoder(body)
1957	decoder.UseNumber()
1958	var shape interface{}
1959	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1960		var snapshot bytes.Buffer
1961		io.Copy(&snapshot, ringBuffer)
1962		err = &smithy.DeserializationError{
1963			Err:      fmt.Errorf("failed to decode response body, %w", err),
1964			Snapshot: snapshot.Bytes(),
1965		}
1966		return out, metadata, err
1967	}
1968
1969	err = awsAwsjson11_deserializeOpDocumentDeleteResolverRuleOutput(&output, shape)
1970	if err != nil {
1971		var snapshot bytes.Buffer
1972		io.Copy(&snapshot, ringBuffer)
1973		err = &smithy.DeserializationError{
1974			Err:      fmt.Errorf("failed to decode response body, %w", err),
1975			Snapshot: snapshot.Bytes(),
1976		}
1977		return out, metadata, err
1978	}
1979
1980	return out, metadata, err
1981}
1982
1983func awsAwsjson11_deserializeOpErrorDeleteResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1984	var errorBuffer bytes.Buffer
1985	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1986		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1987	}
1988	errorBody := bytes.NewReader(errorBuffer.Bytes())
1989
1990	errorCode := "UnknownError"
1991	errorMessage := errorCode
1992
1993	code := response.Header.Get("X-Amzn-ErrorType")
1994	if len(code) != 0 {
1995		errorCode = restjson.SanitizeErrorCode(code)
1996	}
1997
1998	var buff [1024]byte
1999	ringBuffer := smithyio.NewRingBuffer(buff[:])
2000
2001	body := io.TeeReader(errorBody, ringBuffer)
2002	decoder := json.NewDecoder(body)
2003	decoder.UseNumber()
2004	code, message, err := restjson.GetErrorInfo(decoder)
2005	if err != nil {
2006		var snapshot bytes.Buffer
2007		io.Copy(&snapshot, ringBuffer)
2008		err = &smithy.DeserializationError{
2009			Err:      fmt.Errorf("failed to decode response body, %w", err),
2010			Snapshot: snapshot.Bytes(),
2011		}
2012		return err
2013	}
2014
2015	errorBody.Seek(0, io.SeekStart)
2016	if len(code) != 0 {
2017		errorCode = restjson.SanitizeErrorCode(code)
2018	}
2019	if len(message) != 0 {
2020		errorMessage = message
2021	}
2022
2023	switch {
2024	case strings.EqualFold("InternalServiceErrorException", errorCode):
2025		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2026
2027	case strings.EqualFold("InvalidParameterException", errorCode):
2028		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2029
2030	case strings.EqualFold("ResourceInUseException", errorCode):
2031		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2032
2033	case strings.EqualFold("ResourceNotFoundException", errorCode):
2034		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2035
2036	case strings.EqualFold("ThrottlingException", errorCode):
2037		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2038
2039	default:
2040		genericError := &smithy.GenericAPIError{
2041			Code:    errorCode,
2042			Message: errorMessage,
2043		}
2044		return genericError
2045
2046	}
2047}
2048
2049type awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup struct {
2050}
2051
2052func (*awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup) ID() string {
2053	return "OperationDeserializer"
2054}
2055
2056func (m *awsAwsjson11_deserializeOpDisassociateFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2057	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2058) {
2059	out, metadata, err = next.HandleDeserialize(ctx, in)
2060	if err != nil {
2061		return out, metadata, err
2062	}
2063
2064	response, ok := out.RawResponse.(*smithyhttp.Response)
2065	if !ok {
2066		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2067	}
2068
2069	if response.StatusCode < 200 || response.StatusCode >= 300 {
2070		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateFirewallRuleGroup(response, &metadata)
2071	}
2072	output := &DisassociateFirewallRuleGroupOutput{}
2073	out.Result = output
2074
2075	var buff [1024]byte
2076	ringBuffer := smithyio.NewRingBuffer(buff[:])
2077
2078	body := io.TeeReader(response.Body, ringBuffer)
2079	decoder := json.NewDecoder(body)
2080	decoder.UseNumber()
2081	var shape interface{}
2082	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2083		var snapshot bytes.Buffer
2084		io.Copy(&snapshot, ringBuffer)
2085		err = &smithy.DeserializationError{
2086			Err:      fmt.Errorf("failed to decode response body, %w", err),
2087			Snapshot: snapshot.Bytes(),
2088		}
2089		return out, metadata, err
2090	}
2091
2092	err = awsAwsjson11_deserializeOpDocumentDisassociateFirewallRuleGroupOutput(&output, shape)
2093	if err != nil {
2094		var snapshot bytes.Buffer
2095		io.Copy(&snapshot, ringBuffer)
2096		err = &smithy.DeserializationError{
2097			Err:      fmt.Errorf("failed to decode response body, %w", err),
2098			Snapshot: snapshot.Bytes(),
2099		}
2100		return out, metadata, err
2101	}
2102
2103	return out, metadata, err
2104}
2105
2106func awsAwsjson11_deserializeOpErrorDisassociateFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2107	var errorBuffer bytes.Buffer
2108	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2109		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2110	}
2111	errorBody := bytes.NewReader(errorBuffer.Bytes())
2112
2113	errorCode := "UnknownError"
2114	errorMessage := errorCode
2115
2116	code := response.Header.Get("X-Amzn-ErrorType")
2117	if len(code) != 0 {
2118		errorCode = restjson.SanitizeErrorCode(code)
2119	}
2120
2121	var buff [1024]byte
2122	ringBuffer := smithyio.NewRingBuffer(buff[:])
2123
2124	body := io.TeeReader(errorBody, ringBuffer)
2125	decoder := json.NewDecoder(body)
2126	decoder.UseNumber()
2127	code, message, err := restjson.GetErrorInfo(decoder)
2128	if err != nil {
2129		var snapshot bytes.Buffer
2130		io.Copy(&snapshot, ringBuffer)
2131		err = &smithy.DeserializationError{
2132			Err:      fmt.Errorf("failed to decode response body, %w", err),
2133			Snapshot: snapshot.Bytes(),
2134		}
2135		return err
2136	}
2137
2138	errorBody.Seek(0, io.SeekStart)
2139	if len(code) != 0 {
2140		errorCode = restjson.SanitizeErrorCode(code)
2141	}
2142	if len(message) != 0 {
2143		errorMessage = message
2144	}
2145
2146	switch {
2147	case strings.EqualFold("AccessDeniedException", errorCode):
2148		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2149
2150	case strings.EqualFold("ConflictException", errorCode):
2151		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
2152
2153	case strings.EqualFold("InternalServiceErrorException", errorCode):
2154		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2155
2156	case strings.EqualFold("ResourceNotFoundException", errorCode):
2157		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2158
2159	case strings.EqualFold("ThrottlingException", errorCode):
2160		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2161
2162	case strings.EqualFold("ValidationException", errorCode):
2163		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2164
2165	default:
2166		genericError := &smithy.GenericAPIError{
2167			Code:    errorCode,
2168			Message: errorMessage,
2169		}
2170		return genericError
2171
2172	}
2173}
2174
2175type awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress struct {
2176}
2177
2178func (*awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress) ID() string {
2179	return "OperationDeserializer"
2180}
2181
2182func (m *awsAwsjson11_deserializeOpDisassociateResolverEndpointIpAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2183	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2184) {
2185	out, metadata, err = next.HandleDeserialize(ctx, in)
2186	if err != nil {
2187		return out, metadata, err
2188	}
2189
2190	response, ok := out.RawResponse.(*smithyhttp.Response)
2191	if !ok {
2192		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2193	}
2194
2195	if response.StatusCode < 200 || response.StatusCode >= 300 {
2196		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverEndpointIpAddress(response, &metadata)
2197	}
2198	output := &DisassociateResolverEndpointIpAddressOutput{}
2199	out.Result = output
2200
2201	var buff [1024]byte
2202	ringBuffer := smithyio.NewRingBuffer(buff[:])
2203
2204	body := io.TeeReader(response.Body, ringBuffer)
2205	decoder := json.NewDecoder(body)
2206	decoder.UseNumber()
2207	var shape interface{}
2208	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2209		var snapshot bytes.Buffer
2210		io.Copy(&snapshot, ringBuffer)
2211		err = &smithy.DeserializationError{
2212			Err:      fmt.Errorf("failed to decode response body, %w", err),
2213			Snapshot: snapshot.Bytes(),
2214		}
2215		return out, metadata, err
2216	}
2217
2218	err = awsAwsjson11_deserializeOpDocumentDisassociateResolverEndpointIpAddressOutput(&output, shape)
2219	if err != nil {
2220		var snapshot bytes.Buffer
2221		io.Copy(&snapshot, ringBuffer)
2222		err = &smithy.DeserializationError{
2223			Err:      fmt.Errorf("failed to decode response body, %w", err),
2224			Snapshot: snapshot.Bytes(),
2225		}
2226		return out, metadata, err
2227	}
2228
2229	return out, metadata, err
2230}
2231
2232func awsAwsjson11_deserializeOpErrorDisassociateResolverEndpointIpAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2233	var errorBuffer bytes.Buffer
2234	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2235		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2236	}
2237	errorBody := bytes.NewReader(errorBuffer.Bytes())
2238
2239	errorCode := "UnknownError"
2240	errorMessage := errorCode
2241
2242	code := response.Header.Get("X-Amzn-ErrorType")
2243	if len(code) != 0 {
2244		errorCode = restjson.SanitizeErrorCode(code)
2245	}
2246
2247	var buff [1024]byte
2248	ringBuffer := smithyio.NewRingBuffer(buff[:])
2249
2250	body := io.TeeReader(errorBody, ringBuffer)
2251	decoder := json.NewDecoder(body)
2252	decoder.UseNumber()
2253	code, message, err := restjson.GetErrorInfo(decoder)
2254	if err != nil {
2255		var snapshot bytes.Buffer
2256		io.Copy(&snapshot, ringBuffer)
2257		err = &smithy.DeserializationError{
2258			Err:      fmt.Errorf("failed to decode response body, %w", err),
2259			Snapshot: snapshot.Bytes(),
2260		}
2261		return err
2262	}
2263
2264	errorBody.Seek(0, io.SeekStart)
2265	if len(code) != 0 {
2266		errorCode = restjson.SanitizeErrorCode(code)
2267	}
2268	if len(message) != 0 {
2269		errorMessage = message
2270	}
2271
2272	switch {
2273	case strings.EqualFold("InternalServiceErrorException", errorCode):
2274		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2275
2276	case strings.EqualFold("InvalidParameterException", errorCode):
2277		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2278
2279	case strings.EqualFold("InvalidRequestException", errorCode):
2280		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
2281
2282	case strings.EqualFold("ResourceExistsException", errorCode):
2283		return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody)
2284
2285	case strings.EqualFold("ResourceNotFoundException", errorCode):
2286		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2287
2288	case strings.EqualFold("ThrottlingException", errorCode):
2289		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2290
2291	default:
2292		genericError := &smithy.GenericAPIError{
2293			Code:    errorCode,
2294			Message: errorMessage,
2295		}
2296		return genericError
2297
2298	}
2299}
2300
2301type awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig struct {
2302}
2303
2304func (*awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig) ID() string {
2305	return "OperationDeserializer"
2306}
2307
2308func (m *awsAwsjson11_deserializeOpDisassociateResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2309	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2310) {
2311	out, metadata, err = next.HandleDeserialize(ctx, in)
2312	if err != nil {
2313		return out, metadata, err
2314	}
2315
2316	response, ok := out.RawResponse.(*smithyhttp.Response)
2317	if !ok {
2318		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2319	}
2320
2321	if response.StatusCode < 200 || response.StatusCode >= 300 {
2322		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverQueryLogConfig(response, &metadata)
2323	}
2324	output := &DisassociateResolverQueryLogConfigOutput{}
2325	out.Result = output
2326
2327	var buff [1024]byte
2328	ringBuffer := smithyio.NewRingBuffer(buff[:])
2329
2330	body := io.TeeReader(response.Body, ringBuffer)
2331	decoder := json.NewDecoder(body)
2332	decoder.UseNumber()
2333	var shape interface{}
2334	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2335		var snapshot bytes.Buffer
2336		io.Copy(&snapshot, ringBuffer)
2337		err = &smithy.DeserializationError{
2338			Err:      fmt.Errorf("failed to decode response body, %w", err),
2339			Snapshot: snapshot.Bytes(),
2340		}
2341		return out, metadata, err
2342	}
2343
2344	err = awsAwsjson11_deserializeOpDocumentDisassociateResolverQueryLogConfigOutput(&output, shape)
2345	if err != nil {
2346		var snapshot bytes.Buffer
2347		io.Copy(&snapshot, ringBuffer)
2348		err = &smithy.DeserializationError{
2349			Err:      fmt.Errorf("failed to decode response body, %w", err),
2350			Snapshot: snapshot.Bytes(),
2351		}
2352		return out, metadata, err
2353	}
2354
2355	return out, metadata, err
2356}
2357
2358func awsAwsjson11_deserializeOpErrorDisassociateResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2359	var errorBuffer bytes.Buffer
2360	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2361		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2362	}
2363	errorBody := bytes.NewReader(errorBuffer.Bytes())
2364
2365	errorCode := "UnknownError"
2366	errorMessage := errorCode
2367
2368	code := response.Header.Get("X-Amzn-ErrorType")
2369	if len(code) != 0 {
2370		errorCode = restjson.SanitizeErrorCode(code)
2371	}
2372
2373	var buff [1024]byte
2374	ringBuffer := smithyio.NewRingBuffer(buff[:])
2375
2376	body := io.TeeReader(errorBody, ringBuffer)
2377	decoder := json.NewDecoder(body)
2378	decoder.UseNumber()
2379	code, message, err := restjson.GetErrorInfo(decoder)
2380	if err != nil {
2381		var snapshot bytes.Buffer
2382		io.Copy(&snapshot, ringBuffer)
2383		err = &smithy.DeserializationError{
2384			Err:      fmt.Errorf("failed to decode response body, %w", err),
2385			Snapshot: snapshot.Bytes(),
2386		}
2387		return err
2388	}
2389
2390	errorBody.Seek(0, io.SeekStart)
2391	if len(code) != 0 {
2392		errorCode = restjson.SanitizeErrorCode(code)
2393	}
2394	if len(message) != 0 {
2395		errorMessage = message
2396	}
2397
2398	switch {
2399	case strings.EqualFold("AccessDeniedException", errorCode):
2400		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2401
2402	case strings.EqualFold("InternalServiceErrorException", errorCode):
2403		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2404
2405	case strings.EqualFold("InvalidParameterException", errorCode):
2406		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2407
2408	case strings.EqualFold("InvalidRequestException", errorCode):
2409		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
2410
2411	case strings.EqualFold("ResourceNotFoundException", errorCode):
2412		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2413
2414	case strings.EqualFold("ThrottlingException", errorCode):
2415		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2416
2417	default:
2418		genericError := &smithy.GenericAPIError{
2419			Code:    errorCode,
2420			Message: errorMessage,
2421		}
2422		return genericError
2423
2424	}
2425}
2426
2427type awsAwsjson11_deserializeOpDisassociateResolverRule struct {
2428}
2429
2430func (*awsAwsjson11_deserializeOpDisassociateResolverRule) ID() string {
2431	return "OperationDeserializer"
2432}
2433
2434func (m *awsAwsjson11_deserializeOpDisassociateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2435	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2436) {
2437	out, metadata, err = next.HandleDeserialize(ctx, in)
2438	if err != nil {
2439		return out, metadata, err
2440	}
2441
2442	response, ok := out.RawResponse.(*smithyhttp.Response)
2443	if !ok {
2444		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2445	}
2446
2447	if response.StatusCode < 200 || response.StatusCode >= 300 {
2448		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateResolverRule(response, &metadata)
2449	}
2450	output := &DisassociateResolverRuleOutput{}
2451	out.Result = output
2452
2453	var buff [1024]byte
2454	ringBuffer := smithyio.NewRingBuffer(buff[:])
2455
2456	body := io.TeeReader(response.Body, ringBuffer)
2457	decoder := json.NewDecoder(body)
2458	decoder.UseNumber()
2459	var shape interface{}
2460	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2461		var snapshot bytes.Buffer
2462		io.Copy(&snapshot, ringBuffer)
2463		err = &smithy.DeserializationError{
2464			Err:      fmt.Errorf("failed to decode response body, %w", err),
2465			Snapshot: snapshot.Bytes(),
2466		}
2467		return out, metadata, err
2468	}
2469
2470	err = awsAwsjson11_deserializeOpDocumentDisassociateResolverRuleOutput(&output, shape)
2471	if err != nil {
2472		var snapshot bytes.Buffer
2473		io.Copy(&snapshot, ringBuffer)
2474		err = &smithy.DeserializationError{
2475			Err:      fmt.Errorf("failed to decode response body, %w", err),
2476			Snapshot: snapshot.Bytes(),
2477		}
2478		return out, metadata, err
2479	}
2480
2481	return out, metadata, err
2482}
2483
2484func awsAwsjson11_deserializeOpErrorDisassociateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2485	var errorBuffer bytes.Buffer
2486	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2487		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2488	}
2489	errorBody := bytes.NewReader(errorBuffer.Bytes())
2490
2491	errorCode := "UnknownError"
2492	errorMessage := errorCode
2493
2494	code := response.Header.Get("X-Amzn-ErrorType")
2495	if len(code) != 0 {
2496		errorCode = restjson.SanitizeErrorCode(code)
2497	}
2498
2499	var buff [1024]byte
2500	ringBuffer := smithyio.NewRingBuffer(buff[:])
2501
2502	body := io.TeeReader(errorBody, ringBuffer)
2503	decoder := json.NewDecoder(body)
2504	decoder.UseNumber()
2505	code, message, err := restjson.GetErrorInfo(decoder)
2506	if err != nil {
2507		var snapshot bytes.Buffer
2508		io.Copy(&snapshot, ringBuffer)
2509		err = &smithy.DeserializationError{
2510			Err:      fmt.Errorf("failed to decode response body, %w", err),
2511			Snapshot: snapshot.Bytes(),
2512		}
2513		return err
2514	}
2515
2516	errorBody.Seek(0, io.SeekStart)
2517	if len(code) != 0 {
2518		errorCode = restjson.SanitizeErrorCode(code)
2519	}
2520	if len(message) != 0 {
2521		errorMessage = message
2522	}
2523
2524	switch {
2525	case strings.EqualFold("InternalServiceErrorException", errorCode):
2526		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2527
2528	case strings.EqualFold("InvalidParameterException", errorCode):
2529		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
2530
2531	case strings.EqualFold("ResourceNotFoundException", errorCode):
2532		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2533
2534	case strings.EqualFold("ThrottlingException", errorCode):
2535		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2536
2537	default:
2538		genericError := &smithy.GenericAPIError{
2539			Code:    errorCode,
2540			Message: errorMessage,
2541		}
2542		return genericError
2543
2544	}
2545}
2546
2547type awsAwsjson11_deserializeOpGetFirewallConfig struct {
2548}
2549
2550func (*awsAwsjson11_deserializeOpGetFirewallConfig) ID() string {
2551	return "OperationDeserializer"
2552}
2553
2554func (m *awsAwsjson11_deserializeOpGetFirewallConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2555	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2556) {
2557	out, metadata, err = next.HandleDeserialize(ctx, in)
2558	if err != nil {
2559		return out, metadata, err
2560	}
2561
2562	response, ok := out.RawResponse.(*smithyhttp.Response)
2563	if !ok {
2564		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2565	}
2566
2567	if response.StatusCode < 200 || response.StatusCode >= 300 {
2568		return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallConfig(response, &metadata)
2569	}
2570	output := &GetFirewallConfigOutput{}
2571	out.Result = output
2572
2573	var buff [1024]byte
2574	ringBuffer := smithyio.NewRingBuffer(buff[:])
2575
2576	body := io.TeeReader(response.Body, ringBuffer)
2577	decoder := json.NewDecoder(body)
2578	decoder.UseNumber()
2579	var shape interface{}
2580	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2581		var snapshot bytes.Buffer
2582		io.Copy(&snapshot, ringBuffer)
2583		err = &smithy.DeserializationError{
2584			Err:      fmt.Errorf("failed to decode response body, %w", err),
2585			Snapshot: snapshot.Bytes(),
2586		}
2587		return out, metadata, err
2588	}
2589
2590	err = awsAwsjson11_deserializeOpDocumentGetFirewallConfigOutput(&output, shape)
2591	if err != nil {
2592		var snapshot bytes.Buffer
2593		io.Copy(&snapshot, ringBuffer)
2594		err = &smithy.DeserializationError{
2595			Err:      fmt.Errorf("failed to decode response body, %w", err),
2596			Snapshot: snapshot.Bytes(),
2597		}
2598		return out, metadata, err
2599	}
2600
2601	return out, metadata, err
2602}
2603
2604func awsAwsjson11_deserializeOpErrorGetFirewallConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2605	var errorBuffer bytes.Buffer
2606	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2607		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2608	}
2609	errorBody := bytes.NewReader(errorBuffer.Bytes())
2610
2611	errorCode := "UnknownError"
2612	errorMessage := errorCode
2613
2614	code := response.Header.Get("X-Amzn-ErrorType")
2615	if len(code) != 0 {
2616		errorCode = restjson.SanitizeErrorCode(code)
2617	}
2618
2619	var buff [1024]byte
2620	ringBuffer := smithyio.NewRingBuffer(buff[:])
2621
2622	body := io.TeeReader(errorBody, ringBuffer)
2623	decoder := json.NewDecoder(body)
2624	decoder.UseNumber()
2625	code, message, err := restjson.GetErrorInfo(decoder)
2626	if err != nil {
2627		var snapshot bytes.Buffer
2628		io.Copy(&snapshot, ringBuffer)
2629		err = &smithy.DeserializationError{
2630			Err:      fmt.Errorf("failed to decode response body, %w", err),
2631			Snapshot: snapshot.Bytes(),
2632		}
2633		return err
2634	}
2635
2636	errorBody.Seek(0, io.SeekStart)
2637	if len(code) != 0 {
2638		errorCode = restjson.SanitizeErrorCode(code)
2639	}
2640	if len(message) != 0 {
2641		errorMessage = message
2642	}
2643
2644	switch {
2645	case strings.EqualFold("AccessDeniedException", errorCode):
2646		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2647
2648	case strings.EqualFold("InternalServiceErrorException", errorCode):
2649		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2650
2651	case strings.EqualFold("ResourceNotFoundException", errorCode):
2652		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2653
2654	case strings.EqualFold("ThrottlingException", errorCode):
2655		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2656
2657	case strings.EqualFold("ValidationException", errorCode):
2658		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
2659
2660	default:
2661		genericError := &smithy.GenericAPIError{
2662			Code:    errorCode,
2663			Message: errorMessage,
2664		}
2665		return genericError
2666
2667	}
2668}
2669
2670type awsAwsjson11_deserializeOpGetFirewallDomainList struct {
2671}
2672
2673func (*awsAwsjson11_deserializeOpGetFirewallDomainList) ID() string {
2674	return "OperationDeserializer"
2675}
2676
2677func (m *awsAwsjson11_deserializeOpGetFirewallDomainList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2678	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2679) {
2680	out, metadata, err = next.HandleDeserialize(ctx, in)
2681	if err != nil {
2682		return out, metadata, err
2683	}
2684
2685	response, ok := out.RawResponse.(*smithyhttp.Response)
2686	if !ok {
2687		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2688	}
2689
2690	if response.StatusCode < 200 || response.StatusCode >= 300 {
2691		return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallDomainList(response, &metadata)
2692	}
2693	output := &GetFirewallDomainListOutput{}
2694	out.Result = output
2695
2696	var buff [1024]byte
2697	ringBuffer := smithyio.NewRingBuffer(buff[:])
2698
2699	body := io.TeeReader(response.Body, ringBuffer)
2700	decoder := json.NewDecoder(body)
2701	decoder.UseNumber()
2702	var shape interface{}
2703	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2704		var snapshot bytes.Buffer
2705		io.Copy(&snapshot, ringBuffer)
2706		err = &smithy.DeserializationError{
2707			Err:      fmt.Errorf("failed to decode response body, %w", err),
2708			Snapshot: snapshot.Bytes(),
2709		}
2710		return out, metadata, err
2711	}
2712
2713	err = awsAwsjson11_deserializeOpDocumentGetFirewallDomainListOutput(&output, shape)
2714	if err != nil {
2715		var snapshot bytes.Buffer
2716		io.Copy(&snapshot, ringBuffer)
2717		err = &smithy.DeserializationError{
2718			Err:      fmt.Errorf("failed to decode response body, %w", err),
2719			Snapshot: snapshot.Bytes(),
2720		}
2721		return out, metadata, err
2722	}
2723
2724	return out, metadata, err
2725}
2726
2727func awsAwsjson11_deserializeOpErrorGetFirewallDomainList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2728	var errorBuffer bytes.Buffer
2729	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2730		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2731	}
2732	errorBody := bytes.NewReader(errorBuffer.Bytes())
2733
2734	errorCode := "UnknownError"
2735	errorMessage := errorCode
2736
2737	code := response.Header.Get("X-Amzn-ErrorType")
2738	if len(code) != 0 {
2739		errorCode = restjson.SanitizeErrorCode(code)
2740	}
2741
2742	var buff [1024]byte
2743	ringBuffer := smithyio.NewRingBuffer(buff[:])
2744
2745	body := io.TeeReader(errorBody, ringBuffer)
2746	decoder := json.NewDecoder(body)
2747	decoder.UseNumber()
2748	code, message, err := restjson.GetErrorInfo(decoder)
2749	if err != nil {
2750		var snapshot bytes.Buffer
2751		io.Copy(&snapshot, ringBuffer)
2752		err = &smithy.DeserializationError{
2753			Err:      fmt.Errorf("failed to decode response body, %w", err),
2754			Snapshot: snapshot.Bytes(),
2755		}
2756		return err
2757	}
2758
2759	errorBody.Seek(0, io.SeekStart)
2760	if len(code) != 0 {
2761		errorCode = restjson.SanitizeErrorCode(code)
2762	}
2763	if len(message) != 0 {
2764		errorMessage = message
2765	}
2766
2767	switch {
2768	case strings.EqualFold("AccessDeniedException", errorCode):
2769		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2770
2771	case strings.EqualFold("InternalServiceErrorException", errorCode):
2772		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2773
2774	case strings.EqualFold("ResourceNotFoundException", errorCode):
2775		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2776
2777	case strings.EqualFold("ThrottlingException", errorCode):
2778		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2779
2780	default:
2781		genericError := &smithy.GenericAPIError{
2782			Code:    errorCode,
2783			Message: errorMessage,
2784		}
2785		return genericError
2786
2787	}
2788}
2789
2790type awsAwsjson11_deserializeOpGetFirewallRuleGroup struct {
2791}
2792
2793func (*awsAwsjson11_deserializeOpGetFirewallRuleGroup) ID() string {
2794	return "OperationDeserializer"
2795}
2796
2797func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2798	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2799) {
2800	out, metadata, err = next.HandleDeserialize(ctx, in)
2801	if err != nil {
2802		return out, metadata, err
2803	}
2804
2805	response, ok := out.RawResponse.(*smithyhttp.Response)
2806	if !ok {
2807		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2808	}
2809
2810	if response.StatusCode < 200 || response.StatusCode >= 300 {
2811		return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroup(response, &metadata)
2812	}
2813	output := &GetFirewallRuleGroupOutput{}
2814	out.Result = output
2815
2816	var buff [1024]byte
2817	ringBuffer := smithyio.NewRingBuffer(buff[:])
2818
2819	body := io.TeeReader(response.Body, ringBuffer)
2820	decoder := json.NewDecoder(body)
2821	decoder.UseNumber()
2822	var shape interface{}
2823	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2824		var snapshot bytes.Buffer
2825		io.Copy(&snapshot, ringBuffer)
2826		err = &smithy.DeserializationError{
2827			Err:      fmt.Errorf("failed to decode response body, %w", err),
2828			Snapshot: snapshot.Bytes(),
2829		}
2830		return out, metadata, err
2831	}
2832
2833	err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupOutput(&output, shape)
2834	if err != nil {
2835		var snapshot bytes.Buffer
2836		io.Copy(&snapshot, ringBuffer)
2837		err = &smithy.DeserializationError{
2838			Err:      fmt.Errorf("failed to decode response body, %w", err),
2839			Snapshot: snapshot.Bytes(),
2840		}
2841		return out, metadata, err
2842	}
2843
2844	return out, metadata, err
2845}
2846
2847func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2848	var errorBuffer bytes.Buffer
2849	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2850		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2851	}
2852	errorBody := bytes.NewReader(errorBuffer.Bytes())
2853
2854	errorCode := "UnknownError"
2855	errorMessage := errorCode
2856
2857	code := response.Header.Get("X-Amzn-ErrorType")
2858	if len(code) != 0 {
2859		errorCode = restjson.SanitizeErrorCode(code)
2860	}
2861
2862	var buff [1024]byte
2863	ringBuffer := smithyio.NewRingBuffer(buff[:])
2864
2865	body := io.TeeReader(errorBody, ringBuffer)
2866	decoder := json.NewDecoder(body)
2867	decoder.UseNumber()
2868	code, message, err := restjson.GetErrorInfo(decoder)
2869	if err != nil {
2870		var snapshot bytes.Buffer
2871		io.Copy(&snapshot, ringBuffer)
2872		err = &smithy.DeserializationError{
2873			Err:      fmt.Errorf("failed to decode response body, %w", err),
2874			Snapshot: snapshot.Bytes(),
2875		}
2876		return err
2877	}
2878
2879	errorBody.Seek(0, io.SeekStart)
2880	if len(code) != 0 {
2881		errorCode = restjson.SanitizeErrorCode(code)
2882	}
2883	if len(message) != 0 {
2884		errorMessage = message
2885	}
2886
2887	switch {
2888	case strings.EqualFold("AccessDeniedException", errorCode):
2889		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2890
2891	case strings.EqualFold("InternalServiceErrorException", errorCode):
2892		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
2893
2894	case strings.EqualFold("ResourceNotFoundException", errorCode):
2895		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2896
2897	case strings.EqualFold("ThrottlingException", errorCode):
2898		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
2899
2900	default:
2901		genericError := &smithy.GenericAPIError{
2902			Code:    errorCode,
2903			Message: errorMessage,
2904		}
2905		return genericError
2906
2907	}
2908}
2909
2910type awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation struct {
2911}
2912
2913func (*awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation) ID() string {
2914	return "OperationDeserializer"
2915}
2916
2917func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2918	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2919) {
2920	out, metadata, err = next.HandleDeserialize(ctx, in)
2921	if err != nil {
2922		return out, metadata, err
2923	}
2924
2925	response, ok := out.RawResponse.(*smithyhttp.Response)
2926	if !ok {
2927		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2928	}
2929
2930	if response.StatusCode < 200 || response.StatusCode >= 300 {
2931		return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupAssociation(response, &metadata)
2932	}
2933	output := &GetFirewallRuleGroupAssociationOutput{}
2934	out.Result = output
2935
2936	var buff [1024]byte
2937	ringBuffer := smithyio.NewRingBuffer(buff[:])
2938
2939	body := io.TeeReader(response.Body, ringBuffer)
2940	decoder := json.NewDecoder(body)
2941	decoder.UseNumber()
2942	var shape interface{}
2943	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2944		var snapshot bytes.Buffer
2945		io.Copy(&snapshot, ringBuffer)
2946		err = &smithy.DeserializationError{
2947			Err:      fmt.Errorf("failed to decode response body, %w", err),
2948			Snapshot: snapshot.Bytes(),
2949		}
2950		return out, metadata, err
2951	}
2952
2953	err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupAssociationOutput(&output, shape)
2954	if err != nil {
2955		var snapshot bytes.Buffer
2956		io.Copy(&snapshot, ringBuffer)
2957		err = &smithy.DeserializationError{
2958			Err:      fmt.Errorf("failed to decode response body, %w", err),
2959			Snapshot: snapshot.Bytes(),
2960		}
2961		return out, metadata, err
2962	}
2963
2964	return out, metadata, err
2965}
2966
2967func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2968	var errorBuffer bytes.Buffer
2969	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2970		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2971	}
2972	errorBody := bytes.NewReader(errorBuffer.Bytes())
2973
2974	errorCode := "UnknownError"
2975	errorMessage := errorCode
2976
2977	code := response.Header.Get("X-Amzn-ErrorType")
2978	if len(code) != 0 {
2979		errorCode = restjson.SanitizeErrorCode(code)
2980	}
2981
2982	var buff [1024]byte
2983	ringBuffer := smithyio.NewRingBuffer(buff[:])
2984
2985	body := io.TeeReader(errorBody, ringBuffer)
2986	decoder := json.NewDecoder(body)
2987	decoder.UseNumber()
2988	code, message, err := restjson.GetErrorInfo(decoder)
2989	if err != nil {
2990		var snapshot bytes.Buffer
2991		io.Copy(&snapshot, ringBuffer)
2992		err = &smithy.DeserializationError{
2993			Err:      fmt.Errorf("failed to decode response body, %w", err),
2994			Snapshot: snapshot.Bytes(),
2995		}
2996		return err
2997	}
2998
2999	errorBody.Seek(0, io.SeekStart)
3000	if len(code) != 0 {
3001		errorCode = restjson.SanitizeErrorCode(code)
3002	}
3003	if len(message) != 0 {
3004		errorMessage = message
3005	}
3006
3007	switch {
3008	case strings.EqualFold("AccessDeniedException", errorCode):
3009		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3010
3011	case strings.EqualFold("InternalServiceErrorException", errorCode):
3012		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3013
3014	case strings.EqualFold("ResourceNotFoundException", errorCode):
3015		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3016
3017	case strings.EqualFold("ThrottlingException", errorCode):
3018		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3019
3020	default:
3021		genericError := &smithy.GenericAPIError{
3022			Code:    errorCode,
3023			Message: errorMessage,
3024		}
3025		return genericError
3026
3027	}
3028}
3029
3030type awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy struct {
3031}
3032
3033func (*awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy) ID() string {
3034	return "OperationDeserializer"
3035}
3036
3037func (m *awsAwsjson11_deserializeOpGetFirewallRuleGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3038	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3039) {
3040	out, metadata, err = next.HandleDeserialize(ctx, in)
3041	if err != nil {
3042		return out, metadata, err
3043	}
3044
3045	response, ok := out.RawResponse.(*smithyhttp.Response)
3046	if !ok {
3047		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3048	}
3049
3050	if response.StatusCode < 200 || response.StatusCode >= 300 {
3051		return out, metadata, awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupPolicy(response, &metadata)
3052	}
3053	output := &GetFirewallRuleGroupPolicyOutput{}
3054	out.Result = output
3055
3056	var buff [1024]byte
3057	ringBuffer := smithyio.NewRingBuffer(buff[:])
3058
3059	body := io.TeeReader(response.Body, ringBuffer)
3060	decoder := json.NewDecoder(body)
3061	decoder.UseNumber()
3062	var shape interface{}
3063	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3064		var snapshot bytes.Buffer
3065		io.Copy(&snapshot, ringBuffer)
3066		err = &smithy.DeserializationError{
3067			Err:      fmt.Errorf("failed to decode response body, %w", err),
3068			Snapshot: snapshot.Bytes(),
3069		}
3070		return out, metadata, err
3071	}
3072
3073	err = awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupPolicyOutput(&output, shape)
3074	if err != nil {
3075		var snapshot bytes.Buffer
3076		io.Copy(&snapshot, ringBuffer)
3077		err = &smithy.DeserializationError{
3078			Err:      fmt.Errorf("failed to decode response body, %w", err),
3079			Snapshot: snapshot.Bytes(),
3080		}
3081		return out, metadata, err
3082	}
3083
3084	return out, metadata, err
3085}
3086
3087func awsAwsjson11_deserializeOpErrorGetFirewallRuleGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3088	var errorBuffer bytes.Buffer
3089	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3090		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3091	}
3092	errorBody := bytes.NewReader(errorBuffer.Bytes())
3093
3094	errorCode := "UnknownError"
3095	errorMessage := errorCode
3096
3097	code := response.Header.Get("X-Amzn-ErrorType")
3098	if len(code) != 0 {
3099		errorCode = restjson.SanitizeErrorCode(code)
3100	}
3101
3102	var buff [1024]byte
3103	ringBuffer := smithyio.NewRingBuffer(buff[:])
3104
3105	body := io.TeeReader(errorBody, ringBuffer)
3106	decoder := json.NewDecoder(body)
3107	decoder.UseNumber()
3108	code, message, err := restjson.GetErrorInfo(decoder)
3109	if err != nil {
3110		var snapshot bytes.Buffer
3111		io.Copy(&snapshot, ringBuffer)
3112		err = &smithy.DeserializationError{
3113			Err:      fmt.Errorf("failed to decode response body, %w", err),
3114			Snapshot: snapshot.Bytes(),
3115		}
3116		return err
3117	}
3118
3119	errorBody.Seek(0, io.SeekStart)
3120	if len(code) != 0 {
3121		errorCode = restjson.SanitizeErrorCode(code)
3122	}
3123	if len(message) != 0 {
3124		errorMessage = message
3125	}
3126
3127	switch {
3128	case strings.EqualFold("AccessDeniedException", errorCode):
3129		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3130
3131	case strings.EqualFold("InternalServiceErrorException", errorCode):
3132		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3133
3134	case strings.EqualFold("ResourceNotFoundException", errorCode):
3135		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3136
3137	case strings.EqualFold("ThrottlingException", errorCode):
3138		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3139
3140	case strings.EqualFold("ValidationException", errorCode):
3141		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
3142
3143	default:
3144		genericError := &smithy.GenericAPIError{
3145			Code:    errorCode,
3146			Message: errorMessage,
3147		}
3148		return genericError
3149
3150	}
3151}
3152
3153type awsAwsjson11_deserializeOpGetResolverDnssecConfig struct {
3154}
3155
3156func (*awsAwsjson11_deserializeOpGetResolverDnssecConfig) ID() string {
3157	return "OperationDeserializer"
3158}
3159
3160func (m *awsAwsjson11_deserializeOpGetResolverDnssecConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3161	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3162) {
3163	out, metadata, err = next.HandleDeserialize(ctx, in)
3164	if err != nil {
3165		return out, metadata, err
3166	}
3167
3168	response, ok := out.RawResponse.(*smithyhttp.Response)
3169	if !ok {
3170		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3171	}
3172
3173	if response.StatusCode < 200 || response.StatusCode >= 300 {
3174		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverDnssecConfig(response, &metadata)
3175	}
3176	output := &GetResolverDnssecConfigOutput{}
3177	out.Result = output
3178
3179	var buff [1024]byte
3180	ringBuffer := smithyio.NewRingBuffer(buff[:])
3181
3182	body := io.TeeReader(response.Body, ringBuffer)
3183	decoder := json.NewDecoder(body)
3184	decoder.UseNumber()
3185	var shape interface{}
3186	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3187		var snapshot bytes.Buffer
3188		io.Copy(&snapshot, ringBuffer)
3189		err = &smithy.DeserializationError{
3190			Err:      fmt.Errorf("failed to decode response body, %w", err),
3191			Snapshot: snapshot.Bytes(),
3192		}
3193		return out, metadata, err
3194	}
3195
3196	err = awsAwsjson11_deserializeOpDocumentGetResolverDnssecConfigOutput(&output, shape)
3197	if err != nil {
3198		var snapshot bytes.Buffer
3199		io.Copy(&snapshot, ringBuffer)
3200		err = &smithy.DeserializationError{
3201			Err:      fmt.Errorf("failed to decode response body, %w", err),
3202			Snapshot: snapshot.Bytes(),
3203		}
3204		return out, metadata, err
3205	}
3206
3207	return out, metadata, err
3208}
3209
3210func awsAwsjson11_deserializeOpErrorGetResolverDnssecConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3211	var errorBuffer bytes.Buffer
3212	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3213		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3214	}
3215	errorBody := bytes.NewReader(errorBuffer.Bytes())
3216
3217	errorCode := "UnknownError"
3218	errorMessage := errorCode
3219
3220	code := response.Header.Get("X-Amzn-ErrorType")
3221	if len(code) != 0 {
3222		errorCode = restjson.SanitizeErrorCode(code)
3223	}
3224
3225	var buff [1024]byte
3226	ringBuffer := smithyio.NewRingBuffer(buff[:])
3227
3228	body := io.TeeReader(errorBody, ringBuffer)
3229	decoder := json.NewDecoder(body)
3230	decoder.UseNumber()
3231	code, message, err := restjson.GetErrorInfo(decoder)
3232	if err != nil {
3233		var snapshot bytes.Buffer
3234		io.Copy(&snapshot, ringBuffer)
3235		err = &smithy.DeserializationError{
3236			Err:      fmt.Errorf("failed to decode response body, %w", err),
3237			Snapshot: snapshot.Bytes(),
3238		}
3239		return err
3240	}
3241
3242	errorBody.Seek(0, io.SeekStart)
3243	if len(code) != 0 {
3244		errorCode = restjson.SanitizeErrorCode(code)
3245	}
3246	if len(message) != 0 {
3247		errorMessage = message
3248	}
3249
3250	switch {
3251	case strings.EqualFold("AccessDeniedException", errorCode):
3252		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3253
3254	case strings.EqualFold("InternalServiceErrorException", errorCode):
3255		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3256
3257	case strings.EqualFold("InvalidParameterException", errorCode):
3258		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3259
3260	case strings.EqualFold("InvalidRequestException", errorCode):
3261		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
3262
3263	case strings.EqualFold("ResourceNotFoundException", errorCode):
3264		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3265
3266	case strings.EqualFold("ThrottlingException", errorCode):
3267		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3268
3269	default:
3270		genericError := &smithy.GenericAPIError{
3271			Code:    errorCode,
3272			Message: errorMessage,
3273		}
3274		return genericError
3275
3276	}
3277}
3278
3279type awsAwsjson11_deserializeOpGetResolverEndpoint struct {
3280}
3281
3282func (*awsAwsjson11_deserializeOpGetResolverEndpoint) ID() string {
3283	return "OperationDeserializer"
3284}
3285
3286func (m *awsAwsjson11_deserializeOpGetResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3287	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3288) {
3289	out, metadata, err = next.HandleDeserialize(ctx, in)
3290	if err != nil {
3291		return out, metadata, err
3292	}
3293
3294	response, ok := out.RawResponse.(*smithyhttp.Response)
3295	if !ok {
3296		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3297	}
3298
3299	if response.StatusCode < 200 || response.StatusCode >= 300 {
3300		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverEndpoint(response, &metadata)
3301	}
3302	output := &GetResolverEndpointOutput{}
3303	out.Result = output
3304
3305	var buff [1024]byte
3306	ringBuffer := smithyio.NewRingBuffer(buff[:])
3307
3308	body := io.TeeReader(response.Body, ringBuffer)
3309	decoder := json.NewDecoder(body)
3310	decoder.UseNumber()
3311	var shape interface{}
3312	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3313		var snapshot bytes.Buffer
3314		io.Copy(&snapshot, ringBuffer)
3315		err = &smithy.DeserializationError{
3316			Err:      fmt.Errorf("failed to decode response body, %w", err),
3317			Snapshot: snapshot.Bytes(),
3318		}
3319		return out, metadata, err
3320	}
3321
3322	err = awsAwsjson11_deserializeOpDocumentGetResolverEndpointOutput(&output, shape)
3323	if err != nil {
3324		var snapshot bytes.Buffer
3325		io.Copy(&snapshot, ringBuffer)
3326		err = &smithy.DeserializationError{
3327			Err:      fmt.Errorf("failed to decode response body, %w", err),
3328			Snapshot: snapshot.Bytes(),
3329		}
3330		return out, metadata, err
3331	}
3332
3333	return out, metadata, err
3334}
3335
3336func awsAwsjson11_deserializeOpErrorGetResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3337	var errorBuffer bytes.Buffer
3338	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3339		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3340	}
3341	errorBody := bytes.NewReader(errorBuffer.Bytes())
3342
3343	errorCode := "UnknownError"
3344	errorMessage := errorCode
3345
3346	code := response.Header.Get("X-Amzn-ErrorType")
3347	if len(code) != 0 {
3348		errorCode = restjson.SanitizeErrorCode(code)
3349	}
3350
3351	var buff [1024]byte
3352	ringBuffer := smithyio.NewRingBuffer(buff[:])
3353
3354	body := io.TeeReader(errorBody, ringBuffer)
3355	decoder := json.NewDecoder(body)
3356	decoder.UseNumber()
3357	code, message, err := restjson.GetErrorInfo(decoder)
3358	if err != nil {
3359		var snapshot bytes.Buffer
3360		io.Copy(&snapshot, ringBuffer)
3361		err = &smithy.DeserializationError{
3362			Err:      fmt.Errorf("failed to decode response body, %w", err),
3363			Snapshot: snapshot.Bytes(),
3364		}
3365		return err
3366	}
3367
3368	errorBody.Seek(0, io.SeekStart)
3369	if len(code) != 0 {
3370		errorCode = restjson.SanitizeErrorCode(code)
3371	}
3372	if len(message) != 0 {
3373		errorMessage = message
3374	}
3375
3376	switch {
3377	case strings.EqualFold("InternalServiceErrorException", errorCode):
3378		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3379
3380	case strings.EqualFold("InvalidParameterException", errorCode):
3381		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3382
3383	case strings.EqualFold("ResourceNotFoundException", errorCode):
3384		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3385
3386	case strings.EqualFold("ThrottlingException", errorCode):
3387		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3388
3389	default:
3390		genericError := &smithy.GenericAPIError{
3391			Code:    errorCode,
3392			Message: errorMessage,
3393		}
3394		return genericError
3395
3396	}
3397}
3398
3399type awsAwsjson11_deserializeOpGetResolverQueryLogConfig struct {
3400}
3401
3402func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfig) ID() string {
3403	return "OperationDeserializer"
3404}
3405
3406func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3407	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3408) {
3409	out, metadata, err = next.HandleDeserialize(ctx, in)
3410	if err != nil {
3411		return out, metadata, err
3412	}
3413
3414	response, ok := out.RawResponse.(*smithyhttp.Response)
3415	if !ok {
3416		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3417	}
3418
3419	if response.StatusCode < 200 || response.StatusCode >= 300 {
3420		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfig(response, &metadata)
3421	}
3422	output := &GetResolverQueryLogConfigOutput{}
3423	out.Result = output
3424
3425	var buff [1024]byte
3426	ringBuffer := smithyio.NewRingBuffer(buff[:])
3427
3428	body := io.TeeReader(response.Body, ringBuffer)
3429	decoder := json.NewDecoder(body)
3430	decoder.UseNumber()
3431	var shape interface{}
3432	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3433		var snapshot bytes.Buffer
3434		io.Copy(&snapshot, ringBuffer)
3435		err = &smithy.DeserializationError{
3436			Err:      fmt.Errorf("failed to decode response body, %w", err),
3437			Snapshot: snapshot.Bytes(),
3438		}
3439		return out, metadata, err
3440	}
3441
3442	err = awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigOutput(&output, shape)
3443	if err != nil {
3444		var snapshot bytes.Buffer
3445		io.Copy(&snapshot, ringBuffer)
3446		err = &smithy.DeserializationError{
3447			Err:      fmt.Errorf("failed to decode response body, %w", err),
3448			Snapshot: snapshot.Bytes(),
3449		}
3450		return out, metadata, err
3451	}
3452
3453	return out, metadata, err
3454}
3455
3456func awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3457	var errorBuffer bytes.Buffer
3458	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3459		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3460	}
3461	errorBody := bytes.NewReader(errorBuffer.Bytes())
3462
3463	errorCode := "UnknownError"
3464	errorMessage := errorCode
3465
3466	code := response.Header.Get("X-Amzn-ErrorType")
3467	if len(code) != 0 {
3468		errorCode = restjson.SanitizeErrorCode(code)
3469	}
3470
3471	var buff [1024]byte
3472	ringBuffer := smithyio.NewRingBuffer(buff[:])
3473
3474	body := io.TeeReader(errorBody, ringBuffer)
3475	decoder := json.NewDecoder(body)
3476	decoder.UseNumber()
3477	code, message, err := restjson.GetErrorInfo(decoder)
3478	if err != nil {
3479		var snapshot bytes.Buffer
3480		io.Copy(&snapshot, ringBuffer)
3481		err = &smithy.DeserializationError{
3482			Err:      fmt.Errorf("failed to decode response body, %w", err),
3483			Snapshot: snapshot.Bytes(),
3484		}
3485		return err
3486	}
3487
3488	errorBody.Seek(0, io.SeekStart)
3489	if len(code) != 0 {
3490		errorCode = restjson.SanitizeErrorCode(code)
3491	}
3492	if len(message) != 0 {
3493		errorMessage = message
3494	}
3495
3496	switch {
3497	case strings.EqualFold("AccessDeniedException", errorCode):
3498		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3499
3500	case strings.EqualFold("InternalServiceErrorException", errorCode):
3501		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3502
3503	case strings.EqualFold("InvalidParameterException", errorCode):
3504		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3505
3506	case strings.EqualFold("InvalidRequestException", errorCode):
3507		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
3508
3509	case strings.EqualFold("ResourceNotFoundException", errorCode):
3510		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3511
3512	case strings.EqualFold("ThrottlingException", errorCode):
3513		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3514
3515	default:
3516		genericError := &smithy.GenericAPIError{
3517			Code:    errorCode,
3518			Message: errorMessage,
3519		}
3520		return genericError
3521
3522	}
3523}
3524
3525type awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation struct {
3526}
3527
3528func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation) ID() string {
3529	return "OperationDeserializer"
3530}
3531
3532func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfigAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3533	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3534) {
3535	out, metadata, err = next.HandleDeserialize(ctx, in)
3536	if err != nil {
3537		return out, metadata, err
3538	}
3539
3540	response, ok := out.RawResponse.(*smithyhttp.Response)
3541	if !ok {
3542		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3543	}
3544
3545	if response.StatusCode < 200 || response.StatusCode >= 300 {
3546		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigAssociation(response, &metadata)
3547	}
3548	output := &GetResolverQueryLogConfigAssociationOutput{}
3549	out.Result = output
3550
3551	var buff [1024]byte
3552	ringBuffer := smithyio.NewRingBuffer(buff[:])
3553
3554	body := io.TeeReader(response.Body, ringBuffer)
3555	decoder := json.NewDecoder(body)
3556	decoder.UseNumber()
3557	var shape interface{}
3558	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3559		var snapshot bytes.Buffer
3560		io.Copy(&snapshot, ringBuffer)
3561		err = &smithy.DeserializationError{
3562			Err:      fmt.Errorf("failed to decode response body, %w", err),
3563			Snapshot: snapshot.Bytes(),
3564		}
3565		return out, metadata, err
3566	}
3567
3568	err = awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigAssociationOutput(&output, shape)
3569	if err != nil {
3570		var snapshot bytes.Buffer
3571		io.Copy(&snapshot, ringBuffer)
3572		err = &smithy.DeserializationError{
3573			Err:      fmt.Errorf("failed to decode response body, %w", err),
3574			Snapshot: snapshot.Bytes(),
3575		}
3576		return out, metadata, err
3577	}
3578
3579	return out, metadata, err
3580}
3581
3582func awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3583	var errorBuffer bytes.Buffer
3584	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3585		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3586	}
3587	errorBody := bytes.NewReader(errorBuffer.Bytes())
3588
3589	errorCode := "UnknownError"
3590	errorMessage := errorCode
3591
3592	code := response.Header.Get("X-Amzn-ErrorType")
3593	if len(code) != 0 {
3594		errorCode = restjson.SanitizeErrorCode(code)
3595	}
3596
3597	var buff [1024]byte
3598	ringBuffer := smithyio.NewRingBuffer(buff[:])
3599
3600	body := io.TeeReader(errorBody, ringBuffer)
3601	decoder := json.NewDecoder(body)
3602	decoder.UseNumber()
3603	code, message, err := restjson.GetErrorInfo(decoder)
3604	if err != nil {
3605		var snapshot bytes.Buffer
3606		io.Copy(&snapshot, ringBuffer)
3607		err = &smithy.DeserializationError{
3608			Err:      fmt.Errorf("failed to decode response body, %w", err),
3609			Snapshot: snapshot.Bytes(),
3610		}
3611		return err
3612	}
3613
3614	errorBody.Seek(0, io.SeekStart)
3615	if len(code) != 0 {
3616		errorCode = restjson.SanitizeErrorCode(code)
3617	}
3618	if len(message) != 0 {
3619		errorMessage = message
3620	}
3621
3622	switch {
3623	case strings.EqualFold("AccessDeniedException", errorCode):
3624		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3625
3626	case strings.EqualFold("InternalServiceErrorException", errorCode):
3627		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3628
3629	case strings.EqualFold("InvalidParameterException", errorCode):
3630		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3631
3632	case strings.EqualFold("InvalidRequestException", errorCode):
3633		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
3634
3635	case strings.EqualFold("ResourceNotFoundException", errorCode):
3636		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3637
3638	case strings.EqualFold("ThrottlingException", errorCode):
3639		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3640
3641	default:
3642		genericError := &smithy.GenericAPIError{
3643			Code:    errorCode,
3644			Message: errorMessage,
3645		}
3646		return genericError
3647
3648	}
3649}
3650
3651type awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy struct {
3652}
3653
3654func (*awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy) ID() string {
3655	return "OperationDeserializer"
3656}
3657
3658func (m *awsAwsjson11_deserializeOpGetResolverQueryLogConfigPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3659	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3660) {
3661	out, metadata, err = next.HandleDeserialize(ctx, in)
3662	if err != nil {
3663		return out, metadata, err
3664	}
3665
3666	response, ok := out.RawResponse.(*smithyhttp.Response)
3667	if !ok {
3668		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3669	}
3670
3671	if response.StatusCode < 200 || response.StatusCode >= 300 {
3672		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigPolicy(response, &metadata)
3673	}
3674	output := &GetResolverQueryLogConfigPolicyOutput{}
3675	out.Result = output
3676
3677	var buff [1024]byte
3678	ringBuffer := smithyio.NewRingBuffer(buff[:])
3679
3680	body := io.TeeReader(response.Body, ringBuffer)
3681	decoder := json.NewDecoder(body)
3682	decoder.UseNumber()
3683	var shape interface{}
3684	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3685		var snapshot bytes.Buffer
3686		io.Copy(&snapshot, ringBuffer)
3687		err = &smithy.DeserializationError{
3688			Err:      fmt.Errorf("failed to decode response body, %w", err),
3689			Snapshot: snapshot.Bytes(),
3690		}
3691		return out, metadata, err
3692	}
3693
3694	err = awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigPolicyOutput(&output, shape)
3695	if err != nil {
3696		var snapshot bytes.Buffer
3697		io.Copy(&snapshot, ringBuffer)
3698		err = &smithy.DeserializationError{
3699			Err:      fmt.Errorf("failed to decode response body, %w", err),
3700			Snapshot: snapshot.Bytes(),
3701		}
3702		return out, metadata, err
3703	}
3704
3705	return out, metadata, err
3706}
3707
3708func awsAwsjson11_deserializeOpErrorGetResolverQueryLogConfigPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3709	var errorBuffer bytes.Buffer
3710	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3711		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3712	}
3713	errorBody := bytes.NewReader(errorBuffer.Bytes())
3714
3715	errorCode := "UnknownError"
3716	errorMessage := errorCode
3717
3718	code := response.Header.Get("X-Amzn-ErrorType")
3719	if len(code) != 0 {
3720		errorCode = restjson.SanitizeErrorCode(code)
3721	}
3722
3723	var buff [1024]byte
3724	ringBuffer := smithyio.NewRingBuffer(buff[:])
3725
3726	body := io.TeeReader(errorBody, ringBuffer)
3727	decoder := json.NewDecoder(body)
3728	decoder.UseNumber()
3729	code, message, err := restjson.GetErrorInfo(decoder)
3730	if err != nil {
3731		var snapshot bytes.Buffer
3732		io.Copy(&snapshot, ringBuffer)
3733		err = &smithy.DeserializationError{
3734			Err:      fmt.Errorf("failed to decode response body, %w", err),
3735			Snapshot: snapshot.Bytes(),
3736		}
3737		return err
3738	}
3739
3740	errorBody.Seek(0, io.SeekStart)
3741	if len(code) != 0 {
3742		errorCode = restjson.SanitizeErrorCode(code)
3743	}
3744	if len(message) != 0 {
3745		errorMessage = message
3746	}
3747
3748	switch {
3749	case strings.EqualFold("AccessDeniedException", errorCode):
3750		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3751
3752	case strings.EqualFold("InternalServiceErrorException", errorCode):
3753		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3754
3755	case strings.EqualFold("InvalidParameterException", errorCode):
3756		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3757
3758	case strings.EqualFold("InvalidRequestException", errorCode):
3759		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
3760
3761	case strings.EqualFold("UnknownResourceException", errorCode):
3762		return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody)
3763
3764	default:
3765		genericError := &smithy.GenericAPIError{
3766			Code:    errorCode,
3767			Message: errorMessage,
3768		}
3769		return genericError
3770
3771	}
3772}
3773
3774type awsAwsjson11_deserializeOpGetResolverRule struct {
3775}
3776
3777func (*awsAwsjson11_deserializeOpGetResolverRule) ID() string {
3778	return "OperationDeserializer"
3779}
3780
3781func (m *awsAwsjson11_deserializeOpGetResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3782	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3783) {
3784	out, metadata, err = next.HandleDeserialize(ctx, in)
3785	if err != nil {
3786		return out, metadata, err
3787	}
3788
3789	response, ok := out.RawResponse.(*smithyhttp.Response)
3790	if !ok {
3791		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3792	}
3793
3794	if response.StatusCode < 200 || response.StatusCode >= 300 {
3795		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverRule(response, &metadata)
3796	}
3797	output := &GetResolverRuleOutput{}
3798	out.Result = output
3799
3800	var buff [1024]byte
3801	ringBuffer := smithyio.NewRingBuffer(buff[:])
3802
3803	body := io.TeeReader(response.Body, ringBuffer)
3804	decoder := json.NewDecoder(body)
3805	decoder.UseNumber()
3806	var shape interface{}
3807	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3808		var snapshot bytes.Buffer
3809		io.Copy(&snapshot, ringBuffer)
3810		err = &smithy.DeserializationError{
3811			Err:      fmt.Errorf("failed to decode response body, %w", err),
3812			Snapshot: snapshot.Bytes(),
3813		}
3814		return out, metadata, err
3815	}
3816
3817	err = awsAwsjson11_deserializeOpDocumentGetResolverRuleOutput(&output, shape)
3818	if err != nil {
3819		var snapshot bytes.Buffer
3820		io.Copy(&snapshot, ringBuffer)
3821		err = &smithy.DeserializationError{
3822			Err:      fmt.Errorf("failed to decode response body, %w", err),
3823			Snapshot: snapshot.Bytes(),
3824		}
3825		return out, metadata, err
3826	}
3827
3828	return out, metadata, err
3829}
3830
3831func awsAwsjson11_deserializeOpErrorGetResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3832	var errorBuffer bytes.Buffer
3833	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3834		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3835	}
3836	errorBody := bytes.NewReader(errorBuffer.Bytes())
3837
3838	errorCode := "UnknownError"
3839	errorMessage := errorCode
3840
3841	code := response.Header.Get("X-Amzn-ErrorType")
3842	if len(code) != 0 {
3843		errorCode = restjson.SanitizeErrorCode(code)
3844	}
3845
3846	var buff [1024]byte
3847	ringBuffer := smithyio.NewRingBuffer(buff[:])
3848
3849	body := io.TeeReader(errorBody, ringBuffer)
3850	decoder := json.NewDecoder(body)
3851	decoder.UseNumber()
3852	code, message, err := restjson.GetErrorInfo(decoder)
3853	if err != nil {
3854		var snapshot bytes.Buffer
3855		io.Copy(&snapshot, ringBuffer)
3856		err = &smithy.DeserializationError{
3857			Err:      fmt.Errorf("failed to decode response body, %w", err),
3858			Snapshot: snapshot.Bytes(),
3859		}
3860		return err
3861	}
3862
3863	errorBody.Seek(0, io.SeekStart)
3864	if len(code) != 0 {
3865		errorCode = restjson.SanitizeErrorCode(code)
3866	}
3867	if len(message) != 0 {
3868		errorMessage = message
3869	}
3870
3871	switch {
3872	case strings.EqualFold("InternalServiceErrorException", errorCode):
3873		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3874
3875	case strings.EqualFold("InvalidParameterException", errorCode):
3876		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3877
3878	case strings.EqualFold("ResourceNotFoundException", errorCode):
3879		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3880
3881	case strings.EqualFold("ThrottlingException", errorCode):
3882		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
3883
3884	default:
3885		genericError := &smithy.GenericAPIError{
3886			Code:    errorCode,
3887			Message: errorMessage,
3888		}
3889		return genericError
3890
3891	}
3892}
3893
3894type awsAwsjson11_deserializeOpGetResolverRuleAssociation struct {
3895}
3896
3897func (*awsAwsjson11_deserializeOpGetResolverRuleAssociation) ID() string {
3898	return "OperationDeserializer"
3899}
3900
3901func (m *awsAwsjson11_deserializeOpGetResolverRuleAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3902	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3903) {
3904	out, metadata, err = next.HandleDeserialize(ctx, in)
3905	if err != nil {
3906		return out, metadata, err
3907	}
3908
3909	response, ok := out.RawResponse.(*smithyhttp.Response)
3910	if !ok {
3911		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3912	}
3913
3914	if response.StatusCode < 200 || response.StatusCode >= 300 {
3915		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverRuleAssociation(response, &metadata)
3916	}
3917	output := &GetResolverRuleAssociationOutput{}
3918	out.Result = output
3919
3920	var buff [1024]byte
3921	ringBuffer := smithyio.NewRingBuffer(buff[:])
3922
3923	body := io.TeeReader(response.Body, ringBuffer)
3924	decoder := json.NewDecoder(body)
3925	decoder.UseNumber()
3926	var shape interface{}
3927	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3928		var snapshot bytes.Buffer
3929		io.Copy(&snapshot, ringBuffer)
3930		err = &smithy.DeserializationError{
3931			Err:      fmt.Errorf("failed to decode response body, %w", err),
3932			Snapshot: snapshot.Bytes(),
3933		}
3934		return out, metadata, err
3935	}
3936
3937	err = awsAwsjson11_deserializeOpDocumentGetResolverRuleAssociationOutput(&output, shape)
3938	if err != nil {
3939		var snapshot bytes.Buffer
3940		io.Copy(&snapshot, ringBuffer)
3941		err = &smithy.DeserializationError{
3942			Err:      fmt.Errorf("failed to decode response body, %w", err),
3943			Snapshot: snapshot.Bytes(),
3944		}
3945		return out, metadata, err
3946	}
3947
3948	return out, metadata, err
3949}
3950
3951func awsAwsjson11_deserializeOpErrorGetResolverRuleAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3952	var errorBuffer bytes.Buffer
3953	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3954		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3955	}
3956	errorBody := bytes.NewReader(errorBuffer.Bytes())
3957
3958	errorCode := "UnknownError"
3959	errorMessage := errorCode
3960
3961	code := response.Header.Get("X-Amzn-ErrorType")
3962	if len(code) != 0 {
3963		errorCode = restjson.SanitizeErrorCode(code)
3964	}
3965
3966	var buff [1024]byte
3967	ringBuffer := smithyio.NewRingBuffer(buff[:])
3968
3969	body := io.TeeReader(errorBody, ringBuffer)
3970	decoder := json.NewDecoder(body)
3971	decoder.UseNumber()
3972	code, message, err := restjson.GetErrorInfo(decoder)
3973	if err != nil {
3974		var snapshot bytes.Buffer
3975		io.Copy(&snapshot, ringBuffer)
3976		err = &smithy.DeserializationError{
3977			Err:      fmt.Errorf("failed to decode response body, %w", err),
3978			Snapshot: snapshot.Bytes(),
3979		}
3980		return err
3981	}
3982
3983	errorBody.Seek(0, io.SeekStart)
3984	if len(code) != 0 {
3985		errorCode = restjson.SanitizeErrorCode(code)
3986	}
3987	if len(message) != 0 {
3988		errorMessage = message
3989	}
3990
3991	switch {
3992	case strings.EqualFold("InternalServiceErrorException", errorCode):
3993		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
3994
3995	case strings.EqualFold("InvalidParameterException", errorCode):
3996		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
3997
3998	case strings.EqualFold("ResourceNotFoundException", errorCode):
3999		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4000
4001	case strings.EqualFold("ThrottlingException", errorCode):
4002		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4003
4004	default:
4005		genericError := &smithy.GenericAPIError{
4006			Code:    errorCode,
4007			Message: errorMessage,
4008		}
4009		return genericError
4010
4011	}
4012}
4013
4014type awsAwsjson11_deserializeOpGetResolverRulePolicy struct {
4015}
4016
4017func (*awsAwsjson11_deserializeOpGetResolverRulePolicy) ID() string {
4018	return "OperationDeserializer"
4019}
4020
4021func (m *awsAwsjson11_deserializeOpGetResolverRulePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4022	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4023) {
4024	out, metadata, err = next.HandleDeserialize(ctx, in)
4025	if err != nil {
4026		return out, metadata, err
4027	}
4028
4029	response, ok := out.RawResponse.(*smithyhttp.Response)
4030	if !ok {
4031		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4032	}
4033
4034	if response.StatusCode < 200 || response.StatusCode >= 300 {
4035		return out, metadata, awsAwsjson11_deserializeOpErrorGetResolverRulePolicy(response, &metadata)
4036	}
4037	output := &GetResolverRulePolicyOutput{}
4038	out.Result = output
4039
4040	var buff [1024]byte
4041	ringBuffer := smithyio.NewRingBuffer(buff[:])
4042
4043	body := io.TeeReader(response.Body, ringBuffer)
4044	decoder := json.NewDecoder(body)
4045	decoder.UseNumber()
4046	var shape interface{}
4047	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4048		var snapshot bytes.Buffer
4049		io.Copy(&snapshot, ringBuffer)
4050		err = &smithy.DeserializationError{
4051			Err:      fmt.Errorf("failed to decode response body, %w", err),
4052			Snapshot: snapshot.Bytes(),
4053		}
4054		return out, metadata, err
4055	}
4056
4057	err = awsAwsjson11_deserializeOpDocumentGetResolverRulePolicyOutput(&output, shape)
4058	if err != nil {
4059		var snapshot bytes.Buffer
4060		io.Copy(&snapshot, ringBuffer)
4061		err = &smithy.DeserializationError{
4062			Err:      fmt.Errorf("failed to decode response body, %w", err),
4063			Snapshot: snapshot.Bytes(),
4064		}
4065		return out, metadata, err
4066	}
4067
4068	return out, metadata, err
4069}
4070
4071func awsAwsjson11_deserializeOpErrorGetResolverRulePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4072	var errorBuffer bytes.Buffer
4073	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4074		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4075	}
4076	errorBody := bytes.NewReader(errorBuffer.Bytes())
4077
4078	errorCode := "UnknownError"
4079	errorMessage := errorCode
4080
4081	code := response.Header.Get("X-Amzn-ErrorType")
4082	if len(code) != 0 {
4083		errorCode = restjson.SanitizeErrorCode(code)
4084	}
4085
4086	var buff [1024]byte
4087	ringBuffer := smithyio.NewRingBuffer(buff[:])
4088
4089	body := io.TeeReader(errorBody, ringBuffer)
4090	decoder := json.NewDecoder(body)
4091	decoder.UseNumber()
4092	code, message, err := restjson.GetErrorInfo(decoder)
4093	if err != nil {
4094		var snapshot bytes.Buffer
4095		io.Copy(&snapshot, ringBuffer)
4096		err = &smithy.DeserializationError{
4097			Err:      fmt.Errorf("failed to decode response body, %w", err),
4098			Snapshot: snapshot.Bytes(),
4099		}
4100		return err
4101	}
4102
4103	errorBody.Seek(0, io.SeekStart)
4104	if len(code) != 0 {
4105		errorCode = restjson.SanitizeErrorCode(code)
4106	}
4107	if len(message) != 0 {
4108		errorMessage = message
4109	}
4110
4111	switch {
4112	case strings.EqualFold("InternalServiceErrorException", errorCode):
4113		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4114
4115	case strings.EqualFold("InvalidParameterException", errorCode):
4116		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
4117
4118	case strings.EqualFold("UnknownResourceException", errorCode):
4119		return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody)
4120
4121	default:
4122		genericError := &smithy.GenericAPIError{
4123			Code:    errorCode,
4124			Message: errorMessage,
4125		}
4126		return genericError
4127
4128	}
4129}
4130
4131type awsAwsjson11_deserializeOpImportFirewallDomains struct {
4132}
4133
4134func (*awsAwsjson11_deserializeOpImportFirewallDomains) ID() string {
4135	return "OperationDeserializer"
4136}
4137
4138func (m *awsAwsjson11_deserializeOpImportFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4139	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4140) {
4141	out, metadata, err = next.HandleDeserialize(ctx, in)
4142	if err != nil {
4143		return out, metadata, err
4144	}
4145
4146	response, ok := out.RawResponse.(*smithyhttp.Response)
4147	if !ok {
4148		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4149	}
4150
4151	if response.StatusCode < 200 || response.StatusCode >= 300 {
4152		return out, metadata, awsAwsjson11_deserializeOpErrorImportFirewallDomains(response, &metadata)
4153	}
4154	output := &ImportFirewallDomainsOutput{}
4155	out.Result = output
4156
4157	var buff [1024]byte
4158	ringBuffer := smithyio.NewRingBuffer(buff[:])
4159
4160	body := io.TeeReader(response.Body, ringBuffer)
4161	decoder := json.NewDecoder(body)
4162	decoder.UseNumber()
4163	var shape interface{}
4164	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4165		var snapshot bytes.Buffer
4166		io.Copy(&snapshot, ringBuffer)
4167		err = &smithy.DeserializationError{
4168			Err:      fmt.Errorf("failed to decode response body, %w", err),
4169			Snapshot: snapshot.Bytes(),
4170		}
4171		return out, metadata, err
4172	}
4173
4174	err = awsAwsjson11_deserializeOpDocumentImportFirewallDomainsOutput(&output, shape)
4175	if err != nil {
4176		var snapshot bytes.Buffer
4177		io.Copy(&snapshot, ringBuffer)
4178		err = &smithy.DeserializationError{
4179			Err:      fmt.Errorf("failed to decode response body, %w", err),
4180			Snapshot: snapshot.Bytes(),
4181		}
4182		return out, metadata, err
4183	}
4184
4185	return out, metadata, err
4186}
4187
4188func awsAwsjson11_deserializeOpErrorImportFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4189	var errorBuffer bytes.Buffer
4190	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4191		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4192	}
4193	errorBody := bytes.NewReader(errorBuffer.Bytes())
4194
4195	errorCode := "UnknownError"
4196	errorMessage := errorCode
4197
4198	code := response.Header.Get("X-Amzn-ErrorType")
4199	if len(code) != 0 {
4200		errorCode = restjson.SanitizeErrorCode(code)
4201	}
4202
4203	var buff [1024]byte
4204	ringBuffer := smithyio.NewRingBuffer(buff[:])
4205
4206	body := io.TeeReader(errorBody, ringBuffer)
4207	decoder := json.NewDecoder(body)
4208	decoder.UseNumber()
4209	code, message, err := restjson.GetErrorInfo(decoder)
4210	if err != nil {
4211		var snapshot bytes.Buffer
4212		io.Copy(&snapshot, ringBuffer)
4213		err = &smithy.DeserializationError{
4214			Err:      fmt.Errorf("failed to decode response body, %w", err),
4215			Snapshot: snapshot.Bytes(),
4216		}
4217		return err
4218	}
4219
4220	errorBody.Seek(0, io.SeekStart)
4221	if len(code) != 0 {
4222		errorCode = restjson.SanitizeErrorCode(code)
4223	}
4224	if len(message) != 0 {
4225		errorMessage = message
4226	}
4227
4228	switch {
4229	case strings.EqualFold("AccessDeniedException", errorCode):
4230		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4231
4232	case strings.EqualFold("ConflictException", errorCode):
4233		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
4234
4235	case strings.EqualFold("InternalServiceErrorException", errorCode):
4236		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4237
4238	case strings.EqualFold("LimitExceededException", errorCode):
4239		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
4240
4241	case strings.EqualFold("ResourceNotFoundException", errorCode):
4242		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4243
4244	case strings.EqualFold("ThrottlingException", errorCode):
4245		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4246
4247	case strings.EqualFold("ValidationException", errorCode):
4248		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4249
4250	default:
4251		genericError := &smithy.GenericAPIError{
4252			Code:    errorCode,
4253			Message: errorMessage,
4254		}
4255		return genericError
4256
4257	}
4258}
4259
4260type awsAwsjson11_deserializeOpListFirewallConfigs struct {
4261}
4262
4263func (*awsAwsjson11_deserializeOpListFirewallConfigs) ID() string {
4264	return "OperationDeserializer"
4265}
4266
4267func (m *awsAwsjson11_deserializeOpListFirewallConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4268	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4269) {
4270	out, metadata, err = next.HandleDeserialize(ctx, in)
4271	if err != nil {
4272		return out, metadata, err
4273	}
4274
4275	response, ok := out.RawResponse.(*smithyhttp.Response)
4276	if !ok {
4277		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4278	}
4279
4280	if response.StatusCode < 200 || response.StatusCode >= 300 {
4281		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallConfigs(response, &metadata)
4282	}
4283	output := &ListFirewallConfigsOutput{}
4284	out.Result = output
4285
4286	var buff [1024]byte
4287	ringBuffer := smithyio.NewRingBuffer(buff[:])
4288
4289	body := io.TeeReader(response.Body, ringBuffer)
4290	decoder := json.NewDecoder(body)
4291	decoder.UseNumber()
4292	var shape interface{}
4293	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4294		var snapshot bytes.Buffer
4295		io.Copy(&snapshot, ringBuffer)
4296		err = &smithy.DeserializationError{
4297			Err:      fmt.Errorf("failed to decode response body, %w", err),
4298			Snapshot: snapshot.Bytes(),
4299		}
4300		return out, metadata, err
4301	}
4302
4303	err = awsAwsjson11_deserializeOpDocumentListFirewallConfigsOutput(&output, shape)
4304	if err != nil {
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	return out, metadata, err
4315}
4316
4317func awsAwsjson11_deserializeOpErrorListFirewallConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4318	var errorBuffer bytes.Buffer
4319	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4320		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4321	}
4322	errorBody := bytes.NewReader(errorBuffer.Bytes())
4323
4324	errorCode := "UnknownError"
4325	errorMessage := errorCode
4326
4327	code := response.Header.Get("X-Amzn-ErrorType")
4328	if len(code) != 0 {
4329		errorCode = restjson.SanitizeErrorCode(code)
4330	}
4331
4332	var buff [1024]byte
4333	ringBuffer := smithyio.NewRingBuffer(buff[:])
4334
4335	body := io.TeeReader(errorBody, ringBuffer)
4336	decoder := json.NewDecoder(body)
4337	decoder.UseNumber()
4338	code, message, err := restjson.GetErrorInfo(decoder)
4339	if err != nil {
4340		var snapshot bytes.Buffer
4341		io.Copy(&snapshot, ringBuffer)
4342		err = &smithy.DeserializationError{
4343			Err:      fmt.Errorf("failed to decode response body, %w", err),
4344			Snapshot: snapshot.Bytes(),
4345		}
4346		return err
4347	}
4348
4349	errorBody.Seek(0, io.SeekStart)
4350	if len(code) != 0 {
4351		errorCode = restjson.SanitizeErrorCode(code)
4352	}
4353	if len(message) != 0 {
4354		errorMessage = message
4355	}
4356
4357	switch {
4358	case strings.EqualFold("AccessDeniedException", errorCode):
4359		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4360
4361	case strings.EqualFold("InternalServiceErrorException", errorCode):
4362		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4363
4364	case strings.EqualFold("ThrottlingException", errorCode):
4365		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4366
4367	case strings.EqualFold("ValidationException", errorCode):
4368		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4369
4370	default:
4371		genericError := &smithy.GenericAPIError{
4372			Code:    errorCode,
4373			Message: errorMessage,
4374		}
4375		return genericError
4376
4377	}
4378}
4379
4380type awsAwsjson11_deserializeOpListFirewallDomainLists struct {
4381}
4382
4383func (*awsAwsjson11_deserializeOpListFirewallDomainLists) ID() string {
4384	return "OperationDeserializer"
4385}
4386
4387func (m *awsAwsjson11_deserializeOpListFirewallDomainLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4388	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4389) {
4390	out, metadata, err = next.HandleDeserialize(ctx, in)
4391	if err != nil {
4392		return out, metadata, err
4393	}
4394
4395	response, ok := out.RawResponse.(*smithyhttp.Response)
4396	if !ok {
4397		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4398	}
4399
4400	if response.StatusCode < 200 || response.StatusCode >= 300 {
4401		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallDomainLists(response, &metadata)
4402	}
4403	output := &ListFirewallDomainListsOutput{}
4404	out.Result = output
4405
4406	var buff [1024]byte
4407	ringBuffer := smithyio.NewRingBuffer(buff[:])
4408
4409	body := io.TeeReader(response.Body, ringBuffer)
4410	decoder := json.NewDecoder(body)
4411	decoder.UseNumber()
4412	var shape interface{}
4413	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4414		var snapshot bytes.Buffer
4415		io.Copy(&snapshot, ringBuffer)
4416		err = &smithy.DeserializationError{
4417			Err:      fmt.Errorf("failed to decode response body, %w", err),
4418			Snapshot: snapshot.Bytes(),
4419		}
4420		return out, metadata, err
4421	}
4422
4423	err = awsAwsjson11_deserializeOpDocumentListFirewallDomainListsOutput(&output, shape)
4424	if err != nil {
4425		var snapshot bytes.Buffer
4426		io.Copy(&snapshot, ringBuffer)
4427		err = &smithy.DeserializationError{
4428			Err:      fmt.Errorf("failed to decode response body, %w", err),
4429			Snapshot: snapshot.Bytes(),
4430		}
4431		return out, metadata, err
4432	}
4433
4434	return out, metadata, err
4435}
4436
4437func awsAwsjson11_deserializeOpErrorListFirewallDomainLists(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4438	var errorBuffer bytes.Buffer
4439	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4440		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4441	}
4442	errorBody := bytes.NewReader(errorBuffer.Bytes())
4443
4444	errorCode := "UnknownError"
4445	errorMessage := errorCode
4446
4447	code := response.Header.Get("X-Amzn-ErrorType")
4448	if len(code) != 0 {
4449		errorCode = restjson.SanitizeErrorCode(code)
4450	}
4451
4452	var buff [1024]byte
4453	ringBuffer := smithyio.NewRingBuffer(buff[:])
4454
4455	body := io.TeeReader(errorBody, ringBuffer)
4456	decoder := json.NewDecoder(body)
4457	decoder.UseNumber()
4458	code, message, err := restjson.GetErrorInfo(decoder)
4459	if err != nil {
4460		var snapshot bytes.Buffer
4461		io.Copy(&snapshot, ringBuffer)
4462		err = &smithy.DeserializationError{
4463			Err:      fmt.Errorf("failed to decode response body, %w", err),
4464			Snapshot: snapshot.Bytes(),
4465		}
4466		return err
4467	}
4468
4469	errorBody.Seek(0, io.SeekStart)
4470	if len(code) != 0 {
4471		errorCode = restjson.SanitizeErrorCode(code)
4472	}
4473	if len(message) != 0 {
4474		errorMessage = message
4475	}
4476
4477	switch {
4478	case strings.EqualFold("AccessDeniedException", errorCode):
4479		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4480
4481	case strings.EqualFold("InternalServiceErrorException", errorCode):
4482		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4483
4484	case strings.EqualFold("ThrottlingException", errorCode):
4485		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4486
4487	case strings.EqualFold("ValidationException", errorCode):
4488		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4489
4490	default:
4491		genericError := &smithy.GenericAPIError{
4492			Code:    errorCode,
4493			Message: errorMessage,
4494		}
4495		return genericError
4496
4497	}
4498}
4499
4500type awsAwsjson11_deserializeOpListFirewallDomains struct {
4501}
4502
4503func (*awsAwsjson11_deserializeOpListFirewallDomains) ID() string {
4504	return "OperationDeserializer"
4505}
4506
4507func (m *awsAwsjson11_deserializeOpListFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4508	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4509) {
4510	out, metadata, err = next.HandleDeserialize(ctx, in)
4511	if err != nil {
4512		return out, metadata, err
4513	}
4514
4515	response, ok := out.RawResponse.(*smithyhttp.Response)
4516	if !ok {
4517		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4518	}
4519
4520	if response.StatusCode < 200 || response.StatusCode >= 300 {
4521		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallDomains(response, &metadata)
4522	}
4523	output := &ListFirewallDomainsOutput{}
4524	out.Result = output
4525
4526	var buff [1024]byte
4527	ringBuffer := smithyio.NewRingBuffer(buff[:])
4528
4529	body := io.TeeReader(response.Body, ringBuffer)
4530	decoder := json.NewDecoder(body)
4531	decoder.UseNumber()
4532	var shape interface{}
4533	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4534		var snapshot bytes.Buffer
4535		io.Copy(&snapshot, ringBuffer)
4536		err = &smithy.DeserializationError{
4537			Err:      fmt.Errorf("failed to decode response body, %w", err),
4538			Snapshot: snapshot.Bytes(),
4539		}
4540		return out, metadata, err
4541	}
4542
4543	err = awsAwsjson11_deserializeOpDocumentListFirewallDomainsOutput(&output, shape)
4544	if err != nil {
4545		var snapshot bytes.Buffer
4546		io.Copy(&snapshot, ringBuffer)
4547		err = &smithy.DeserializationError{
4548			Err:      fmt.Errorf("failed to decode response body, %w", err),
4549			Snapshot: snapshot.Bytes(),
4550		}
4551		return out, metadata, err
4552	}
4553
4554	return out, metadata, err
4555}
4556
4557func awsAwsjson11_deserializeOpErrorListFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4558	var errorBuffer bytes.Buffer
4559	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4560		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4561	}
4562	errorBody := bytes.NewReader(errorBuffer.Bytes())
4563
4564	errorCode := "UnknownError"
4565	errorMessage := errorCode
4566
4567	code := response.Header.Get("X-Amzn-ErrorType")
4568	if len(code) != 0 {
4569		errorCode = restjson.SanitizeErrorCode(code)
4570	}
4571
4572	var buff [1024]byte
4573	ringBuffer := smithyio.NewRingBuffer(buff[:])
4574
4575	body := io.TeeReader(errorBody, ringBuffer)
4576	decoder := json.NewDecoder(body)
4577	decoder.UseNumber()
4578	code, message, err := restjson.GetErrorInfo(decoder)
4579	if err != nil {
4580		var snapshot bytes.Buffer
4581		io.Copy(&snapshot, ringBuffer)
4582		err = &smithy.DeserializationError{
4583			Err:      fmt.Errorf("failed to decode response body, %w", err),
4584			Snapshot: snapshot.Bytes(),
4585		}
4586		return err
4587	}
4588
4589	errorBody.Seek(0, io.SeekStart)
4590	if len(code) != 0 {
4591		errorCode = restjson.SanitizeErrorCode(code)
4592	}
4593	if len(message) != 0 {
4594		errorMessage = message
4595	}
4596
4597	switch {
4598	case strings.EqualFold("AccessDeniedException", errorCode):
4599		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4600
4601	case strings.EqualFold("InternalServiceErrorException", errorCode):
4602		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4603
4604	case strings.EqualFold("ResourceNotFoundException", errorCode):
4605		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4606
4607	case strings.EqualFold("ThrottlingException", errorCode):
4608		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4609
4610	case strings.EqualFold("ValidationException", errorCode):
4611		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4612
4613	default:
4614		genericError := &smithy.GenericAPIError{
4615			Code:    errorCode,
4616			Message: errorMessage,
4617		}
4618		return genericError
4619
4620	}
4621}
4622
4623type awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations struct {
4624}
4625
4626func (*awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations) ID() string {
4627	return "OperationDeserializer"
4628}
4629
4630func (m *awsAwsjson11_deserializeOpListFirewallRuleGroupAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4631	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4632) {
4633	out, metadata, err = next.HandleDeserialize(ctx, in)
4634	if err != nil {
4635		return out, metadata, err
4636	}
4637
4638	response, ok := out.RawResponse.(*smithyhttp.Response)
4639	if !ok {
4640		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4641	}
4642
4643	if response.StatusCode < 200 || response.StatusCode >= 300 {
4644		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRuleGroupAssociations(response, &metadata)
4645	}
4646	output := &ListFirewallRuleGroupAssociationsOutput{}
4647	out.Result = output
4648
4649	var buff [1024]byte
4650	ringBuffer := smithyio.NewRingBuffer(buff[:])
4651
4652	body := io.TeeReader(response.Body, ringBuffer)
4653	decoder := json.NewDecoder(body)
4654	decoder.UseNumber()
4655	var shape interface{}
4656	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4657		var snapshot bytes.Buffer
4658		io.Copy(&snapshot, ringBuffer)
4659		err = &smithy.DeserializationError{
4660			Err:      fmt.Errorf("failed to decode response body, %w", err),
4661			Snapshot: snapshot.Bytes(),
4662		}
4663		return out, metadata, err
4664	}
4665
4666	err = awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupAssociationsOutput(&output, shape)
4667	if err != nil {
4668		var snapshot bytes.Buffer
4669		io.Copy(&snapshot, ringBuffer)
4670		err = &smithy.DeserializationError{
4671			Err:      fmt.Errorf("failed to decode response body, %w", err),
4672			Snapshot: snapshot.Bytes(),
4673		}
4674		return out, metadata, err
4675	}
4676
4677	return out, metadata, err
4678}
4679
4680func awsAwsjson11_deserializeOpErrorListFirewallRuleGroupAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4681	var errorBuffer bytes.Buffer
4682	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4683		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4684	}
4685	errorBody := bytes.NewReader(errorBuffer.Bytes())
4686
4687	errorCode := "UnknownError"
4688	errorMessage := errorCode
4689
4690	code := response.Header.Get("X-Amzn-ErrorType")
4691	if len(code) != 0 {
4692		errorCode = restjson.SanitizeErrorCode(code)
4693	}
4694
4695	var buff [1024]byte
4696	ringBuffer := smithyio.NewRingBuffer(buff[:])
4697
4698	body := io.TeeReader(errorBody, ringBuffer)
4699	decoder := json.NewDecoder(body)
4700	decoder.UseNumber()
4701	code, message, err := restjson.GetErrorInfo(decoder)
4702	if err != nil {
4703		var snapshot bytes.Buffer
4704		io.Copy(&snapshot, ringBuffer)
4705		err = &smithy.DeserializationError{
4706			Err:      fmt.Errorf("failed to decode response body, %w", err),
4707			Snapshot: snapshot.Bytes(),
4708		}
4709		return err
4710	}
4711
4712	errorBody.Seek(0, io.SeekStart)
4713	if len(code) != 0 {
4714		errorCode = restjson.SanitizeErrorCode(code)
4715	}
4716	if len(message) != 0 {
4717		errorMessage = message
4718	}
4719
4720	switch {
4721	case strings.EqualFold("AccessDeniedException", errorCode):
4722		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4723
4724	case strings.EqualFold("InternalServiceErrorException", errorCode):
4725		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4726
4727	case strings.EqualFold("ThrottlingException", errorCode):
4728		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4729
4730	case strings.EqualFold("ValidationException", errorCode):
4731		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4732
4733	default:
4734		genericError := &smithy.GenericAPIError{
4735			Code:    errorCode,
4736			Message: errorMessage,
4737		}
4738		return genericError
4739
4740	}
4741}
4742
4743type awsAwsjson11_deserializeOpListFirewallRuleGroups struct {
4744}
4745
4746func (*awsAwsjson11_deserializeOpListFirewallRuleGroups) ID() string {
4747	return "OperationDeserializer"
4748}
4749
4750func (m *awsAwsjson11_deserializeOpListFirewallRuleGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4751	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4752) {
4753	out, metadata, err = next.HandleDeserialize(ctx, in)
4754	if err != nil {
4755		return out, metadata, err
4756	}
4757
4758	response, ok := out.RawResponse.(*smithyhttp.Response)
4759	if !ok {
4760		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4761	}
4762
4763	if response.StatusCode < 200 || response.StatusCode >= 300 {
4764		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRuleGroups(response, &metadata)
4765	}
4766	output := &ListFirewallRuleGroupsOutput{}
4767	out.Result = output
4768
4769	var buff [1024]byte
4770	ringBuffer := smithyio.NewRingBuffer(buff[:])
4771
4772	body := io.TeeReader(response.Body, ringBuffer)
4773	decoder := json.NewDecoder(body)
4774	decoder.UseNumber()
4775	var shape interface{}
4776	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4777		var snapshot bytes.Buffer
4778		io.Copy(&snapshot, ringBuffer)
4779		err = &smithy.DeserializationError{
4780			Err:      fmt.Errorf("failed to decode response body, %w", err),
4781			Snapshot: snapshot.Bytes(),
4782		}
4783		return out, metadata, err
4784	}
4785
4786	err = awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupsOutput(&output, shape)
4787	if err != nil {
4788		var snapshot bytes.Buffer
4789		io.Copy(&snapshot, ringBuffer)
4790		err = &smithy.DeserializationError{
4791			Err:      fmt.Errorf("failed to decode response body, %w", err),
4792			Snapshot: snapshot.Bytes(),
4793		}
4794		return out, metadata, err
4795	}
4796
4797	return out, metadata, err
4798}
4799
4800func awsAwsjson11_deserializeOpErrorListFirewallRuleGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4801	var errorBuffer bytes.Buffer
4802	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4803		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4804	}
4805	errorBody := bytes.NewReader(errorBuffer.Bytes())
4806
4807	errorCode := "UnknownError"
4808	errorMessage := errorCode
4809
4810	code := response.Header.Get("X-Amzn-ErrorType")
4811	if len(code) != 0 {
4812		errorCode = restjson.SanitizeErrorCode(code)
4813	}
4814
4815	var buff [1024]byte
4816	ringBuffer := smithyio.NewRingBuffer(buff[:])
4817
4818	body := io.TeeReader(errorBody, ringBuffer)
4819	decoder := json.NewDecoder(body)
4820	decoder.UseNumber()
4821	code, message, err := restjson.GetErrorInfo(decoder)
4822	if err != nil {
4823		var snapshot bytes.Buffer
4824		io.Copy(&snapshot, ringBuffer)
4825		err = &smithy.DeserializationError{
4826			Err:      fmt.Errorf("failed to decode response body, %w", err),
4827			Snapshot: snapshot.Bytes(),
4828		}
4829		return err
4830	}
4831
4832	errorBody.Seek(0, io.SeekStart)
4833	if len(code) != 0 {
4834		errorCode = restjson.SanitizeErrorCode(code)
4835	}
4836	if len(message) != 0 {
4837		errorMessage = message
4838	}
4839
4840	switch {
4841	case strings.EqualFold("AccessDeniedException", errorCode):
4842		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4843
4844	case strings.EqualFold("InternalServiceErrorException", errorCode):
4845		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4846
4847	case strings.EqualFold("ThrottlingException", errorCode):
4848		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4849
4850	case strings.EqualFold("ValidationException", errorCode):
4851		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4852
4853	default:
4854		genericError := &smithy.GenericAPIError{
4855			Code:    errorCode,
4856			Message: errorMessage,
4857		}
4858		return genericError
4859
4860	}
4861}
4862
4863type awsAwsjson11_deserializeOpListFirewallRules struct {
4864}
4865
4866func (*awsAwsjson11_deserializeOpListFirewallRules) ID() string {
4867	return "OperationDeserializer"
4868}
4869
4870func (m *awsAwsjson11_deserializeOpListFirewallRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4871	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4872) {
4873	out, metadata, err = next.HandleDeserialize(ctx, in)
4874	if err != nil {
4875		return out, metadata, err
4876	}
4877
4878	response, ok := out.RawResponse.(*smithyhttp.Response)
4879	if !ok {
4880		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4881	}
4882
4883	if response.StatusCode < 200 || response.StatusCode >= 300 {
4884		return out, metadata, awsAwsjson11_deserializeOpErrorListFirewallRules(response, &metadata)
4885	}
4886	output := &ListFirewallRulesOutput{}
4887	out.Result = output
4888
4889	var buff [1024]byte
4890	ringBuffer := smithyio.NewRingBuffer(buff[:])
4891
4892	body := io.TeeReader(response.Body, ringBuffer)
4893	decoder := json.NewDecoder(body)
4894	decoder.UseNumber()
4895	var shape interface{}
4896	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4897		var snapshot bytes.Buffer
4898		io.Copy(&snapshot, ringBuffer)
4899		err = &smithy.DeserializationError{
4900			Err:      fmt.Errorf("failed to decode response body, %w", err),
4901			Snapshot: snapshot.Bytes(),
4902		}
4903		return out, metadata, err
4904	}
4905
4906	err = awsAwsjson11_deserializeOpDocumentListFirewallRulesOutput(&output, shape)
4907	if err != nil {
4908		var snapshot bytes.Buffer
4909		io.Copy(&snapshot, ringBuffer)
4910		err = &smithy.DeserializationError{
4911			Err:      fmt.Errorf("failed to decode response body, %w", err),
4912			Snapshot: snapshot.Bytes(),
4913		}
4914		return out, metadata, err
4915	}
4916
4917	return out, metadata, err
4918}
4919
4920func awsAwsjson11_deserializeOpErrorListFirewallRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4921	var errorBuffer bytes.Buffer
4922	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4923		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4924	}
4925	errorBody := bytes.NewReader(errorBuffer.Bytes())
4926
4927	errorCode := "UnknownError"
4928	errorMessage := errorCode
4929
4930	code := response.Header.Get("X-Amzn-ErrorType")
4931	if len(code) != 0 {
4932		errorCode = restjson.SanitizeErrorCode(code)
4933	}
4934
4935	var buff [1024]byte
4936	ringBuffer := smithyio.NewRingBuffer(buff[:])
4937
4938	body := io.TeeReader(errorBody, ringBuffer)
4939	decoder := json.NewDecoder(body)
4940	decoder.UseNumber()
4941	code, message, err := restjson.GetErrorInfo(decoder)
4942	if err != nil {
4943		var snapshot bytes.Buffer
4944		io.Copy(&snapshot, ringBuffer)
4945		err = &smithy.DeserializationError{
4946			Err:      fmt.Errorf("failed to decode response body, %w", err),
4947			Snapshot: snapshot.Bytes(),
4948		}
4949		return err
4950	}
4951
4952	errorBody.Seek(0, io.SeekStart)
4953	if len(code) != 0 {
4954		errorCode = restjson.SanitizeErrorCode(code)
4955	}
4956	if len(message) != 0 {
4957		errorMessage = message
4958	}
4959
4960	switch {
4961	case strings.EqualFold("AccessDeniedException", errorCode):
4962		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4963
4964	case strings.EqualFold("InternalServiceErrorException", errorCode):
4965		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
4966
4967	case strings.EqualFold("ResourceNotFoundException", errorCode):
4968		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4969
4970	case strings.EqualFold("ThrottlingException", errorCode):
4971		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
4972
4973	case strings.EqualFold("ValidationException", errorCode):
4974		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
4975
4976	default:
4977		genericError := &smithy.GenericAPIError{
4978			Code:    errorCode,
4979			Message: errorMessage,
4980		}
4981		return genericError
4982
4983	}
4984}
4985
4986type awsAwsjson11_deserializeOpListResolverDnssecConfigs struct {
4987}
4988
4989func (*awsAwsjson11_deserializeOpListResolverDnssecConfigs) ID() string {
4990	return "OperationDeserializer"
4991}
4992
4993func (m *awsAwsjson11_deserializeOpListResolverDnssecConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4994	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4995) {
4996	out, metadata, err = next.HandleDeserialize(ctx, in)
4997	if err != nil {
4998		return out, metadata, err
4999	}
5000
5001	response, ok := out.RawResponse.(*smithyhttp.Response)
5002	if !ok {
5003		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5004	}
5005
5006	if response.StatusCode < 200 || response.StatusCode >= 300 {
5007		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverDnssecConfigs(response, &metadata)
5008	}
5009	output := &ListResolverDnssecConfigsOutput{}
5010	out.Result = output
5011
5012	var buff [1024]byte
5013	ringBuffer := smithyio.NewRingBuffer(buff[:])
5014
5015	body := io.TeeReader(response.Body, ringBuffer)
5016	decoder := json.NewDecoder(body)
5017	decoder.UseNumber()
5018	var shape interface{}
5019	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5020		var snapshot bytes.Buffer
5021		io.Copy(&snapshot, ringBuffer)
5022		err = &smithy.DeserializationError{
5023			Err:      fmt.Errorf("failed to decode response body, %w", err),
5024			Snapshot: snapshot.Bytes(),
5025		}
5026		return out, metadata, err
5027	}
5028
5029	err = awsAwsjson11_deserializeOpDocumentListResolverDnssecConfigsOutput(&output, shape)
5030	if err != nil {
5031		var snapshot bytes.Buffer
5032		io.Copy(&snapshot, ringBuffer)
5033		err = &smithy.DeserializationError{
5034			Err:      fmt.Errorf("failed to decode response body, %w", err),
5035			Snapshot: snapshot.Bytes(),
5036		}
5037		return out, metadata, err
5038	}
5039
5040	return out, metadata, err
5041}
5042
5043func awsAwsjson11_deserializeOpErrorListResolverDnssecConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5044	var errorBuffer bytes.Buffer
5045	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5046		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5047	}
5048	errorBody := bytes.NewReader(errorBuffer.Bytes())
5049
5050	errorCode := "UnknownError"
5051	errorMessage := errorCode
5052
5053	code := response.Header.Get("X-Amzn-ErrorType")
5054	if len(code) != 0 {
5055		errorCode = restjson.SanitizeErrorCode(code)
5056	}
5057
5058	var buff [1024]byte
5059	ringBuffer := smithyio.NewRingBuffer(buff[:])
5060
5061	body := io.TeeReader(errorBody, ringBuffer)
5062	decoder := json.NewDecoder(body)
5063	decoder.UseNumber()
5064	code, message, err := restjson.GetErrorInfo(decoder)
5065	if err != nil {
5066		var snapshot bytes.Buffer
5067		io.Copy(&snapshot, ringBuffer)
5068		err = &smithy.DeserializationError{
5069			Err:      fmt.Errorf("failed to decode response body, %w", err),
5070			Snapshot: snapshot.Bytes(),
5071		}
5072		return err
5073	}
5074
5075	errorBody.Seek(0, io.SeekStart)
5076	if len(code) != 0 {
5077		errorCode = restjson.SanitizeErrorCode(code)
5078	}
5079	if len(message) != 0 {
5080		errorMessage = message
5081	}
5082
5083	switch {
5084	case strings.EqualFold("AccessDeniedException", errorCode):
5085		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5086
5087	case strings.EqualFold("InternalServiceErrorException", errorCode):
5088		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5089
5090	case strings.EqualFold("InvalidNextTokenException", errorCode):
5091		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5092
5093	case strings.EqualFold("InvalidParameterException", errorCode):
5094		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5095
5096	case strings.EqualFold("InvalidRequestException", errorCode):
5097		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5098
5099	case strings.EqualFold("ThrottlingException", errorCode):
5100		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5101
5102	default:
5103		genericError := &smithy.GenericAPIError{
5104			Code:    errorCode,
5105			Message: errorMessage,
5106		}
5107		return genericError
5108
5109	}
5110}
5111
5112type awsAwsjson11_deserializeOpListResolverEndpointIpAddresses struct {
5113}
5114
5115func (*awsAwsjson11_deserializeOpListResolverEndpointIpAddresses) ID() string {
5116	return "OperationDeserializer"
5117}
5118
5119func (m *awsAwsjson11_deserializeOpListResolverEndpointIpAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5120	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5121) {
5122	out, metadata, err = next.HandleDeserialize(ctx, in)
5123	if err != nil {
5124		return out, metadata, err
5125	}
5126
5127	response, ok := out.RawResponse.(*smithyhttp.Response)
5128	if !ok {
5129		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5130	}
5131
5132	if response.StatusCode < 200 || response.StatusCode >= 300 {
5133		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverEndpointIpAddresses(response, &metadata)
5134	}
5135	output := &ListResolverEndpointIpAddressesOutput{}
5136	out.Result = output
5137
5138	var buff [1024]byte
5139	ringBuffer := smithyio.NewRingBuffer(buff[:])
5140
5141	body := io.TeeReader(response.Body, ringBuffer)
5142	decoder := json.NewDecoder(body)
5143	decoder.UseNumber()
5144	var shape interface{}
5145	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5146		var snapshot bytes.Buffer
5147		io.Copy(&snapshot, ringBuffer)
5148		err = &smithy.DeserializationError{
5149			Err:      fmt.Errorf("failed to decode response body, %w", err),
5150			Snapshot: snapshot.Bytes(),
5151		}
5152		return out, metadata, err
5153	}
5154
5155	err = awsAwsjson11_deserializeOpDocumentListResolverEndpointIpAddressesOutput(&output, shape)
5156	if err != nil {
5157		var snapshot bytes.Buffer
5158		io.Copy(&snapshot, ringBuffer)
5159		err = &smithy.DeserializationError{
5160			Err:      fmt.Errorf("failed to decode response body, %w", err),
5161			Snapshot: snapshot.Bytes(),
5162		}
5163		return out, metadata, err
5164	}
5165
5166	return out, metadata, err
5167}
5168
5169func awsAwsjson11_deserializeOpErrorListResolverEndpointIpAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5170	var errorBuffer bytes.Buffer
5171	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5172		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5173	}
5174	errorBody := bytes.NewReader(errorBuffer.Bytes())
5175
5176	errorCode := "UnknownError"
5177	errorMessage := errorCode
5178
5179	code := response.Header.Get("X-Amzn-ErrorType")
5180	if len(code) != 0 {
5181		errorCode = restjson.SanitizeErrorCode(code)
5182	}
5183
5184	var buff [1024]byte
5185	ringBuffer := smithyio.NewRingBuffer(buff[:])
5186
5187	body := io.TeeReader(errorBody, ringBuffer)
5188	decoder := json.NewDecoder(body)
5189	decoder.UseNumber()
5190	code, message, err := restjson.GetErrorInfo(decoder)
5191	if err != nil {
5192		var snapshot bytes.Buffer
5193		io.Copy(&snapshot, ringBuffer)
5194		err = &smithy.DeserializationError{
5195			Err:      fmt.Errorf("failed to decode response body, %w", err),
5196			Snapshot: snapshot.Bytes(),
5197		}
5198		return err
5199	}
5200
5201	errorBody.Seek(0, io.SeekStart)
5202	if len(code) != 0 {
5203		errorCode = restjson.SanitizeErrorCode(code)
5204	}
5205	if len(message) != 0 {
5206		errorMessage = message
5207	}
5208
5209	switch {
5210	case strings.EqualFold("InternalServiceErrorException", errorCode):
5211		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5212
5213	case strings.EqualFold("InvalidNextTokenException", errorCode):
5214		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5215
5216	case strings.EqualFold("InvalidParameterException", errorCode):
5217		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5218
5219	case strings.EqualFold("ResourceNotFoundException", errorCode):
5220		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5221
5222	case strings.EqualFold("ThrottlingException", errorCode):
5223		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5224
5225	default:
5226		genericError := &smithy.GenericAPIError{
5227			Code:    errorCode,
5228			Message: errorMessage,
5229		}
5230		return genericError
5231
5232	}
5233}
5234
5235type awsAwsjson11_deserializeOpListResolverEndpoints struct {
5236}
5237
5238func (*awsAwsjson11_deserializeOpListResolverEndpoints) ID() string {
5239	return "OperationDeserializer"
5240}
5241
5242func (m *awsAwsjson11_deserializeOpListResolverEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5243	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5244) {
5245	out, metadata, err = next.HandleDeserialize(ctx, in)
5246	if err != nil {
5247		return out, metadata, err
5248	}
5249
5250	response, ok := out.RawResponse.(*smithyhttp.Response)
5251	if !ok {
5252		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5253	}
5254
5255	if response.StatusCode < 200 || response.StatusCode >= 300 {
5256		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverEndpoints(response, &metadata)
5257	}
5258	output := &ListResolverEndpointsOutput{}
5259	out.Result = output
5260
5261	var buff [1024]byte
5262	ringBuffer := smithyio.NewRingBuffer(buff[:])
5263
5264	body := io.TeeReader(response.Body, ringBuffer)
5265	decoder := json.NewDecoder(body)
5266	decoder.UseNumber()
5267	var shape interface{}
5268	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5269		var snapshot bytes.Buffer
5270		io.Copy(&snapshot, ringBuffer)
5271		err = &smithy.DeserializationError{
5272			Err:      fmt.Errorf("failed to decode response body, %w", err),
5273			Snapshot: snapshot.Bytes(),
5274		}
5275		return out, metadata, err
5276	}
5277
5278	err = awsAwsjson11_deserializeOpDocumentListResolverEndpointsOutput(&output, shape)
5279	if err != nil {
5280		var snapshot bytes.Buffer
5281		io.Copy(&snapshot, ringBuffer)
5282		err = &smithy.DeserializationError{
5283			Err:      fmt.Errorf("failed to decode response body, %w", err),
5284			Snapshot: snapshot.Bytes(),
5285		}
5286		return out, metadata, err
5287	}
5288
5289	return out, metadata, err
5290}
5291
5292func awsAwsjson11_deserializeOpErrorListResolverEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5293	var errorBuffer bytes.Buffer
5294	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5295		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5296	}
5297	errorBody := bytes.NewReader(errorBuffer.Bytes())
5298
5299	errorCode := "UnknownError"
5300	errorMessage := errorCode
5301
5302	code := response.Header.Get("X-Amzn-ErrorType")
5303	if len(code) != 0 {
5304		errorCode = restjson.SanitizeErrorCode(code)
5305	}
5306
5307	var buff [1024]byte
5308	ringBuffer := smithyio.NewRingBuffer(buff[:])
5309
5310	body := io.TeeReader(errorBody, ringBuffer)
5311	decoder := json.NewDecoder(body)
5312	decoder.UseNumber()
5313	code, message, err := restjson.GetErrorInfo(decoder)
5314	if err != nil {
5315		var snapshot bytes.Buffer
5316		io.Copy(&snapshot, ringBuffer)
5317		err = &smithy.DeserializationError{
5318			Err:      fmt.Errorf("failed to decode response body, %w", err),
5319			Snapshot: snapshot.Bytes(),
5320		}
5321		return err
5322	}
5323
5324	errorBody.Seek(0, io.SeekStart)
5325	if len(code) != 0 {
5326		errorCode = restjson.SanitizeErrorCode(code)
5327	}
5328	if len(message) != 0 {
5329		errorMessage = message
5330	}
5331
5332	switch {
5333	case strings.EqualFold("InternalServiceErrorException", errorCode):
5334		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5335
5336	case strings.EqualFold("InvalidNextTokenException", errorCode):
5337		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5338
5339	case strings.EqualFold("InvalidParameterException", errorCode):
5340		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5341
5342	case strings.EqualFold("InvalidRequestException", errorCode):
5343		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5344
5345	case strings.EqualFold("ThrottlingException", errorCode):
5346		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5347
5348	default:
5349		genericError := &smithy.GenericAPIError{
5350			Code:    errorCode,
5351			Message: errorMessage,
5352		}
5353		return genericError
5354
5355	}
5356}
5357
5358type awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations struct {
5359}
5360
5361func (*awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations) ID() string {
5362	return "OperationDeserializer"
5363}
5364
5365func (m *awsAwsjson11_deserializeOpListResolverQueryLogConfigAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5366	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5367) {
5368	out, metadata, err = next.HandleDeserialize(ctx, in)
5369	if err != nil {
5370		return out, metadata, err
5371	}
5372
5373	response, ok := out.RawResponse.(*smithyhttp.Response)
5374	if !ok {
5375		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5376	}
5377
5378	if response.StatusCode < 200 || response.StatusCode >= 300 {
5379		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigAssociations(response, &metadata)
5380	}
5381	output := &ListResolverQueryLogConfigAssociationsOutput{}
5382	out.Result = output
5383
5384	var buff [1024]byte
5385	ringBuffer := smithyio.NewRingBuffer(buff[:])
5386
5387	body := io.TeeReader(response.Body, ringBuffer)
5388	decoder := json.NewDecoder(body)
5389	decoder.UseNumber()
5390	var shape interface{}
5391	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5392		var snapshot bytes.Buffer
5393		io.Copy(&snapshot, ringBuffer)
5394		err = &smithy.DeserializationError{
5395			Err:      fmt.Errorf("failed to decode response body, %w", err),
5396			Snapshot: snapshot.Bytes(),
5397		}
5398		return out, metadata, err
5399	}
5400
5401	err = awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigAssociationsOutput(&output, shape)
5402	if err != nil {
5403		var snapshot bytes.Buffer
5404		io.Copy(&snapshot, ringBuffer)
5405		err = &smithy.DeserializationError{
5406			Err:      fmt.Errorf("failed to decode response body, %w", err),
5407			Snapshot: snapshot.Bytes(),
5408		}
5409		return out, metadata, err
5410	}
5411
5412	return out, metadata, err
5413}
5414
5415func awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5416	var errorBuffer bytes.Buffer
5417	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5418		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5419	}
5420	errorBody := bytes.NewReader(errorBuffer.Bytes())
5421
5422	errorCode := "UnknownError"
5423	errorMessage := errorCode
5424
5425	code := response.Header.Get("X-Amzn-ErrorType")
5426	if len(code) != 0 {
5427		errorCode = restjson.SanitizeErrorCode(code)
5428	}
5429
5430	var buff [1024]byte
5431	ringBuffer := smithyio.NewRingBuffer(buff[:])
5432
5433	body := io.TeeReader(errorBody, ringBuffer)
5434	decoder := json.NewDecoder(body)
5435	decoder.UseNumber()
5436	code, message, err := restjson.GetErrorInfo(decoder)
5437	if err != nil {
5438		var snapshot bytes.Buffer
5439		io.Copy(&snapshot, ringBuffer)
5440		err = &smithy.DeserializationError{
5441			Err:      fmt.Errorf("failed to decode response body, %w", err),
5442			Snapshot: snapshot.Bytes(),
5443		}
5444		return err
5445	}
5446
5447	errorBody.Seek(0, io.SeekStart)
5448	if len(code) != 0 {
5449		errorCode = restjson.SanitizeErrorCode(code)
5450	}
5451	if len(message) != 0 {
5452		errorMessage = message
5453	}
5454
5455	switch {
5456	case strings.EqualFold("AccessDeniedException", errorCode):
5457		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5458
5459	case strings.EqualFold("InternalServiceErrorException", errorCode):
5460		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5461
5462	case strings.EqualFold("InvalidParameterException", errorCode):
5463		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5464
5465	case strings.EqualFold("InvalidRequestException", errorCode):
5466		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5467
5468	case strings.EqualFold("LimitExceededException", errorCode):
5469		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
5470
5471	case strings.EqualFold("ThrottlingException", errorCode):
5472		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5473
5474	default:
5475		genericError := &smithy.GenericAPIError{
5476			Code:    errorCode,
5477			Message: errorMessage,
5478		}
5479		return genericError
5480
5481	}
5482}
5483
5484type awsAwsjson11_deserializeOpListResolverQueryLogConfigs struct {
5485}
5486
5487func (*awsAwsjson11_deserializeOpListResolverQueryLogConfigs) ID() string {
5488	return "OperationDeserializer"
5489}
5490
5491func (m *awsAwsjson11_deserializeOpListResolverQueryLogConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5492	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5493) {
5494	out, metadata, err = next.HandleDeserialize(ctx, in)
5495	if err != nil {
5496		return out, metadata, err
5497	}
5498
5499	response, ok := out.RawResponse.(*smithyhttp.Response)
5500	if !ok {
5501		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5502	}
5503
5504	if response.StatusCode < 200 || response.StatusCode >= 300 {
5505		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigs(response, &metadata)
5506	}
5507	output := &ListResolverQueryLogConfigsOutput{}
5508	out.Result = output
5509
5510	var buff [1024]byte
5511	ringBuffer := smithyio.NewRingBuffer(buff[:])
5512
5513	body := io.TeeReader(response.Body, ringBuffer)
5514	decoder := json.NewDecoder(body)
5515	decoder.UseNumber()
5516	var shape interface{}
5517	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5518		var snapshot bytes.Buffer
5519		io.Copy(&snapshot, ringBuffer)
5520		err = &smithy.DeserializationError{
5521			Err:      fmt.Errorf("failed to decode response body, %w", err),
5522			Snapshot: snapshot.Bytes(),
5523		}
5524		return out, metadata, err
5525	}
5526
5527	err = awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigsOutput(&output, shape)
5528	if err != nil {
5529		var snapshot bytes.Buffer
5530		io.Copy(&snapshot, ringBuffer)
5531		err = &smithy.DeserializationError{
5532			Err:      fmt.Errorf("failed to decode response body, %w", err),
5533			Snapshot: snapshot.Bytes(),
5534		}
5535		return out, metadata, err
5536	}
5537
5538	return out, metadata, err
5539}
5540
5541func awsAwsjson11_deserializeOpErrorListResolverQueryLogConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5542	var errorBuffer bytes.Buffer
5543	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5544		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5545	}
5546	errorBody := bytes.NewReader(errorBuffer.Bytes())
5547
5548	errorCode := "UnknownError"
5549	errorMessage := errorCode
5550
5551	code := response.Header.Get("X-Amzn-ErrorType")
5552	if len(code) != 0 {
5553		errorCode = restjson.SanitizeErrorCode(code)
5554	}
5555
5556	var buff [1024]byte
5557	ringBuffer := smithyio.NewRingBuffer(buff[:])
5558
5559	body := io.TeeReader(errorBody, ringBuffer)
5560	decoder := json.NewDecoder(body)
5561	decoder.UseNumber()
5562	code, message, err := restjson.GetErrorInfo(decoder)
5563	if err != nil {
5564		var snapshot bytes.Buffer
5565		io.Copy(&snapshot, ringBuffer)
5566		err = &smithy.DeserializationError{
5567			Err:      fmt.Errorf("failed to decode response body, %w", err),
5568			Snapshot: snapshot.Bytes(),
5569		}
5570		return err
5571	}
5572
5573	errorBody.Seek(0, io.SeekStart)
5574	if len(code) != 0 {
5575		errorCode = restjson.SanitizeErrorCode(code)
5576	}
5577	if len(message) != 0 {
5578		errorMessage = message
5579	}
5580
5581	switch {
5582	case strings.EqualFold("AccessDeniedException", errorCode):
5583		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5584
5585	case strings.EqualFold("InternalServiceErrorException", errorCode):
5586		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5587
5588	case strings.EqualFold("InvalidNextTokenException", errorCode):
5589		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5590
5591	case strings.EqualFold("InvalidParameterException", errorCode):
5592		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5593
5594	case strings.EqualFold("InvalidRequestException", errorCode):
5595		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5596
5597	case strings.EqualFold("ThrottlingException", errorCode):
5598		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5599
5600	default:
5601		genericError := &smithy.GenericAPIError{
5602			Code:    errorCode,
5603			Message: errorMessage,
5604		}
5605		return genericError
5606
5607	}
5608}
5609
5610type awsAwsjson11_deserializeOpListResolverRuleAssociations struct {
5611}
5612
5613func (*awsAwsjson11_deserializeOpListResolverRuleAssociations) ID() string {
5614	return "OperationDeserializer"
5615}
5616
5617func (m *awsAwsjson11_deserializeOpListResolverRuleAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5618	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5619) {
5620	out, metadata, err = next.HandleDeserialize(ctx, in)
5621	if err != nil {
5622		return out, metadata, err
5623	}
5624
5625	response, ok := out.RawResponse.(*smithyhttp.Response)
5626	if !ok {
5627		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5628	}
5629
5630	if response.StatusCode < 200 || response.StatusCode >= 300 {
5631		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverRuleAssociations(response, &metadata)
5632	}
5633	output := &ListResolverRuleAssociationsOutput{}
5634	out.Result = output
5635
5636	var buff [1024]byte
5637	ringBuffer := smithyio.NewRingBuffer(buff[:])
5638
5639	body := io.TeeReader(response.Body, ringBuffer)
5640	decoder := json.NewDecoder(body)
5641	decoder.UseNumber()
5642	var shape interface{}
5643	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5644		var snapshot bytes.Buffer
5645		io.Copy(&snapshot, ringBuffer)
5646		err = &smithy.DeserializationError{
5647			Err:      fmt.Errorf("failed to decode response body, %w", err),
5648			Snapshot: snapshot.Bytes(),
5649		}
5650		return out, metadata, err
5651	}
5652
5653	err = awsAwsjson11_deserializeOpDocumentListResolverRuleAssociationsOutput(&output, shape)
5654	if err != nil {
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 out, metadata, err
5662	}
5663
5664	return out, metadata, err
5665}
5666
5667func awsAwsjson11_deserializeOpErrorListResolverRuleAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5668	var errorBuffer bytes.Buffer
5669	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5670		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5671	}
5672	errorBody := bytes.NewReader(errorBuffer.Bytes())
5673
5674	errorCode := "UnknownError"
5675	errorMessage := errorCode
5676
5677	code := response.Header.Get("X-Amzn-ErrorType")
5678	if len(code) != 0 {
5679		errorCode = restjson.SanitizeErrorCode(code)
5680	}
5681
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	code, message, err := restjson.GetErrorInfo(decoder)
5689	if err != nil {
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	errorBody.Seek(0, io.SeekStart)
5700	if len(code) != 0 {
5701		errorCode = restjson.SanitizeErrorCode(code)
5702	}
5703	if len(message) != 0 {
5704		errorMessage = message
5705	}
5706
5707	switch {
5708	case strings.EqualFold("InternalServiceErrorException", errorCode):
5709		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5710
5711	case strings.EqualFold("InvalidNextTokenException", errorCode):
5712		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5713
5714	case strings.EqualFold("InvalidParameterException", errorCode):
5715		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5716
5717	case strings.EqualFold("InvalidRequestException", errorCode):
5718		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5719
5720	case strings.EqualFold("ThrottlingException", errorCode):
5721		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5722
5723	default:
5724		genericError := &smithy.GenericAPIError{
5725			Code:    errorCode,
5726			Message: errorMessage,
5727		}
5728		return genericError
5729
5730	}
5731}
5732
5733type awsAwsjson11_deserializeOpListResolverRules struct {
5734}
5735
5736func (*awsAwsjson11_deserializeOpListResolverRules) ID() string {
5737	return "OperationDeserializer"
5738}
5739
5740func (m *awsAwsjson11_deserializeOpListResolverRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5741	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5742) {
5743	out, metadata, err = next.HandleDeserialize(ctx, in)
5744	if err != nil {
5745		return out, metadata, err
5746	}
5747
5748	response, ok := out.RawResponse.(*smithyhttp.Response)
5749	if !ok {
5750		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5751	}
5752
5753	if response.StatusCode < 200 || response.StatusCode >= 300 {
5754		return out, metadata, awsAwsjson11_deserializeOpErrorListResolverRules(response, &metadata)
5755	}
5756	output := &ListResolverRulesOutput{}
5757	out.Result = output
5758
5759	var buff [1024]byte
5760	ringBuffer := smithyio.NewRingBuffer(buff[:])
5761
5762	body := io.TeeReader(response.Body, ringBuffer)
5763	decoder := json.NewDecoder(body)
5764	decoder.UseNumber()
5765	var shape interface{}
5766	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5767		var snapshot bytes.Buffer
5768		io.Copy(&snapshot, ringBuffer)
5769		err = &smithy.DeserializationError{
5770			Err:      fmt.Errorf("failed to decode response body, %w", err),
5771			Snapshot: snapshot.Bytes(),
5772		}
5773		return out, metadata, err
5774	}
5775
5776	err = awsAwsjson11_deserializeOpDocumentListResolverRulesOutput(&output, shape)
5777	if err != nil {
5778		var snapshot bytes.Buffer
5779		io.Copy(&snapshot, ringBuffer)
5780		err = &smithy.DeserializationError{
5781			Err:      fmt.Errorf("failed to decode response body, %w", err),
5782			Snapshot: snapshot.Bytes(),
5783		}
5784		return out, metadata, err
5785	}
5786
5787	return out, metadata, err
5788}
5789
5790func awsAwsjson11_deserializeOpErrorListResolverRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5791	var errorBuffer bytes.Buffer
5792	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5793		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5794	}
5795	errorBody := bytes.NewReader(errorBuffer.Bytes())
5796
5797	errorCode := "UnknownError"
5798	errorMessage := errorCode
5799
5800	code := response.Header.Get("X-Amzn-ErrorType")
5801	if len(code) != 0 {
5802		errorCode = restjson.SanitizeErrorCode(code)
5803	}
5804
5805	var buff [1024]byte
5806	ringBuffer := smithyio.NewRingBuffer(buff[:])
5807
5808	body := io.TeeReader(errorBody, ringBuffer)
5809	decoder := json.NewDecoder(body)
5810	decoder.UseNumber()
5811	code, message, err := restjson.GetErrorInfo(decoder)
5812	if err != nil {
5813		var snapshot bytes.Buffer
5814		io.Copy(&snapshot, ringBuffer)
5815		err = &smithy.DeserializationError{
5816			Err:      fmt.Errorf("failed to decode response body, %w", err),
5817			Snapshot: snapshot.Bytes(),
5818		}
5819		return err
5820	}
5821
5822	errorBody.Seek(0, io.SeekStart)
5823	if len(code) != 0 {
5824		errorCode = restjson.SanitizeErrorCode(code)
5825	}
5826	if len(message) != 0 {
5827		errorMessage = message
5828	}
5829
5830	switch {
5831	case strings.EqualFold("InternalServiceErrorException", errorCode):
5832		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5833
5834	case strings.EqualFold("InvalidNextTokenException", errorCode):
5835		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5836
5837	case strings.EqualFold("InvalidParameterException", errorCode):
5838		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5839
5840	case strings.EqualFold("InvalidRequestException", errorCode):
5841		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5842
5843	case strings.EqualFold("ThrottlingException", errorCode):
5844		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5845
5846	default:
5847		genericError := &smithy.GenericAPIError{
5848			Code:    errorCode,
5849			Message: errorMessage,
5850		}
5851		return genericError
5852
5853	}
5854}
5855
5856type awsAwsjson11_deserializeOpListTagsForResource struct {
5857}
5858
5859func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
5860	return "OperationDeserializer"
5861}
5862
5863func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5864	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5865) {
5866	out, metadata, err = next.HandleDeserialize(ctx, in)
5867	if err != nil {
5868		return out, metadata, err
5869	}
5870
5871	response, ok := out.RawResponse.(*smithyhttp.Response)
5872	if !ok {
5873		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5874	}
5875
5876	if response.StatusCode < 200 || response.StatusCode >= 300 {
5877		return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
5878	}
5879	output := &ListTagsForResourceOutput{}
5880	out.Result = output
5881
5882	var buff [1024]byte
5883	ringBuffer := smithyio.NewRingBuffer(buff[:])
5884
5885	body := io.TeeReader(response.Body, ringBuffer)
5886	decoder := json.NewDecoder(body)
5887	decoder.UseNumber()
5888	var shape interface{}
5889	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5890		var snapshot bytes.Buffer
5891		io.Copy(&snapshot, ringBuffer)
5892		err = &smithy.DeserializationError{
5893			Err:      fmt.Errorf("failed to decode response body, %w", err),
5894			Snapshot: snapshot.Bytes(),
5895		}
5896		return out, metadata, err
5897	}
5898
5899	err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
5900	if err != nil {
5901		var snapshot bytes.Buffer
5902		io.Copy(&snapshot, ringBuffer)
5903		err = &smithy.DeserializationError{
5904			Err:      fmt.Errorf("failed to decode response body, %w", err),
5905			Snapshot: snapshot.Bytes(),
5906		}
5907		return out, metadata, err
5908	}
5909
5910	return out, metadata, err
5911}
5912
5913func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5914	var errorBuffer bytes.Buffer
5915	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5916		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5917	}
5918	errorBody := bytes.NewReader(errorBuffer.Bytes())
5919
5920	errorCode := "UnknownError"
5921	errorMessage := errorCode
5922
5923	code := response.Header.Get("X-Amzn-ErrorType")
5924	if len(code) != 0 {
5925		errorCode = restjson.SanitizeErrorCode(code)
5926	}
5927
5928	var buff [1024]byte
5929	ringBuffer := smithyio.NewRingBuffer(buff[:])
5930
5931	body := io.TeeReader(errorBody, ringBuffer)
5932	decoder := json.NewDecoder(body)
5933	decoder.UseNumber()
5934	code, message, err := restjson.GetErrorInfo(decoder)
5935	if err != nil {
5936		var snapshot bytes.Buffer
5937		io.Copy(&snapshot, ringBuffer)
5938		err = &smithy.DeserializationError{
5939			Err:      fmt.Errorf("failed to decode response body, %w", err),
5940			Snapshot: snapshot.Bytes(),
5941		}
5942		return err
5943	}
5944
5945	errorBody.Seek(0, io.SeekStart)
5946	if len(code) != 0 {
5947		errorCode = restjson.SanitizeErrorCode(code)
5948	}
5949	if len(message) != 0 {
5950		errorMessage = message
5951	}
5952
5953	switch {
5954	case strings.EqualFold("InternalServiceErrorException", errorCode):
5955		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
5956
5957	case strings.EqualFold("InvalidNextTokenException", errorCode):
5958		return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody)
5959
5960	case strings.EqualFold("InvalidParameterException", errorCode):
5961		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
5962
5963	case strings.EqualFold("InvalidRequestException", errorCode):
5964		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
5965
5966	case strings.EqualFold("ResourceNotFoundException", errorCode):
5967		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5968
5969	case strings.EqualFold("ThrottlingException", errorCode):
5970		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
5971
5972	default:
5973		genericError := &smithy.GenericAPIError{
5974			Code:    errorCode,
5975			Message: errorMessage,
5976		}
5977		return genericError
5978
5979	}
5980}
5981
5982type awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy struct {
5983}
5984
5985func (*awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy) ID() string {
5986	return "OperationDeserializer"
5987}
5988
5989func (m *awsAwsjson11_deserializeOpPutFirewallRuleGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5990	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5991) {
5992	out, metadata, err = next.HandleDeserialize(ctx, in)
5993	if err != nil {
5994		return out, metadata, err
5995	}
5996
5997	response, ok := out.RawResponse.(*smithyhttp.Response)
5998	if !ok {
5999		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6000	}
6001
6002	if response.StatusCode < 200 || response.StatusCode >= 300 {
6003		return out, metadata, awsAwsjson11_deserializeOpErrorPutFirewallRuleGroupPolicy(response, &metadata)
6004	}
6005	output := &PutFirewallRuleGroupPolicyOutput{}
6006	out.Result = output
6007
6008	var buff [1024]byte
6009	ringBuffer := smithyio.NewRingBuffer(buff[:])
6010
6011	body := io.TeeReader(response.Body, ringBuffer)
6012	decoder := json.NewDecoder(body)
6013	decoder.UseNumber()
6014	var shape interface{}
6015	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6016		var snapshot bytes.Buffer
6017		io.Copy(&snapshot, ringBuffer)
6018		err = &smithy.DeserializationError{
6019			Err:      fmt.Errorf("failed to decode response body, %w", err),
6020			Snapshot: snapshot.Bytes(),
6021		}
6022		return out, metadata, err
6023	}
6024
6025	err = awsAwsjson11_deserializeOpDocumentPutFirewallRuleGroupPolicyOutput(&output, shape)
6026	if err != nil {
6027		var snapshot bytes.Buffer
6028		io.Copy(&snapshot, ringBuffer)
6029		err = &smithy.DeserializationError{
6030			Err:      fmt.Errorf("failed to decode response body, %w", err),
6031			Snapshot: snapshot.Bytes(),
6032		}
6033		return out, metadata, err
6034	}
6035
6036	return out, metadata, err
6037}
6038
6039func awsAwsjson11_deserializeOpErrorPutFirewallRuleGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6040	var errorBuffer bytes.Buffer
6041	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6042		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6043	}
6044	errorBody := bytes.NewReader(errorBuffer.Bytes())
6045
6046	errorCode := "UnknownError"
6047	errorMessage := errorCode
6048
6049	code := response.Header.Get("X-Amzn-ErrorType")
6050	if len(code) != 0 {
6051		errorCode = restjson.SanitizeErrorCode(code)
6052	}
6053
6054	var buff [1024]byte
6055	ringBuffer := smithyio.NewRingBuffer(buff[:])
6056
6057	body := io.TeeReader(errorBody, ringBuffer)
6058	decoder := json.NewDecoder(body)
6059	decoder.UseNumber()
6060	code, message, err := restjson.GetErrorInfo(decoder)
6061	if err != nil {
6062		var snapshot bytes.Buffer
6063		io.Copy(&snapshot, ringBuffer)
6064		err = &smithy.DeserializationError{
6065			Err:      fmt.Errorf("failed to decode response body, %w", err),
6066			Snapshot: snapshot.Bytes(),
6067		}
6068		return err
6069	}
6070
6071	errorBody.Seek(0, io.SeekStart)
6072	if len(code) != 0 {
6073		errorCode = restjson.SanitizeErrorCode(code)
6074	}
6075	if len(message) != 0 {
6076		errorMessage = message
6077	}
6078
6079	switch {
6080	case strings.EqualFold("AccessDeniedException", errorCode):
6081		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6082
6083	case strings.EqualFold("InternalServiceErrorException", errorCode):
6084		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6085
6086	case strings.EqualFold("ResourceNotFoundException", errorCode):
6087		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6088
6089	case strings.EqualFold("ThrottlingException", errorCode):
6090		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6091
6092	case strings.EqualFold("ValidationException", errorCode):
6093		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
6094
6095	default:
6096		genericError := &smithy.GenericAPIError{
6097			Code:    errorCode,
6098			Message: errorMessage,
6099		}
6100		return genericError
6101
6102	}
6103}
6104
6105type awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy struct {
6106}
6107
6108func (*awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy) ID() string {
6109	return "OperationDeserializer"
6110}
6111
6112func (m *awsAwsjson11_deserializeOpPutResolverQueryLogConfigPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6113	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6114) {
6115	out, metadata, err = next.HandleDeserialize(ctx, in)
6116	if err != nil {
6117		return out, metadata, err
6118	}
6119
6120	response, ok := out.RawResponse.(*smithyhttp.Response)
6121	if !ok {
6122		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6123	}
6124
6125	if response.StatusCode < 200 || response.StatusCode >= 300 {
6126		return out, metadata, awsAwsjson11_deserializeOpErrorPutResolverQueryLogConfigPolicy(response, &metadata)
6127	}
6128	output := &PutResolverQueryLogConfigPolicyOutput{}
6129	out.Result = output
6130
6131	var buff [1024]byte
6132	ringBuffer := smithyio.NewRingBuffer(buff[:])
6133
6134	body := io.TeeReader(response.Body, ringBuffer)
6135	decoder := json.NewDecoder(body)
6136	decoder.UseNumber()
6137	var shape interface{}
6138	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6139		var snapshot bytes.Buffer
6140		io.Copy(&snapshot, ringBuffer)
6141		err = &smithy.DeserializationError{
6142			Err:      fmt.Errorf("failed to decode response body, %w", err),
6143			Snapshot: snapshot.Bytes(),
6144		}
6145		return out, metadata, err
6146	}
6147
6148	err = awsAwsjson11_deserializeOpDocumentPutResolverQueryLogConfigPolicyOutput(&output, shape)
6149	if err != nil {
6150		var snapshot bytes.Buffer
6151		io.Copy(&snapshot, ringBuffer)
6152		err = &smithy.DeserializationError{
6153			Err:      fmt.Errorf("failed to decode response body, %w", err),
6154			Snapshot: snapshot.Bytes(),
6155		}
6156		return out, metadata, err
6157	}
6158
6159	return out, metadata, err
6160}
6161
6162func awsAwsjson11_deserializeOpErrorPutResolverQueryLogConfigPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6163	var errorBuffer bytes.Buffer
6164	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6165		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6166	}
6167	errorBody := bytes.NewReader(errorBuffer.Bytes())
6168
6169	errorCode := "UnknownError"
6170	errorMessage := errorCode
6171
6172	code := response.Header.Get("X-Amzn-ErrorType")
6173	if len(code) != 0 {
6174		errorCode = restjson.SanitizeErrorCode(code)
6175	}
6176
6177	var buff [1024]byte
6178	ringBuffer := smithyio.NewRingBuffer(buff[:])
6179
6180	body := io.TeeReader(errorBody, ringBuffer)
6181	decoder := json.NewDecoder(body)
6182	decoder.UseNumber()
6183	code, message, err := restjson.GetErrorInfo(decoder)
6184	if err != nil {
6185		var snapshot bytes.Buffer
6186		io.Copy(&snapshot, ringBuffer)
6187		err = &smithy.DeserializationError{
6188			Err:      fmt.Errorf("failed to decode response body, %w", err),
6189			Snapshot: snapshot.Bytes(),
6190		}
6191		return err
6192	}
6193
6194	errorBody.Seek(0, io.SeekStart)
6195	if len(code) != 0 {
6196		errorCode = restjson.SanitizeErrorCode(code)
6197	}
6198	if len(message) != 0 {
6199		errorMessage = message
6200	}
6201
6202	switch {
6203	case strings.EqualFold("AccessDeniedException", errorCode):
6204		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6205
6206	case strings.EqualFold("InternalServiceErrorException", errorCode):
6207		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6208
6209	case strings.EqualFold("InvalidParameterException", errorCode):
6210		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6211
6212	case strings.EqualFold("InvalidPolicyDocument", errorCode):
6213		return awsAwsjson11_deserializeErrorInvalidPolicyDocument(response, errorBody)
6214
6215	case strings.EqualFold("InvalidRequestException", errorCode):
6216		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
6217
6218	case strings.EqualFold("UnknownResourceException", errorCode):
6219		return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody)
6220
6221	default:
6222		genericError := &smithy.GenericAPIError{
6223			Code:    errorCode,
6224			Message: errorMessage,
6225		}
6226		return genericError
6227
6228	}
6229}
6230
6231type awsAwsjson11_deserializeOpPutResolverRulePolicy struct {
6232}
6233
6234func (*awsAwsjson11_deserializeOpPutResolverRulePolicy) ID() string {
6235	return "OperationDeserializer"
6236}
6237
6238func (m *awsAwsjson11_deserializeOpPutResolverRulePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6239	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6240) {
6241	out, metadata, err = next.HandleDeserialize(ctx, in)
6242	if err != nil {
6243		return out, metadata, err
6244	}
6245
6246	response, ok := out.RawResponse.(*smithyhttp.Response)
6247	if !ok {
6248		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6249	}
6250
6251	if response.StatusCode < 200 || response.StatusCode >= 300 {
6252		return out, metadata, awsAwsjson11_deserializeOpErrorPutResolverRulePolicy(response, &metadata)
6253	}
6254	output := &PutResolverRulePolicyOutput{}
6255	out.Result = output
6256
6257	var buff [1024]byte
6258	ringBuffer := smithyio.NewRingBuffer(buff[:])
6259
6260	body := io.TeeReader(response.Body, ringBuffer)
6261	decoder := json.NewDecoder(body)
6262	decoder.UseNumber()
6263	var shape interface{}
6264	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6265		var snapshot bytes.Buffer
6266		io.Copy(&snapshot, ringBuffer)
6267		err = &smithy.DeserializationError{
6268			Err:      fmt.Errorf("failed to decode response body, %w", err),
6269			Snapshot: snapshot.Bytes(),
6270		}
6271		return out, metadata, err
6272	}
6273
6274	err = awsAwsjson11_deserializeOpDocumentPutResolverRulePolicyOutput(&output, shape)
6275	if err != nil {
6276		var snapshot bytes.Buffer
6277		io.Copy(&snapshot, ringBuffer)
6278		err = &smithy.DeserializationError{
6279			Err:      fmt.Errorf("failed to decode response body, %w", err),
6280			Snapshot: snapshot.Bytes(),
6281		}
6282		return out, metadata, err
6283	}
6284
6285	return out, metadata, err
6286}
6287
6288func awsAwsjson11_deserializeOpErrorPutResolverRulePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6289	var errorBuffer bytes.Buffer
6290	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6291		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6292	}
6293	errorBody := bytes.NewReader(errorBuffer.Bytes())
6294
6295	errorCode := "UnknownError"
6296	errorMessage := errorCode
6297
6298	code := response.Header.Get("X-Amzn-ErrorType")
6299	if len(code) != 0 {
6300		errorCode = restjson.SanitizeErrorCode(code)
6301	}
6302
6303	var buff [1024]byte
6304	ringBuffer := smithyio.NewRingBuffer(buff[:])
6305
6306	body := io.TeeReader(errorBody, ringBuffer)
6307	decoder := json.NewDecoder(body)
6308	decoder.UseNumber()
6309	code, message, err := restjson.GetErrorInfo(decoder)
6310	if err != nil {
6311		var snapshot bytes.Buffer
6312		io.Copy(&snapshot, ringBuffer)
6313		err = &smithy.DeserializationError{
6314			Err:      fmt.Errorf("failed to decode response body, %w", err),
6315			Snapshot: snapshot.Bytes(),
6316		}
6317		return err
6318	}
6319
6320	errorBody.Seek(0, io.SeekStart)
6321	if len(code) != 0 {
6322		errorCode = restjson.SanitizeErrorCode(code)
6323	}
6324	if len(message) != 0 {
6325		errorMessage = message
6326	}
6327
6328	switch {
6329	case strings.EqualFold("InternalServiceErrorException", errorCode):
6330		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6331
6332	case strings.EqualFold("InvalidParameterException", errorCode):
6333		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6334
6335	case strings.EqualFold("InvalidPolicyDocument", errorCode):
6336		return awsAwsjson11_deserializeErrorInvalidPolicyDocument(response, errorBody)
6337
6338	case strings.EqualFold("UnknownResourceException", errorCode):
6339		return awsAwsjson11_deserializeErrorUnknownResourceException(response, errorBody)
6340
6341	default:
6342		genericError := &smithy.GenericAPIError{
6343			Code:    errorCode,
6344			Message: errorMessage,
6345		}
6346		return genericError
6347
6348	}
6349}
6350
6351type awsAwsjson11_deserializeOpTagResource struct {
6352}
6353
6354func (*awsAwsjson11_deserializeOpTagResource) ID() string {
6355	return "OperationDeserializer"
6356}
6357
6358func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6359	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6360) {
6361	out, metadata, err = next.HandleDeserialize(ctx, in)
6362	if err != nil {
6363		return out, metadata, err
6364	}
6365
6366	response, ok := out.RawResponse.(*smithyhttp.Response)
6367	if !ok {
6368		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6369	}
6370
6371	if response.StatusCode < 200 || response.StatusCode >= 300 {
6372		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
6373	}
6374	output := &TagResourceOutput{}
6375	out.Result = output
6376
6377	var buff [1024]byte
6378	ringBuffer := smithyio.NewRingBuffer(buff[:])
6379
6380	body := io.TeeReader(response.Body, ringBuffer)
6381	decoder := json.NewDecoder(body)
6382	decoder.UseNumber()
6383	var shape interface{}
6384	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6385		var snapshot bytes.Buffer
6386		io.Copy(&snapshot, ringBuffer)
6387		err = &smithy.DeserializationError{
6388			Err:      fmt.Errorf("failed to decode response body, %w", err),
6389			Snapshot: snapshot.Bytes(),
6390		}
6391		return out, metadata, err
6392	}
6393
6394	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
6395	if err != nil {
6396		var snapshot bytes.Buffer
6397		io.Copy(&snapshot, ringBuffer)
6398		err = &smithy.DeserializationError{
6399			Err:      fmt.Errorf("failed to decode response body, %w", err),
6400			Snapshot: snapshot.Bytes(),
6401		}
6402		return out, metadata, err
6403	}
6404
6405	return out, metadata, err
6406}
6407
6408func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6409	var errorBuffer bytes.Buffer
6410	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6411		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6412	}
6413	errorBody := bytes.NewReader(errorBuffer.Bytes())
6414
6415	errorCode := "UnknownError"
6416	errorMessage := errorCode
6417
6418	code := response.Header.Get("X-Amzn-ErrorType")
6419	if len(code) != 0 {
6420		errorCode = restjson.SanitizeErrorCode(code)
6421	}
6422
6423	var buff [1024]byte
6424	ringBuffer := smithyio.NewRingBuffer(buff[:])
6425
6426	body := io.TeeReader(errorBody, ringBuffer)
6427	decoder := json.NewDecoder(body)
6428	decoder.UseNumber()
6429	code, message, err := restjson.GetErrorInfo(decoder)
6430	if err != nil {
6431		var snapshot bytes.Buffer
6432		io.Copy(&snapshot, ringBuffer)
6433		err = &smithy.DeserializationError{
6434			Err:      fmt.Errorf("failed to decode response body, %w", err),
6435			Snapshot: snapshot.Bytes(),
6436		}
6437		return err
6438	}
6439
6440	errorBody.Seek(0, io.SeekStart)
6441	if len(code) != 0 {
6442		errorCode = restjson.SanitizeErrorCode(code)
6443	}
6444	if len(message) != 0 {
6445		errorMessage = message
6446	}
6447
6448	switch {
6449	case strings.EqualFold("InternalServiceErrorException", errorCode):
6450		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6451
6452	case strings.EqualFold("InvalidParameterException", errorCode):
6453		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6454
6455	case strings.EqualFold("InvalidRequestException", errorCode):
6456		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
6457
6458	case strings.EqualFold("InvalidTagException", errorCode):
6459		return awsAwsjson11_deserializeErrorInvalidTagException(response, errorBody)
6460
6461	case strings.EqualFold("LimitExceededException", errorCode):
6462		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
6463
6464	case strings.EqualFold("ResourceNotFoundException", errorCode):
6465		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6466
6467	case strings.EqualFold("ThrottlingException", errorCode):
6468		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6469
6470	default:
6471		genericError := &smithy.GenericAPIError{
6472			Code:    errorCode,
6473			Message: errorMessage,
6474		}
6475		return genericError
6476
6477	}
6478}
6479
6480type awsAwsjson11_deserializeOpUntagResource struct {
6481}
6482
6483func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
6484	return "OperationDeserializer"
6485}
6486
6487func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6488	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6489) {
6490	out, metadata, err = next.HandleDeserialize(ctx, in)
6491	if err != nil {
6492		return out, metadata, err
6493	}
6494
6495	response, ok := out.RawResponse.(*smithyhttp.Response)
6496	if !ok {
6497		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6498	}
6499
6500	if response.StatusCode < 200 || response.StatusCode >= 300 {
6501		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
6502	}
6503	output := &UntagResourceOutput{}
6504	out.Result = output
6505
6506	var buff [1024]byte
6507	ringBuffer := smithyio.NewRingBuffer(buff[:])
6508
6509	body := io.TeeReader(response.Body, ringBuffer)
6510	decoder := json.NewDecoder(body)
6511	decoder.UseNumber()
6512	var shape interface{}
6513	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6514		var snapshot bytes.Buffer
6515		io.Copy(&snapshot, ringBuffer)
6516		err = &smithy.DeserializationError{
6517			Err:      fmt.Errorf("failed to decode response body, %w", err),
6518			Snapshot: snapshot.Bytes(),
6519		}
6520		return out, metadata, err
6521	}
6522
6523	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
6524	if err != nil {
6525		var snapshot bytes.Buffer
6526		io.Copy(&snapshot, ringBuffer)
6527		err = &smithy.DeserializationError{
6528			Err:      fmt.Errorf("failed to decode response body, %w", err),
6529			Snapshot: snapshot.Bytes(),
6530		}
6531		return out, metadata, err
6532	}
6533
6534	return out, metadata, err
6535}
6536
6537func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6538	var errorBuffer bytes.Buffer
6539	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6540		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6541	}
6542	errorBody := bytes.NewReader(errorBuffer.Bytes())
6543
6544	errorCode := "UnknownError"
6545	errorMessage := errorCode
6546
6547	code := response.Header.Get("X-Amzn-ErrorType")
6548	if len(code) != 0 {
6549		errorCode = restjson.SanitizeErrorCode(code)
6550	}
6551
6552	var buff [1024]byte
6553	ringBuffer := smithyio.NewRingBuffer(buff[:])
6554
6555	body := io.TeeReader(errorBody, ringBuffer)
6556	decoder := json.NewDecoder(body)
6557	decoder.UseNumber()
6558	code, message, err := restjson.GetErrorInfo(decoder)
6559	if err != nil {
6560		var snapshot bytes.Buffer
6561		io.Copy(&snapshot, ringBuffer)
6562		err = &smithy.DeserializationError{
6563			Err:      fmt.Errorf("failed to decode response body, %w", err),
6564			Snapshot: snapshot.Bytes(),
6565		}
6566		return err
6567	}
6568
6569	errorBody.Seek(0, io.SeekStart)
6570	if len(code) != 0 {
6571		errorCode = restjson.SanitizeErrorCode(code)
6572	}
6573	if len(message) != 0 {
6574		errorMessage = message
6575	}
6576
6577	switch {
6578	case strings.EqualFold("InternalServiceErrorException", errorCode):
6579		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6580
6581	case strings.EqualFold("InvalidParameterException", errorCode):
6582		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
6583
6584	case strings.EqualFold("InvalidRequestException", errorCode):
6585		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
6586
6587	case strings.EqualFold("ResourceNotFoundException", errorCode):
6588		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6589
6590	case strings.EqualFold("ThrottlingException", errorCode):
6591		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6592
6593	default:
6594		genericError := &smithy.GenericAPIError{
6595			Code:    errorCode,
6596			Message: errorMessage,
6597		}
6598		return genericError
6599
6600	}
6601}
6602
6603type awsAwsjson11_deserializeOpUpdateFirewallConfig struct {
6604}
6605
6606func (*awsAwsjson11_deserializeOpUpdateFirewallConfig) ID() string {
6607	return "OperationDeserializer"
6608}
6609
6610func (m *awsAwsjson11_deserializeOpUpdateFirewallConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6611	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6612) {
6613	out, metadata, err = next.HandleDeserialize(ctx, in)
6614	if err != nil {
6615		return out, metadata, err
6616	}
6617
6618	response, ok := out.RawResponse.(*smithyhttp.Response)
6619	if !ok {
6620		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6621	}
6622
6623	if response.StatusCode < 200 || response.StatusCode >= 300 {
6624		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallConfig(response, &metadata)
6625	}
6626	output := &UpdateFirewallConfigOutput{}
6627	out.Result = output
6628
6629	var buff [1024]byte
6630	ringBuffer := smithyio.NewRingBuffer(buff[:])
6631
6632	body := io.TeeReader(response.Body, ringBuffer)
6633	decoder := json.NewDecoder(body)
6634	decoder.UseNumber()
6635	var shape interface{}
6636	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6637		var snapshot bytes.Buffer
6638		io.Copy(&snapshot, ringBuffer)
6639		err = &smithy.DeserializationError{
6640			Err:      fmt.Errorf("failed to decode response body, %w", err),
6641			Snapshot: snapshot.Bytes(),
6642		}
6643		return out, metadata, err
6644	}
6645
6646	err = awsAwsjson11_deserializeOpDocumentUpdateFirewallConfigOutput(&output, shape)
6647	if err != nil {
6648		var snapshot bytes.Buffer
6649		io.Copy(&snapshot, ringBuffer)
6650		err = &smithy.DeserializationError{
6651			Err:      fmt.Errorf("failed to decode response body, %w", err),
6652			Snapshot: snapshot.Bytes(),
6653		}
6654		return out, metadata, err
6655	}
6656
6657	return out, metadata, err
6658}
6659
6660func awsAwsjson11_deserializeOpErrorUpdateFirewallConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6661	var errorBuffer bytes.Buffer
6662	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6663		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6664	}
6665	errorBody := bytes.NewReader(errorBuffer.Bytes())
6666
6667	errorCode := "UnknownError"
6668	errorMessage := errorCode
6669
6670	code := response.Header.Get("X-Amzn-ErrorType")
6671	if len(code) != 0 {
6672		errorCode = restjson.SanitizeErrorCode(code)
6673	}
6674
6675	var buff [1024]byte
6676	ringBuffer := smithyio.NewRingBuffer(buff[:])
6677
6678	body := io.TeeReader(errorBody, ringBuffer)
6679	decoder := json.NewDecoder(body)
6680	decoder.UseNumber()
6681	code, message, err := restjson.GetErrorInfo(decoder)
6682	if err != nil {
6683		var snapshot bytes.Buffer
6684		io.Copy(&snapshot, ringBuffer)
6685		err = &smithy.DeserializationError{
6686			Err:      fmt.Errorf("failed to decode response body, %w", err),
6687			Snapshot: snapshot.Bytes(),
6688		}
6689		return err
6690	}
6691
6692	errorBody.Seek(0, io.SeekStart)
6693	if len(code) != 0 {
6694		errorCode = restjson.SanitizeErrorCode(code)
6695	}
6696	if len(message) != 0 {
6697		errorMessage = message
6698	}
6699
6700	switch {
6701	case strings.EqualFold("AccessDeniedException", errorCode):
6702		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6703
6704	case strings.EqualFold("InternalServiceErrorException", errorCode):
6705		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6706
6707	case strings.EqualFold("ResourceNotFoundException", errorCode):
6708		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6709
6710	case strings.EqualFold("ThrottlingException", errorCode):
6711		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6712
6713	case strings.EqualFold("ValidationException", errorCode):
6714		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
6715
6716	default:
6717		genericError := &smithy.GenericAPIError{
6718			Code:    errorCode,
6719			Message: errorMessage,
6720		}
6721		return genericError
6722
6723	}
6724}
6725
6726type awsAwsjson11_deserializeOpUpdateFirewallDomains struct {
6727}
6728
6729func (*awsAwsjson11_deserializeOpUpdateFirewallDomains) ID() string {
6730	return "OperationDeserializer"
6731}
6732
6733func (m *awsAwsjson11_deserializeOpUpdateFirewallDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6734	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6735) {
6736	out, metadata, err = next.HandleDeserialize(ctx, in)
6737	if err != nil {
6738		return out, metadata, err
6739	}
6740
6741	response, ok := out.RawResponse.(*smithyhttp.Response)
6742	if !ok {
6743		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6744	}
6745
6746	if response.StatusCode < 200 || response.StatusCode >= 300 {
6747		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallDomains(response, &metadata)
6748	}
6749	output := &UpdateFirewallDomainsOutput{}
6750	out.Result = output
6751
6752	var buff [1024]byte
6753	ringBuffer := smithyio.NewRingBuffer(buff[:])
6754
6755	body := io.TeeReader(response.Body, ringBuffer)
6756	decoder := json.NewDecoder(body)
6757	decoder.UseNumber()
6758	var shape interface{}
6759	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6760		var snapshot bytes.Buffer
6761		io.Copy(&snapshot, ringBuffer)
6762		err = &smithy.DeserializationError{
6763			Err:      fmt.Errorf("failed to decode response body, %w", err),
6764			Snapshot: snapshot.Bytes(),
6765		}
6766		return out, metadata, err
6767	}
6768
6769	err = awsAwsjson11_deserializeOpDocumentUpdateFirewallDomainsOutput(&output, shape)
6770	if err != nil {
6771		var snapshot bytes.Buffer
6772		io.Copy(&snapshot, ringBuffer)
6773		err = &smithy.DeserializationError{
6774			Err:      fmt.Errorf("failed to decode response body, %w", err),
6775			Snapshot: snapshot.Bytes(),
6776		}
6777		return out, metadata, err
6778	}
6779
6780	return out, metadata, err
6781}
6782
6783func awsAwsjson11_deserializeOpErrorUpdateFirewallDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6784	var errorBuffer bytes.Buffer
6785	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6786		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6787	}
6788	errorBody := bytes.NewReader(errorBuffer.Bytes())
6789
6790	errorCode := "UnknownError"
6791	errorMessage := errorCode
6792
6793	code := response.Header.Get("X-Amzn-ErrorType")
6794	if len(code) != 0 {
6795		errorCode = restjson.SanitizeErrorCode(code)
6796	}
6797
6798	var buff [1024]byte
6799	ringBuffer := smithyio.NewRingBuffer(buff[:])
6800
6801	body := io.TeeReader(errorBody, ringBuffer)
6802	decoder := json.NewDecoder(body)
6803	decoder.UseNumber()
6804	code, message, err := restjson.GetErrorInfo(decoder)
6805	if err != nil {
6806		var snapshot bytes.Buffer
6807		io.Copy(&snapshot, ringBuffer)
6808		err = &smithy.DeserializationError{
6809			Err:      fmt.Errorf("failed to decode response body, %w", err),
6810			Snapshot: snapshot.Bytes(),
6811		}
6812		return err
6813	}
6814
6815	errorBody.Seek(0, io.SeekStart)
6816	if len(code) != 0 {
6817		errorCode = restjson.SanitizeErrorCode(code)
6818	}
6819	if len(message) != 0 {
6820		errorMessage = message
6821	}
6822
6823	switch {
6824	case strings.EqualFold("AccessDeniedException", errorCode):
6825		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6826
6827	case strings.EqualFold("ConflictException", errorCode):
6828		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
6829
6830	case strings.EqualFold("InternalServiceErrorException", errorCode):
6831		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6832
6833	case strings.EqualFold("LimitExceededException", errorCode):
6834		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
6835
6836	case strings.EqualFold("ResourceNotFoundException", errorCode):
6837		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6838
6839	case strings.EqualFold("ThrottlingException", errorCode):
6840		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6841
6842	case strings.EqualFold("ValidationException", errorCode):
6843		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
6844
6845	default:
6846		genericError := &smithy.GenericAPIError{
6847			Code:    errorCode,
6848			Message: errorMessage,
6849		}
6850		return genericError
6851
6852	}
6853}
6854
6855type awsAwsjson11_deserializeOpUpdateFirewallRule struct {
6856}
6857
6858func (*awsAwsjson11_deserializeOpUpdateFirewallRule) ID() string {
6859	return "OperationDeserializer"
6860}
6861
6862func (m *awsAwsjson11_deserializeOpUpdateFirewallRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6863	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6864) {
6865	out, metadata, err = next.HandleDeserialize(ctx, in)
6866	if err != nil {
6867		return out, metadata, err
6868	}
6869
6870	response, ok := out.RawResponse.(*smithyhttp.Response)
6871	if !ok {
6872		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6873	}
6874
6875	if response.StatusCode < 200 || response.StatusCode >= 300 {
6876		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallRule(response, &metadata)
6877	}
6878	output := &UpdateFirewallRuleOutput{}
6879	out.Result = output
6880
6881	var buff [1024]byte
6882	ringBuffer := smithyio.NewRingBuffer(buff[:])
6883
6884	body := io.TeeReader(response.Body, ringBuffer)
6885	decoder := json.NewDecoder(body)
6886	decoder.UseNumber()
6887	var shape interface{}
6888	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6889		var snapshot bytes.Buffer
6890		io.Copy(&snapshot, ringBuffer)
6891		err = &smithy.DeserializationError{
6892			Err:      fmt.Errorf("failed to decode response body, %w", err),
6893			Snapshot: snapshot.Bytes(),
6894		}
6895		return out, metadata, err
6896	}
6897
6898	err = awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleOutput(&output, shape)
6899	if err != nil {
6900		var snapshot bytes.Buffer
6901		io.Copy(&snapshot, ringBuffer)
6902		err = &smithy.DeserializationError{
6903			Err:      fmt.Errorf("failed to decode response body, %w", err),
6904			Snapshot: snapshot.Bytes(),
6905		}
6906		return out, metadata, err
6907	}
6908
6909	return out, metadata, err
6910}
6911
6912func awsAwsjson11_deserializeOpErrorUpdateFirewallRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6913	var errorBuffer bytes.Buffer
6914	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6915		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6916	}
6917	errorBody := bytes.NewReader(errorBuffer.Bytes())
6918
6919	errorCode := "UnknownError"
6920	errorMessage := errorCode
6921
6922	code := response.Header.Get("X-Amzn-ErrorType")
6923	if len(code) != 0 {
6924		errorCode = restjson.SanitizeErrorCode(code)
6925	}
6926
6927	var buff [1024]byte
6928	ringBuffer := smithyio.NewRingBuffer(buff[:])
6929
6930	body := io.TeeReader(errorBody, ringBuffer)
6931	decoder := json.NewDecoder(body)
6932	decoder.UseNumber()
6933	code, message, err := restjson.GetErrorInfo(decoder)
6934	if err != nil {
6935		var snapshot bytes.Buffer
6936		io.Copy(&snapshot, ringBuffer)
6937		err = &smithy.DeserializationError{
6938			Err:      fmt.Errorf("failed to decode response body, %w", err),
6939			Snapshot: snapshot.Bytes(),
6940		}
6941		return err
6942	}
6943
6944	errorBody.Seek(0, io.SeekStart)
6945	if len(code) != 0 {
6946		errorCode = restjson.SanitizeErrorCode(code)
6947	}
6948	if len(message) != 0 {
6949		errorMessage = message
6950	}
6951
6952	switch {
6953	case strings.EqualFold("AccessDeniedException", errorCode):
6954		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6955
6956	case strings.EqualFold("ConflictException", errorCode):
6957		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
6958
6959	case strings.EqualFold("InternalServiceErrorException", errorCode):
6960		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
6961
6962	case strings.EqualFold("ResourceNotFoundException", errorCode):
6963		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6964
6965	case strings.EqualFold("ThrottlingException", errorCode):
6966		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
6967
6968	case strings.EqualFold("ValidationException", errorCode):
6969		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
6970
6971	default:
6972		genericError := &smithy.GenericAPIError{
6973			Code:    errorCode,
6974			Message: errorMessage,
6975		}
6976		return genericError
6977
6978	}
6979}
6980
6981type awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation struct {
6982}
6983
6984func (*awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation) ID() string {
6985	return "OperationDeserializer"
6986}
6987
6988func (m *awsAwsjson11_deserializeOpUpdateFirewallRuleGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6989	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6990) {
6991	out, metadata, err = next.HandleDeserialize(ctx, in)
6992	if err != nil {
6993		return out, metadata, err
6994	}
6995
6996	response, ok := out.RawResponse.(*smithyhttp.Response)
6997	if !ok {
6998		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6999	}
7000
7001	if response.StatusCode < 200 || response.StatusCode >= 300 {
7002		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFirewallRuleGroupAssociation(response, &metadata)
7003	}
7004	output := &UpdateFirewallRuleGroupAssociationOutput{}
7005	out.Result = output
7006
7007	var buff [1024]byte
7008	ringBuffer := smithyio.NewRingBuffer(buff[:])
7009
7010	body := io.TeeReader(response.Body, ringBuffer)
7011	decoder := json.NewDecoder(body)
7012	decoder.UseNumber()
7013	var shape interface{}
7014	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7015		var snapshot bytes.Buffer
7016		io.Copy(&snapshot, ringBuffer)
7017		err = &smithy.DeserializationError{
7018			Err:      fmt.Errorf("failed to decode response body, %w", err),
7019			Snapshot: snapshot.Bytes(),
7020		}
7021		return out, metadata, err
7022	}
7023
7024	err = awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleGroupAssociationOutput(&output, shape)
7025	if err != nil {
7026		var snapshot bytes.Buffer
7027		io.Copy(&snapshot, ringBuffer)
7028		err = &smithy.DeserializationError{
7029			Err:      fmt.Errorf("failed to decode response body, %w", err),
7030			Snapshot: snapshot.Bytes(),
7031		}
7032		return out, metadata, err
7033	}
7034
7035	return out, metadata, err
7036}
7037
7038func awsAwsjson11_deserializeOpErrorUpdateFirewallRuleGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7039	var errorBuffer bytes.Buffer
7040	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7041		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7042	}
7043	errorBody := bytes.NewReader(errorBuffer.Bytes())
7044
7045	errorCode := "UnknownError"
7046	errorMessage := errorCode
7047
7048	code := response.Header.Get("X-Amzn-ErrorType")
7049	if len(code) != 0 {
7050		errorCode = restjson.SanitizeErrorCode(code)
7051	}
7052
7053	var buff [1024]byte
7054	ringBuffer := smithyio.NewRingBuffer(buff[:])
7055
7056	body := io.TeeReader(errorBody, ringBuffer)
7057	decoder := json.NewDecoder(body)
7058	decoder.UseNumber()
7059	code, message, err := restjson.GetErrorInfo(decoder)
7060	if err != nil {
7061		var snapshot bytes.Buffer
7062		io.Copy(&snapshot, ringBuffer)
7063		err = &smithy.DeserializationError{
7064			Err:      fmt.Errorf("failed to decode response body, %w", err),
7065			Snapshot: snapshot.Bytes(),
7066		}
7067		return err
7068	}
7069
7070	errorBody.Seek(0, io.SeekStart)
7071	if len(code) != 0 {
7072		errorCode = restjson.SanitizeErrorCode(code)
7073	}
7074	if len(message) != 0 {
7075		errorMessage = message
7076	}
7077
7078	switch {
7079	case strings.EqualFold("AccessDeniedException", errorCode):
7080		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7081
7082	case strings.EqualFold("ConflictException", errorCode):
7083		return awsAwsjson11_deserializeErrorConflictException(response, errorBody)
7084
7085	case strings.EqualFold("InternalServiceErrorException", errorCode):
7086		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
7087
7088	case strings.EqualFold("ResourceNotFoundException", errorCode):
7089		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7090
7091	case strings.EqualFold("ThrottlingException", errorCode):
7092		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
7093
7094	case strings.EqualFold("ValidationException", errorCode):
7095		return awsAwsjson11_deserializeErrorValidationException(response, errorBody)
7096
7097	default:
7098		genericError := &smithy.GenericAPIError{
7099			Code:    errorCode,
7100			Message: errorMessage,
7101		}
7102		return genericError
7103
7104	}
7105}
7106
7107type awsAwsjson11_deserializeOpUpdateResolverDnssecConfig struct {
7108}
7109
7110func (*awsAwsjson11_deserializeOpUpdateResolverDnssecConfig) ID() string {
7111	return "OperationDeserializer"
7112}
7113
7114func (m *awsAwsjson11_deserializeOpUpdateResolverDnssecConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7115	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7116) {
7117	out, metadata, err = next.HandleDeserialize(ctx, in)
7118	if err != nil {
7119		return out, metadata, err
7120	}
7121
7122	response, ok := out.RawResponse.(*smithyhttp.Response)
7123	if !ok {
7124		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7125	}
7126
7127	if response.StatusCode < 200 || response.StatusCode >= 300 {
7128		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverDnssecConfig(response, &metadata)
7129	}
7130	output := &UpdateResolverDnssecConfigOutput{}
7131	out.Result = output
7132
7133	var buff [1024]byte
7134	ringBuffer := smithyio.NewRingBuffer(buff[:])
7135
7136	body := io.TeeReader(response.Body, ringBuffer)
7137	decoder := json.NewDecoder(body)
7138	decoder.UseNumber()
7139	var shape interface{}
7140	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7141		var snapshot bytes.Buffer
7142		io.Copy(&snapshot, ringBuffer)
7143		err = &smithy.DeserializationError{
7144			Err:      fmt.Errorf("failed to decode response body, %w", err),
7145			Snapshot: snapshot.Bytes(),
7146		}
7147		return out, metadata, err
7148	}
7149
7150	err = awsAwsjson11_deserializeOpDocumentUpdateResolverDnssecConfigOutput(&output, shape)
7151	if err != nil {
7152		var snapshot bytes.Buffer
7153		io.Copy(&snapshot, ringBuffer)
7154		err = &smithy.DeserializationError{
7155			Err:      fmt.Errorf("failed to decode response body, %w", err),
7156			Snapshot: snapshot.Bytes(),
7157		}
7158		return out, metadata, err
7159	}
7160
7161	return out, metadata, err
7162}
7163
7164func awsAwsjson11_deserializeOpErrorUpdateResolverDnssecConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7165	var errorBuffer bytes.Buffer
7166	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7167		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7168	}
7169	errorBody := bytes.NewReader(errorBuffer.Bytes())
7170
7171	errorCode := "UnknownError"
7172	errorMessage := errorCode
7173
7174	code := response.Header.Get("X-Amzn-ErrorType")
7175	if len(code) != 0 {
7176		errorCode = restjson.SanitizeErrorCode(code)
7177	}
7178
7179	var buff [1024]byte
7180	ringBuffer := smithyio.NewRingBuffer(buff[:])
7181
7182	body := io.TeeReader(errorBody, ringBuffer)
7183	decoder := json.NewDecoder(body)
7184	decoder.UseNumber()
7185	code, message, err := restjson.GetErrorInfo(decoder)
7186	if err != nil {
7187		var snapshot bytes.Buffer
7188		io.Copy(&snapshot, ringBuffer)
7189		err = &smithy.DeserializationError{
7190			Err:      fmt.Errorf("failed to decode response body, %w", err),
7191			Snapshot: snapshot.Bytes(),
7192		}
7193		return err
7194	}
7195
7196	errorBody.Seek(0, io.SeekStart)
7197	if len(code) != 0 {
7198		errorCode = restjson.SanitizeErrorCode(code)
7199	}
7200	if len(message) != 0 {
7201		errorMessage = message
7202	}
7203
7204	switch {
7205	case strings.EqualFold("AccessDeniedException", errorCode):
7206		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
7207
7208	case strings.EqualFold("InternalServiceErrorException", errorCode):
7209		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
7210
7211	case strings.EqualFold("InvalidParameterException", errorCode):
7212		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
7213
7214	case strings.EqualFold("InvalidRequestException", errorCode):
7215		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
7216
7217	case strings.EqualFold("ResourceNotFoundException", errorCode):
7218		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7219
7220	case strings.EqualFold("ThrottlingException", errorCode):
7221		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
7222
7223	default:
7224		genericError := &smithy.GenericAPIError{
7225			Code:    errorCode,
7226			Message: errorMessage,
7227		}
7228		return genericError
7229
7230	}
7231}
7232
7233type awsAwsjson11_deserializeOpUpdateResolverEndpoint struct {
7234}
7235
7236func (*awsAwsjson11_deserializeOpUpdateResolverEndpoint) ID() string {
7237	return "OperationDeserializer"
7238}
7239
7240func (m *awsAwsjson11_deserializeOpUpdateResolverEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7241	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7242) {
7243	out, metadata, err = next.HandleDeserialize(ctx, in)
7244	if err != nil {
7245		return out, metadata, err
7246	}
7247
7248	response, ok := out.RawResponse.(*smithyhttp.Response)
7249	if !ok {
7250		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7251	}
7252
7253	if response.StatusCode < 200 || response.StatusCode >= 300 {
7254		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverEndpoint(response, &metadata)
7255	}
7256	output := &UpdateResolverEndpointOutput{}
7257	out.Result = output
7258
7259	var buff [1024]byte
7260	ringBuffer := smithyio.NewRingBuffer(buff[:])
7261
7262	body := io.TeeReader(response.Body, ringBuffer)
7263	decoder := json.NewDecoder(body)
7264	decoder.UseNumber()
7265	var shape interface{}
7266	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7267		var snapshot bytes.Buffer
7268		io.Copy(&snapshot, ringBuffer)
7269		err = &smithy.DeserializationError{
7270			Err:      fmt.Errorf("failed to decode response body, %w", err),
7271			Snapshot: snapshot.Bytes(),
7272		}
7273		return out, metadata, err
7274	}
7275
7276	err = awsAwsjson11_deserializeOpDocumentUpdateResolverEndpointOutput(&output, shape)
7277	if err != nil {
7278		var snapshot bytes.Buffer
7279		io.Copy(&snapshot, ringBuffer)
7280		err = &smithy.DeserializationError{
7281			Err:      fmt.Errorf("failed to decode response body, %w", err),
7282			Snapshot: snapshot.Bytes(),
7283		}
7284		return out, metadata, err
7285	}
7286
7287	return out, metadata, err
7288}
7289
7290func awsAwsjson11_deserializeOpErrorUpdateResolverEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7291	var errorBuffer bytes.Buffer
7292	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7293		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7294	}
7295	errorBody := bytes.NewReader(errorBuffer.Bytes())
7296
7297	errorCode := "UnknownError"
7298	errorMessage := errorCode
7299
7300	code := response.Header.Get("X-Amzn-ErrorType")
7301	if len(code) != 0 {
7302		errorCode = restjson.SanitizeErrorCode(code)
7303	}
7304
7305	var buff [1024]byte
7306	ringBuffer := smithyio.NewRingBuffer(buff[:])
7307
7308	body := io.TeeReader(errorBody, ringBuffer)
7309	decoder := json.NewDecoder(body)
7310	decoder.UseNumber()
7311	code, message, err := restjson.GetErrorInfo(decoder)
7312	if err != nil {
7313		var snapshot bytes.Buffer
7314		io.Copy(&snapshot, ringBuffer)
7315		err = &smithy.DeserializationError{
7316			Err:      fmt.Errorf("failed to decode response body, %w", err),
7317			Snapshot: snapshot.Bytes(),
7318		}
7319		return err
7320	}
7321
7322	errorBody.Seek(0, io.SeekStart)
7323	if len(code) != 0 {
7324		errorCode = restjson.SanitizeErrorCode(code)
7325	}
7326	if len(message) != 0 {
7327		errorMessage = message
7328	}
7329
7330	switch {
7331	case strings.EqualFold("InternalServiceErrorException", errorCode):
7332		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
7333
7334	case strings.EqualFold("InvalidParameterException", errorCode):
7335		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
7336
7337	case strings.EqualFold("InvalidRequestException", errorCode):
7338		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
7339
7340	case strings.EqualFold("ResourceNotFoundException", errorCode):
7341		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7342
7343	case strings.EqualFold("ThrottlingException", errorCode):
7344		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
7345
7346	default:
7347		genericError := &smithy.GenericAPIError{
7348			Code:    errorCode,
7349			Message: errorMessage,
7350		}
7351		return genericError
7352
7353	}
7354}
7355
7356type awsAwsjson11_deserializeOpUpdateResolverRule struct {
7357}
7358
7359func (*awsAwsjson11_deserializeOpUpdateResolverRule) ID() string {
7360	return "OperationDeserializer"
7361}
7362
7363func (m *awsAwsjson11_deserializeOpUpdateResolverRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7364	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7365) {
7366	out, metadata, err = next.HandleDeserialize(ctx, in)
7367	if err != nil {
7368		return out, metadata, err
7369	}
7370
7371	response, ok := out.RawResponse.(*smithyhttp.Response)
7372	if !ok {
7373		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7374	}
7375
7376	if response.StatusCode < 200 || response.StatusCode >= 300 {
7377		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateResolverRule(response, &metadata)
7378	}
7379	output := &UpdateResolverRuleOutput{}
7380	out.Result = output
7381
7382	var buff [1024]byte
7383	ringBuffer := smithyio.NewRingBuffer(buff[:])
7384
7385	body := io.TeeReader(response.Body, ringBuffer)
7386	decoder := json.NewDecoder(body)
7387	decoder.UseNumber()
7388	var shape interface{}
7389	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7390		var snapshot bytes.Buffer
7391		io.Copy(&snapshot, ringBuffer)
7392		err = &smithy.DeserializationError{
7393			Err:      fmt.Errorf("failed to decode response body, %w", err),
7394			Snapshot: snapshot.Bytes(),
7395		}
7396		return out, metadata, err
7397	}
7398
7399	err = awsAwsjson11_deserializeOpDocumentUpdateResolverRuleOutput(&output, shape)
7400	if err != nil {
7401		var snapshot bytes.Buffer
7402		io.Copy(&snapshot, ringBuffer)
7403		err = &smithy.DeserializationError{
7404			Err:      fmt.Errorf("failed to decode response body, %w", err),
7405			Snapshot: snapshot.Bytes(),
7406		}
7407		return out, metadata, err
7408	}
7409
7410	return out, metadata, err
7411}
7412
7413func awsAwsjson11_deserializeOpErrorUpdateResolverRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7414	var errorBuffer bytes.Buffer
7415	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7416		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7417	}
7418	errorBody := bytes.NewReader(errorBuffer.Bytes())
7419
7420	errorCode := "UnknownError"
7421	errorMessage := errorCode
7422
7423	code := response.Header.Get("X-Amzn-ErrorType")
7424	if len(code) != 0 {
7425		errorCode = restjson.SanitizeErrorCode(code)
7426	}
7427
7428	var buff [1024]byte
7429	ringBuffer := smithyio.NewRingBuffer(buff[:])
7430
7431	body := io.TeeReader(errorBody, ringBuffer)
7432	decoder := json.NewDecoder(body)
7433	decoder.UseNumber()
7434	code, message, err := restjson.GetErrorInfo(decoder)
7435	if err != nil {
7436		var snapshot bytes.Buffer
7437		io.Copy(&snapshot, ringBuffer)
7438		err = &smithy.DeserializationError{
7439			Err:      fmt.Errorf("failed to decode response body, %w", err),
7440			Snapshot: snapshot.Bytes(),
7441		}
7442		return err
7443	}
7444
7445	errorBody.Seek(0, io.SeekStart)
7446	if len(code) != 0 {
7447		errorCode = restjson.SanitizeErrorCode(code)
7448	}
7449	if len(message) != 0 {
7450		errorMessage = message
7451	}
7452
7453	switch {
7454	case strings.EqualFold("InternalServiceErrorException", errorCode):
7455		return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody)
7456
7457	case strings.EqualFold("InvalidParameterException", errorCode):
7458		return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody)
7459
7460	case strings.EqualFold("InvalidRequestException", errorCode):
7461		return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody)
7462
7463	case strings.EqualFold("LimitExceededException", errorCode):
7464		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
7465
7466	case strings.EqualFold("ResourceNotFoundException", errorCode):
7467		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7468
7469	case strings.EqualFold("ResourceUnavailableException", errorCode):
7470		return awsAwsjson11_deserializeErrorResourceUnavailableException(response, errorBody)
7471
7472	case strings.EqualFold("ThrottlingException", errorCode):
7473		return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody)
7474
7475	default:
7476		genericError := &smithy.GenericAPIError{
7477			Code:    errorCode,
7478			Message: errorMessage,
7479		}
7480		return genericError
7481
7482	}
7483}
7484
7485func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7486	var buff [1024]byte
7487	ringBuffer := smithyio.NewRingBuffer(buff[:])
7488
7489	body := io.TeeReader(errorBody, ringBuffer)
7490	decoder := json.NewDecoder(body)
7491	decoder.UseNumber()
7492	var shape interface{}
7493	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7494		var snapshot bytes.Buffer
7495		io.Copy(&snapshot, ringBuffer)
7496		err = &smithy.DeserializationError{
7497			Err:      fmt.Errorf("failed to decode response body, %w", err),
7498			Snapshot: snapshot.Bytes(),
7499		}
7500		return err
7501	}
7502
7503	output := &types.AccessDeniedException{}
7504	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
7505
7506	if err != nil {
7507		var snapshot bytes.Buffer
7508		io.Copy(&snapshot, ringBuffer)
7509		err = &smithy.DeserializationError{
7510			Err:      fmt.Errorf("failed to decode response body, %w", err),
7511			Snapshot: snapshot.Bytes(),
7512		}
7513		return err
7514	}
7515
7516	errorBody.Seek(0, io.SeekStart)
7517	return output
7518}
7519
7520func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7521	var buff [1024]byte
7522	ringBuffer := smithyio.NewRingBuffer(buff[:])
7523
7524	body := io.TeeReader(errorBody, ringBuffer)
7525	decoder := json.NewDecoder(body)
7526	decoder.UseNumber()
7527	var shape interface{}
7528	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7529		var snapshot bytes.Buffer
7530		io.Copy(&snapshot, ringBuffer)
7531		err = &smithy.DeserializationError{
7532			Err:      fmt.Errorf("failed to decode response body, %w", err),
7533			Snapshot: snapshot.Bytes(),
7534		}
7535		return err
7536	}
7537
7538	output := &types.ConflictException{}
7539	err := awsAwsjson11_deserializeDocumentConflictException(&output, shape)
7540
7541	if err != nil {
7542		var snapshot bytes.Buffer
7543		io.Copy(&snapshot, ringBuffer)
7544		err = &smithy.DeserializationError{
7545			Err:      fmt.Errorf("failed to decode response body, %w", err),
7546			Snapshot: snapshot.Bytes(),
7547		}
7548		return err
7549	}
7550
7551	errorBody.Seek(0, io.SeekStart)
7552	return output
7553}
7554
7555func awsAwsjson11_deserializeErrorInternalServiceErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7556	var buff [1024]byte
7557	ringBuffer := smithyio.NewRingBuffer(buff[:])
7558
7559	body := io.TeeReader(errorBody, ringBuffer)
7560	decoder := json.NewDecoder(body)
7561	decoder.UseNumber()
7562	var shape interface{}
7563	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7564		var snapshot bytes.Buffer
7565		io.Copy(&snapshot, ringBuffer)
7566		err = &smithy.DeserializationError{
7567			Err:      fmt.Errorf("failed to decode response body, %w", err),
7568			Snapshot: snapshot.Bytes(),
7569		}
7570		return err
7571	}
7572
7573	output := &types.InternalServiceErrorException{}
7574	err := awsAwsjson11_deserializeDocumentInternalServiceErrorException(&output, shape)
7575
7576	if err != nil {
7577		var snapshot bytes.Buffer
7578		io.Copy(&snapshot, ringBuffer)
7579		err = &smithy.DeserializationError{
7580			Err:      fmt.Errorf("failed to decode response body, %w", err),
7581			Snapshot: snapshot.Bytes(),
7582		}
7583		return err
7584	}
7585
7586	errorBody.Seek(0, io.SeekStart)
7587	return output
7588}
7589
7590func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7591	var buff [1024]byte
7592	ringBuffer := smithyio.NewRingBuffer(buff[:])
7593
7594	body := io.TeeReader(errorBody, ringBuffer)
7595	decoder := json.NewDecoder(body)
7596	decoder.UseNumber()
7597	var shape interface{}
7598	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7599		var snapshot bytes.Buffer
7600		io.Copy(&snapshot, ringBuffer)
7601		err = &smithy.DeserializationError{
7602			Err:      fmt.Errorf("failed to decode response body, %w", err),
7603			Snapshot: snapshot.Bytes(),
7604		}
7605		return err
7606	}
7607
7608	output := &types.InvalidNextTokenException{}
7609	err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape)
7610
7611	if err != nil {
7612		var snapshot bytes.Buffer
7613		io.Copy(&snapshot, ringBuffer)
7614		err = &smithy.DeserializationError{
7615			Err:      fmt.Errorf("failed to decode response body, %w", err),
7616			Snapshot: snapshot.Bytes(),
7617		}
7618		return err
7619	}
7620
7621	errorBody.Seek(0, io.SeekStart)
7622	return output
7623}
7624
7625func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7626	var buff [1024]byte
7627	ringBuffer := smithyio.NewRingBuffer(buff[:])
7628
7629	body := io.TeeReader(errorBody, ringBuffer)
7630	decoder := json.NewDecoder(body)
7631	decoder.UseNumber()
7632	var shape interface{}
7633	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7634		var snapshot bytes.Buffer
7635		io.Copy(&snapshot, ringBuffer)
7636		err = &smithy.DeserializationError{
7637			Err:      fmt.Errorf("failed to decode response body, %w", err),
7638			Snapshot: snapshot.Bytes(),
7639		}
7640		return err
7641	}
7642
7643	output := &types.InvalidParameterException{}
7644	err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape)
7645
7646	if err != nil {
7647		var snapshot bytes.Buffer
7648		io.Copy(&snapshot, ringBuffer)
7649		err = &smithy.DeserializationError{
7650			Err:      fmt.Errorf("failed to decode response body, %w", err),
7651			Snapshot: snapshot.Bytes(),
7652		}
7653		return err
7654	}
7655
7656	errorBody.Seek(0, io.SeekStart)
7657	return output
7658}
7659
7660func awsAwsjson11_deserializeErrorInvalidPolicyDocument(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7661	var buff [1024]byte
7662	ringBuffer := smithyio.NewRingBuffer(buff[:])
7663
7664	body := io.TeeReader(errorBody, ringBuffer)
7665	decoder := json.NewDecoder(body)
7666	decoder.UseNumber()
7667	var shape interface{}
7668	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7669		var snapshot bytes.Buffer
7670		io.Copy(&snapshot, ringBuffer)
7671		err = &smithy.DeserializationError{
7672			Err:      fmt.Errorf("failed to decode response body, %w", err),
7673			Snapshot: snapshot.Bytes(),
7674		}
7675		return err
7676	}
7677
7678	output := &types.InvalidPolicyDocument{}
7679	err := awsAwsjson11_deserializeDocumentInvalidPolicyDocument(&output, shape)
7680
7681	if err != nil {
7682		var snapshot bytes.Buffer
7683		io.Copy(&snapshot, ringBuffer)
7684		err = &smithy.DeserializationError{
7685			Err:      fmt.Errorf("failed to decode response body, %w", err),
7686			Snapshot: snapshot.Bytes(),
7687		}
7688		return err
7689	}
7690
7691	errorBody.Seek(0, io.SeekStart)
7692	return output
7693}
7694
7695func awsAwsjson11_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7696	var buff [1024]byte
7697	ringBuffer := smithyio.NewRingBuffer(buff[:])
7698
7699	body := io.TeeReader(errorBody, ringBuffer)
7700	decoder := json.NewDecoder(body)
7701	decoder.UseNumber()
7702	var shape interface{}
7703	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7704		var snapshot bytes.Buffer
7705		io.Copy(&snapshot, ringBuffer)
7706		err = &smithy.DeserializationError{
7707			Err:      fmt.Errorf("failed to decode response body, %w", err),
7708			Snapshot: snapshot.Bytes(),
7709		}
7710		return err
7711	}
7712
7713	output := &types.InvalidRequestException{}
7714	err := awsAwsjson11_deserializeDocumentInvalidRequestException(&output, shape)
7715
7716	if err != nil {
7717		var snapshot bytes.Buffer
7718		io.Copy(&snapshot, ringBuffer)
7719		err = &smithy.DeserializationError{
7720			Err:      fmt.Errorf("failed to decode response body, %w", err),
7721			Snapshot: snapshot.Bytes(),
7722		}
7723		return err
7724	}
7725
7726	errorBody.Seek(0, io.SeekStart)
7727	return output
7728}
7729
7730func awsAwsjson11_deserializeErrorInvalidTagException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7731	var buff [1024]byte
7732	ringBuffer := smithyio.NewRingBuffer(buff[:])
7733
7734	body := io.TeeReader(errorBody, ringBuffer)
7735	decoder := json.NewDecoder(body)
7736	decoder.UseNumber()
7737	var shape interface{}
7738	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7739		var snapshot bytes.Buffer
7740		io.Copy(&snapshot, ringBuffer)
7741		err = &smithy.DeserializationError{
7742			Err:      fmt.Errorf("failed to decode response body, %w", err),
7743			Snapshot: snapshot.Bytes(),
7744		}
7745		return err
7746	}
7747
7748	output := &types.InvalidTagException{}
7749	err := awsAwsjson11_deserializeDocumentInvalidTagException(&output, shape)
7750
7751	if err != nil {
7752		var snapshot bytes.Buffer
7753		io.Copy(&snapshot, ringBuffer)
7754		err = &smithy.DeserializationError{
7755			Err:      fmt.Errorf("failed to decode response body, %w", err),
7756			Snapshot: snapshot.Bytes(),
7757		}
7758		return err
7759	}
7760
7761	errorBody.Seek(0, io.SeekStart)
7762	return output
7763}
7764
7765func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7766	var buff [1024]byte
7767	ringBuffer := smithyio.NewRingBuffer(buff[:])
7768
7769	body := io.TeeReader(errorBody, ringBuffer)
7770	decoder := json.NewDecoder(body)
7771	decoder.UseNumber()
7772	var shape interface{}
7773	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7774		var snapshot bytes.Buffer
7775		io.Copy(&snapshot, ringBuffer)
7776		err = &smithy.DeserializationError{
7777			Err:      fmt.Errorf("failed to decode response body, %w", err),
7778			Snapshot: snapshot.Bytes(),
7779		}
7780		return err
7781	}
7782
7783	output := &types.LimitExceededException{}
7784	err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
7785
7786	if err != nil {
7787		var snapshot bytes.Buffer
7788		io.Copy(&snapshot, ringBuffer)
7789		err = &smithy.DeserializationError{
7790			Err:      fmt.Errorf("failed to decode response body, %w", err),
7791			Snapshot: snapshot.Bytes(),
7792		}
7793		return err
7794	}
7795
7796	errorBody.Seek(0, io.SeekStart)
7797	return output
7798}
7799
7800func awsAwsjson11_deserializeErrorResourceExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7801	var buff [1024]byte
7802	ringBuffer := smithyio.NewRingBuffer(buff[:])
7803
7804	body := io.TeeReader(errorBody, ringBuffer)
7805	decoder := json.NewDecoder(body)
7806	decoder.UseNumber()
7807	var shape interface{}
7808	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7809		var snapshot bytes.Buffer
7810		io.Copy(&snapshot, ringBuffer)
7811		err = &smithy.DeserializationError{
7812			Err:      fmt.Errorf("failed to decode response body, %w", err),
7813			Snapshot: snapshot.Bytes(),
7814		}
7815		return err
7816	}
7817
7818	output := &types.ResourceExistsException{}
7819	err := awsAwsjson11_deserializeDocumentResourceExistsException(&output, shape)
7820
7821	if err != nil {
7822		var snapshot bytes.Buffer
7823		io.Copy(&snapshot, ringBuffer)
7824		err = &smithy.DeserializationError{
7825			Err:      fmt.Errorf("failed to decode response body, %w", err),
7826			Snapshot: snapshot.Bytes(),
7827		}
7828		return err
7829	}
7830
7831	errorBody.Seek(0, io.SeekStart)
7832	return output
7833}
7834
7835func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7836	var buff [1024]byte
7837	ringBuffer := smithyio.NewRingBuffer(buff[:])
7838
7839	body := io.TeeReader(errorBody, ringBuffer)
7840	decoder := json.NewDecoder(body)
7841	decoder.UseNumber()
7842	var shape interface{}
7843	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7844		var snapshot bytes.Buffer
7845		io.Copy(&snapshot, ringBuffer)
7846		err = &smithy.DeserializationError{
7847			Err:      fmt.Errorf("failed to decode response body, %w", err),
7848			Snapshot: snapshot.Bytes(),
7849		}
7850		return err
7851	}
7852
7853	output := &types.ResourceInUseException{}
7854	err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape)
7855
7856	if err != nil {
7857		var snapshot bytes.Buffer
7858		io.Copy(&snapshot, ringBuffer)
7859		err = &smithy.DeserializationError{
7860			Err:      fmt.Errorf("failed to decode response body, %w", err),
7861			Snapshot: snapshot.Bytes(),
7862		}
7863		return err
7864	}
7865
7866	errorBody.Seek(0, io.SeekStart)
7867	return output
7868}
7869
7870func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7871	var buff [1024]byte
7872	ringBuffer := smithyio.NewRingBuffer(buff[:])
7873
7874	body := io.TeeReader(errorBody, ringBuffer)
7875	decoder := json.NewDecoder(body)
7876	decoder.UseNumber()
7877	var shape interface{}
7878	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7879		var snapshot bytes.Buffer
7880		io.Copy(&snapshot, ringBuffer)
7881		err = &smithy.DeserializationError{
7882			Err:      fmt.Errorf("failed to decode response body, %w", err),
7883			Snapshot: snapshot.Bytes(),
7884		}
7885		return err
7886	}
7887
7888	output := &types.ResourceNotFoundException{}
7889	err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape)
7890
7891	if err != nil {
7892		var snapshot bytes.Buffer
7893		io.Copy(&snapshot, ringBuffer)
7894		err = &smithy.DeserializationError{
7895			Err:      fmt.Errorf("failed to decode response body, %w", err),
7896			Snapshot: snapshot.Bytes(),
7897		}
7898		return err
7899	}
7900
7901	errorBody.Seek(0, io.SeekStart)
7902	return output
7903}
7904
7905func awsAwsjson11_deserializeErrorResourceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7906	var buff [1024]byte
7907	ringBuffer := smithyio.NewRingBuffer(buff[:])
7908
7909	body := io.TeeReader(errorBody, ringBuffer)
7910	decoder := json.NewDecoder(body)
7911	decoder.UseNumber()
7912	var shape interface{}
7913	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7914		var snapshot bytes.Buffer
7915		io.Copy(&snapshot, ringBuffer)
7916		err = &smithy.DeserializationError{
7917			Err:      fmt.Errorf("failed to decode response body, %w", err),
7918			Snapshot: snapshot.Bytes(),
7919		}
7920		return err
7921	}
7922
7923	output := &types.ResourceUnavailableException{}
7924	err := awsAwsjson11_deserializeDocumentResourceUnavailableException(&output, shape)
7925
7926	if err != nil {
7927		var snapshot bytes.Buffer
7928		io.Copy(&snapshot, ringBuffer)
7929		err = &smithy.DeserializationError{
7930			Err:      fmt.Errorf("failed to decode response body, %w", err),
7931			Snapshot: snapshot.Bytes(),
7932		}
7933		return err
7934	}
7935
7936	errorBody.Seek(0, io.SeekStart)
7937	return output
7938}
7939
7940func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7941	var buff [1024]byte
7942	ringBuffer := smithyio.NewRingBuffer(buff[:])
7943
7944	body := io.TeeReader(errorBody, ringBuffer)
7945	decoder := json.NewDecoder(body)
7946	decoder.UseNumber()
7947	var shape interface{}
7948	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7949		var snapshot bytes.Buffer
7950		io.Copy(&snapshot, ringBuffer)
7951		err = &smithy.DeserializationError{
7952			Err:      fmt.Errorf("failed to decode response body, %w", err),
7953			Snapshot: snapshot.Bytes(),
7954		}
7955		return err
7956	}
7957
7958	output := &types.ThrottlingException{}
7959	err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape)
7960
7961	if err != nil {
7962		var snapshot bytes.Buffer
7963		io.Copy(&snapshot, ringBuffer)
7964		err = &smithy.DeserializationError{
7965			Err:      fmt.Errorf("failed to decode response body, %w", err),
7966			Snapshot: snapshot.Bytes(),
7967		}
7968		return err
7969	}
7970
7971	errorBody.Seek(0, io.SeekStart)
7972	return output
7973}
7974
7975func awsAwsjson11_deserializeErrorUnknownResourceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7976	var buff [1024]byte
7977	ringBuffer := smithyio.NewRingBuffer(buff[:])
7978
7979	body := io.TeeReader(errorBody, ringBuffer)
7980	decoder := json.NewDecoder(body)
7981	decoder.UseNumber()
7982	var shape interface{}
7983	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7984		var snapshot bytes.Buffer
7985		io.Copy(&snapshot, ringBuffer)
7986		err = &smithy.DeserializationError{
7987			Err:      fmt.Errorf("failed to decode response body, %w", err),
7988			Snapshot: snapshot.Bytes(),
7989		}
7990		return err
7991	}
7992
7993	output := &types.UnknownResourceException{}
7994	err := awsAwsjson11_deserializeDocumentUnknownResourceException(&output, shape)
7995
7996	if err != nil {
7997		var snapshot bytes.Buffer
7998		io.Copy(&snapshot, ringBuffer)
7999		err = &smithy.DeserializationError{
8000			Err:      fmt.Errorf("failed to decode response body, %w", err),
8001			Snapshot: snapshot.Bytes(),
8002		}
8003		return err
8004	}
8005
8006	errorBody.Seek(0, io.SeekStart)
8007	return output
8008}
8009
8010func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
8011	var buff [1024]byte
8012	ringBuffer := smithyio.NewRingBuffer(buff[:])
8013
8014	body := io.TeeReader(errorBody, ringBuffer)
8015	decoder := json.NewDecoder(body)
8016	decoder.UseNumber()
8017	var shape interface{}
8018	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8019		var snapshot bytes.Buffer
8020		io.Copy(&snapshot, ringBuffer)
8021		err = &smithy.DeserializationError{
8022			Err:      fmt.Errorf("failed to decode response body, %w", err),
8023			Snapshot: snapshot.Bytes(),
8024		}
8025		return err
8026	}
8027
8028	output := &types.ValidationException{}
8029	err := awsAwsjson11_deserializeDocumentValidationException(&output, shape)
8030
8031	if err != nil {
8032		var snapshot bytes.Buffer
8033		io.Copy(&snapshot, ringBuffer)
8034		err = &smithy.DeserializationError{
8035			Err:      fmt.Errorf("failed to decode response body, %w", err),
8036			Snapshot: snapshot.Bytes(),
8037		}
8038		return err
8039	}
8040
8041	errorBody.Seek(0, io.SeekStart)
8042	return output
8043}
8044
8045func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
8046	if v == nil {
8047		return fmt.Errorf("unexpected nil of type %T", v)
8048	}
8049	if value == nil {
8050		return nil
8051	}
8052
8053	shape, ok := value.(map[string]interface{})
8054	if !ok {
8055		return fmt.Errorf("unexpected JSON type %v", value)
8056	}
8057
8058	var sv *types.AccessDeniedException
8059	if *v == nil {
8060		sv = &types.AccessDeniedException{}
8061	} else {
8062		sv = *v
8063	}
8064
8065	for key, value := range shape {
8066		switch key {
8067		case "Message":
8068			if value != nil {
8069				jtv, ok := value.(string)
8070				if !ok {
8071					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8072				}
8073				sv.Message = ptr.String(jtv)
8074			}
8075
8076		default:
8077			_, _ = key, value
8078
8079		}
8080	}
8081	*v = sv
8082	return nil
8083}
8084
8085func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error {
8086	if v == nil {
8087		return fmt.Errorf("unexpected nil of type %T", v)
8088	}
8089	if value == nil {
8090		return nil
8091	}
8092
8093	shape, ok := value.(map[string]interface{})
8094	if !ok {
8095		return fmt.Errorf("unexpected JSON type %v", value)
8096	}
8097
8098	var sv *types.ConflictException
8099	if *v == nil {
8100		sv = &types.ConflictException{}
8101	} else {
8102		sv = *v
8103	}
8104
8105	for key, value := range shape {
8106		switch key {
8107		case "Message":
8108			if value != nil {
8109				jtv, ok := value.(string)
8110				if !ok {
8111					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8112				}
8113				sv.Message = ptr.String(jtv)
8114			}
8115
8116		default:
8117			_, _ = key, value
8118
8119		}
8120	}
8121	*v = sv
8122	return nil
8123}
8124
8125func awsAwsjson11_deserializeDocumentFirewallConfig(v **types.FirewallConfig, value interface{}) error {
8126	if v == nil {
8127		return fmt.Errorf("unexpected nil of type %T", v)
8128	}
8129	if value == nil {
8130		return nil
8131	}
8132
8133	shape, ok := value.(map[string]interface{})
8134	if !ok {
8135		return fmt.Errorf("unexpected JSON type %v", value)
8136	}
8137
8138	var sv *types.FirewallConfig
8139	if *v == nil {
8140		sv = &types.FirewallConfig{}
8141	} else {
8142		sv = *v
8143	}
8144
8145	for key, value := range shape {
8146		switch key {
8147		case "FirewallFailOpen":
8148			if value != nil {
8149				jtv, ok := value.(string)
8150				if !ok {
8151					return fmt.Errorf("expected FirewallFailOpenStatus to be of type string, got %T instead", value)
8152				}
8153				sv.FirewallFailOpen = types.FirewallFailOpenStatus(jtv)
8154			}
8155
8156		case "Id":
8157			if value != nil {
8158				jtv, ok := value.(string)
8159				if !ok {
8160					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8161				}
8162				sv.Id = ptr.String(jtv)
8163			}
8164
8165		case "OwnerId":
8166			if value != nil {
8167				jtv, ok := value.(string)
8168				if !ok {
8169					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8170				}
8171				sv.OwnerId = ptr.String(jtv)
8172			}
8173
8174		case "ResourceId":
8175			if value != nil {
8176				jtv, ok := value.(string)
8177				if !ok {
8178					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8179				}
8180				sv.ResourceId = ptr.String(jtv)
8181			}
8182
8183		default:
8184			_, _ = key, value
8185
8186		}
8187	}
8188	*v = sv
8189	return nil
8190}
8191
8192func awsAwsjson11_deserializeDocumentFirewallConfigList(v *[]types.FirewallConfig, value interface{}) error {
8193	if v == nil {
8194		return fmt.Errorf("unexpected nil of type %T", v)
8195	}
8196	if value == nil {
8197		return nil
8198	}
8199
8200	shape, ok := value.([]interface{})
8201	if !ok {
8202		return fmt.Errorf("unexpected JSON type %v", value)
8203	}
8204
8205	var cv []types.FirewallConfig
8206	if *v == nil {
8207		cv = []types.FirewallConfig{}
8208	} else {
8209		cv = *v
8210	}
8211
8212	for _, value := range shape {
8213		var col types.FirewallConfig
8214		destAddr := &col
8215		if err := awsAwsjson11_deserializeDocumentFirewallConfig(&destAddr, value); err != nil {
8216			return err
8217		}
8218		col = *destAddr
8219		cv = append(cv, col)
8220
8221	}
8222	*v = cv
8223	return nil
8224}
8225
8226func awsAwsjson11_deserializeDocumentFirewallDomainList(v **types.FirewallDomainList, value interface{}) error {
8227	if v == nil {
8228		return fmt.Errorf("unexpected nil of type %T", v)
8229	}
8230	if value == nil {
8231		return nil
8232	}
8233
8234	shape, ok := value.(map[string]interface{})
8235	if !ok {
8236		return fmt.Errorf("unexpected JSON type %v", value)
8237	}
8238
8239	var sv *types.FirewallDomainList
8240	if *v == nil {
8241		sv = &types.FirewallDomainList{}
8242	} else {
8243		sv = *v
8244	}
8245
8246	for key, value := range shape {
8247		switch key {
8248		case "Arn":
8249			if value != nil {
8250				jtv, ok := value.(string)
8251				if !ok {
8252					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
8253				}
8254				sv.Arn = ptr.String(jtv)
8255			}
8256
8257		case "CreationTime":
8258			if value != nil {
8259				jtv, ok := value.(string)
8260				if !ok {
8261					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8262				}
8263				sv.CreationTime = ptr.String(jtv)
8264			}
8265
8266		case "CreatorRequestId":
8267			if value != nil {
8268				jtv, ok := value.(string)
8269				if !ok {
8270					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
8271				}
8272				sv.CreatorRequestId = ptr.String(jtv)
8273			}
8274
8275		case "DomainCount":
8276			if value != nil {
8277				jtv, ok := value.(json.Number)
8278				if !ok {
8279					return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value)
8280				}
8281				i64, err := jtv.Int64()
8282				if err != nil {
8283					return err
8284				}
8285				sv.DomainCount = ptr.Int32(int32(i64))
8286			}
8287
8288		case "Id":
8289			if value != nil {
8290				jtv, ok := value.(string)
8291				if !ok {
8292					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8293				}
8294				sv.Id = ptr.String(jtv)
8295			}
8296
8297		case "ManagedOwnerName":
8298			if value != nil {
8299				jtv, ok := value.(string)
8300				if !ok {
8301					return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value)
8302				}
8303				sv.ManagedOwnerName = ptr.String(jtv)
8304			}
8305
8306		case "ModificationTime":
8307			if value != nil {
8308				jtv, ok := value.(string)
8309				if !ok {
8310					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8311				}
8312				sv.ModificationTime = ptr.String(jtv)
8313			}
8314
8315		case "Name":
8316			if value != nil {
8317				jtv, ok := value.(string)
8318				if !ok {
8319					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
8320				}
8321				sv.Name = ptr.String(jtv)
8322			}
8323
8324		case "Status":
8325			if value != nil {
8326				jtv, ok := value.(string)
8327				if !ok {
8328					return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value)
8329				}
8330				sv.Status = types.FirewallDomainListStatus(jtv)
8331			}
8332
8333		case "StatusMessage":
8334			if value != nil {
8335				jtv, ok := value.(string)
8336				if !ok {
8337					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
8338				}
8339				sv.StatusMessage = ptr.String(jtv)
8340			}
8341
8342		default:
8343			_, _ = key, value
8344
8345		}
8346	}
8347	*v = sv
8348	return nil
8349}
8350
8351func awsAwsjson11_deserializeDocumentFirewallDomainListMetadata(v **types.FirewallDomainListMetadata, value interface{}) error {
8352	if v == nil {
8353		return fmt.Errorf("unexpected nil of type %T", v)
8354	}
8355	if value == nil {
8356		return nil
8357	}
8358
8359	shape, ok := value.(map[string]interface{})
8360	if !ok {
8361		return fmt.Errorf("unexpected JSON type %v", value)
8362	}
8363
8364	var sv *types.FirewallDomainListMetadata
8365	if *v == nil {
8366		sv = &types.FirewallDomainListMetadata{}
8367	} else {
8368		sv = *v
8369	}
8370
8371	for key, value := range shape {
8372		switch key {
8373		case "Arn":
8374			if value != nil {
8375				jtv, ok := value.(string)
8376				if !ok {
8377					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
8378				}
8379				sv.Arn = ptr.String(jtv)
8380			}
8381
8382		case "CreatorRequestId":
8383			if value != nil {
8384				jtv, ok := value.(string)
8385				if !ok {
8386					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
8387				}
8388				sv.CreatorRequestId = ptr.String(jtv)
8389			}
8390
8391		case "Id":
8392			if value != nil {
8393				jtv, ok := value.(string)
8394				if !ok {
8395					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8396				}
8397				sv.Id = ptr.String(jtv)
8398			}
8399
8400		case "ManagedOwnerName":
8401			if value != nil {
8402				jtv, ok := value.(string)
8403				if !ok {
8404					return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value)
8405				}
8406				sv.ManagedOwnerName = ptr.String(jtv)
8407			}
8408
8409		case "Name":
8410			if value != nil {
8411				jtv, ok := value.(string)
8412				if !ok {
8413					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
8414				}
8415				sv.Name = ptr.String(jtv)
8416			}
8417
8418		default:
8419			_, _ = key, value
8420
8421		}
8422	}
8423	*v = sv
8424	return nil
8425}
8426
8427func awsAwsjson11_deserializeDocumentFirewallDomainListMetadataList(v *[]types.FirewallDomainListMetadata, value interface{}) error {
8428	if v == nil {
8429		return fmt.Errorf("unexpected nil of type %T", v)
8430	}
8431	if value == nil {
8432		return nil
8433	}
8434
8435	shape, ok := value.([]interface{})
8436	if !ok {
8437		return fmt.Errorf("unexpected JSON type %v", value)
8438	}
8439
8440	var cv []types.FirewallDomainListMetadata
8441	if *v == nil {
8442		cv = []types.FirewallDomainListMetadata{}
8443	} else {
8444		cv = *v
8445	}
8446
8447	for _, value := range shape {
8448		var col types.FirewallDomainListMetadata
8449		destAddr := &col
8450		if err := awsAwsjson11_deserializeDocumentFirewallDomainListMetadata(&destAddr, value); err != nil {
8451			return err
8452		}
8453		col = *destAddr
8454		cv = append(cv, col)
8455
8456	}
8457	*v = cv
8458	return nil
8459}
8460
8461func awsAwsjson11_deserializeDocumentFirewallDomains(v *[]string, value interface{}) error {
8462	if v == nil {
8463		return fmt.Errorf("unexpected nil of type %T", v)
8464	}
8465	if value == nil {
8466		return nil
8467	}
8468
8469	shape, ok := value.([]interface{})
8470	if !ok {
8471		return fmt.Errorf("unexpected JSON type %v", value)
8472	}
8473
8474	var cv []string
8475	if *v == nil {
8476		cv = []string{}
8477	} else {
8478		cv = *v
8479	}
8480
8481	for _, value := range shape {
8482		var col string
8483		if value != nil {
8484			jtv, ok := value.(string)
8485			if !ok {
8486				return fmt.Errorf("expected FirewallDomainName to be of type string, got %T instead", value)
8487			}
8488			col = jtv
8489		}
8490		cv = append(cv, col)
8491
8492	}
8493	*v = cv
8494	return nil
8495}
8496
8497func awsAwsjson11_deserializeDocumentFirewallRule(v **types.FirewallRule, value interface{}) error {
8498	if v == nil {
8499		return fmt.Errorf("unexpected nil of type %T", v)
8500	}
8501	if value == nil {
8502		return nil
8503	}
8504
8505	shape, ok := value.(map[string]interface{})
8506	if !ok {
8507		return fmt.Errorf("unexpected JSON type %v", value)
8508	}
8509
8510	var sv *types.FirewallRule
8511	if *v == nil {
8512		sv = &types.FirewallRule{}
8513	} else {
8514		sv = *v
8515	}
8516
8517	for key, value := range shape {
8518		switch key {
8519		case "Action":
8520			if value != nil {
8521				jtv, ok := value.(string)
8522				if !ok {
8523					return fmt.Errorf("expected Action to be of type string, got %T instead", value)
8524				}
8525				sv.Action = types.Action(jtv)
8526			}
8527
8528		case "BlockOverrideDnsType":
8529			if value != nil {
8530				jtv, ok := value.(string)
8531				if !ok {
8532					return fmt.Errorf("expected BlockOverrideDnsType to be of type string, got %T instead", value)
8533				}
8534				sv.BlockOverrideDnsType = types.BlockOverrideDnsType(jtv)
8535			}
8536
8537		case "BlockOverrideDomain":
8538			if value != nil {
8539				jtv, ok := value.(string)
8540				if !ok {
8541					return fmt.Errorf("expected BlockOverrideDomain to be of type string, got %T instead", value)
8542				}
8543				sv.BlockOverrideDomain = ptr.String(jtv)
8544			}
8545
8546		case "BlockOverrideTtl":
8547			if value != nil {
8548				jtv, ok := value.(json.Number)
8549				if !ok {
8550					return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value)
8551				}
8552				i64, err := jtv.Int64()
8553				if err != nil {
8554					return err
8555				}
8556				sv.BlockOverrideTtl = ptr.Int32(int32(i64))
8557			}
8558
8559		case "BlockResponse":
8560			if value != nil {
8561				jtv, ok := value.(string)
8562				if !ok {
8563					return fmt.Errorf("expected BlockResponse to be of type string, got %T instead", value)
8564				}
8565				sv.BlockResponse = types.BlockResponse(jtv)
8566			}
8567
8568		case "CreationTime":
8569			if value != nil {
8570				jtv, ok := value.(string)
8571				if !ok {
8572					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8573				}
8574				sv.CreationTime = ptr.String(jtv)
8575			}
8576
8577		case "CreatorRequestId":
8578			if value != nil {
8579				jtv, ok := value.(string)
8580				if !ok {
8581					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
8582				}
8583				sv.CreatorRequestId = ptr.String(jtv)
8584			}
8585
8586		case "FirewallDomainListId":
8587			if value != nil {
8588				jtv, ok := value.(string)
8589				if !ok {
8590					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8591				}
8592				sv.FirewallDomainListId = ptr.String(jtv)
8593			}
8594
8595		case "FirewallRuleGroupId":
8596			if value != nil {
8597				jtv, ok := value.(string)
8598				if !ok {
8599					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8600				}
8601				sv.FirewallRuleGroupId = ptr.String(jtv)
8602			}
8603
8604		case "ModificationTime":
8605			if value != nil {
8606				jtv, ok := value.(string)
8607				if !ok {
8608					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8609				}
8610				sv.ModificationTime = ptr.String(jtv)
8611			}
8612
8613		case "Name":
8614			if value != nil {
8615				jtv, ok := value.(string)
8616				if !ok {
8617					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
8618				}
8619				sv.Name = ptr.String(jtv)
8620			}
8621
8622		case "Priority":
8623			if value != nil {
8624				jtv, ok := value.(json.Number)
8625				if !ok {
8626					return fmt.Errorf("expected Priority to be json.Number, got %T instead", value)
8627				}
8628				i64, err := jtv.Int64()
8629				if err != nil {
8630					return err
8631				}
8632				sv.Priority = ptr.Int32(int32(i64))
8633			}
8634
8635		default:
8636			_, _ = key, value
8637
8638		}
8639	}
8640	*v = sv
8641	return nil
8642}
8643
8644func awsAwsjson11_deserializeDocumentFirewallRuleGroup(v **types.FirewallRuleGroup, value interface{}) error {
8645	if v == nil {
8646		return fmt.Errorf("unexpected nil of type %T", v)
8647	}
8648	if value == nil {
8649		return nil
8650	}
8651
8652	shape, ok := value.(map[string]interface{})
8653	if !ok {
8654		return fmt.Errorf("unexpected JSON type %v", value)
8655	}
8656
8657	var sv *types.FirewallRuleGroup
8658	if *v == nil {
8659		sv = &types.FirewallRuleGroup{}
8660	} else {
8661		sv = *v
8662	}
8663
8664	for key, value := range shape {
8665		switch key {
8666		case "Arn":
8667			if value != nil {
8668				jtv, ok := value.(string)
8669				if !ok {
8670					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
8671				}
8672				sv.Arn = ptr.String(jtv)
8673			}
8674
8675		case "CreationTime":
8676			if value != nil {
8677				jtv, ok := value.(string)
8678				if !ok {
8679					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8680				}
8681				sv.CreationTime = ptr.String(jtv)
8682			}
8683
8684		case "CreatorRequestId":
8685			if value != nil {
8686				jtv, ok := value.(string)
8687				if !ok {
8688					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
8689				}
8690				sv.CreatorRequestId = ptr.String(jtv)
8691			}
8692
8693		case "Id":
8694			if value != nil {
8695				jtv, ok := value.(string)
8696				if !ok {
8697					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8698				}
8699				sv.Id = ptr.String(jtv)
8700			}
8701
8702		case "ModificationTime":
8703			if value != nil {
8704				jtv, ok := value.(string)
8705				if !ok {
8706					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8707				}
8708				sv.ModificationTime = ptr.String(jtv)
8709			}
8710
8711		case "Name":
8712			if value != nil {
8713				jtv, ok := value.(string)
8714				if !ok {
8715					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
8716				}
8717				sv.Name = ptr.String(jtv)
8718			}
8719
8720		case "OwnerId":
8721			if value != nil {
8722				jtv, ok := value.(string)
8723				if !ok {
8724					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8725				}
8726				sv.OwnerId = ptr.String(jtv)
8727			}
8728
8729		case "RuleCount":
8730			if value != nil {
8731				jtv, ok := value.(json.Number)
8732				if !ok {
8733					return fmt.Errorf("expected Unsigned to be json.Number, got %T instead", value)
8734				}
8735				i64, err := jtv.Int64()
8736				if err != nil {
8737					return err
8738				}
8739				sv.RuleCount = ptr.Int32(int32(i64))
8740			}
8741
8742		case "ShareStatus":
8743			if value != nil {
8744				jtv, ok := value.(string)
8745				if !ok {
8746					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
8747				}
8748				sv.ShareStatus = types.ShareStatus(jtv)
8749			}
8750
8751		case "Status":
8752			if value != nil {
8753				jtv, ok := value.(string)
8754				if !ok {
8755					return fmt.Errorf("expected FirewallRuleGroupStatus to be of type string, got %T instead", value)
8756				}
8757				sv.Status = types.FirewallRuleGroupStatus(jtv)
8758			}
8759
8760		case "StatusMessage":
8761			if value != nil {
8762				jtv, ok := value.(string)
8763				if !ok {
8764					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
8765				}
8766				sv.StatusMessage = ptr.String(jtv)
8767			}
8768
8769		default:
8770			_, _ = key, value
8771
8772		}
8773	}
8774	*v = sv
8775	return nil
8776}
8777
8778func awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(v **types.FirewallRuleGroupAssociation, value interface{}) error {
8779	if v == nil {
8780		return fmt.Errorf("unexpected nil of type %T", v)
8781	}
8782	if value == nil {
8783		return nil
8784	}
8785
8786	shape, ok := value.(map[string]interface{})
8787	if !ok {
8788		return fmt.Errorf("unexpected JSON type %v", value)
8789	}
8790
8791	var sv *types.FirewallRuleGroupAssociation
8792	if *v == nil {
8793		sv = &types.FirewallRuleGroupAssociation{}
8794	} else {
8795		sv = *v
8796	}
8797
8798	for key, value := range shape {
8799		switch key {
8800		case "Arn":
8801			if value != nil {
8802				jtv, ok := value.(string)
8803				if !ok {
8804					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
8805				}
8806				sv.Arn = ptr.String(jtv)
8807			}
8808
8809		case "CreationTime":
8810			if value != nil {
8811				jtv, ok := value.(string)
8812				if !ok {
8813					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8814				}
8815				sv.CreationTime = ptr.String(jtv)
8816			}
8817
8818		case "CreatorRequestId":
8819			if value != nil {
8820				jtv, ok := value.(string)
8821				if !ok {
8822					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
8823				}
8824				sv.CreatorRequestId = ptr.String(jtv)
8825			}
8826
8827		case "FirewallRuleGroupId":
8828			if value != nil {
8829				jtv, ok := value.(string)
8830				if !ok {
8831					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8832				}
8833				sv.FirewallRuleGroupId = ptr.String(jtv)
8834			}
8835
8836		case "Id":
8837			if value != nil {
8838				jtv, ok := value.(string)
8839				if !ok {
8840					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8841				}
8842				sv.Id = ptr.String(jtv)
8843			}
8844
8845		case "ManagedOwnerName":
8846			if value != nil {
8847				jtv, ok := value.(string)
8848				if !ok {
8849					return fmt.Errorf("expected ServicePrinciple to be of type string, got %T instead", value)
8850				}
8851				sv.ManagedOwnerName = ptr.String(jtv)
8852			}
8853
8854		case "ModificationTime":
8855			if value != nil {
8856				jtv, ok := value.(string)
8857				if !ok {
8858					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
8859				}
8860				sv.ModificationTime = ptr.String(jtv)
8861			}
8862
8863		case "MutationProtection":
8864			if value != nil {
8865				jtv, ok := value.(string)
8866				if !ok {
8867					return fmt.Errorf("expected MutationProtectionStatus to be of type string, got %T instead", value)
8868				}
8869				sv.MutationProtection = types.MutationProtectionStatus(jtv)
8870			}
8871
8872		case "Name":
8873			if value != nil {
8874				jtv, ok := value.(string)
8875				if !ok {
8876					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
8877				}
8878				sv.Name = ptr.String(jtv)
8879			}
8880
8881		case "Priority":
8882			if value != nil {
8883				jtv, ok := value.(json.Number)
8884				if !ok {
8885					return fmt.Errorf("expected Priority to be json.Number, got %T instead", value)
8886				}
8887				i64, err := jtv.Int64()
8888				if err != nil {
8889					return err
8890				}
8891				sv.Priority = ptr.Int32(int32(i64))
8892			}
8893
8894		case "Status":
8895			if value != nil {
8896				jtv, ok := value.(string)
8897				if !ok {
8898					return fmt.Errorf("expected FirewallRuleGroupAssociationStatus to be of type string, got %T instead", value)
8899				}
8900				sv.Status = types.FirewallRuleGroupAssociationStatus(jtv)
8901			}
8902
8903		case "StatusMessage":
8904			if value != nil {
8905				jtv, ok := value.(string)
8906				if !ok {
8907					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
8908				}
8909				sv.StatusMessage = ptr.String(jtv)
8910			}
8911
8912		case "VpcId":
8913			if value != nil {
8914				jtv, ok := value.(string)
8915				if !ok {
8916					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
8917				}
8918				sv.VpcId = ptr.String(jtv)
8919			}
8920
8921		default:
8922			_, _ = key, value
8923
8924		}
8925	}
8926	*v = sv
8927	return nil
8928}
8929
8930func awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociations(v *[]types.FirewallRuleGroupAssociation, value interface{}) error {
8931	if v == nil {
8932		return fmt.Errorf("unexpected nil of type %T", v)
8933	}
8934	if value == nil {
8935		return nil
8936	}
8937
8938	shape, ok := value.([]interface{})
8939	if !ok {
8940		return fmt.Errorf("unexpected JSON type %v", value)
8941	}
8942
8943	var cv []types.FirewallRuleGroupAssociation
8944	if *v == nil {
8945		cv = []types.FirewallRuleGroupAssociation{}
8946	} else {
8947		cv = *v
8948	}
8949
8950	for _, value := range shape {
8951		var col types.FirewallRuleGroupAssociation
8952		destAddr := &col
8953		if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&destAddr, value); err != nil {
8954			return err
8955		}
8956		col = *destAddr
8957		cv = append(cv, col)
8958
8959	}
8960	*v = cv
8961	return nil
8962}
8963
8964func awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadata(v **types.FirewallRuleGroupMetadata, value interface{}) error {
8965	if v == nil {
8966		return fmt.Errorf("unexpected nil of type %T", v)
8967	}
8968	if value == nil {
8969		return nil
8970	}
8971
8972	shape, ok := value.(map[string]interface{})
8973	if !ok {
8974		return fmt.Errorf("unexpected JSON type %v", value)
8975	}
8976
8977	var sv *types.FirewallRuleGroupMetadata
8978	if *v == nil {
8979		sv = &types.FirewallRuleGroupMetadata{}
8980	} else {
8981		sv = *v
8982	}
8983
8984	for key, value := range shape {
8985		switch key {
8986		case "Arn":
8987			if value != nil {
8988				jtv, ok := value.(string)
8989				if !ok {
8990					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
8991				}
8992				sv.Arn = ptr.String(jtv)
8993			}
8994
8995		case "CreatorRequestId":
8996			if value != nil {
8997				jtv, ok := value.(string)
8998				if !ok {
8999					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
9000				}
9001				sv.CreatorRequestId = ptr.String(jtv)
9002			}
9003
9004		case "Id":
9005			if value != nil {
9006				jtv, ok := value.(string)
9007				if !ok {
9008					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9009				}
9010				sv.Id = ptr.String(jtv)
9011			}
9012
9013		case "Name":
9014			if value != nil {
9015				jtv, ok := value.(string)
9016				if !ok {
9017					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
9018				}
9019				sv.Name = ptr.String(jtv)
9020			}
9021
9022		case "OwnerId":
9023			if value != nil {
9024				jtv, ok := value.(string)
9025				if !ok {
9026					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
9027				}
9028				sv.OwnerId = ptr.String(jtv)
9029			}
9030
9031		case "ShareStatus":
9032			if value != nil {
9033				jtv, ok := value.(string)
9034				if !ok {
9035					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
9036				}
9037				sv.ShareStatus = types.ShareStatus(jtv)
9038			}
9039
9040		default:
9041			_, _ = key, value
9042
9043		}
9044	}
9045	*v = sv
9046	return nil
9047}
9048
9049func awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadataList(v *[]types.FirewallRuleGroupMetadata, value interface{}) error {
9050	if v == nil {
9051		return fmt.Errorf("unexpected nil of type %T", v)
9052	}
9053	if value == nil {
9054		return nil
9055	}
9056
9057	shape, ok := value.([]interface{})
9058	if !ok {
9059		return fmt.Errorf("unexpected JSON type %v", value)
9060	}
9061
9062	var cv []types.FirewallRuleGroupMetadata
9063	if *v == nil {
9064		cv = []types.FirewallRuleGroupMetadata{}
9065	} else {
9066		cv = *v
9067	}
9068
9069	for _, value := range shape {
9070		var col types.FirewallRuleGroupMetadata
9071		destAddr := &col
9072		if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadata(&destAddr, value); err != nil {
9073			return err
9074		}
9075		col = *destAddr
9076		cv = append(cv, col)
9077
9078	}
9079	*v = cv
9080	return nil
9081}
9082
9083func awsAwsjson11_deserializeDocumentFirewallRules(v *[]types.FirewallRule, value interface{}) error {
9084	if v == nil {
9085		return fmt.Errorf("unexpected nil of type %T", v)
9086	}
9087	if value == nil {
9088		return nil
9089	}
9090
9091	shape, ok := value.([]interface{})
9092	if !ok {
9093		return fmt.Errorf("unexpected JSON type %v", value)
9094	}
9095
9096	var cv []types.FirewallRule
9097	if *v == nil {
9098		cv = []types.FirewallRule{}
9099	} else {
9100		cv = *v
9101	}
9102
9103	for _, value := range shape {
9104		var col types.FirewallRule
9105		destAddr := &col
9106		if err := awsAwsjson11_deserializeDocumentFirewallRule(&destAddr, value); err != nil {
9107			return err
9108		}
9109		col = *destAddr
9110		cv = append(cv, col)
9111
9112	}
9113	*v = cv
9114	return nil
9115}
9116
9117func awsAwsjson11_deserializeDocumentInternalServiceErrorException(v **types.InternalServiceErrorException, value interface{}) error {
9118	if v == nil {
9119		return fmt.Errorf("unexpected nil of type %T", v)
9120	}
9121	if value == nil {
9122		return nil
9123	}
9124
9125	shape, ok := value.(map[string]interface{})
9126	if !ok {
9127		return fmt.Errorf("unexpected JSON type %v", value)
9128	}
9129
9130	var sv *types.InternalServiceErrorException
9131	if *v == nil {
9132		sv = &types.InternalServiceErrorException{}
9133	} else {
9134		sv = *v
9135	}
9136
9137	for key, value := range shape {
9138		switch key {
9139		case "Message":
9140			if value != nil {
9141				jtv, ok := value.(string)
9142				if !ok {
9143					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9144				}
9145				sv.Message = ptr.String(jtv)
9146			}
9147
9148		default:
9149			_, _ = key, value
9150
9151		}
9152	}
9153	*v = sv
9154	return nil
9155}
9156
9157func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error {
9158	if v == nil {
9159		return fmt.Errorf("unexpected nil of type %T", v)
9160	}
9161	if value == nil {
9162		return nil
9163	}
9164
9165	shape, ok := value.(map[string]interface{})
9166	if !ok {
9167		return fmt.Errorf("unexpected JSON type %v", value)
9168	}
9169
9170	var sv *types.InvalidNextTokenException
9171	if *v == nil {
9172		sv = &types.InvalidNextTokenException{}
9173	} else {
9174		sv = *v
9175	}
9176
9177	for key, value := range shape {
9178		switch key {
9179		case "Message":
9180			if value != nil {
9181				jtv, ok := value.(string)
9182				if !ok {
9183					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9184				}
9185				sv.Message = ptr.String(jtv)
9186			}
9187
9188		default:
9189			_, _ = key, value
9190
9191		}
9192	}
9193	*v = sv
9194	return nil
9195}
9196
9197func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error {
9198	if v == nil {
9199		return fmt.Errorf("unexpected nil of type %T", v)
9200	}
9201	if value == nil {
9202		return nil
9203	}
9204
9205	shape, ok := value.(map[string]interface{})
9206	if !ok {
9207		return fmt.Errorf("unexpected JSON type %v", value)
9208	}
9209
9210	var sv *types.InvalidParameterException
9211	if *v == nil {
9212		sv = &types.InvalidParameterException{}
9213	} else {
9214		sv = *v
9215	}
9216
9217	for key, value := range shape {
9218		switch key {
9219		case "FieldName":
9220			if value != nil {
9221				jtv, ok := value.(string)
9222				if !ok {
9223					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9224				}
9225				sv.FieldName = ptr.String(jtv)
9226			}
9227
9228		case "Message":
9229			if value != nil {
9230				jtv, ok := value.(string)
9231				if !ok {
9232					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9233				}
9234				sv.Message = ptr.String(jtv)
9235			}
9236
9237		default:
9238			_, _ = key, value
9239
9240		}
9241	}
9242	*v = sv
9243	return nil
9244}
9245
9246func awsAwsjson11_deserializeDocumentInvalidPolicyDocument(v **types.InvalidPolicyDocument, value interface{}) error {
9247	if v == nil {
9248		return fmt.Errorf("unexpected nil of type %T", v)
9249	}
9250	if value == nil {
9251		return nil
9252	}
9253
9254	shape, ok := value.(map[string]interface{})
9255	if !ok {
9256		return fmt.Errorf("unexpected JSON type %v", value)
9257	}
9258
9259	var sv *types.InvalidPolicyDocument
9260	if *v == nil {
9261		sv = &types.InvalidPolicyDocument{}
9262	} else {
9263		sv = *v
9264	}
9265
9266	for key, value := range shape {
9267		switch key {
9268		case "Message":
9269			if value != nil {
9270				jtv, ok := value.(string)
9271				if !ok {
9272					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9273				}
9274				sv.Message = ptr.String(jtv)
9275			}
9276
9277		default:
9278			_, _ = key, value
9279
9280		}
9281	}
9282	*v = sv
9283	return nil
9284}
9285
9286func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
9287	if v == nil {
9288		return fmt.Errorf("unexpected nil of type %T", v)
9289	}
9290	if value == nil {
9291		return nil
9292	}
9293
9294	shape, ok := value.(map[string]interface{})
9295	if !ok {
9296		return fmt.Errorf("unexpected JSON type %v", value)
9297	}
9298
9299	var sv *types.InvalidRequestException
9300	if *v == nil {
9301		sv = &types.InvalidRequestException{}
9302	} else {
9303		sv = *v
9304	}
9305
9306	for key, value := range shape {
9307		switch key {
9308		case "Message":
9309			if value != nil {
9310				jtv, ok := value.(string)
9311				if !ok {
9312					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9313				}
9314				sv.Message = ptr.String(jtv)
9315			}
9316
9317		default:
9318			_, _ = key, value
9319
9320		}
9321	}
9322	*v = sv
9323	return nil
9324}
9325
9326func awsAwsjson11_deserializeDocumentInvalidTagException(v **types.InvalidTagException, value interface{}) error {
9327	if v == nil {
9328		return fmt.Errorf("unexpected nil of type %T", v)
9329	}
9330	if value == nil {
9331		return nil
9332	}
9333
9334	shape, ok := value.(map[string]interface{})
9335	if !ok {
9336		return fmt.Errorf("unexpected JSON type %v", value)
9337	}
9338
9339	var sv *types.InvalidTagException
9340	if *v == nil {
9341		sv = &types.InvalidTagException{}
9342	} else {
9343		sv = *v
9344	}
9345
9346	for key, value := range shape {
9347		switch key {
9348		case "Message":
9349			if value != nil {
9350				jtv, ok := value.(string)
9351				if !ok {
9352					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9353				}
9354				sv.Message = ptr.String(jtv)
9355			}
9356
9357		default:
9358			_, _ = key, value
9359
9360		}
9361	}
9362	*v = sv
9363	return nil
9364}
9365
9366func awsAwsjson11_deserializeDocumentIpAddressesResponse(v *[]types.IpAddressResponse, value interface{}) error {
9367	if v == nil {
9368		return fmt.Errorf("unexpected nil of type %T", v)
9369	}
9370	if value == nil {
9371		return nil
9372	}
9373
9374	shape, ok := value.([]interface{})
9375	if !ok {
9376		return fmt.Errorf("unexpected JSON type %v", value)
9377	}
9378
9379	var cv []types.IpAddressResponse
9380	if *v == nil {
9381		cv = []types.IpAddressResponse{}
9382	} else {
9383		cv = *v
9384	}
9385
9386	for _, value := range shape {
9387		var col types.IpAddressResponse
9388		destAddr := &col
9389		if err := awsAwsjson11_deserializeDocumentIpAddressResponse(&destAddr, value); err != nil {
9390			return err
9391		}
9392		col = *destAddr
9393		cv = append(cv, col)
9394
9395	}
9396	*v = cv
9397	return nil
9398}
9399
9400func awsAwsjson11_deserializeDocumentIpAddressResponse(v **types.IpAddressResponse, value interface{}) error {
9401	if v == nil {
9402		return fmt.Errorf("unexpected nil of type %T", v)
9403	}
9404	if value == nil {
9405		return nil
9406	}
9407
9408	shape, ok := value.(map[string]interface{})
9409	if !ok {
9410		return fmt.Errorf("unexpected JSON type %v", value)
9411	}
9412
9413	var sv *types.IpAddressResponse
9414	if *v == nil {
9415		sv = &types.IpAddressResponse{}
9416	} else {
9417		sv = *v
9418	}
9419
9420	for key, value := range shape {
9421		switch key {
9422		case "CreationTime":
9423			if value != nil {
9424				jtv, ok := value.(string)
9425				if !ok {
9426					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9427				}
9428				sv.CreationTime = ptr.String(jtv)
9429			}
9430
9431		case "Ip":
9432			if value != nil {
9433				jtv, ok := value.(string)
9434				if !ok {
9435					return fmt.Errorf("expected Ip to be of type string, got %T instead", value)
9436				}
9437				sv.Ip = ptr.String(jtv)
9438			}
9439
9440		case "IpId":
9441			if value != nil {
9442				jtv, ok := value.(string)
9443				if !ok {
9444					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9445				}
9446				sv.IpId = ptr.String(jtv)
9447			}
9448
9449		case "ModificationTime":
9450			if value != nil {
9451				jtv, ok := value.(string)
9452				if !ok {
9453					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9454				}
9455				sv.ModificationTime = ptr.String(jtv)
9456			}
9457
9458		case "Status":
9459			if value != nil {
9460				jtv, ok := value.(string)
9461				if !ok {
9462					return fmt.Errorf("expected IpAddressStatus to be of type string, got %T instead", value)
9463				}
9464				sv.Status = types.IpAddressStatus(jtv)
9465			}
9466
9467		case "StatusMessage":
9468			if value != nil {
9469				jtv, ok := value.(string)
9470				if !ok {
9471					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
9472				}
9473				sv.StatusMessage = ptr.String(jtv)
9474			}
9475
9476		case "SubnetId":
9477			if value != nil {
9478				jtv, ok := value.(string)
9479				if !ok {
9480					return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value)
9481				}
9482				sv.SubnetId = ptr.String(jtv)
9483			}
9484
9485		default:
9486			_, _ = key, value
9487
9488		}
9489	}
9490	*v = sv
9491	return nil
9492}
9493
9494func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
9495	if v == nil {
9496		return fmt.Errorf("unexpected nil of type %T", v)
9497	}
9498	if value == nil {
9499		return nil
9500	}
9501
9502	shape, ok := value.(map[string]interface{})
9503	if !ok {
9504		return fmt.Errorf("unexpected JSON type %v", value)
9505	}
9506
9507	var sv *types.LimitExceededException
9508	if *v == nil {
9509		sv = &types.LimitExceededException{}
9510	} else {
9511		sv = *v
9512	}
9513
9514	for key, value := range shape {
9515		switch key {
9516		case "Message":
9517			if value != nil {
9518				jtv, ok := value.(string)
9519				if !ok {
9520					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9521				}
9522				sv.Message = ptr.String(jtv)
9523			}
9524
9525		case "ResourceType":
9526			if value != nil {
9527				jtv, ok := value.(string)
9528				if !ok {
9529					return fmt.Errorf("expected String to be of type string, got %T instead", value)
9530				}
9531				sv.ResourceType = ptr.String(jtv)
9532			}
9533
9534		default:
9535			_, _ = key, value
9536
9537		}
9538	}
9539	*v = sv
9540	return nil
9541}
9542
9543func awsAwsjson11_deserializeDocumentResolverDnssecConfig(v **types.ResolverDnssecConfig, value interface{}) error {
9544	if v == nil {
9545		return fmt.Errorf("unexpected nil of type %T", v)
9546	}
9547	if value == nil {
9548		return nil
9549	}
9550
9551	shape, ok := value.(map[string]interface{})
9552	if !ok {
9553		return fmt.Errorf("unexpected JSON type %v", value)
9554	}
9555
9556	var sv *types.ResolverDnssecConfig
9557	if *v == nil {
9558		sv = &types.ResolverDnssecConfig{}
9559	} else {
9560		sv = *v
9561	}
9562
9563	for key, value := range shape {
9564		switch key {
9565		case "Id":
9566			if value != nil {
9567				jtv, ok := value.(string)
9568				if !ok {
9569					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9570				}
9571				sv.Id = ptr.String(jtv)
9572			}
9573
9574		case "OwnerId":
9575			if value != nil {
9576				jtv, ok := value.(string)
9577				if !ok {
9578					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
9579				}
9580				sv.OwnerId = ptr.String(jtv)
9581			}
9582
9583		case "ResourceId":
9584			if value != nil {
9585				jtv, ok := value.(string)
9586				if !ok {
9587					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9588				}
9589				sv.ResourceId = ptr.String(jtv)
9590			}
9591
9592		case "ValidationStatus":
9593			if value != nil {
9594				jtv, ok := value.(string)
9595				if !ok {
9596					return fmt.Errorf("expected ResolverDNSSECValidationStatus to be of type string, got %T instead", value)
9597				}
9598				sv.ValidationStatus = types.ResolverDNSSECValidationStatus(jtv)
9599			}
9600
9601		default:
9602			_, _ = key, value
9603
9604		}
9605	}
9606	*v = sv
9607	return nil
9608}
9609
9610func awsAwsjson11_deserializeDocumentResolverDnssecConfigList(v *[]types.ResolverDnssecConfig, value interface{}) error {
9611	if v == nil {
9612		return fmt.Errorf("unexpected nil of type %T", v)
9613	}
9614	if value == nil {
9615		return nil
9616	}
9617
9618	shape, ok := value.([]interface{})
9619	if !ok {
9620		return fmt.Errorf("unexpected JSON type %v", value)
9621	}
9622
9623	var cv []types.ResolverDnssecConfig
9624	if *v == nil {
9625		cv = []types.ResolverDnssecConfig{}
9626	} else {
9627		cv = *v
9628	}
9629
9630	for _, value := range shape {
9631		var col types.ResolverDnssecConfig
9632		destAddr := &col
9633		if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&destAddr, value); err != nil {
9634			return err
9635		}
9636		col = *destAddr
9637		cv = append(cv, col)
9638
9639	}
9640	*v = cv
9641	return nil
9642}
9643
9644func awsAwsjson11_deserializeDocumentResolverEndpoint(v **types.ResolverEndpoint, value interface{}) error {
9645	if v == nil {
9646		return fmt.Errorf("unexpected nil of type %T", v)
9647	}
9648	if value == nil {
9649		return nil
9650	}
9651
9652	shape, ok := value.(map[string]interface{})
9653	if !ok {
9654		return fmt.Errorf("unexpected JSON type %v", value)
9655	}
9656
9657	var sv *types.ResolverEndpoint
9658	if *v == nil {
9659		sv = &types.ResolverEndpoint{}
9660	} else {
9661		sv = *v
9662	}
9663
9664	for key, value := range shape {
9665		switch key {
9666		case "Arn":
9667			if value != nil {
9668				jtv, ok := value.(string)
9669				if !ok {
9670					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
9671				}
9672				sv.Arn = ptr.String(jtv)
9673			}
9674
9675		case "CreationTime":
9676			if value != nil {
9677				jtv, ok := value.(string)
9678				if !ok {
9679					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9680				}
9681				sv.CreationTime = ptr.String(jtv)
9682			}
9683
9684		case "CreatorRequestId":
9685			if value != nil {
9686				jtv, ok := value.(string)
9687				if !ok {
9688					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
9689				}
9690				sv.CreatorRequestId = ptr.String(jtv)
9691			}
9692
9693		case "Direction":
9694			if value != nil {
9695				jtv, ok := value.(string)
9696				if !ok {
9697					return fmt.Errorf("expected ResolverEndpointDirection to be of type string, got %T instead", value)
9698				}
9699				sv.Direction = types.ResolverEndpointDirection(jtv)
9700			}
9701
9702		case "HostVPCId":
9703			if value != nil {
9704				jtv, ok := value.(string)
9705				if !ok {
9706					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9707				}
9708				sv.HostVPCId = ptr.String(jtv)
9709			}
9710
9711		case "Id":
9712			if value != nil {
9713				jtv, ok := value.(string)
9714				if !ok {
9715					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9716				}
9717				sv.Id = ptr.String(jtv)
9718			}
9719
9720		case "IpAddressCount":
9721			if value != nil {
9722				jtv, ok := value.(json.Number)
9723				if !ok {
9724					return fmt.Errorf("expected IpAddressCount to be json.Number, got %T instead", value)
9725				}
9726				i64, err := jtv.Int64()
9727				if err != nil {
9728					return err
9729				}
9730				sv.IpAddressCount = ptr.Int32(int32(i64))
9731			}
9732
9733		case "ModificationTime":
9734			if value != nil {
9735				jtv, ok := value.(string)
9736				if !ok {
9737					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9738				}
9739				sv.ModificationTime = ptr.String(jtv)
9740			}
9741
9742		case "Name":
9743			if value != nil {
9744				jtv, ok := value.(string)
9745				if !ok {
9746					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
9747				}
9748				sv.Name = ptr.String(jtv)
9749			}
9750
9751		case "SecurityGroupIds":
9752			if err := awsAwsjson11_deserializeDocumentSecurityGroupIds(&sv.SecurityGroupIds, value); err != nil {
9753				return err
9754			}
9755
9756		case "Status":
9757			if value != nil {
9758				jtv, ok := value.(string)
9759				if !ok {
9760					return fmt.Errorf("expected ResolverEndpointStatus to be of type string, got %T instead", value)
9761				}
9762				sv.Status = types.ResolverEndpointStatus(jtv)
9763			}
9764
9765		case "StatusMessage":
9766			if value != nil {
9767				jtv, ok := value.(string)
9768				if !ok {
9769					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
9770				}
9771				sv.StatusMessage = ptr.String(jtv)
9772			}
9773
9774		default:
9775			_, _ = key, value
9776
9777		}
9778	}
9779	*v = sv
9780	return nil
9781}
9782
9783func awsAwsjson11_deserializeDocumentResolverEndpoints(v *[]types.ResolverEndpoint, value interface{}) error {
9784	if v == nil {
9785		return fmt.Errorf("unexpected nil of type %T", v)
9786	}
9787	if value == nil {
9788		return nil
9789	}
9790
9791	shape, ok := value.([]interface{})
9792	if !ok {
9793		return fmt.Errorf("unexpected JSON type %v", value)
9794	}
9795
9796	var cv []types.ResolverEndpoint
9797	if *v == nil {
9798		cv = []types.ResolverEndpoint{}
9799	} else {
9800		cv = *v
9801	}
9802
9803	for _, value := range shape {
9804		var col types.ResolverEndpoint
9805		destAddr := &col
9806		if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&destAddr, value); err != nil {
9807			return err
9808		}
9809		col = *destAddr
9810		cv = append(cv, col)
9811
9812	}
9813	*v = cv
9814	return nil
9815}
9816
9817func awsAwsjson11_deserializeDocumentResolverQueryLogConfig(v **types.ResolverQueryLogConfig, value interface{}) error {
9818	if v == nil {
9819		return fmt.Errorf("unexpected nil of type %T", v)
9820	}
9821	if value == nil {
9822		return nil
9823	}
9824
9825	shape, ok := value.(map[string]interface{})
9826	if !ok {
9827		return fmt.Errorf("unexpected JSON type %v", value)
9828	}
9829
9830	var sv *types.ResolverQueryLogConfig
9831	if *v == nil {
9832		sv = &types.ResolverQueryLogConfig{}
9833	} else {
9834		sv = *v
9835	}
9836
9837	for key, value := range shape {
9838		switch key {
9839		case "Arn":
9840			if value != nil {
9841				jtv, ok := value.(string)
9842				if !ok {
9843					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
9844				}
9845				sv.Arn = ptr.String(jtv)
9846			}
9847
9848		case "AssociationCount":
9849			if value != nil {
9850				jtv, ok := value.(json.Number)
9851				if !ok {
9852					return fmt.Errorf("expected Count to be json.Number, got %T instead", value)
9853				}
9854				i64, err := jtv.Int64()
9855				if err != nil {
9856					return err
9857				}
9858				sv.AssociationCount = int32(i64)
9859			}
9860
9861		case "CreationTime":
9862			if value != nil {
9863				jtv, ok := value.(string)
9864				if !ok {
9865					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9866				}
9867				sv.CreationTime = ptr.String(jtv)
9868			}
9869
9870		case "CreatorRequestId":
9871			if value != nil {
9872				jtv, ok := value.(string)
9873				if !ok {
9874					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
9875				}
9876				sv.CreatorRequestId = ptr.String(jtv)
9877			}
9878
9879		case "DestinationArn":
9880			if value != nil {
9881				jtv, ok := value.(string)
9882				if !ok {
9883					return fmt.Errorf("expected DestinationArn to be of type string, got %T instead", value)
9884				}
9885				sv.DestinationArn = ptr.String(jtv)
9886			}
9887
9888		case "Id":
9889			if value != nil {
9890				jtv, ok := value.(string)
9891				if !ok {
9892					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9893				}
9894				sv.Id = ptr.String(jtv)
9895			}
9896
9897		case "Name":
9898			if value != nil {
9899				jtv, ok := value.(string)
9900				if !ok {
9901					return fmt.Errorf("expected ResolverQueryLogConfigName to be of type string, got %T instead", value)
9902				}
9903				sv.Name = ptr.String(jtv)
9904			}
9905
9906		case "OwnerId":
9907			if value != nil {
9908				jtv, ok := value.(string)
9909				if !ok {
9910					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
9911				}
9912				sv.OwnerId = ptr.String(jtv)
9913			}
9914
9915		case "ShareStatus":
9916			if value != nil {
9917				jtv, ok := value.(string)
9918				if !ok {
9919					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
9920				}
9921				sv.ShareStatus = types.ShareStatus(jtv)
9922			}
9923
9924		case "Status":
9925			if value != nil {
9926				jtv, ok := value.(string)
9927				if !ok {
9928					return fmt.Errorf("expected ResolverQueryLogConfigStatus to be of type string, got %T instead", value)
9929				}
9930				sv.Status = types.ResolverQueryLogConfigStatus(jtv)
9931			}
9932
9933		default:
9934			_, _ = key, value
9935
9936		}
9937	}
9938	*v = sv
9939	return nil
9940}
9941
9942func awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(v **types.ResolverQueryLogConfigAssociation, value interface{}) error {
9943	if v == nil {
9944		return fmt.Errorf("unexpected nil of type %T", v)
9945	}
9946	if value == nil {
9947		return nil
9948	}
9949
9950	shape, ok := value.(map[string]interface{})
9951	if !ok {
9952		return fmt.Errorf("unexpected JSON type %v", value)
9953	}
9954
9955	var sv *types.ResolverQueryLogConfigAssociation
9956	if *v == nil {
9957		sv = &types.ResolverQueryLogConfigAssociation{}
9958	} else {
9959		sv = *v
9960	}
9961
9962	for key, value := range shape {
9963		switch key {
9964		case "CreationTime":
9965			if value != nil {
9966				jtv, ok := value.(string)
9967				if !ok {
9968					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
9969				}
9970				sv.CreationTime = ptr.String(jtv)
9971			}
9972
9973		case "Error":
9974			if value != nil {
9975				jtv, ok := value.(string)
9976				if !ok {
9977					return fmt.Errorf("expected ResolverQueryLogConfigAssociationError to be of type string, got %T instead", value)
9978				}
9979				sv.Error = types.ResolverQueryLogConfigAssociationError(jtv)
9980			}
9981
9982		case "ErrorMessage":
9983			if value != nil {
9984				jtv, ok := value.(string)
9985				if !ok {
9986					return fmt.Errorf("expected ResolverQueryLogConfigAssociationErrorMessage to be of type string, got %T instead", value)
9987				}
9988				sv.ErrorMessage = ptr.String(jtv)
9989			}
9990
9991		case "Id":
9992			if value != nil {
9993				jtv, ok := value.(string)
9994				if !ok {
9995					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
9996				}
9997				sv.Id = ptr.String(jtv)
9998			}
9999
10000		case "ResolverQueryLogConfigId":
10001			if value != nil {
10002				jtv, ok := value.(string)
10003				if !ok {
10004					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10005				}
10006				sv.ResolverQueryLogConfigId = ptr.String(jtv)
10007			}
10008
10009		case "ResourceId":
10010			if value != nil {
10011				jtv, ok := value.(string)
10012				if !ok {
10013					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10014				}
10015				sv.ResourceId = ptr.String(jtv)
10016			}
10017
10018		case "Status":
10019			if value != nil {
10020				jtv, ok := value.(string)
10021				if !ok {
10022					return fmt.Errorf("expected ResolverQueryLogConfigAssociationStatus to be of type string, got %T instead", value)
10023				}
10024				sv.Status = types.ResolverQueryLogConfigAssociationStatus(jtv)
10025			}
10026
10027		default:
10028			_, _ = key, value
10029
10030		}
10031	}
10032	*v = sv
10033	return nil
10034}
10035
10036func awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociationList(v *[]types.ResolverQueryLogConfigAssociation, value interface{}) error {
10037	if v == nil {
10038		return fmt.Errorf("unexpected nil of type %T", v)
10039	}
10040	if value == nil {
10041		return nil
10042	}
10043
10044	shape, ok := value.([]interface{})
10045	if !ok {
10046		return fmt.Errorf("unexpected JSON type %v", value)
10047	}
10048
10049	var cv []types.ResolverQueryLogConfigAssociation
10050	if *v == nil {
10051		cv = []types.ResolverQueryLogConfigAssociation{}
10052	} else {
10053		cv = *v
10054	}
10055
10056	for _, value := range shape {
10057		var col types.ResolverQueryLogConfigAssociation
10058		destAddr := &col
10059		if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&destAddr, value); err != nil {
10060			return err
10061		}
10062		col = *destAddr
10063		cv = append(cv, col)
10064
10065	}
10066	*v = cv
10067	return nil
10068}
10069
10070func awsAwsjson11_deserializeDocumentResolverQueryLogConfigList(v *[]types.ResolverQueryLogConfig, value interface{}) error {
10071	if v == nil {
10072		return fmt.Errorf("unexpected nil of type %T", v)
10073	}
10074	if value == nil {
10075		return nil
10076	}
10077
10078	shape, ok := value.([]interface{})
10079	if !ok {
10080		return fmt.Errorf("unexpected JSON type %v", value)
10081	}
10082
10083	var cv []types.ResolverQueryLogConfig
10084	if *v == nil {
10085		cv = []types.ResolverQueryLogConfig{}
10086	} else {
10087		cv = *v
10088	}
10089
10090	for _, value := range shape {
10091		var col types.ResolverQueryLogConfig
10092		destAddr := &col
10093		if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&destAddr, value); err != nil {
10094			return err
10095		}
10096		col = *destAddr
10097		cv = append(cv, col)
10098
10099	}
10100	*v = cv
10101	return nil
10102}
10103
10104func awsAwsjson11_deserializeDocumentResolverRule(v **types.ResolverRule, value interface{}) error {
10105	if v == nil {
10106		return fmt.Errorf("unexpected nil of type %T", v)
10107	}
10108	if value == nil {
10109		return nil
10110	}
10111
10112	shape, ok := value.(map[string]interface{})
10113	if !ok {
10114		return fmt.Errorf("unexpected JSON type %v", value)
10115	}
10116
10117	var sv *types.ResolverRule
10118	if *v == nil {
10119		sv = &types.ResolverRule{}
10120	} else {
10121		sv = *v
10122	}
10123
10124	for key, value := range shape {
10125		switch key {
10126		case "Arn":
10127			if value != nil {
10128				jtv, ok := value.(string)
10129				if !ok {
10130					return fmt.Errorf("expected Arn to be of type string, got %T instead", value)
10131				}
10132				sv.Arn = ptr.String(jtv)
10133			}
10134
10135		case "CreationTime":
10136			if value != nil {
10137				jtv, ok := value.(string)
10138				if !ok {
10139					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
10140				}
10141				sv.CreationTime = ptr.String(jtv)
10142			}
10143
10144		case "CreatorRequestId":
10145			if value != nil {
10146				jtv, ok := value.(string)
10147				if !ok {
10148					return fmt.Errorf("expected CreatorRequestId to be of type string, got %T instead", value)
10149				}
10150				sv.CreatorRequestId = ptr.String(jtv)
10151			}
10152
10153		case "DomainName":
10154			if value != nil {
10155				jtv, ok := value.(string)
10156				if !ok {
10157					return fmt.Errorf("expected DomainName to be of type string, got %T instead", value)
10158				}
10159				sv.DomainName = ptr.String(jtv)
10160			}
10161
10162		case "Id":
10163			if value != nil {
10164				jtv, ok := value.(string)
10165				if !ok {
10166					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10167				}
10168				sv.Id = ptr.String(jtv)
10169			}
10170
10171		case "ModificationTime":
10172			if value != nil {
10173				jtv, ok := value.(string)
10174				if !ok {
10175					return fmt.Errorf("expected Rfc3339TimeString to be of type string, got %T instead", value)
10176				}
10177				sv.ModificationTime = ptr.String(jtv)
10178			}
10179
10180		case "Name":
10181			if value != nil {
10182				jtv, ok := value.(string)
10183				if !ok {
10184					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
10185				}
10186				sv.Name = ptr.String(jtv)
10187			}
10188
10189		case "OwnerId":
10190			if value != nil {
10191				jtv, ok := value.(string)
10192				if !ok {
10193					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
10194				}
10195				sv.OwnerId = ptr.String(jtv)
10196			}
10197
10198		case "ResolverEndpointId":
10199			if value != nil {
10200				jtv, ok := value.(string)
10201				if !ok {
10202					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10203				}
10204				sv.ResolverEndpointId = ptr.String(jtv)
10205			}
10206
10207		case "RuleType":
10208			if value != nil {
10209				jtv, ok := value.(string)
10210				if !ok {
10211					return fmt.Errorf("expected RuleTypeOption to be of type string, got %T instead", value)
10212				}
10213				sv.RuleType = types.RuleTypeOption(jtv)
10214			}
10215
10216		case "ShareStatus":
10217			if value != nil {
10218				jtv, ok := value.(string)
10219				if !ok {
10220					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
10221				}
10222				sv.ShareStatus = types.ShareStatus(jtv)
10223			}
10224
10225		case "Status":
10226			if value != nil {
10227				jtv, ok := value.(string)
10228				if !ok {
10229					return fmt.Errorf("expected ResolverRuleStatus to be of type string, got %T instead", value)
10230				}
10231				sv.Status = types.ResolverRuleStatus(jtv)
10232			}
10233
10234		case "StatusMessage":
10235			if value != nil {
10236				jtv, ok := value.(string)
10237				if !ok {
10238					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
10239				}
10240				sv.StatusMessage = ptr.String(jtv)
10241			}
10242
10243		case "TargetIps":
10244			if err := awsAwsjson11_deserializeDocumentTargetList(&sv.TargetIps, value); err != nil {
10245				return err
10246			}
10247
10248		default:
10249			_, _ = key, value
10250
10251		}
10252	}
10253	*v = sv
10254	return nil
10255}
10256
10257func awsAwsjson11_deserializeDocumentResolverRuleAssociation(v **types.ResolverRuleAssociation, value interface{}) error {
10258	if v == nil {
10259		return fmt.Errorf("unexpected nil of type %T", v)
10260	}
10261	if value == nil {
10262		return nil
10263	}
10264
10265	shape, ok := value.(map[string]interface{})
10266	if !ok {
10267		return fmt.Errorf("unexpected JSON type %v", value)
10268	}
10269
10270	var sv *types.ResolverRuleAssociation
10271	if *v == nil {
10272		sv = &types.ResolverRuleAssociation{}
10273	} else {
10274		sv = *v
10275	}
10276
10277	for key, value := range shape {
10278		switch key {
10279		case "Id":
10280			if value != nil {
10281				jtv, ok := value.(string)
10282				if !ok {
10283					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10284				}
10285				sv.Id = ptr.String(jtv)
10286			}
10287
10288		case "Name":
10289			if value != nil {
10290				jtv, ok := value.(string)
10291				if !ok {
10292					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
10293				}
10294				sv.Name = ptr.String(jtv)
10295			}
10296
10297		case "ResolverRuleId":
10298			if value != nil {
10299				jtv, ok := value.(string)
10300				if !ok {
10301					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10302				}
10303				sv.ResolverRuleId = ptr.String(jtv)
10304			}
10305
10306		case "Status":
10307			if value != nil {
10308				jtv, ok := value.(string)
10309				if !ok {
10310					return fmt.Errorf("expected ResolverRuleAssociationStatus to be of type string, got %T instead", value)
10311				}
10312				sv.Status = types.ResolverRuleAssociationStatus(jtv)
10313			}
10314
10315		case "StatusMessage":
10316			if value != nil {
10317				jtv, ok := value.(string)
10318				if !ok {
10319					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
10320				}
10321				sv.StatusMessage = ptr.String(jtv)
10322			}
10323
10324		case "VPCId":
10325			if value != nil {
10326				jtv, ok := value.(string)
10327				if !ok {
10328					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10329				}
10330				sv.VPCId = ptr.String(jtv)
10331			}
10332
10333		default:
10334			_, _ = key, value
10335
10336		}
10337	}
10338	*v = sv
10339	return nil
10340}
10341
10342func awsAwsjson11_deserializeDocumentResolverRuleAssociations(v *[]types.ResolverRuleAssociation, value interface{}) error {
10343	if v == nil {
10344		return fmt.Errorf("unexpected nil of type %T", v)
10345	}
10346	if value == nil {
10347		return nil
10348	}
10349
10350	shape, ok := value.([]interface{})
10351	if !ok {
10352		return fmt.Errorf("unexpected JSON type %v", value)
10353	}
10354
10355	var cv []types.ResolverRuleAssociation
10356	if *v == nil {
10357		cv = []types.ResolverRuleAssociation{}
10358	} else {
10359		cv = *v
10360	}
10361
10362	for _, value := range shape {
10363		var col types.ResolverRuleAssociation
10364		destAddr := &col
10365		if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&destAddr, value); err != nil {
10366			return err
10367		}
10368		col = *destAddr
10369		cv = append(cv, col)
10370
10371	}
10372	*v = cv
10373	return nil
10374}
10375
10376func awsAwsjson11_deserializeDocumentResolverRules(v *[]types.ResolverRule, value interface{}) error {
10377	if v == nil {
10378		return fmt.Errorf("unexpected nil of type %T", v)
10379	}
10380	if value == nil {
10381		return nil
10382	}
10383
10384	shape, ok := value.([]interface{})
10385	if !ok {
10386		return fmt.Errorf("unexpected JSON type %v", value)
10387	}
10388
10389	var cv []types.ResolverRule
10390	if *v == nil {
10391		cv = []types.ResolverRule{}
10392	} else {
10393		cv = *v
10394	}
10395
10396	for _, value := range shape {
10397		var col types.ResolverRule
10398		destAddr := &col
10399		if err := awsAwsjson11_deserializeDocumentResolverRule(&destAddr, value); err != nil {
10400			return err
10401		}
10402		col = *destAddr
10403		cv = append(cv, col)
10404
10405	}
10406	*v = cv
10407	return nil
10408}
10409
10410func awsAwsjson11_deserializeDocumentResourceExistsException(v **types.ResourceExistsException, value interface{}) error {
10411	if v == nil {
10412		return fmt.Errorf("unexpected nil of type %T", v)
10413	}
10414	if value == nil {
10415		return nil
10416	}
10417
10418	shape, ok := value.(map[string]interface{})
10419	if !ok {
10420		return fmt.Errorf("unexpected JSON type %v", value)
10421	}
10422
10423	var sv *types.ResourceExistsException
10424	if *v == nil {
10425		sv = &types.ResourceExistsException{}
10426	} else {
10427		sv = *v
10428	}
10429
10430	for key, value := range shape {
10431		switch key {
10432		case "Message":
10433			if value != nil {
10434				jtv, ok := value.(string)
10435				if !ok {
10436					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10437				}
10438				sv.Message = ptr.String(jtv)
10439			}
10440
10441		case "ResourceType":
10442			if value != nil {
10443				jtv, ok := value.(string)
10444				if !ok {
10445					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10446				}
10447				sv.ResourceType = ptr.String(jtv)
10448			}
10449
10450		default:
10451			_, _ = key, value
10452
10453		}
10454	}
10455	*v = sv
10456	return nil
10457}
10458
10459func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error {
10460	if v == nil {
10461		return fmt.Errorf("unexpected nil of type %T", v)
10462	}
10463	if value == nil {
10464		return nil
10465	}
10466
10467	shape, ok := value.(map[string]interface{})
10468	if !ok {
10469		return fmt.Errorf("unexpected JSON type %v", value)
10470	}
10471
10472	var sv *types.ResourceInUseException
10473	if *v == nil {
10474		sv = &types.ResourceInUseException{}
10475	} else {
10476		sv = *v
10477	}
10478
10479	for key, value := range shape {
10480		switch key {
10481		case "Message":
10482			if value != nil {
10483				jtv, ok := value.(string)
10484				if !ok {
10485					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10486				}
10487				sv.Message = ptr.String(jtv)
10488			}
10489
10490		case "ResourceType":
10491			if value != nil {
10492				jtv, ok := value.(string)
10493				if !ok {
10494					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10495				}
10496				sv.ResourceType = ptr.String(jtv)
10497			}
10498
10499		default:
10500			_, _ = key, value
10501
10502		}
10503	}
10504	*v = sv
10505	return nil
10506}
10507
10508func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
10509	if v == nil {
10510		return fmt.Errorf("unexpected nil of type %T", v)
10511	}
10512	if value == nil {
10513		return nil
10514	}
10515
10516	shape, ok := value.(map[string]interface{})
10517	if !ok {
10518		return fmt.Errorf("unexpected JSON type %v", value)
10519	}
10520
10521	var sv *types.ResourceNotFoundException
10522	if *v == nil {
10523		sv = &types.ResourceNotFoundException{}
10524	} else {
10525		sv = *v
10526	}
10527
10528	for key, value := range shape {
10529		switch key {
10530		case "Message":
10531			if value != nil {
10532				jtv, ok := value.(string)
10533				if !ok {
10534					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10535				}
10536				sv.Message = ptr.String(jtv)
10537			}
10538
10539		case "ResourceType":
10540			if value != nil {
10541				jtv, ok := value.(string)
10542				if !ok {
10543					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10544				}
10545				sv.ResourceType = ptr.String(jtv)
10546			}
10547
10548		default:
10549			_, _ = key, value
10550
10551		}
10552	}
10553	*v = sv
10554	return nil
10555}
10556
10557func awsAwsjson11_deserializeDocumentResourceUnavailableException(v **types.ResourceUnavailableException, value interface{}) error {
10558	if v == nil {
10559		return fmt.Errorf("unexpected nil of type %T", v)
10560	}
10561	if value == nil {
10562		return nil
10563	}
10564
10565	shape, ok := value.(map[string]interface{})
10566	if !ok {
10567		return fmt.Errorf("unexpected JSON type %v", value)
10568	}
10569
10570	var sv *types.ResourceUnavailableException
10571	if *v == nil {
10572		sv = &types.ResourceUnavailableException{}
10573	} else {
10574		sv = *v
10575	}
10576
10577	for key, value := range shape {
10578		switch key {
10579		case "Message":
10580			if value != nil {
10581				jtv, ok := value.(string)
10582				if !ok {
10583					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10584				}
10585				sv.Message = ptr.String(jtv)
10586			}
10587
10588		case "ResourceType":
10589			if value != nil {
10590				jtv, ok := value.(string)
10591				if !ok {
10592					return fmt.Errorf("expected String to be of type string, got %T instead", value)
10593				}
10594				sv.ResourceType = ptr.String(jtv)
10595			}
10596
10597		default:
10598			_, _ = key, value
10599
10600		}
10601	}
10602	*v = sv
10603	return nil
10604}
10605
10606func awsAwsjson11_deserializeDocumentSecurityGroupIds(v *[]string, value interface{}) error {
10607	if v == nil {
10608		return fmt.Errorf("unexpected nil of type %T", v)
10609	}
10610	if value == nil {
10611		return nil
10612	}
10613
10614	shape, ok := value.([]interface{})
10615	if !ok {
10616		return fmt.Errorf("unexpected JSON type %v", value)
10617	}
10618
10619	var cv []string
10620	if *v == nil {
10621		cv = []string{}
10622	} else {
10623		cv = *v
10624	}
10625
10626	for _, value := range shape {
10627		var col string
10628		if value != nil {
10629			jtv, ok := value.(string)
10630			if !ok {
10631				return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10632			}
10633			col = jtv
10634		}
10635		cv = append(cv, col)
10636
10637	}
10638	*v = cv
10639	return nil
10640}
10641
10642func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
10643	if v == nil {
10644		return fmt.Errorf("unexpected nil of type %T", v)
10645	}
10646	if value == nil {
10647		return nil
10648	}
10649
10650	shape, ok := value.(map[string]interface{})
10651	if !ok {
10652		return fmt.Errorf("unexpected JSON type %v", value)
10653	}
10654
10655	var sv *types.Tag
10656	if *v == nil {
10657		sv = &types.Tag{}
10658	} else {
10659		sv = *v
10660	}
10661
10662	for key, value := range shape {
10663		switch key {
10664		case "Key":
10665			if value != nil {
10666				jtv, ok := value.(string)
10667				if !ok {
10668					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
10669				}
10670				sv.Key = ptr.String(jtv)
10671			}
10672
10673		case "Value":
10674			if value != nil {
10675				jtv, ok := value.(string)
10676				if !ok {
10677					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
10678				}
10679				sv.Value = ptr.String(jtv)
10680			}
10681
10682		default:
10683			_, _ = key, value
10684
10685		}
10686	}
10687	*v = sv
10688	return nil
10689}
10690
10691func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
10692	if v == nil {
10693		return fmt.Errorf("unexpected nil of type %T", v)
10694	}
10695	if value == nil {
10696		return nil
10697	}
10698
10699	shape, ok := value.([]interface{})
10700	if !ok {
10701		return fmt.Errorf("unexpected JSON type %v", value)
10702	}
10703
10704	var cv []types.Tag
10705	if *v == nil {
10706		cv = []types.Tag{}
10707	} else {
10708		cv = *v
10709	}
10710
10711	for _, value := range shape {
10712		var col types.Tag
10713		destAddr := &col
10714		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
10715			return err
10716		}
10717		col = *destAddr
10718		cv = append(cv, col)
10719
10720	}
10721	*v = cv
10722	return nil
10723}
10724
10725func awsAwsjson11_deserializeDocumentTargetAddress(v **types.TargetAddress, value interface{}) error {
10726	if v == nil {
10727		return fmt.Errorf("unexpected nil of type %T", v)
10728	}
10729	if value == nil {
10730		return nil
10731	}
10732
10733	shape, ok := value.(map[string]interface{})
10734	if !ok {
10735		return fmt.Errorf("unexpected JSON type %v", value)
10736	}
10737
10738	var sv *types.TargetAddress
10739	if *v == nil {
10740		sv = &types.TargetAddress{}
10741	} else {
10742		sv = *v
10743	}
10744
10745	for key, value := range shape {
10746		switch key {
10747		case "Ip":
10748			if value != nil {
10749				jtv, ok := value.(string)
10750				if !ok {
10751					return fmt.Errorf("expected Ip to be of type string, got %T instead", value)
10752				}
10753				sv.Ip = ptr.String(jtv)
10754			}
10755
10756		case "Port":
10757			if value != nil {
10758				jtv, ok := value.(json.Number)
10759				if !ok {
10760					return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
10761				}
10762				i64, err := jtv.Int64()
10763				if err != nil {
10764					return err
10765				}
10766				sv.Port = ptr.Int32(int32(i64))
10767			}
10768
10769		default:
10770			_, _ = key, value
10771
10772		}
10773	}
10774	*v = sv
10775	return nil
10776}
10777
10778func awsAwsjson11_deserializeDocumentTargetList(v *[]types.TargetAddress, value interface{}) error {
10779	if v == nil {
10780		return fmt.Errorf("unexpected nil of type %T", v)
10781	}
10782	if value == nil {
10783		return nil
10784	}
10785
10786	shape, ok := value.([]interface{})
10787	if !ok {
10788		return fmt.Errorf("unexpected JSON type %v", value)
10789	}
10790
10791	var cv []types.TargetAddress
10792	if *v == nil {
10793		cv = []types.TargetAddress{}
10794	} else {
10795		cv = *v
10796	}
10797
10798	for _, value := range shape {
10799		var col types.TargetAddress
10800		destAddr := &col
10801		if err := awsAwsjson11_deserializeDocumentTargetAddress(&destAddr, value); err != nil {
10802			return err
10803		}
10804		col = *destAddr
10805		cv = append(cv, col)
10806
10807	}
10808	*v = cv
10809	return nil
10810}
10811
10812func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error {
10813	if v == nil {
10814		return fmt.Errorf("unexpected nil of type %T", v)
10815	}
10816	if value == nil {
10817		return nil
10818	}
10819
10820	shape, ok := value.(map[string]interface{})
10821	if !ok {
10822		return fmt.Errorf("unexpected JSON type %v", value)
10823	}
10824
10825	var sv *types.ThrottlingException
10826	if *v == nil {
10827		sv = &types.ThrottlingException{}
10828	} else {
10829		sv = *v
10830	}
10831
10832	for key, value := range shape {
10833		switch key {
10834		case "Message":
10835			if value != nil {
10836				jtv, ok := value.(string)
10837				if !ok {
10838					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10839				}
10840				sv.Message = ptr.String(jtv)
10841			}
10842
10843		default:
10844			_, _ = key, value
10845
10846		}
10847	}
10848	*v = sv
10849	return nil
10850}
10851
10852func awsAwsjson11_deserializeDocumentUnknownResourceException(v **types.UnknownResourceException, value interface{}) error {
10853	if v == nil {
10854		return fmt.Errorf("unexpected nil of type %T", v)
10855	}
10856	if value == nil {
10857		return nil
10858	}
10859
10860	shape, ok := value.(map[string]interface{})
10861	if !ok {
10862		return fmt.Errorf("unexpected JSON type %v", value)
10863	}
10864
10865	var sv *types.UnknownResourceException
10866	if *v == nil {
10867		sv = &types.UnknownResourceException{}
10868	} else {
10869		sv = *v
10870	}
10871
10872	for key, value := range shape {
10873		switch key {
10874		case "Message":
10875			if value != nil {
10876				jtv, ok := value.(string)
10877				if !ok {
10878					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10879				}
10880				sv.Message = ptr.String(jtv)
10881			}
10882
10883		default:
10884			_, _ = key, value
10885
10886		}
10887	}
10888	*v = sv
10889	return nil
10890}
10891
10892func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
10893	if v == nil {
10894		return fmt.Errorf("unexpected nil of type %T", v)
10895	}
10896	if value == nil {
10897		return nil
10898	}
10899
10900	shape, ok := value.(map[string]interface{})
10901	if !ok {
10902		return fmt.Errorf("unexpected JSON type %v", value)
10903	}
10904
10905	var sv *types.ValidationException
10906	if *v == nil {
10907		sv = &types.ValidationException{}
10908	} else {
10909		sv = *v
10910	}
10911
10912	for key, value := range shape {
10913		switch key {
10914		case "Message":
10915			if value != nil {
10916				jtv, ok := value.(string)
10917				if !ok {
10918					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10919				}
10920				sv.Message = ptr.String(jtv)
10921			}
10922
10923		default:
10924			_, _ = key, value
10925
10926		}
10927	}
10928	*v = sv
10929	return nil
10930}
10931
10932func awsAwsjson11_deserializeOpDocumentAssociateFirewallRuleGroupOutput(v **AssociateFirewallRuleGroupOutput, value interface{}) error {
10933	if v == nil {
10934		return fmt.Errorf("unexpected nil of type %T", v)
10935	}
10936	if value == nil {
10937		return nil
10938	}
10939
10940	shape, ok := value.(map[string]interface{})
10941	if !ok {
10942		return fmt.Errorf("unexpected JSON type %v", value)
10943	}
10944
10945	var sv *AssociateFirewallRuleGroupOutput
10946	if *v == nil {
10947		sv = &AssociateFirewallRuleGroupOutput{}
10948	} else {
10949		sv = *v
10950	}
10951
10952	for key, value := range shape {
10953		switch key {
10954		case "FirewallRuleGroupAssociation":
10955			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil {
10956				return err
10957			}
10958
10959		default:
10960			_, _ = key, value
10961
10962		}
10963	}
10964	*v = sv
10965	return nil
10966}
10967
10968func awsAwsjson11_deserializeOpDocumentAssociateResolverEndpointIpAddressOutput(v **AssociateResolverEndpointIpAddressOutput, value interface{}) error {
10969	if v == nil {
10970		return fmt.Errorf("unexpected nil of type %T", v)
10971	}
10972	if value == nil {
10973		return nil
10974	}
10975
10976	shape, ok := value.(map[string]interface{})
10977	if !ok {
10978		return fmt.Errorf("unexpected JSON type %v", value)
10979	}
10980
10981	var sv *AssociateResolverEndpointIpAddressOutput
10982	if *v == nil {
10983		sv = &AssociateResolverEndpointIpAddressOutput{}
10984	} else {
10985		sv = *v
10986	}
10987
10988	for key, value := range shape {
10989		switch key {
10990		case "ResolverEndpoint":
10991			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
10992				return err
10993			}
10994
10995		default:
10996			_, _ = key, value
10997
10998		}
10999	}
11000	*v = sv
11001	return nil
11002}
11003
11004func awsAwsjson11_deserializeOpDocumentAssociateResolverQueryLogConfigOutput(v **AssociateResolverQueryLogConfigOutput, value interface{}) error {
11005	if v == nil {
11006		return fmt.Errorf("unexpected nil of type %T", v)
11007	}
11008	if value == nil {
11009		return nil
11010	}
11011
11012	shape, ok := value.(map[string]interface{})
11013	if !ok {
11014		return fmt.Errorf("unexpected JSON type %v", value)
11015	}
11016
11017	var sv *AssociateResolverQueryLogConfigOutput
11018	if *v == nil {
11019		sv = &AssociateResolverQueryLogConfigOutput{}
11020	} else {
11021		sv = *v
11022	}
11023
11024	for key, value := range shape {
11025		switch key {
11026		case "ResolverQueryLogConfigAssociation":
11027			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil {
11028				return err
11029			}
11030
11031		default:
11032			_, _ = key, value
11033
11034		}
11035	}
11036	*v = sv
11037	return nil
11038}
11039
11040func awsAwsjson11_deserializeOpDocumentAssociateResolverRuleOutput(v **AssociateResolverRuleOutput, value interface{}) error {
11041	if v == nil {
11042		return fmt.Errorf("unexpected nil of type %T", v)
11043	}
11044	if value == nil {
11045		return nil
11046	}
11047
11048	shape, ok := value.(map[string]interface{})
11049	if !ok {
11050		return fmt.Errorf("unexpected JSON type %v", value)
11051	}
11052
11053	var sv *AssociateResolverRuleOutput
11054	if *v == nil {
11055		sv = &AssociateResolverRuleOutput{}
11056	} else {
11057		sv = *v
11058	}
11059
11060	for key, value := range shape {
11061		switch key {
11062		case "ResolverRuleAssociation":
11063			if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil {
11064				return err
11065			}
11066
11067		default:
11068			_, _ = key, value
11069
11070		}
11071	}
11072	*v = sv
11073	return nil
11074}
11075
11076func awsAwsjson11_deserializeOpDocumentCreateFirewallDomainListOutput(v **CreateFirewallDomainListOutput, value interface{}) error {
11077	if v == nil {
11078		return fmt.Errorf("unexpected nil of type %T", v)
11079	}
11080	if value == nil {
11081		return nil
11082	}
11083
11084	shape, ok := value.(map[string]interface{})
11085	if !ok {
11086		return fmt.Errorf("unexpected JSON type %v", value)
11087	}
11088
11089	var sv *CreateFirewallDomainListOutput
11090	if *v == nil {
11091		sv = &CreateFirewallDomainListOutput{}
11092	} else {
11093		sv = *v
11094	}
11095
11096	for key, value := range shape {
11097		switch key {
11098		case "FirewallDomainList":
11099			if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil {
11100				return err
11101			}
11102
11103		default:
11104			_, _ = key, value
11105
11106		}
11107	}
11108	*v = sv
11109	return nil
11110}
11111
11112func awsAwsjson11_deserializeOpDocumentCreateFirewallRuleGroupOutput(v **CreateFirewallRuleGroupOutput, value interface{}) error {
11113	if v == nil {
11114		return fmt.Errorf("unexpected nil of type %T", v)
11115	}
11116	if value == nil {
11117		return nil
11118	}
11119
11120	shape, ok := value.(map[string]interface{})
11121	if !ok {
11122		return fmt.Errorf("unexpected JSON type %v", value)
11123	}
11124
11125	var sv *CreateFirewallRuleGroupOutput
11126	if *v == nil {
11127		sv = &CreateFirewallRuleGroupOutput{}
11128	} else {
11129		sv = *v
11130	}
11131
11132	for key, value := range shape {
11133		switch key {
11134		case "FirewallRuleGroup":
11135			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil {
11136				return err
11137			}
11138
11139		default:
11140			_, _ = key, value
11141
11142		}
11143	}
11144	*v = sv
11145	return nil
11146}
11147
11148func awsAwsjson11_deserializeOpDocumentCreateFirewallRuleOutput(v **CreateFirewallRuleOutput, value interface{}) error {
11149	if v == nil {
11150		return fmt.Errorf("unexpected nil of type %T", v)
11151	}
11152	if value == nil {
11153		return nil
11154	}
11155
11156	shape, ok := value.(map[string]interface{})
11157	if !ok {
11158		return fmt.Errorf("unexpected JSON type %v", value)
11159	}
11160
11161	var sv *CreateFirewallRuleOutput
11162	if *v == nil {
11163		sv = &CreateFirewallRuleOutput{}
11164	} else {
11165		sv = *v
11166	}
11167
11168	for key, value := range shape {
11169		switch key {
11170		case "FirewallRule":
11171			if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil {
11172				return err
11173			}
11174
11175		default:
11176			_, _ = key, value
11177
11178		}
11179	}
11180	*v = sv
11181	return nil
11182}
11183
11184func awsAwsjson11_deserializeOpDocumentCreateResolverEndpointOutput(v **CreateResolverEndpointOutput, value interface{}) error {
11185	if v == nil {
11186		return fmt.Errorf("unexpected nil of type %T", v)
11187	}
11188	if value == nil {
11189		return nil
11190	}
11191
11192	shape, ok := value.(map[string]interface{})
11193	if !ok {
11194		return fmt.Errorf("unexpected JSON type %v", value)
11195	}
11196
11197	var sv *CreateResolverEndpointOutput
11198	if *v == nil {
11199		sv = &CreateResolverEndpointOutput{}
11200	} else {
11201		sv = *v
11202	}
11203
11204	for key, value := range shape {
11205		switch key {
11206		case "ResolverEndpoint":
11207			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
11208				return err
11209			}
11210
11211		default:
11212			_, _ = key, value
11213
11214		}
11215	}
11216	*v = sv
11217	return nil
11218}
11219
11220func awsAwsjson11_deserializeOpDocumentCreateResolverQueryLogConfigOutput(v **CreateResolverQueryLogConfigOutput, value interface{}) error {
11221	if v == nil {
11222		return fmt.Errorf("unexpected nil of type %T", v)
11223	}
11224	if value == nil {
11225		return nil
11226	}
11227
11228	shape, ok := value.(map[string]interface{})
11229	if !ok {
11230		return fmt.Errorf("unexpected JSON type %v", value)
11231	}
11232
11233	var sv *CreateResolverQueryLogConfigOutput
11234	if *v == nil {
11235		sv = &CreateResolverQueryLogConfigOutput{}
11236	} else {
11237		sv = *v
11238	}
11239
11240	for key, value := range shape {
11241		switch key {
11242		case "ResolverQueryLogConfig":
11243			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil {
11244				return err
11245			}
11246
11247		default:
11248			_, _ = key, value
11249
11250		}
11251	}
11252	*v = sv
11253	return nil
11254}
11255
11256func awsAwsjson11_deserializeOpDocumentCreateResolverRuleOutput(v **CreateResolverRuleOutput, value interface{}) error {
11257	if v == nil {
11258		return fmt.Errorf("unexpected nil of type %T", v)
11259	}
11260	if value == nil {
11261		return nil
11262	}
11263
11264	shape, ok := value.(map[string]interface{})
11265	if !ok {
11266		return fmt.Errorf("unexpected JSON type %v", value)
11267	}
11268
11269	var sv *CreateResolverRuleOutput
11270	if *v == nil {
11271		sv = &CreateResolverRuleOutput{}
11272	} else {
11273		sv = *v
11274	}
11275
11276	for key, value := range shape {
11277		switch key {
11278		case "ResolverRule":
11279			if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil {
11280				return err
11281			}
11282
11283		default:
11284			_, _ = key, value
11285
11286		}
11287	}
11288	*v = sv
11289	return nil
11290}
11291
11292func awsAwsjson11_deserializeOpDocumentDeleteFirewallDomainListOutput(v **DeleteFirewallDomainListOutput, value interface{}) error {
11293	if v == nil {
11294		return fmt.Errorf("unexpected nil of type %T", v)
11295	}
11296	if value == nil {
11297		return nil
11298	}
11299
11300	shape, ok := value.(map[string]interface{})
11301	if !ok {
11302		return fmt.Errorf("unexpected JSON type %v", value)
11303	}
11304
11305	var sv *DeleteFirewallDomainListOutput
11306	if *v == nil {
11307		sv = &DeleteFirewallDomainListOutput{}
11308	} else {
11309		sv = *v
11310	}
11311
11312	for key, value := range shape {
11313		switch key {
11314		case "FirewallDomainList":
11315			if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil {
11316				return err
11317			}
11318
11319		default:
11320			_, _ = key, value
11321
11322		}
11323	}
11324	*v = sv
11325	return nil
11326}
11327
11328func awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleGroupOutput(v **DeleteFirewallRuleGroupOutput, value interface{}) error {
11329	if v == nil {
11330		return fmt.Errorf("unexpected nil of type %T", v)
11331	}
11332	if value == nil {
11333		return nil
11334	}
11335
11336	shape, ok := value.(map[string]interface{})
11337	if !ok {
11338		return fmt.Errorf("unexpected JSON type %v", value)
11339	}
11340
11341	var sv *DeleteFirewallRuleGroupOutput
11342	if *v == nil {
11343		sv = &DeleteFirewallRuleGroupOutput{}
11344	} else {
11345		sv = *v
11346	}
11347
11348	for key, value := range shape {
11349		switch key {
11350		case "FirewallRuleGroup":
11351			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil {
11352				return err
11353			}
11354
11355		default:
11356			_, _ = key, value
11357
11358		}
11359	}
11360	*v = sv
11361	return nil
11362}
11363
11364func awsAwsjson11_deserializeOpDocumentDeleteFirewallRuleOutput(v **DeleteFirewallRuleOutput, value interface{}) error {
11365	if v == nil {
11366		return fmt.Errorf("unexpected nil of type %T", v)
11367	}
11368	if value == nil {
11369		return nil
11370	}
11371
11372	shape, ok := value.(map[string]interface{})
11373	if !ok {
11374		return fmt.Errorf("unexpected JSON type %v", value)
11375	}
11376
11377	var sv *DeleteFirewallRuleOutput
11378	if *v == nil {
11379		sv = &DeleteFirewallRuleOutput{}
11380	} else {
11381		sv = *v
11382	}
11383
11384	for key, value := range shape {
11385		switch key {
11386		case "FirewallRule":
11387			if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil {
11388				return err
11389			}
11390
11391		default:
11392			_, _ = key, value
11393
11394		}
11395	}
11396	*v = sv
11397	return nil
11398}
11399
11400func awsAwsjson11_deserializeOpDocumentDeleteResolverEndpointOutput(v **DeleteResolverEndpointOutput, value interface{}) error {
11401	if v == nil {
11402		return fmt.Errorf("unexpected nil of type %T", v)
11403	}
11404	if value == nil {
11405		return nil
11406	}
11407
11408	shape, ok := value.(map[string]interface{})
11409	if !ok {
11410		return fmt.Errorf("unexpected JSON type %v", value)
11411	}
11412
11413	var sv *DeleteResolverEndpointOutput
11414	if *v == nil {
11415		sv = &DeleteResolverEndpointOutput{}
11416	} else {
11417		sv = *v
11418	}
11419
11420	for key, value := range shape {
11421		switch key {
11422		case "ResolverEndpoint":
11423			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
11424				return err
11425			}
11426
11427		default:
11428			_, _ = key, value
11429
11430		}
11431	}
11432	*v = sv
11433	return nil
11434}
11435
11436func awsAwsjson11_deserializeOpDocumentDeleteResolverQueryLogConfigOutput(v **DeleteResolverQueryLogConfigOutput, value interface{}) error {
11437	if v == nil {
11438		return fmt.Errorf("unexpected nil of type %T", v)
11439	}
11440	if value == nil {
11441		return nil
11442	}
11443
11444	shape, ok := value.(map[string]interface{})
11445	if !ok {
11446		return fmt.Errorf("unexpected JSON type %v", value)
11447	}
11448
11449	var sv *DeleteResolverQueryLogConfigOutput
11450	if *v == nil {
11451		sv = &DeleteResolverQueryLogConfigOutput{}
11452	} else {
11453		sv = *v
11454	}
11455
11456	for key, value := range shape {
11457		switch key {
11458		case "ResolverQueryLogConfig":
11459			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil {
11460				return err
11461			}
11462
11463		default:
11464			_, _ = key, value
11465
11466		}
11467	}
11468	*v = sv
11469	return nil
11470}
11471
11472func awsAwsjson11_deserializeOpDocumentDeleteResolverRuleOutput(v **DeleteResolverRuleOutput, value interface{}) error {
11473	if v == nil {
11474		return fmt.Errorf("unexpected nil of type %T", v)
11475	}
11476	if value == nil {
11477		return nil
11478	}
11479
11480	shape, ok := value.(map[string]interface{})
11481	if !ok {
11482		return fmt.Errorf("unexpected JSON type %v", value)
11483	}
11484
11485	var sv *DeleteResolverRuleOutput
11486	if *v == nil {
11487		sv = &DeleteResolverRuleOutput{}
11488	} else {
11489		sv = *v
11490	}
11491
11492	for key, value := range shape {
11493		switch key {
11494		case "ResolverRule":
11495			if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil {
11496				return err
11497			}
11498
11499		default:
11500			_, _ = key, value
11501
11502		}
11503	}
11504	*v = sv
11505	return nil
11506}
11507
11508func awsAwsjson11_deserializeOpDocumentDisassociateFirewallRuleGroupOutput(v **DisassociateFirewallRuleGroupOutput, value interface{}) error {
11509	if v == nil {
11510		return fmt.Errorf("unexpected nil of type %T", v)
11511	}
11512	if value == nil {
11513		return nil
11514	}
11515
11516	shape, ok := value.(map[string]interface{})
11517	if !ok {
11518		return fmt.Errorf("unexpected JSON type %v", value)
11519	}
11520
11521	var sv *DisassociateFirewallRuleGroupOutput
11522	if *v == nil {
11523		sv = &DisassociateFirewallRuleGroupOutput{}
11524	} else {
11525		sv = *v
11526	}
11527
11528	for key, value := range shape {
11529		switch key {
11530		case "FirewallRuleGroupAssociation":
11531			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil {
11532				return err
11533			}
11534
11535		default:
11536			_, _ = key, value
11537
11538		}
11539	}
11540	*v = sv
11541	return nil
11542}
11543
11544func awsAwsjson11_deserializeOpDocumentDisassociateResolverEndpointIpAddressOutput(v **DisassociateResolverEndpointIpAddressOutput, value interface{}) error {
11545	if v == nil {
11546		return fmt.Errorf("unexpected nil of type %T", v)
11547	}
11548	if value == nil {
11549		return nil
11550	}
11551
11552	shape, ok := value.(map[string]interface{})
11553	if !ok {
11554		return fmt.Errorf("unexpected JSON type %v", value)
11555	}
11556
11557	var sv *DisassociateResolverEndpointIpAddressOutput
11558	if *v == nil {
11559		sv = &DisassociateResolverEndpointIpAddressOutput{}
11560	} else {
11561		sv = *v
11562	}
11563
11564	for key, value := range shape {
11565		switch key {
11566		case "ResolverEndpoint":
11567			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
11568				return err
11569			}
11570
11571		default:
11572			_, _ = key, value
11573
11574		}
11575	}
11576	*v = sv
11577	return nil
11578}
11579
11580func awsAwsjson11_deserializeOpDocumentDisassociateResolverQueryLogConfigOutput(v **DisassociateResolverQueryLogConfigOutput, value interface{}) error {
11581	if v == nil {
11582		return fmt.Errorf("unexpected nil of type %T", v)
11583	}
11584	if value == nil {
11585		return nil
11586	}
11587
11588	shape, ok := value.(map[string]interface{})
11589	if !ok {
11590		return fmt.Errorf("unexpected JSON type %v", value)
11591	}
11592
11593	var sv *DisassociateResolverQueryLogConfigOutput
11594	if *v == nil {
11595		sv = &DisassociateResolverQueryLogConfigOutput{}
11596	} else {
11597		sv = *v
11598	}
11599
11600	for key, value := range shape {
11601		switch key {
11602		case "ResolverQueryLogConfigAssociation":
11603			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil {
11604				return err
11605			}
11606
11607		default:
11608			_, _ = key, value
11609
11610		}
11611	}
11612	*v = sv
11613	return nil
11614}
11615
11616func awsAwsjson11_deserializeOpDocumentDisassociateResolverRuleOutput(v **DisassociateResolverRuleOutput, value interface{}) error {
11617	if v == nil {
11618		return fmt.Errorf("unexpected nil of type %T", v)
11619	}
11620	if value == nil {
11621		return nil
11622	}
11623
11624	shape, ok := value.(map[string]interface{})
11625	if !ok {
11626		return fmt.Errorf("unexpected JSON type %v", value)
11627	}
11628
11629	var sv *DisassociateResolverRuleOutput
11630	if *v == nil {
11631		sv = &DisassociateResolverRuleOutput{}
11632	} else {
11633		sv = *v
11634	}
11635
11636	for key, value := range shape {
11637		switch key {
11638		case "ResolverRuleAssociation":
11639			if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil {
11640				return err
11641			}
11642
11643		default:
11644			_, _ = key, value
11645
11646		}
11647	}
11648	*v = sv
11649	return nil
11650}
11651
11652func awsAwsjson11_deserializeOpDocumentGetFirewallConfigOutput(v **GetFirewallConfigOutput, value interface{}) error {
11653	if v == nil {
11654		return fmt.Errorf("unexpected nil of type %T", v)
11655	}
11656	if value == nil {
11657		return nil
11658	}
11659
11660	shape, ok := value.(map[string]interface{})
11661	if !ok {
11662		return fmt.Errorf("unexpected JSON type %v", value)
11663	}
11664
11665	var sv *GetFirewallConfigOutput
11666	if *v == nil {
11667		sv = &GetFirewallConfigOutput{}
11668	} else {
11669		sv = *v
11670	}
11671
11672	for key, value := range shape {
11673		switch key {
11674		case "FirewallConfig":
11675			if err := awsAwsjson11_deserializeDocumentFirewallConfig(&sv.FirewallConfig, value); err != nil {
11676				return err
11677			}
11678
11679		default:
11680			_, _ = key, value
11681
11682		}
11683	}
11684	*v = sv
11685	return nil
11686}
11687
11688func awsAwsjson11_deserializeOpDocumentGetFirewallDomainListOutput(v **GetFirewallDomainListOutput, value interface{}) error {
11689	if v == nil {
11690		return fmt.Errorf("unexpected nil of type %T", v)
11691	}
11692	if value == nil {
11693		return nil
11694	}
11695
11696	shape, ok := value.(map[string]interface{})
11697	if !ok {
11698		return fmt.Errorf("unexpected JSON type %v", value)
11699	}
11700
11701	var sv *GetFirewallDomainListOutput
11702	if *v == nil {
11703		sv = &GetFirewallDomainListOutput{}
11704	} else {
11705		sv = *v
11706	}
11707
11708	for key, value := range shape {
11709		switch key {
11710		case "FirewallDomainList":
11711			if err := awsAwsjson11_deserializeDocumentFirewallDomainList(&sv.FirewallDomainList, value); err != nil {
11712				return err
11713			}
11714
11715		default:
11716			_, _ = key, value
11717
11718		}
11719	}
11720	*v = sv
11721	return nil
11722}
11723
11724func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupAssociationOutput(v **GetFirewallRuleGroupAssociationOutput, value interface{}) error {
11725	if v == nil {
11726		return fmt.Errorf("unexpected nil of type %T", v)
11727	}
11728	if value == nil {
11729		return nil
11730	}
11731
11732	shape, ok := value.(map[string]interface{})
11733	if !ok {
11734		return fmt.Errorf("unexpected JSON type %v", value)
11735	}
11736
11737	var sv *GetFirewallRuleGroupAssociationOutput
11738	if *v == nil {
11739		sv = &GetFirewallRuleGroupAssociationOutput{}
11740	} else {
11741		sv = *v
11742	}
11743
11744	for key, value := range shape {
11745		switch key {
11746		case "FirewallRuleGroupAssociation":
11747			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil {
11748				return err
11749			}
11750
11751		default:
11752			_, _ = key, value
11753
11754		}
11755	}
11756	*v = sv
11757	return nil
11758}
11759
11760func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupOutput(v **GetFirewallRuleGroupOutput, value interface{}) error {
11761	if v == nil {
11762		return fmt.Errorf("unexpected nil of type %T", v)
11763	}
11764	if value == nil {
11765		return nil
11766	}
11767
11768	shape, ok := value.(map[string]interface{})
11769	if !ok {
11770		return fmt.Errorf("unexpected JSON type %v", value)
11771	}
11772
11773	var sv *GetFirewallRuleGroupOutput
11774	if *v == nil {
11775		sv = &GetFirewallRuleGroupOutput{}
11776	} else {
11777		sv = *v
11778	}
11779
11780	for key, value := range shape {
11781		switch key {
11782		case "FirewallRuleGroup":
11783			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroup(&sv.FirewallRuleGroup, value); err != nil {
11784				return err
11785			}
11786
11787		default:
11788			_, _ = key, value
11789
11790		}
11791	}
11792	*v = sv
11793	return nil
11794}
11795
11796func awsAwsjson11_deserializeOpDocumentGetFirewallRuleGroupPolicyOutput(v **GetFirewallRuleGroupPolicyOutput, value interface{}) error {
11797	if v == nil {
11798		return fmt.Errorf("unexpected nil of type %T", v)
11799	}
11800	if value == nil {
11801		return nil
11802	}
11803
11804	shape, ok := value.(map[string]interface{})
11805	if !ok {
11806		return fmt.Errorf("unexpected JSON type %v", value)
11807	}
11808
11809	var sv *GetFirewallRuleGroupPolicyOutput
11810	if *v == nil {
11811		sv = &GetFirewallRuleGroupPolicyOutput{}
11812	} else {
11813		sv = *v
11814	}
11815
11816	for key, value := range shape {
11817		switch key {
11818		case "FirewallRuleGroupPolicy":
11819			if value != nil {
11820				jtv, ok := value.(string)
11821				if !ok {
11822					return fmt.Errorf("expected FirewallRuleGroupPolicy to be of type string, got %T instead", value)
11823				}
11824				sv.FirewallRuleGroupPolicy = ptr.String(jtv)
11825			}
11826
11827		default:
11828			_, _ = key, value
11829
11830		}
11831	}
11832	*v = sv
11833	return nil
11834}
11835
11836func awsAwsjson11_deserializeOpDocumentGetResolverDnssecConfigOutput(v **GetResolverDnssecConfigOutput, value interface{}) error {
11837	if v == nil {
11838		return fmt.Errorf("unexpected nil of type %T", v)
11839	}
11840	if value == nil {
11841		return nil
11842	}
11843
11844	shape, ok := value.(map[string]interface{})
11845	if !ok {
11846		return fmt.Errorf("unexpected JSON type %v", value)
11847	}
11848
11849	var sv *GetResolverDnssecConfigOutput
11850	if *v == nil {
11851		sv = &GetResolverDnssecConfigOutput{}
11852	} else {
11853		sv = *v
11854	}
11855
11856	for key, value := range shape {
11857		switch key {
11858		case "ResolverDNSSECConfig":
11859			if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&sv.ResolverDNSSECConfig, value); err != nil {
11860				return err
11861			}
11862
11863		default:
11864			_, _ = key, value
11865
11866		}
11867	}
11868	*v = sv
11869	return nil
11870}
11871
11872func awsAwsjson11_deserializeOpDocumentGetResolverEndpointOutput(v **GetResolverEndpointOutput, value interface{}) error {
11873	if v == nil {
11874		return fmt.Errorf("unexpected nil of type %T", v)
11875	}
11876	if value == nil {
11877		return nil
11878	}
11879
11880	shape, ok := value.(map[string]interface{})
11881	if !ok {
11882		return fmt.Errorf("unexpected JSON type %v", value)
11883	}
11884
11885	var sv *GetResolverEndpointOutput
11886	if *v == nil {
11887		sv = &GetResolverEndpointOutput{}
11888	} else {
11889		sv = *v
11890	}
11891
11892	for key, value := range shape {
11893		switch key {
11894		case "ResolverEndpoint":
11895			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
11896				return err
11897			}
11898
11899		default:
11900			_, _ = key, value
11901
11902		}
11903	}
11904	*v = sv
11905	return nil
11906}
11907
11908func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigAssociationOutput(v **GetResolverQueryLogConfigAssociationOutput, value interface{}) error {
11909	if v == nil {
11910		return fmt.Errorf("unexpected nil of type %T", v)
11911	}
11912	if value == nil {
11913		return nil
11914	}
11915
11916	shape, ok := value.(map[string]interface{})
11917	if !ok {
11918		return fmt.Errorf("unexpected JSON type %v", value)
11919	}
11920
11921	var sv *GetResolverQueryLogConfigAssociationOutput
11922	if *v == nil {
11923		sv = &GetResolverQueryLogConfigAssociationOutput{}
11924	} else {
11925		sv = *v
11926	}
11927
11928	for key, value := range shape {
11929		switch key {
11930		case "ResolverQueryLogConfigAssociation":
11931			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociation(&sv.ResolverQueryLogConfigAssociation, value); err != nil {
11932				return err
11933			}
11934
11935		default:
11936			_, _ = key, value
11937
11938		}
11939	}
11940	*v = sv
11941	return nil
11942}
11943
11944func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigOutput(v **GetResolverQueryLogConfigOutput, value interface{}) error {
11945	if v == nil {
11946		return fmt.Errorf("unexpected nil of type %T", v)
11947	}
11948	if value == nil {
11949		return nil
11950	}
11951
11952	shape, ok := value.(map[string]interface{})
11953	if !ok {
11954		return fmt.Errorf("unexpected JSON type %v", value)
11955	}
11956
11957	var sv *GetResolverQueryLogConfigOutput
11958	if *v == nil {
11959		sv = &GetResolverQueryLogConfigOutput{}
11960	} else {
11961		sv = *v
11962	}
11963
11964	for key, value := range shape {
11965		switch key {
11966		case "ResolverQueryLogConfig":
11967			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfig(&sv.ResolverQueryLogConfig, value); err != nil {
11968				return err
11969			}
11970
11971		default:
11972			_, _ = key, value
11973
11974		}
11975	}
11976	*v = sv
11977	return nil
11978}
11979
11980func awsAwsjson11_deserializeOpDocumentGetResolverQueryLogConfigPolicyOutput(v **GetResolverQueryLogConfigPolicyOutput, value interface{}) error {
11981	if v == nil {
11982		return fmt.Errorf("unexpected nil of type %T", v)
11983	}
11984	if value == nil {
11985		return nil
11986	}
11987
11988	shape, ok := value.(map[string]interface{})
11989	if !ok {
11990		return fmt.Errorf("unexpected JSON type %v", value)
11991	}
11992
11993	var sv *GetResolverQueryLogConfigPolicyOutput
11994	if *v == nil {
11995		sv = &GetResolverQueryLogConfigPolicyOutput{}
11996	} else {
11997		sv = *v
11998	}
11999
12000	for key, value := range shape {
12001		switch key {
12002		case "ResolverQueryLogConfigPolicy":
12003			if value != nil {
12004				jtv, ok := value.(string)
12005				if !ok {
12006					return fmt.Errorf("expected ResolverQueryLogConfigPolicy to be of type string, got %T instead", value)
12007				}
12008				sv.ResolverQueryLogConfigPolicy = ptr.String(jtv)
12009			}
12010
12011		default:
12012			_, _ = key, value
12013
12014		}
12015	}
12016	*v = sv
12017	return nil
12018}
12019
12020func awsAwsjson11_deserializeOpDocumentGetResolverRuleAssociationOutput(v **GetResolverRuleAssociationOutput, value interface{}) error {
12021	if v == nil {
12022		return fmt.Errorf("unexpected nil of type %T", v)
12023	}
12024	if value == nil {
12025		return nil
12026	}
12027
12028	shape, ok := value.(map[string]interface{})
12029	if !ok {
12030		return fmt.Errorf("unexpected JSON type %v", value)
12031	}
12032
12033	var sv *GetResolverRuleAssociationOutput
12034	if *v == nil {
12035		sv = &GetResolverRuleAssociationOutput{}
12036	} else {
12037		sv = *v
12038	}
12039
12040	for key, value := range shape {
12041		switch key {
12042		case "ResolverRuleAssociation":
12043			if err := awsAwsjson11_deserializeDocumentResolverRuleAssociation(&sv.ResolverRuleAssociation, value); err != nil {
12044				return err
12045			}
12046
12047		default:
12048			_, _ = key, value
12049
12050		}
12051	}
12052	*v = sv
12053	return nil
12054}
12055
12056func awsAwsjson11_deserializeOpDocumentGetResolverRuleOutput(v **GetResolverRuleOutput, value interface{}) error {
12057	if v == nil {
12058		return fmt.Errorf("unexpected nil of type %T", v)
12059	}
12060	if value == nil {
12061		return nil
12062	}
12063
12064	shape, ok := value.(map[string]interface{})
12065	if !ok {
12066		return fmt.Errorf("unexpected JSON type %v", value)
12067	}
12068
12069	var sv *GetResolverRuleOutput
12070	if *v == nil {
12071		sv = &GetResolverRuleOutput{}
12072	} else {
12073		sv = *v
12074	}
12075
12076	for key, value := range shape {
12077		switch key {
12078		case "ResolverRule":
12079			if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil {
12080				return err
12081			}
12082
12083		default:
12084			_, _ = key, value
12085
12086		}
12087	}
12088	*v = sv
12089	return nil
12090}
12091
12092func awsAwsjson11_deserializeOpDocumentGetResolverRulePolicyOutput(v **GetResolverRulePolicyOutput, value interface{}) error {
12093	if v == nil {
12094		return fmt.Errorf("unexpected nil of type %T", v)
12095	}
12096	if value == nil {
12097		return nil
12098	}
12099
12100	shape, ok := value.(map[string]interface{})
12101	if !ok {
12102		return fmt.Errorf("unexpected JSON type %v", value)
12103	}
12104
12105	var sv *GetResolverRulePolicyOutput
12106	if *v == nil {
12107		sv = &GetResolverRulePolicyOutput{}
12108	} else {
12109		sv = *v
12110	}
12111
12112	for key, value := range shape {
12113		switch key {
12114		case "ResolverRulePolicy":
12115			if value != nil {
12116				jtv, ok := value.(string)
12117				if !ok {
12118					return fmt.Errorf("expected ResolverRulePolicy to be of type string, got %T instead", value)
12119				}
12120				sv.ResolverRulePolicy = ptr.String(jtv)
12121			}
12122
12123		default:
12124			_, _ = key, value
12125
12126		}
12127	}
12128	*v = sv
12129	return nil
12130}
12131
12132func awsAwsjson11_deserializeOpDocumentImportFirewallDomainsOutput(v **ImportFirewallDomainsOutput, value interface{}) error {
12133	if v == nil {
12134		return fmt.Errorf("unexpected nil of type %T", v)
12135	}
12136	if value == nil {
12137		return nil
12138	}
12139
12140	shape, ok := value.(map[string]interface{})
12141	if !ok {
12142		return fmt.Errorf("unexpected JSON type %v", value)
12143	}
12144
12145	var sv *ImportFirewallDomainsOutput
12146	if *v == nil {
12147		sv = &ImportFirewallDomainsOutput{}
12148	} else {
12149		sv = *v
12150	}
12151
12152	for key, value := range shape {
12153		switch key {
12154		case "Id":
12155			if value != nil {
12156				jtv, ok := value.(string)
12157				if !ok {
12158					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12159				}
12160				sv.Id = ptr.String(jtv)
12161			}
12162
12163		case "Name":
12164			if value != nil {
12165				jtv, ok := value.(string)
12166				if !ok {
12167					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
12168				}
12169				sv.Name = ptr.String(jtv)
12170			}
12171
12172		case "Status":
12173			if value != nil {
12174				jtv, ok := value.(string)
12175				if !ok {
12176					return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value)
12177				}
12178				sv.Status = types.FirewallDomainListStatus(jtv)
12179			}
12180
12181		case "StatusMessage":
12182			if value != nil {
12183				jtv, ok := value.(string)
12184				if !ok {
12185					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
12186				}
12187				sv.StatusMessage = ptr.String(jtv)
12188			}
12189
12190		default:
12191			_, _ = key, value
12192
12193		}
12194	}
12195	*v = sv
12196	return nil
12197}
12198
12199func awsAwsjson11_deserializeOpDocumentListFirewallConfigsOutput(v **ListFirewallConfigsOutput, value interface{}) error {
12200	if v == nil {
12201		return fmt.Errorf("unexpected nil of type %T", v)
12202	}
12203	if value == nil {
12204		return nil
12205	}
12206
12207	shape, ok := value.(map[string]interface{})
12208	if !ok {
12209		return fmt.Errorf("unexpected JSON type %v", value)
12210	}
12211
12212	var sv *ListFirewallConfigsOutput
12213	if *v == nil {
12214		sv = &ListFirewallConfigsOutput{}
12215	} else {
12216		sv = *v
12217	}
12218
12219	for key, value := range shape {
12220		switch key {
12221		case "FirewallConfigs":
12222			if err := awsAwsjson11_deserializeDocumentFirewallConfigList(&sv.FirewallConfigs, value); err != nil {
12223				return err
12224			}
12225
12226		case "NextToken":
12227			if value != nil {
12228				jtv, ok := value.(string)
12229				if !ok {
12230					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12231				}
12232				sv.NextToken = ptr.String(jtv)
12233			}
12234
12235		default:
12236			_, _ = key, value
12237
12238		}
12239	}
12240	*v = sv
12241	return nil
12242}
12243
12244func awsAwsjson11_deserializeOpDocumentListFirewallDomainListsOutput(v **ListFirewallDomainListsOutput, value interface{}) error {
12245	if v == nil {
12246		return fmt.Errorf("unexpected nil of type %T", v)
12247	}
12248	if value == nil {
12249		return nil
12250	}
12251
12252	shape, ok := value.(map[string]interface{})
12253	if !ok {
12254		return fmt.Errorf("unexpected JSON type %v", value)
12255	}
12256
12257	var sv *ListFirewallDomainListsOutput
12258	if *v == nil {
12259		sv = &ListFirewallDomainListsOutput{}
12260	} else {
12261		sv = *v
12262	}
12263
12264	for key, value := range shape {
12265		switch key {
12266		case "FirewallDomainLists":
12267			if err := awsAwsjson11_deserializeDocumentFirewallDomainListMetadataList(&sv.FirewallDomainLists, value); err != nil {
12268				return err
12269			}
12270
12271		case "NextToken":
12272			if value != nil {
12273				jtv, ok := value.(string)
12274				if !ok {
12275					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12276				}
12277				sv.NextToken = ptr.String(jtv)
12278			}
12279
12280		default:
12281			_, _ = key, value
12282
12283		}
12284	}
12285	*v = sv
12286	return nil
12287}
12288
12289func awsAwsjson11_deserializeOpDocumentListFirewallDomainsOutput(v **ListFirewallDomainsOutput, value interface{}) error {
12290	if v == nil {
12291		return fmt.Errorf("unexpected nil of type %T", v)
12292	}
12293	if value == nil {
12294		return nil
12295	}
12296
12297	shape, ok := value.(map[string]interface{})
12298	if !ok {
12299		return fmt.Errorf("unexpected JSON type %v", value)
12300	}
12301
12302	var sv *ListFirewallDomainsOutput
12303	if *v == nil {
12304		sv = &ListFirewallDomainsOutput{}
12305	} else {
12306		sv = *v
12307	}
12308
12309	for key, value := range shape {
12310		switch key {
12311		case "Domains":
12312			if err := awsAwsjson11_deserializeDocumentFirewallDomains(&sv.Domains, value); err != nil {
12313				return err
12314			}
12315
12316		case "NextToken":
12317			if value != nil {
12318				jtv, ok := value.(string)
12319				if !ok {
12320					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12321				}
12322				sv.NextToken = ptr.String(jtv)
12323			}
12324
12325		default:
12326			_, _ = key, value
12327
12328		}
12329	}
12330	*v = sv
12331	return nil
12332}
12333
12334func awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupAssociationsOutput(v **ListFirewallRuleGroupAssociationsOutput, value interface{}) error {
12335	if v == nil {
12336		return fmt.Errorf("unexpected nil of type %T", v)
12337	}
12338	if value == nil {
12339		return nil
12340	}
12341
12342	shape, ok := value.(map[string]interface{})
12343	if !ok {
12344		return fmt.Errorf("unexpected JSON type %v", value)
12345	}
12346
12347	var sv *ListFirewallRuleGroupAssociationsOutput
12348	if *v == nil {
12349		sv = &ListFirewallRuleGroupAssociationsOutput{}
12350	} else {
12351		sv = *v
12352	}
12353
12354	for key, value := range shape {
12355		switch key {
12356		case "FirewallRuleGroupAssociations":
12357			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociations(&sv.FirewallRuleGroupAssociations, value); err != nil {
12358				return err
12359			}
12360
12361		case "NextToken":
12362			if value != nil {
12363				jtv, ok := value.(string)
12364				if !ok {
12365					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12366				}
12367				sv.NextToken = ptr.String(jtv)
12368			}
12369
12370		default:
12371			_, _ = key, value
12372
12373		}
12374	}
12375	*v = sv
12376	return nil
12377}
12378
12379func awsAwsjson11_deserializeOpDocumentListFirewallRuleGroupsOutput(v **ListFirewallRuleGroupsOutput, value interface{}) error {
12380	if v == nil {
12381		return fmt.Errorf("unexpected nil of type %T", v)
12382	}
12383	if value == nil {
12384		return nil
12385	}
12386
12387	shape, ok := value.(map[string]interface{})
12388	if !ok {
12389		return fmt.Errorf("unexpected JSON type %v", value)
12390	}
12391
12392	var sv *ListFirewallRuleGroupsOutput
12393	if *v == nil {
12394		sv = &ListFirewallRuleGroupsOutput{}
12395	} else {
12396		sv = *v
12397	}
12398
12399	for key, value := range shape {
12400		switch key {
12401		case "FirewallRuleGroups":
12402			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupMetadataList(&sv.FirewallRuleGroups, value); err != nil {
12403				return err
12404			}
12405
12406		case "NextToken":
12407			if value != nil {
12408				jtv, ok := value.(string)
12409				if !ok {
12410					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12411				}
12412				sv.NextToken = ptr.String(jtv)
12413			}
12414
12415		default:
12416			_, _ = key, value
12417
12418		}
12419	}
12420	*v = sv
12421	return nil
12422}
12423
12424func awsAwsjson11_deserializeOpDocumentListFirewallRulesOutput(v **ListFirewallRulesOutput, value interface{}) error {
12425	if v == nil {
12426		return fmt.Errorf("unexpected nil of type %T", v)
12427	}
12428	if value == nil {
12429		return nil
12430	}
12431
12432	shape, ok := value.(map[string]interface{})
12433	if !ok {
12434		return fmt.Errorf("unexpected JSON type %v", value)
12435	}
12436
12437	var sv *ListFirewallRulesOutput
12438	if *v == nil {
12439		sv = &ListFirewallRulesOutput{}
12440	} else {
12441		sv = *v
12442	}
12443
12444	for key, value := range shape {
12445		switch key {
12446		case "FirewallRules":
12447			if err := awsAwsjson11_deserializeDocumentFirewallRules(&sv.FirewallRules, value); err != nil {
12448				return err
12449			}
12450
12451		case "NextToken":
12452			if value != nil {
12453				jtv, ok := value.(string)
12454				if !ok {
12455					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12456				}
12457				sv.NextToken = ptr.String(jtv)
12458			}
12459
12460		default:
12461			_, _ = key, value
12462
12463		}
12464	}
12465	*v = sv
12466	return nil
12467}
12468
12469func awsAwsjson11_deserializeOpDocumentListResolverDnssecConfigsOutput(v **ListResolverDnssecConfigsOutput, value interface{}) error {
12470	if v == nil {
12471		return fmt.Errorf("unexpected nil of type %T", v)
12472	}
12473	if value == nil {
12474		return nil
12475	}
12476
12477	shape, ok := value.(map[string]interface{})
12478	if !ok {
12479		return fmt.Errorf("unexpected JSON type %v", value)
12480	}
12481
12482	var sv *ListResolverDnssecConfigsOutput
12483	if *v == nil {
12484		sv = &ListResolverDnssecConfigsOutput{}
12485	} else {
12486		sv = *v
12487	}
12488
12489	for key, value := range shape {
12490		switch key {
12491		case "NextToken":
12492			if value != nil {
12493				jtv, ok := value.(string)
12494				if !ok {
12495					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12496				}
12497				sv.NextToken = ptr.String(jtv)
12498			}
12499
12500		case "ResolverDnssecConfigs":
12501			if err := awsAwsjson11_deserializeDocumentResolverDnssecConfigList(&sv.ResolverDnssecConfigs, value); err != nil {
12502				return err
12503			}
12504
12505		default:
12506			_, _ = key, value
12507
12508		}
12509	}
12510	*v = sv
12511	return nil
12512}
12513
12514func awsAwsjson11_deserializeOpDocumentListResolverEndpointIpAddressesOutput(v **ListResolverEndpointIpAddressesOutput, value interface{}) error {
12515	if v == nil {
12516		return fmt.Errorf("unexpected nil of type %T", v)
12517	}
12518	if value == nil {
12519		return nil
12520	}
12521
12522	shape, ok := value.(map[string]interface{})
12523	if !ok {
12524		return fmt.Errorf("unexpected JSON type %v", value)
12525	}
12526
12527	var sv *ListResolverEndpointIpAddressesOutput
12528	if *v == nil {
12529		sv = &ListResolverEndpointIpAddressesOutput{}
12530	} else {
12531		sv = *v
12532	}
12533
12534	for key, value := range shape {
12535		switch key {
12536		case "IpAddresses":
12537			if err := awsAwsjson11_deserializeDocumentIpAddressesResponse(&sv.IpAddresses, value); err != nil {
12538				return err
12539			}
12540
12541		case "MaxResults":
12542			if value != nil {
12543				jtv, ok := value.(json.Number)
12544				if !ok {
12545					return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value)
12546				}
12547				i64, err := jtv.Int64()
12548				if err != nil {
12549					return err
12550				}
12551				sv.MaxResults = ptr.Int32(int32(i64))
12552			}
12553
12554		case "NextToken":
12555			if value != nil {
12556				jtv, ok := value.(string)
12557				if !ok {
12558					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12559				}
12560				sv.NextToken = ptr.String(jtv)
12561			}
12562
12563		default:
12564			_, _ = key, value
12565
12566		}
12567	}
12568	*v = sv
12569	return nil
12570}
12571
12572func awsAwsjson11_deserializeOpDocumentListResolverEndpointsOutput(v **ListResolverEndpointsOutput, value interface{}) error {
12573	if v == nil {
12574		return fmt.Errorf("unexpected nil of type %T", v)
12575	}
12576	if value == nil {
12577		return nil
12578	}
12579
12580	shape, ok := value.(map[string]interface{})
12581	if !ok {
12582		return fmt.Errorf("unexpected JSON type %v", value)
12583	}
12584
12585	var sv *ListResolverEndpointsOutput
12586	if *v == nil {
12587		sv = &ListResolverEndpointsOutput{}
12588	} else {
12589		sv = *v
12590	}
12591
12592	for key, value := range shape {
12593		switch key {
12594		case "MaxResults":
12595			if value != nil {
12596				jtv, ok := value.(json.Number)
12597				if !ok {
12598					return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value)
12599				}
12600				i64, err := jtv.Int64()
12601				if err != nil {
12602					return err
12603				}
12604				sv.MaxResults = ptr.Int32(int32(i64))
12605			}
12606
12607		case "NextToken":
12608			if value != nil {
12609				jtv, ok := value.(string)
12610				if !ok {
12611					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12612				}
12613				sv.NextToken = ptr.String(jtv)
12614			}
12615
12616		case "ResolverEndpoints":
12617			if err := awsAwsjson11_deserializeDocumentResolverEndpoints(&sv.ResolverEndpoints, value); err != nil {
12618				return err
12619			}
12620
12621		default:
12622			_, _ = key, value
12623
12624		}
12625	}
12626	*v = sv
12627	return nil
12628}
12629
12630func awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigAssociationsOutput(v **ListResolverQueryLogConfigAssociationsOutput, value interface{}) error {
12631	if v == nil {
12632		return fmt.Errorf("unexpected nil of type %T", v)
12633	}
12634	if value == nil {
12635		return nil
12636	}
12637
12638	shape, ok := value.(map[string]interface{})
12639	if !ok {
12640		return fmt.Errorf("unexpected JSON type %v", value)
12641	}
12642
12643	var sv *ListResolverQueryLogConfigAssociationsOutput
12644	if *v == nil {
12645		sv = &ListResolverQueryLogConfigAssociationsOutput{}
12646	} else {
12647		sv = *v
12648	}
12649
12650	for key, value := range shape {
12651		switch key {
12652		case "NextToken":
12653			if value != nil {
12654				jtv, ok := value.(string)
12655				if !ok {
12656					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12657				}
12658				sv.NextToken = ptr.String(jtv)
12659			}
12660
12661		case "ResolverQueryLogConfigAssociations":
12662			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigAssociationList(&sv.ResolverQueryLogConfigAssociations, value); err != nil {
12663				return err
12664			}
12665
12666		case "TotalCount":
12667			if value != nil {
12668				jtv, ok := value.(json.Number)
12669				if !ok {
12670					return fmt.Errorf("expected Count to be json.Number, got %T instead", value)
12671				}
12672				i64, err := jtv.Int64()
12673				if err != nil {
12674					return err
12675				}
12676				sv.TotalCount = int32(i64)
12677			}
12678
12679		case "TotalFilteredCount":
12680			if value != nil {
12681				jtv, ok := value.(json.Number)
12682				if !ok {
12683					return fmt.Errorf("expected Count to be json.Number, got %T instead", value)
12684				}
12685				i64, err := jtv.Int64()
12686				if err != nil {
12687					return err
12688				}
12689				sv.TotalFilteredCount = int32(i64)
12690			}
12691
12692		default:
12693			_, _ = key, value
12694
12695		}
12696	}
12697	*v = sv
12698	return nil
12699}
12700
12701func awsAwsjson11_deserializeOpDocumentListResolverQueryLogConfigsOutput(v **ListResolverQueryLogConfigsOutput, value interface{}) error {
12702	if v == nil {
12703		return fmt.Errorf("unexpected nil of type %T", v)
12704	}
12705	if value == nil {
12706		return nil
12707	}
12708
12709	shape, ok := value.(map[string]interface{})
12710	if !ok {
12711		return fmt.Errorf("unexpected JSON type %v", value)
12712	}
12713
12714	var sv *ListResolverQueryLogConfigsOutput
12715	if *v == nil {
12716		sv = &ListResolverQueryLogConfigsOutput{}
12717	} else {
12718		sv = *v
12719	}
12720
12721	for key, value := range shape {
12722		switch key {
12723		case "NextToken":
12724			if value != nil {
12725				jtv, ok := value.(string)
12726				if !ok {
12727					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12728				}
12729				sv.NextToken = ptr.String(jtv)
12730			}
12731
12732		case "ResolverQueryLogConfigs":
12733			if err := awsAwsjson11_deserializeDocumentResolverQueryLogConfigList(&sv.ResolverQueryLogConfigs, value); err != nil {
12734				return err
12735			}
12736
12737		case "TotalCount":
12738			if value != nil {
12739				jtv, ok := value.(json.Number)
12740				if !ok {
12741					return fmt.Errorf("expected Count to be json.Number, got %T instead", value)
12742				}
12743				i64, err := jtv.Int64()
12744				if err != nil {
12745					return err
12746				}
12747				sv.TotalCount = int32(i64)
12748			}
12749
12750		case "TotalFilteredCount":
12751			if value != nil {
12752				jtv, ok := value.(json.Number)
12753				if !ok {
12754					return fmt.Errorf("expected Count to be json.Number, got %T instead", value)
12755				}
12756				i64, err := jtv.Int64()
12757				if err != nil {
12758					return err
12759				}
12760				sv.TotalFilteredCount = int32(i64)
12761			}
12762
12763		default:
12764			_, _ = key, value
12765
12766		}
12767	}
12768	*v = sv
12769	return nil
12770}
12771
12772func awsAwsjson11_deserializeOpDocumentListResolverRuleAssociationsOutput(v **ListResolverRuleAssociationsOutput, value interface{}) error {
12773	if v == nil {
12774		return fmt.Errorf("unexpected nil of type %T", v)
12775	}
12776	if value == nil {
12777		return nil
12778	}
12779
12780	shape, ok := value.(map[string]interface{})
12781	if !ok {
12782		return fmt.Errorf("unexpected JSON type %v", value)
12783	}
12784
12785	var sv *ListResolverRuleAssociationsOutput
12786	if *v == nil {
12787		sv = &ListResolverRuleAssociationsOutput{}
12788	} else {
12789		sv = *v
12790	}
12791
12792	for key, value := range shape {
12793		switch key {
12794		case "MaxResults":
12795			if value != nil {
12796				jtv, ok := value.(json.Number)
12797				if !ok {
12798					return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value)
12799				}
12800				i64, err := jtv.Int64()
12801				if err != nil {
12802					return err
12803				}
12804				sv.MaxResults = ptr.Int32(int32(i64))
12805			}
12806
12807		case "NextToken":
12808			if value != nil {
12809				jtv, ok := value.(string)
12810				if !ok {
12811					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12812				}
12813				sv.NextToken = ptr.String(jtv)
12814			}
12815
12816		case "ResolverRuleAssociations":
12817			if err := awsAwsjson11_deserializeDocumentResolverRuleAssociations(&sv.ResolverRuleAssociations, value); err != nil {
12818				return err
12819			}
12820
12821		default:
12822			_, _ = key, value
12823
12824		}
12825	}
12826	*v = sv
12827	return nil
12828}
12829
12830func awsAwsjson11_deserializeOpDocumentListResolverRulesOutput(v **ListResolverRulesOutput, value interface{}) error {
12831	if v == nil {
12832		return fmt.Errorf("unexpected nil of type %T", v)
12833	}
12834	if value == nil {
12835		return nil
12836	}
12837
12838	shape, ok := value.(map[string]interface{})
12839	if !ok {
12840		return fmt.Errorf("unexpected JSON type %v", value)
12841	}
12842
12843	var sv *ListResolverRulesOutput
12844	if *v == nil {
12845		sv = &ListResolverRulesOutput{}
12846	} else {
12847		sv = *v
12848	}
12849
12850	for key, value := range shape {
12851		switch key {
12852		case "MaxResults":
12853			if value != nil {
12854				jtv, ok := value.(json.Number)
12855				if !ok {
12856					return fmt.Errorf("expected MaxResults to be json.Number, got %T instead", value)
12857				}
12858				i64, err := jtv.Int64()
12859				if err != nil {
12860					return err
12861				}
12862				sv.MaxResults = ptr.Int32(int32(i64))
12863			}
12864
12865		case "NextToken":
12866			if value != nil {
12867				jtv, ok := value.(string)
12868				if !ok {
12869					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12870				}
12871				sv.NextToken = ptr.String(jtv)
12872			}
12873
12874		case "ResolverRules":
12875			if err := awsAwsjson11_deserializeDocumentResolverRules(&sv.ResolverRules, value); err != nil {
12876				return err
12877			}
12878
12879		default:
12880			_, _ = key, value
12881
12882		}
12883	}
12884	*v = sv
12885	return nil
12886}
12887
12888func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
12889	if v == nil {
12890		return fmt.Errorf("unexpected nil of type %T", v)
12891	}
12892	if value == nil {
12893		return nil
12894	}
12895
12896	shape, ok := value.(map[string]interface{})
12897	if !ok {
12898		return fmt.Errorf("unexpected JSON type %v", value)
12899	}
12900
12901	var sv *ListTagsForResourceOutput
12902	if *v == nil {
12903		sv = &ListTagsForResourceOutput{}
12904	} else {
12905		sv = *v
12906	}
12907
12908	for key, value := range shape {
12909		switch key {
12910		case "NextToken":
12911			if value != nil {
12912				jtv, ok := value.(string)
12913				if !ok {
12914					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12915				}
12916				sv.NextToken = ptr.String(jtv)
12917			}
12918
12919		case "Tags":
12920			if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil {
12921				return err
12922			}
12923
12924		default:
12925			_, _ = key, value
12926
12927		}
12928	}
12929	*v = sv
12930	return nil
12931}
12932
12933func awsAwsjson11_deserializeOpDocumentPutFirewallRuleGroupPolicyOutput(v **PutFirewallRuleGroupPolicyOutput, value interface{}) error {
12934	if v == nil {
12935		return fmt.Errorf("unexpected nil of type %T", v)
12936	}
12937	if value == nil {
12938		return nil
12939	}
12940
12941	shape, ok := value.(map[string]interface{})
12942	if !ok {
12943		return fmt.Errorf("unexpected JSON type %v", value)
12944	}
12945
12946	var sv *PutFirewallRuleGroupPolicyOutput
12947	if *v == nil {
12948		sv = &PutFirewallRuleGroupPolicyOutput{}
12949	} else {
12950		sv = *v
12951	}
12952
12953	for key, value := range shape {
12954		switch key {
12955		case "ReturnValue":
12956			if value != nil {
12957				jtv, ok := value.(bool)
12958				if !ok {
12959					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
12960				}
12961				sv.ReturnValue = jtv
12962			}
12963
12964		default:
12965			_, _ = key, value
12966
12967		}
12968	}
12969	*v = sv
12970	return nil
12971}
12972
12973func awsAwsjson11_deserializeOpDocumentPutResolverQueryLogConfigPolicyOutput(v **PutResolverQueryLogConfigPolicyOutput, value interface{}) error {
12974	if v == nil {
12975		return fmt.Errorf("unexpected nil of type %T", v)
12976	}
12977	if value == nil {
12978		return nil
12979	}
12980
12981	shape, ok := value.(map[string]interface{})
12982	if !ok {
12983		return fmt.Errorf("unexpected JSON type %v", value)
12984	}
12985
12986	var sv *PutResolverQueryLogConfigPolicyOutput
12987	if *v == nil {
12988		sv = &PutResolverQueryLogConfigPolicyOutput{}
12989	} else {
12990		sv = *v
12991	}
12992
12993	for key, value := range shape {
12994		switch key {
12995		case "ReturnValue":
12996			if value != nil {
12997				jtv, ok := value.(bool)
12998				if !ok {
12999					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
13000				}
13001				sv.ReturnValue = jtv
13002			}
13003
13004		default:
13005			_, _ = key, value
13006
13007		}
13008	}
13009	*v = sv
13010	return nil
13011}
13012
13013func awsAwsjson11_deserializeOpDocumentPutResolverRulePolicyOutput(v **PutResolverRulePolicyOutput, value interface{}) error {
13014	if v == nil {
13015		return fmt.Errorf("unexpected nil of type %T", v)
13016	}
13017	if value == nil {
13018		return nil
13019	}
13020
13021	shape, ok := value.(map[string]interface{})
13022	if !ok {
13023		return fmt.Errorf("unexpected JSON type %v", value)
13024	}
13025
13026	var sv *PutResolverRulePolicyOutput
13027	if *v == nil {
13028		sv = &PutResolverRulePolicyOutput{}
13029	} else {
13030		sv = *v
13031	}
13032
13033	for key, value := range shape {
13034		switch key {
13035		case "ReturnValue":
13036			if value != nil {
13037				jtv, ok := value.(bool)
13038				if !ok {
13039					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
13040				}
13041				sv.ReturnValue = jtv
13042			}
13043
13044		default:
13045			_, _ = key, value
13046
13047		}
13048	}
13049	*v = sv
13050	return nil
13051}
13052
13053func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
13054	if v == nil {
13055		return fmt.Errorf("unexpected nil of type %T", v)
13056	}
13057	if value == nil {
13058		return nil
13059	}
13060
13061	shape, ok := value.(map[string]interface{})
13062	if !ok {
13063		return fmt.Errorf("unexpected JSON type %v", value)
13064	}
13065
13066	var sv *TagResourceOutput
13067	if *v == nil {
13068		sv = &TagResourceOutput{}
13069	} else {
13070		sv = *v
13071	}
13072
13073	for key, value := range shape {
13074		switch key {
13075		default:
13076			_, _ = key, value
13077
13078		}
13079	}
13080	*v = sv
13081	return nil
13082}
13083
13084func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
13085	if v == nil {
13086		return fmt.Errorf("unexpected nil of type %T", v)
13087	}
13088	if value == nil {
13089		return nil
13090	}
13091
13092	shape, ok := value.(map[string]interface{})
13093	if !ok {
13094		return fmt.Errorf("unexpected JSON type %v", value)
13095	}
13096
13097	var sv *UntagResourceOutput
13098	if *v == nil {
13099		sv = &UntagResourceOutput{}
13100	} else {
13101		sv = *v
13102	}
13103
13104	for key, value := range shape {
13105		switch key {
13106		default:
13107			_, _ = key, value
13108
13109		}
13110	}
13111	*v = sv
13112	return nil
13113}
13114
13115func awsAwsjson11_deserializeOpDocumentUpdateFirewallConfigOutput(v **UpdateFirewallConfigOutput, value interface{}) error {
13116	if v == nil {
13117		return fmt.Errorf("unexpected nil of type %T", v)
13118	}
13119	if value == nil {
13120		return nil
13121	}
13122
13123	shape, ok := value.(map[string]interface{})
13124	if !ok {
13125		return fmt.Errorf("unexpected JSON type %v", value)
13126	}
13127
13128	var sv *UpdateFirewallConfigOutput
13129	if *v == nil {
13130		sv = &UpdateFirewallConfigOutput{}
13131	} else {
13132		sv = *v
13133	}
13134
13135	for key, value := range shape {
13136		switch key {
13137		case "FirewallConfig":
13138			if err := awsAwsjson11_deserializeDocumentFirewallConfig(&sv.FirewallConfig, value); err != nil {
13139				return err
13140			}
13141
13142		default:
13143			_, _ = key, value
13144
13145		}
13146	}
13147	*v = sv
13148	return nil
13149}
13150
13151func awsAwsjson11_deserializeOpDocumentUpdateFirewallDomainsOutput(v **UpdateFirewallDomainsOutput, value interface{}) error {
13152	if v == nil {
13153		return fmt.Errorf("unexpected nil of type %T", v)
13154	}
13155	if value == nil {
13156		return nil
13157	}
13158
13159	shape, ok := value.(map[string]interface{})
13160	if !ok {
13161		return fmt.Errorf("unexpected JSON type %v", value)
13162	}
13163
13164	var sv *UpdateFirewallDomainsOutput
13165	if *v == nil {
13166		sv = &UpdateFirewallDomainsOutput{}
13167	} else {
13168		sv = *v
13169	}
13170
13171	for key, value := range shape {
13172		switch key {
13173		case "Id":
13174			if value != nil {
13175				jtv, ok := value.(string)
13176				if !ok {
13177					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
13178				}
13179				sv.Id = ptr.String(jtv)
13180			}
13181
13182		case "Name":
13183			if value != nil {
13184				jtv, ok := value.(string)
13185				if !ok {
13186					return fmt.Errorf("expected Name to be of type string, got %T instead", value)
13187				}
13188				sv.Name = ptr.String(jtv)
13189			}
13190
13191		case "Status":
13192			if value != nil {
13193				jtv, ok := value.(string)
13194				if !ok {
13195					return fmt.Errorf("expected FirewallDomainListStatus to be of type string, got %T instead", value)
13196				}
13197				sv.Status = types.FirewallDomainListStatus(jtv)
13198			}
13199
13200		case "StatusMessage":
13201			if value != nil {
13202				jtv, ok := value.(string)
13203				if !ok {
13204					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
13205				}
13206				sv.StatusMessage = ptr.String(jtv)
13207			}
13208
13209		default:
13210			_, _ = key, value
13211
13212		}
13213	}
13214	*v = sv
13215	return nil
13216}
13217
13218func awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleGroupAssociationOutput(v **UpdateFirewallRuleGroupAssociationOutput, value interface{}) error {
13219	if v == nil {
13220		return fmt.Errorf("unexpected nil of type %T", v)
13221	}
13222	if value == nil {
13223		return nil
13224	}
13225
13226	shape, ok := value.(map[string]interface{})
13227	if !ok {
13228		return fmt.Errorf("unexpected JSON type %v", value)
13229	}
13230
13231	var sv *UpdateFirewallRuleGroupAssociationOutput
13232	if *v == nil {
13233		sv = &UpdateFirewallRuleGroupAssociationOutput{}
13234	} else {
13235		sv = *v
13236	}
13237
13238	for key, value := range shape {
13239		switch key {
13240		case "FirewallRuleGroupAssociation":
13241			if err := awsAwsjson11_deserializeDocumentFirewallRuleGroupAssociation(&sv.FirewallRuleGroupAssociation, value); err != nil {
13242				return err
13243			}
13244
13245		default:
13246			_, _ = key, value
13247
13248		}
13249	}
13250	*v = sv
13251	return nil
13252}
13253
13254func awsAwsjson11_deserializeOpDocumentUpdateFirewallRuleOutput(v **UpdateFirewallRuleOutput, value interface{}) error {
13255	if v == nil {
13256		return fmt.Errorf("unexpected nil of type %T", v)
13257	}
13258	if value == nil {
13259		return nil
13260	}
13261
13262	shape, ok := value.(map[string]interface{})
13263	if !ok {
13264		return fmt.Errorf("unexpected JSON type %v", value)
13265	}
13266
13267	var sv *UpdateFirewallRuleOutput
13268	if *v == nil {
13269		sv = &UpdateFirewallRuleOutput{}
13270	} else {
13271		sv = *v
13272	}
13273
13274	for key, value := range shape {
13275		switch key {
13276		case "FirewallRule":
13277			if err := awsAwsjson11_deserializeDocumentFirewallRule(&sv.FirewallRule, value); err != nil {
13278				return err
13279			}
13280
13281		default:
13282			_, _ = key, value
13283
13284		}
13285	}
13286	*v = sv
13287	return nil
13288}
13289
13290func awsAwsjson11_deserializeOpDocumentUpdateResolverDnssecConfigOutput(v **UpdateResolverDnssecConfigOutput, value interface{}) error {
13291	if v == nil {
13292		return fmt.Errorf("unexpected nil of type %T", v)
13293	}
13294	if value == nil {
13295		return nil
13296	}
13297
13298	shape, ok := value.(map[string]interface{})
13299	if !ok {
13300		return fmt.Errorf("unexpected JSON type %v", value)
13301	}
13302
13303	var sv *UpdateResolverDnssecConfigOutput
13304	if *v == nil {
13305		sv = &UpdateResolverDnssecConfigOutput{}
13306	} else {
13307		sv = *v
13308	}
13309
13310	for key, value := range shape {
13311		switch key {
13312		case "ResolverDNSSECConfig":
13313			if err := awsAwsjson11_deserializeDocumentResolverDnssecConfig(&sv.ResolverDNSSECConfig, value); err != nil {
13314				return err
13315			}
13316
13317		default:
13318			_, _ = key, value
13319
13320		}
13321	}
13322	*v = sv
13323	return nil
13324}
13325
13326func awsAwsjson11_deserializeOpDocumentUpdateResolverEndpointOutput(v **UpdateResolverEndpointOutput, value interface{}) error {
13327	if v == nil {
13328		return fmt.Errorf("unexpected nil of type %T", v)
13329	}
13330	if value == nil {
13331		return nil
13332	}
13333
13334	shape, ok := value.(map[string]interface{})
13335	if !ok {
13336		return fmt.Errorf("unexpected JSON type %v", value)
13337	}
13338
13339	var sv *UpdateResolverEndpointOutput
13340	if *v == nil {
13341		sv = &UpdateResolverEndpointOutput{}
13342	} else {
13343		sv = *v
13344	}
13345
13346	for key, value := range shape {
13347		switch key {
13348		case "ResolverEndpoint":
13349			if err := awsAwsjson11_deserializeDocumentResolverEndpoint(&sv.ResolverEndpoint, value); err != nil {
13350				return err
13351			}
13352
13353		default:
13354			_, _ = key, value
13355
13356		}
13357	}
13358	*v = sv
13359	return nil
13360}
13361
13362func awsAwsjson11_deserializeOpDocumentUpdateResolverRuleOutput(v **UpdateResolverRuleOutput, value interface{}) error {
13363	if v == nil {
13364		return fmt.Errorf("unexpected nil of type %T", v)
13365	}
13366	if value == nil {
13367		return nil
13368	}
13369
13370	shape, ok := value.(map[string]interface{})
13371	if !ok {
13372		return fmt.Errorf("unexpected JSON type %v", value)
13373	}
13374
13375	var sv *UpdateResolverRuleOutput
13376	if *v == nil {
13377		sv = &UpdateResolverRuleOutput{}
13378	} else {
13379		sv = *v
13380	}
13381
13382	for key, value := range shape {
13383		switch key {
13384		case "ResolverRule":
13385			if err := awsAwsjson11_deserializeDocumentResolverRule(&sv.ResolverRule, value); err != nil {
13386				return err
13387			}
13388
13389		default:
13390			_, _ = key, value
13391
13392		}
13393	}
13394	*v = sv
13395	return nil
13396}
13397