1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package waf
4
5import (
6	"bytes"
7	"context"
8	"encoding/base64"
9	"encoding/json"
10	"fmt"
11	"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
12	"github.com/aws/aws-sdk-go-v2/service/waf/types"
13	smithy "github.com/aws/smithy-go"
14	smithyio "github.com/aws/smithy-go/io"
15	"github.com/aws/smithy-go/middleware"
16	"github.com/aws/smithy-go/ptr"
17	smithytime "github.com/aws/smithy-go/time"
18	smithyhttp "github.com/aws/smithy-go/transport/http"
19	"io"
20	"strings"
21)
22
23type awsAwsjson11_deserializeOpCreateByteMatchSet struct {
24}
25
26func (*awsAwsjson11_deserializeOpCreateByteMatchSet) ID() string {
27	return "OperationDeserializer"
28}
29
30func (m *awsAwsjson11_deserializeOpCreateByteMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32) {
33	out, metadata, err = next.HandleDeserialize(ctx, in)
34	if err != nil {
35		return out, metadata, err
36	}
37
38	response, ok := out.RawResponse.(*smithyhttp.Response)
39	if !ok {
40		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
41	}
42
43	if response.StatusCode < 200 || response.StatusCode >= 300 {
44		return out, metadata, awsAwsjson11_deserializeOpErrorCreateByteMatchSet(response, &metadata)
45	}
46	output := &CreateByteMatchSetOutput{}
47	out.Result = output
48
49	var buff [1024]byte
50	ringBuffer := smithyio.NewRingBuffer(buff[:])
51
52	body := io.TeeReader(response.Body, ringBuffer)
53	decoder := json.NewDecoder(body)
54	decoder.UseNumber()
55	var shape interface{}
56	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
57		var snapshot bytes.Buffer
58		io.Copy(&snapshot, ringBuffer)
59		err = &smithy.DeserializationError{
60			Err:      fmt.Errorf("failed to decode response body, %w", err),
61			Snapshot: snapshot.Bytes(),
62		}
63		return out, metadata, err
64	}
65
66	err = awsAwsjson11_deserializeOpDocumentCreateByteMatchSetOutput(&output, shape)
67	if err != nil {
68		var snapshot bytes.Buffer
69		io.Copy(&snapshot, ringBuffer)
70		err = &smithy.DeserializationError{
71			Err:      fmt.Errorf("failed to decode response body, %w", err),
72			Snapshot: snapshot.Bytes(),
73		}
74		return out, metadata, err
75	}
76
77	return out, metadata, err
78}
79
80func awsAwsjson11_deserializeOpErrorCreateByteMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
81	var errorBuffer bytes.Buffer
82	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
83		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
84	}
85	errorBody := bytes.NewReader(errorBuffer.Bytes())
86
87	errorCode := "UnknownError"
88	errorMessage := errorCode
89
90	code := response.Header.Get("X-Amzn-ErrorType")
91	if len(code) != 0 {
92		errorCode = restjson.SanitizeErrorCode(code)
93	}
94
95	var buff [1024]byte
96	ringBuffer := smithyio.NewRingBuffer(buff[:])
97
98	body := io.TeeReader(errorBody, ringBuffer)
99	decoder := json.NewDecoder(body)
100	decoder.UseNumber()
101	code, message, err := restjson.GetErrorInfo(decoder)
102	if err != nil {
103		var snapshot bytes.Buffer
104		io.Copy(&snapshot, ringBuffer)
105		err = &smithy.DeserializationError{
106			Err:      fmt.Errorf("failed to decode response body, %w", err),
107			Snapshot: snapshot.Bytes(),
108		}
109		return err
110	}
111
112	errorBody.Seek(0, io.SeekStart)
113	if len(code) != 0 {
114		errorCode = restjson.SanitizeErrorCode(code)
115	}
116	if len(message) != 0 {
117		errorMessage = message
118	}
119
120	switch {
121	case strings.EqualFold("WAFDisallowedNameException", errorCode):
122		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
123
124	case strings.EqualFold("WAFInternalErrorException", errorCode):
125		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
126
127	case strings.EqualFold("WAFInvalidAccountException", errorCode):
128		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
129
130	case strings.EqualFold("WAFInvalidParameterException", errorCode):
131		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
132
133	case strings.EqualFold("WAFLimitsExceededException", errorCode):
134		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
135
136	case strings.EqualFold("WAFStaleDataException", errorCode):
137		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
138
139	default:
140		genericError := &smithy.GenericAPIError{
141			Code:    errorCode,
142			Message: errorMessage,
143		}
144		return genericError
145
146	}
147}
148
149type awsAwsjson11_deserializeOpCreateGeoMatchSet struct {
150}
151
152func (*awsAwsjson11_deserializeOpCreateGeoMatchSet) ID() string {
153	return "OperationDeserializer"
154}
155
156func (m *awsAwsjson11_deserializeOpCreateGeoMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
157	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
158) {
159	out, metadata, err = next.HandleDeserialize(ctx, in)
160	if err != nil {
161		return out, metadata, err
162	}
163
164	response, ok := out.RawResponse.(*smithyhttp.Response)
165	if !ok {
166		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
167	}
168
169	if response.StatusCode < 200 || response.StatusCode >= 300 {
170		return out, metadata, awsAwsjson11_deserializeOpErrorCreateGeoMatchSet(response, &metadata)
171	}
172	output := &CreateGeoMatchSetOutput{}
173	out.Result = output
174
175	var buff [1024]byte
176	ringBuffer := smithyio.NewRingBuffer(buff[:])
177
178	body := io.TeeReader(response.Body, ringBuffer)
179	decoder := json.NewDecoder(body)
180	decoder.UseNumber()
181	var shape interface{}
182	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
183		var snapshot bytes.Buffer
184		io.Copy(&snapshot, ringBuffer)
185		err = &smithy.DeserializationError{
186			Err:      fmt.Errorf("failed to decode response body, %w", err),
187			Snapshot: snapshot.Bytes(),
188		}
189		return out, metadata, err
190	}
191
192	err = awsAwsjson11_deserializeOpDocumentCreateGeoMatchSetOutput(&output, shape)
193	if err != nil {
194		var snapshot bytes.Buffer
195		io.Copy(&snapshot, ringBuffer)
196		err = &smithy.DeserializationError{
197			Err:      fmt.Errorf("failed to decode response body, %w", err),
198			Snapshot: snapshot.Bytes(),
199		}
200		return out, metadata, err
201	}
202
203	return out, metadata, err
204}
205
206func awsAwsjson11_deserializeOpErrorCreateGeoMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
207	var errorBuffer bytes.Buffer
208	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
209		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
210	}
211	errorBody := bytes.NewReader(errorBuffer.Bytes())
212
213	errorCode := "UnknownError"
214	errorMessage := errorCode
215
216	code := response.Header.Get("X-Amzn-ErrorType")
217	if len(code) != 0 {
218		errorCode = restjson.SanitizeErrorCode(code)
219	}
220
221	var buff [1024]byte
222	ringBuffer := smithyio.NewRingBuffer(buff[:])
223
224	body := io.TeeReader(errorBody, ringBuffer)
225	decoder := json.NewDecoder(body)
226	decoder.UseNumber()
227	code, message, err := restjson.GetErrorInfo(decoder)
228	if err != nil {
229		var snapshot bytes.Buffer
230		io.Copy(&snapshot, ringBuffer)
231		err = &smithy.DeserializationError{
232			Err:      fmt.Errorf("failed to decode response body, %w", err),
233			Snapshot: snapshot.Bytes(),
234		}
235		return err
236	}
237
238	errorBody.Seek(0, io.SeekStart)
239	if len(code) != 0 {
240		errorCode = restjson.SanitizeErrorCode(code)
241	}
242	if len(message) != 0 {
243		errorMessage = message
244	}
245
246	switch {
247	case strings.EqualFold("WAFDisallowedNameException", errorCode):
248		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
249
250	case strings.EqualFold("WAFInternalErrorException", errorCode):
251		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
252
253	case strings.EqualFold("WAFInvalidAccountException", errorCode):
254		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
255
256	case strings.EqualFold("WAFInvalidParameterException", errorCode):
257		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
258
259	case strings.EqualFold("WAFLimitsExceededException", errorCode):
260		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
261
262	case strings.EqualFold("WAFStaleDataException", errorCode):
263		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
264
265	default:
266		genericError := &smithy.GenericAPIError{
267			Code:    errorCode,
268			Message: errorMessage,
269		}
270		return genericError
271
272	}
273}
274
275type awsAwsjson11_deserializeOpCreateIPSet struct {
276}
277
278func (*awsAwsjson11_deserializeOpCreateIPSet) ID() string {
279	return "OperationDeserializer"
280}
281
282func (m *awsAwsjson11_deserializeOpCreateIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
283	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
284) {
285	out, metadata, err = next.HandleDeserialize(ctx, in)
286	if err != nil {
287		return out, metadata, err
288	}
289
290	response, ok := out.RawResponse.(*smithyhttp.Response)
291	if !ok {
292		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
293	}
294
295	if response.StatusCode < 200 || response.StatusCode >= 300 {
296		return out, metadata, awsAwsjson11_deserializeOpErrorCreateIPSet(response, &metadata)
297	}
298	output := &CreateIPSetOutput{}
299	out.Result = output
300
301	var buff [1024]byte
302	ringBuffer := smithyio.NewRingBuffer(buff[:])
303
304	body := io.TeeReader(response.Body, ringBuffer)
305	decoder := json.NewDecoder(body)
306	decoder.UseNumber()
307	var shape interface{}
308	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
309		var snapshot bytes.Buffer
310		io.Copy(&snapshot, ringBuffer)
311		err = &smithy.DeserializationError{
312			Err:      fmt.Errorf("failed to decode response body, %w", err),
313			Snapshot: snapshot.Bytes(),
314		}
315		return out, metadata, err
316	}
317
318	err = awsAwsjson11_deserializeOpDocumentCreateIPSetOutput(&output, shape)
319	if err != nil {
320		var snapshot bytes.Buffer
321		io.Copy(&snapshot, ringBuffer)
322		err = &smithy.DeserializationError{
323			Err:      fmt.Errorf("failed to decode response body, %w", err),
324			Snapshot: snapshot.Bytes(),
325		}
326		return out, metadata, err
327	}
328
329	return out, metadata, err
330}
331
332func awsAwsjson11_deserializeOpErrorCreateIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
333	var errorBuffer bytes.Buffer
334	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
335		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
336	}
337	errorBody := bytes.NewReader(errorBuffer.Bytes())
338
339	errorCode := "UnknownError"
340	errorMessage := errorCode
341
342	code := response.Header.Get("X-Amzn-ErrorType")
343	if len(code) != 0 {
344		errorCode = restjson.SanitizeErrorCode(code)
345	}
346
347	var buff [1024]byte
348	ringBuffer := smithyio.NewRingBuffer(buff[:])
349
350	body := io.TeeReader(errorBody, ringBuffer)
351	decoder := json.NewDecoder(body)
352	decoder.UseNumber()
353	code, message, err := restjson.GetErrorInfo(decoder)
354	if err != nil {
355		var snapshot bytes.Buffer
356		io.Copy(&snapshot, ringBuffer)
357		err = &smithy.DeserializationError{
358			Err:      fmt.Errorf("failed to decode response body, %w", err),
359			Snapshot: snapshot.Bytes(),
360		}
361		return err
362	}
363
364	errorBody.Seek(0, io.SeekStart)
365	if len(code) != 0 {
366		errorCode = restjson.SanitizeErrorCode(code)
367	}
368	if len(message) != 0 {
369		errorMessage = message
370	}
371
372	switch {
373	case strings.EqualFold("WAFDisallowedNameException", errorCode):
374		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
375
376	case strings.EqualFold("WAFInternalErrorException", errorCode):
377		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
378
379	case strings.EqualFold("WAFInvalidAccountException", errorCode):
380		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
381
382	case strings.EqualFold("WAFInvalidParameterException", errorCode):
383		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
384
385	case strings.EqualFold("WAFLimitsExceededException", errorCode):
386		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
387
388	case strings.EqualFold("WAFStaleDataException", errorCode):
389		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
390
391	default:
392		genericError := &smithy.GenericAPIError{
393			Code:    errorCode,
394			Message: errorMessage,
395		}
396		return genericError
397
398	}
399}
400
401type awsAwsjson11_deserializeOpCreateRateBasedRule struct {
402}
403
404func (*awsAwsjson11_deserializeOpCreateRateBasedRule) ID() string {
405	return "OperationDeserializer"
406}
407
408func (m *awsAwsjson11_deserializeOpCreateRateBasedRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
409	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
410) {
411	out, metadata, err = next.HandleDeserialize(ctx, in)
412	if err != nil {
413		return out, metadata, err
414	}
415
416	response, ok := out.RawResponse.(*smithyhttp.Response)
417	if !ok {
418		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
419	}
420
421	if response.StatusCode < 200 || response.StatusCode >= 300 {
422		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRateBasedRule(response, &metadata)
423	}
424	output := &CreateRateBasedRuleOutput{}
425	out.Result = output
426
427	var buff [1024]byte
428	ringBuffer := smithyio.NewRingBuffer(buff[:])
429
430	body := io.TeeReader(response.Body, ringBuffer)
431	decoder := json.NewDecoder(body)
432	decoder.UseNumber()
433	var shape interface{}
434	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
435		var snapshot bytes.Buffer
436		io.Copy(&snapshot, ringBuffer)
437		err = &smithy.DeserializationError{
438			Err:      fmt.Errorf("failed to decode response body, %w", err),
439			Snapshot: snapshot.Bytes(),
440		}
441		return out, metadata, err
442	}
443
444	err = awsAwsjson11_deserializeOpDocumentCreateRateBasedRuleOutput(&output, shape)
445	if err != nil {
446		var snapshot bytes.Buffer
447		io.Copy(&snapshot, ringBuffer)
448		err = &smithy.DeserializationError{
449			Err:      fmt.Errorf("failed to decode response body, %w", err),
450			Snapshot: snapshot.Bytes(),
451		}
452		return out, metadata, err
453	}
454
455	return out, metadata, err
456}
457
458func awsAwsjson11_deserializeOpErrorCreateRateBasedRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
459	var errorBuffer bytes.Buffer
460	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
461		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
462	}
463	errorBody := bytes.NewReader(errorBuffer.Bytes())
464
465	errorCode := "UnknownError"
466	errorMessage := errorCode
467
468	code := response.Header.Get("X-Amzn-ErrorType")
469	if len(code) != 0 {
470		errorCode = restjson.SanitizeErrorCode(code)
471	}
472
473	var buff [1024]byte
474	ringBuffer := smithyio.NewRingBuffer(buff[:])
475
476	body := io.TeeReader(errorBody, ringBuffer)
477	decoder := json.NewDecoder(body)
478	decoder.UseNumber()
479	code, message, err := restjson.GetErrorInfo(decoder)
480	if err != nil {
481		var snapshot bytes.Buffer
482		io.Copy(&snapshot, ringBuffer)
483		err = &smithy.DeserializationError{
484			Err:      fmt.Errorf("failed to decode response body, %w", err),
485			Snapshot: snapshot.Bytes(),
486		}
487		return err
488	}
489
490	errorBody.Seek(0, io.SeekStart)
491	if len(code) != 0 {
492		errorCode = restjson.SanitizeErrorCode(code)
493	}
494	if len(message) != 0 {
495		errorMessage = message
496	}
497
498	switch {
499	case strings.EqualFold("WAFBadRequestException", errorCode):
500		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
501
502	case strings.EqualFold("WAFDisallowedNameException", errorCode):
503		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
504
505	case strings.EqualFold("WAFInternalErrorException", errorCode):
506		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
507
508	case strings.EqualFold("WAFInvalidParameterException", errorCode):
509		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
510
511	case strings.EqualFold("WAFLimitsExceededException", errorCode):
512		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
513
514	case strings.EqualFold("WAFStaleDataException", errorCode):
515		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
516
517	case strings.EqualFold("WAFTagOperationException", errorCode):
518		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
519
520	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
521		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
522
523	default:
524		genericError := &smithy.GenericAPIError{
525			Code:    errorCode,
526			Message: errorMessage,
527		}
528		return genericError
529
530	}
531}
532
533type awsAwsjson11_deserializeOpCreateRegexMatchSet struct {
534}
535
536func (*awsAwsjson11_deserializeOpCreateRegexMatchSet) ID() string {
537	return "OperationDeserializer"
538}
539
540func (m *awsAwsjson11_deserializeOpCreateRegexMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
541	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
542) {
543	out, metadata, err = next.HandleDeserialize(ctx, in)
544	if err != nil {
545		return out, metadata, err
546	}
547
548	response, ok := out.RawResponse.(*smithyhttp.Response)
549	if !ok {
550		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
551	}
552
553	if response.StatusCode < 200 || response.StatusCode >= 300 {
554		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRegexMatchSet(response, &metadata)
555	}
556	output := &CreateRegexMatchSetOutput{}
557	out.Result = output
558
559	var buff [1024]byte
560	ringBuffer := smithyio.NewRingBuffer(buff[:])
561
562	body := io.TeeReader(response.Body, ringBuffer)
563	decoder := json.NewDecoder(body)
564	decoder.UseNumber()
565	var shape interface{}
566	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
567		var snapshot bytes.Buffer
568		io.Copy(&snapshot, ringBuffer)
569		err = &smithy.DeserializationError{
570			Err:      fmt.Errorf("failed to decode response body, %w", err),
571			Snapshot: snapshot.Bytes(),
572		}
573		return out, metadata, err
574	}
575
576	err = awsAwsjson11_deserializeOpDocumentCreateRegexMatchSetOutput(&output, shape)
577	if err != nil {
578		var snapshot bytes.Buffer
579		io.Copy(&snapshot, ringBuffer)
580		err = &smithy.DeserializationError{
581			Err:      fmt.Errorf("failed to decode response body, %w", err),
582			Snapshot: snapshot.Bytes(),
583		}
584		return out, metadata, err
585	}
586
587	return out, metadata, err
588}
589
590func awsAwsjson11_deserializeOpErrorCreateRegexMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
591	var errorBuffer bytes.Buffer
592	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
593		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
594	}
595	errorBody := bytes.NewReader(errorBuffer.Bytes())
596
597	errorCode := "UnknownError"
598	errorMessage := errorCode
599
600	code := response.Header.Get("X-Amzn-ErrorType")
601	if len(code) != 0 {
602		errorCode = restjson.SanitizeErrorCode(code)
603	}
604
605	var buff [1024]byte
606	ringBuffer := smithyio.NewRingBuffer(buff[:])
607
608	body := io.TeeReader(errorBody, ringBuffer)
609	decoder := json.NewDecoder(body)
610	decoder.UseNumber()
611	code, message, err := restjson.GetErrorInfo(decoder)
612	if err != nil {
613		var snapshot bytes.Buffer
614		io.Copy(&snapshot, ringBuffer)
615		err = &smithy.DeserializationError{
616			Err:      fmt.Errorf("failed to decode response body, %w", err),
617			Snapshot: snapshot.Bytes(),
618		}
619		return err
620	}
621
622	errorBody.Seek(0, io.SeekStart)
623	if len(code) != 0 {
624		errorCode = restjson.SanitizeErrorCode(code)
625	}
626	if len(message) != 0 {
627		errorMessage = message
628	}
629
630	switch {
631	case strings.EqualFold("WAFDisallowedNameException", errorCode):
632		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
633
634	case strings.EqualFold("WAFInternalErrorException", errorCode):
635		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
636
637	case strings.EqualFold("WAFLimitsExceededException", errorCode):
638		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
639
640	case strings.EqualFold("WAFStaleDataException", errorCode):
641		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
642
643	default:
644		genericError := &smithy.GenericAPIError{
645			Code:    errorCode,
646			Message: errorMessage,
647		}
648		return genericError
649
650	}
651}
652
653type awsAwsjson11_deserializeOpCreateRegexPatternSet struct {
654}
655
656func (*awsAwsjson11_deserializeOpCreateRegexPatternSet) ID() string {
657	return "OperationDeserializer"
658}
659
660func (m *awsAwsjson11_deserializeOpCreateRegexPatternSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
661	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
662) {
663	out, metadata, err = next.HandleDeserialize(ctx, in)
664	if err != nil {
665		return out, metadata, err
666	}
667
668	response, ok := out.RawResponse.(*smithyhttp.Response)
669	if !ok {
670		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
671	}
672
673	if response.StatusCode < 200 || response.StatusCode >= 300 {
674		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRegexPatternSet(response, &metadata)
675	}
676	output := &CreateRegexPatternSetOutput{}
677	out.Result = output
678
679	var buff [1024]byte
680	ringBuffer := smithyio.NewRingBuffer(buff[:])
681
682	body := io.TeeReader(response.Body, ringBuffer)
683	decoder := json.NewDecoder(body)
684	decoder.UseNumber()
685	var shape interface{}
686	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
687		var snapshot bytes.Buffer
688		io.Copy(&snapshot, ringBuffer)
689		err = &smithy.DeserializationError{
690			Err:      fmt.Errorf("failed to decode response body, %w", err),
691			Snapshot: snapshot.Bytes(),
692		}
693		return out, metadata, err
694	}
695
696	err = awsAwsjson11_deserializeOpDocumentCreateRegexPatternSetOutput(&output, shape)
697	if err != nil {
698		var snapshot bytes.Buffer
699		io.Copy(&snapshot, ringBuffer)
700		err = &smithy.DeserializationError{
701			Err:      fmt.Errorf("failed to decode response body, %w", err),
702			Snapshot: snapshot.Bytes(),
703		}
704		return out, metadata, err
705	}
706
707	return out, metadata, err
708}
709
710func awsAwsjson11_deserializeOpErrorCreateRegexPatternSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
711	var errorBuffer bytes.Buffer
712	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
713		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
714	}
715	errorBody := bytes.NewReader(errorBuffer.Bytes())
716
717	errorCode := "UnknownError"
718	errorMessage := errorCode
719
720	code := response.Header.Get("X-Amzn-ErrorType")
721	if len(code) != 0 {
722		errorCode = restjson.SanitizeErrorCode(code)
723	}
724
725	var buff [1024]byte
726	ringBuffer := smithyio.NewRingBuffer(buff[:])
727
728	body := io.TeeReader(errorBody, ringBuffer)
729	decoder := json.NewDecoder(body)
730	decoder.UseNumber()
731	code, message, err := restjson.GetErrorInfo(decoder)
732	if err != nil {
733		var snapshot bytes.Buffer
734		io.Copy(&snapshot, ringBuffer)
735		err = &smithy.DeserializationError{
736			Err:      fmt.Errorf("failed to decode response body, %w", err),
737			Snapshot: snapshot.Bytes(),
738		}
739		return err
740	}
741
742	errorBody.Seek(0, io.SeekStart)
743	if len(code) != 0 {
744		errorCode = restjson.SanitizeErrorCode(code)
745	}
746	if len(message) != 0 {
747		errorMessage = message
748	}
749
750	switch {
751	case strings.EqualFold("WAFDisallowedNameException", errorCode):
752		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
753
754	case strings.EqualFold("WAFInternalErrorException", errorCode):
755		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
756
757	case strings.EqualFold("WAFLimitsExceededException", errorCode):
758		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
759
760	case strings.EqualFold("WAFStaleDataException", errorCode):
761		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
762
763	default:
764		genericError := &smithy.GenericAPIError{
765			Code:    errorCode,
766			Message: errorMessage,
767		}
768		return genericError
769
770	}
771}
772
773type awsAwsjson11_deserializeOpCreateRule struct {
774}
775
776func (*awsAwsjson11_deserializeOpCreateRule) ID() string {
777	return "OperationDeserializer"
778}
779
780func (m *awsAwsjson11_deserializeOpCreateRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
781	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
782) {
783	out, metadata, err = next.HandleDeserialize(ctx, in)
784	if err != nil {
785		return out, metadata, err
786	}
787
788	response, ok := out.RawResponse.(*smithyhttp.Response)
789	if !ok {
790		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
791	}
792
793	if response.StatusCode < 200 || response.StatusCode >= 300 {
794		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRule(response, &metadata)
795	}
796	output := &CreateRuleOutput{}
797	out.Result = output
798
799	var buff [1024]byte
800	ringBuffer := smithyio.NewRingBuffer(buff[:])
801
802	body := io.TeeReader(response.Body, ringBuffer)
803	decoder := json.NewDecoder(body)
804	decoder.UseNumber()
805	var shape interface{}
806	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
807		var snapshot bytes.Buffer
808		io.Copy(&snapshot, ringBuffer)
809		err = &smithy.DeserializationError{
810			Err:      fmt.Errorf("failed to decode response body, %w", err),
811			Snapshot: snapshot.Bytes(),
812		}
813		return out, metadata, err
814	}
815
816	err = awsAwsjson11_deserializeOpDocumentCreateRuleOutput(&output, shape)
817	if err != nil {
818		var snapshot bytes.Buffer
819		io.Copy(&snapshot, ringBuffer)
820		err = &smithy.DeserializationError{
821			Err:      fmt.Errorf("failed to decode response body, %w", err),
822			Snapshot: snapshot.Bytes(),
823		}
824		return out, metadata, err
825	}
826
827	return out, metadata, err
828}
829
830func awsAwsjson11_deserializeOpErrorCreateRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
831	var errorBuffer bytes.Buffer
832	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
833		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
834	}
835	errorBody := bytes.NewReader(errorBuffer.Bytes())
836
837	errorCode := "UnknownError"
838	errorMessage := errorCode
839
840	code := response.Header.Get("X-Amzn-ErrorType")
841	if len(code) != 0 {
842		errorCode = restjson.SanitizeErrorCode(code)
843	}
844
845	var buff [1024]byte
846	ringBuffer := smithyio.NewRingBuffer(buff[:])
847
848	body := io.TeeReader(errorBody, ringBuffer)
849	decoder := json.NewDecoder(body)
850	decoder.UseNumber()
851	code, message, err := restjson.GetErrorInfo(decoder)
852	if err != nil {
853		var snapshot bytes.Buffer
854		io.Copy(&snapshot, ringBuffer)
855		err = &smithy.DeserializationError{
856			Err:      fmt.Errorf("failed to decode response body, %w", err),
857			Snapshot: snapshot.Bytes(),
858		}
859		return err
860	}
861
862	errorBody.Seek(0, io.SeekStart)
863	if len(code) != 0 {
864		errorCode = restjson.SanitizeErrorCode(code)
865	}
866	if len(message) != 0 {
867		errorMessage = message
868	}
869
870	switch {
871	case strings.EqualFold("WAFBadRequestException", errorCode):
872		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
873
874	case strings.EqualFold("WAFDisallowedNameException", errorCode):
875		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
876
877	case strings.EqualFold("WAFInternalErrorException", errorCode):
878		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
879
880	case strings.EqualFold("WAFInvalidParameterException", errorCode):
881		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
882
883	case strings.EqualFold("WAFLimitsExceededException", errorCode):
884		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
885
886	case strings.EqualFold("WAFStaleDataException", errorCode):
887		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
888
889	case strings.EqualFold("WAFTagOperationException", errorCode):
890		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
891
892	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
893		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
894
895	default:
896		genericError := &smithy.GenericAPIError{
897			Code:    errorCode,
898			Message: errorMessage,
899		}
900		return genericError
901
902	}
903}
904
905type awsAwsjson11_deserializeOpCreateRuleGroup struct {
906}
907
908func (*awsAwsjson11_deserializeOpCreateRuleGroup) ID() string {
909	return "OperationDeserializer"
910}
911
912func (m *awsAwsjson11_deserializeOpCreateRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
913	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
914) {
915	out, metadata, err = next.HandleDeserialize(ctx, in)
916	if err != nil {
917		return out, metadata, err
918	}
919
920	response, ok := out.RawResponse.(*smithyhttp.Response)
921	if !ok {
922		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
923	}
924
925	if response.StatusCode < 200 || response.StatusCode >= 300 {
926		return out, metadata, awsAwsjson11_deserializeOpErrorCreateRuleGroup(response, &metadata)
927	}
928	output := &CreateRuleGroupOutput{}
929	out.Result = output
930
931	var buff [1024]byte
932	ringBuffer := smithyio.NewRingBuffer(buff[:])
933
934	body := io.TeeReader(response.Body, ringBuffer)
935	decoder := json.NewDecoder(body)
936	decoder.UseNumber()
937	var shape interface{}
938	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
939		var snapshot bytes.Buffer
940		io.Copy(&snapshot, ringBuffer)
941		err = &smithy.DeserializationError{
942			Err:      fmt.Errorf("failed to decode response body, %w", err),
943			Snapshot: snapshot.Bytes(),
944		}
945		return out, metadata, err
946	}
947
948	err = awsAwsjson11_deserializeOpDocumentCreateRuleGroupOutput(&output, shape)
949	if err != nil {
950		var snapshot bytes.Buffer
951		io.Copy(&snapshot, ringBuffer)
952		err = &smithy.DeserializationError{
953			Err:      fmt.Errorf("failed to decode response body, %w", err),
954			Snapshot: snapshot.Bytes(),
955		}
956		return out, metadata, err
957	}
958
959	return out, metadata, err
960}
961
962func awsAwsjson11_deserializeOpErrorCreateRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
963	var errorBuffer bytes.Buffer
964	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
965		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
966	}
967	errorBody := bytes.NewReader(errorBuffer.Bytes())
968
969	errorCode := "UnknownError"
970	errorMessage := errorCode
971
972	code := response.Header.Get("X-Amzn-ErrorType")
973	if len(code) != 0 {
974		errorCode = restjson.SanitizeErrorCode(code)
975	}
976
977	var buff [1024]byte
978	ringBuffer := smithyio.NewRingBuffer(buff[:])
979
980	body := io.TeeReader(errorBody, ringBuffer)
981	decoder := json.NewDecoder(body)
982	decoder.UseNumber()
983	code, message, err := restjson.GetErrorInfo(decoder)
984	if err != nil {
985		var snapshot bytes.Buffer
986		io.Copy(&snapshot, ringBuffer)
987		err = &smithy.DeserializationError{
988			Err:      fmt.Errorf("failed to decode response body, %w", err),
989			Snapshot: snapshot.Bytes(),
990		}
991		return err
992	}
993
994	errorBody.Seek(0, io.SeekStart)
995	if len(code) != 0 {
996		errorCode = restjson.SanitizeErrorCode(code)
997	}
998	if len(message) != 0 {
999		errorMessage = message
1000	}
1001
1002	switch {
1003	case strings.EqualFold("WAFBadRequestException", errorCode):
1004		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
1005
1006	case strings.EqualFold("WAFDisallowedNameException", errorCode):
1007		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
1008
1009	case strings.EqualFold("WAFInternalErrorException", errorCode):
1010		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1011
1012	case strings.EqualFold("WAFLimitsExceededException", errorCode):
1013		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
1014
1015	case strings.EqualFold("WAFStaleDataException", errorCode):
1016		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1017
1018	case strings.EqualFold("WAFTagOperationException", errorCode):
1019		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
1020
1021	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
1022		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
1023
1024	default:
1025		genericError := &smithy.GenericAPIError{
1026			Code:    errorCode,
1027			Message: errorMessage,
1028		}
1029		return genericError
1030
1031	}
1032}
1033
1034type awsAwsjson11_deserializeOpCreateSizeConstraintSet struct {
1035}
1036
1037func (*awsAwsjson11_deserializeOpCreateSizeConstraintSet) ID() string {
1038	return "OperationDeserializer"
1039}
1040
1041func (m *awsAwsjson11_deserializeOpCreateSizeConstraintSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1042	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1043) {
1044	out, metadata, err = next.HandleDeserialize(ctx, in)
1045	if err != nil {
1046		return out, metadata, err
1047	}
1048
1049	response, ok := out.RawResponse.(*smithyhttp.Response)
1050	if !ok {
1051		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1052	}
1053
1054	if response.StatusCode < 200 || response.StatusCode >= 300 {
1055		return out, metadata, awsAwsjson11_deserializeOpErrorCreateSizeConstraintSet(response, &metadata)
1056	}
1057	output := &CreateSizeConstraintSetOutput{}
1058	out.Result = output
1059
1060	var buff [1024]byte
1061	ringBuffer := smithyio.NewRingBuffer(buff[:])
1062
1063	body := io.TeeReader(response.Body, ringBuffer)
1064	decoder := json.NewDecoder(body)
1065	decoder.UseNumber()
1066	var shape interface{}
1067	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1068		var snapshot bytes.Buffer
1069		io.Copy(&snapshot, ringBuffer)
1070		err = &smithy.DeserializationError{
1071			Err:      fmt.Errorf("failed to decode response body, %w", err),
1072			Snapshot: snapshot.Bytes(),
1073		}
1074		return out, metadata, err
1075	}
1076
1077	err = awsAwsjson11_deserializeOpDocumentCreateSizeConstraintSetOutput(&output, shape)
1078	if err != nil {
1079		var snapshot bytes.Buffer
1080		io.Copy(&snapshot, ringBuffer)
1081		err = &smithy.DeserializationError{
1082			Err:      fmt.Errorf("failed to decode response body, %w", err),
1083			Snapshot: snapshot.Bytes(),
1084		}
1085		return out, metadata, err
1086	}
1087
1088	return out, metadata, err
1089}
1090
1091func awsAwsjson11_deserializeOpErrorCreateSizeConstraintSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1092	var errorBuffer bytes.Buffer
1093	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1094		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1095	}
1096	errorBody := bytes.NewReader(errorBuffer.Bytes())
1097
1098	errorCode := "UnknownError"
1099	errorMessage := errorCode
1100
1101	code := response.Header.Get("X-Amzn-ErrorType")
1102	if len(code) != 0 {
1103		errorCode = restjson.SanitizeErrorCode(code)
1104	}
1105
1106	var buff [1024]byte
1107	ringBuffer := smithyio.NewRingBuffer(buff[:])
1108
1109	body := io.TeeReader(errorBody, ringBuffer)
1110	decoder := json.NewDecoder(body)
1111	decoder.UseNumber()
1112	code, message, err := restjson.GetErrorInfo(decoder)
1113	if err != nil {
1114		var snapshot bytes.Buffer
1115		io.Copy(&snapshot, ringBuffer)
1116		err = &smithy.DeserializationError{
1117			Err:      fmt.Errorf("failed to decode response body, %w", err),
1118			Snapshot: snapshot.Bytes(),
1119		}
1120		return err
1121	}
1122
1123	errorBody.Seek(0, io.SeekStart)
1124	if len(code) != 0 {
1125		errorCode = restjson.SanitizeErrorCode(code)
1126	}
1127	if len(message) != 0 {
1128		errorMessage = message
1129	}
1130
1131	switch {
1132	case strings.EqualFold("WAFDisallowedNameException", errorCode):
1133		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
1134
1135	case strings.EqualFold("WAFInternalErrorException", errorCode):
1136		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1137
1138	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1139		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1140
1141	case strings.EqualFold("WAFInvalidParameterException", errorCode):
1142		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
1143
1144	case strings.EqualFold("WAFLimitsExceededException", errorCode):
1145		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
1146
1147	case strings.EqualFold("WAFStaleDataException", errorCode):
1148		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1149
1150	default:
1151		genericError := &smithy.GenericAPIError{
1152			Code:    errorCode,
1153			Message: errorMessage,
1154		}
1155		return genericError
1156
1157	}
1158}
1159
1160type awsAwsjson11_deserializeOpCreateSqlInjectionMatchSet struct {
1161}
1162
1163func (*awsAwsjson11_deserializeOpCreateSqlInjectionMatchSet) ID() string {
1164	return "OperationDeserializer"
1165}
1166
1167func (m *awsAwsjson11_deserializeOpCreateSqlInjectionMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1168	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1169) {
1170	out, metadata, err = next.HandleDeserialize(ctx, in)
1171	if err != nil {
1172		return out, metadata, err
1173	}
1174
1175	response, ok := out.RawResponse.(*smithyhttp.Response)
1176	if !ok {
1177		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1178	}
1179
1180	if response.StatusCode < 200 || response.StatusCode >= 300 {
1181		return out, metadata, awsAwsjson11_deserializeOpErrorCreateSqlInjectionMatchSet(response, &metadata)
1182	}
1183	output := &CreateSqlInjectionMatchSetOutput{}
1184	out.Result = output
1185
1186	var buff [1024]byte
1187	ringBuffer := smithyio.NewRingBuffer(buff[:])
1188
1189	body := io.TeeReader(response.Body, ringBuffer)
1190	decoder := json.NewDecoder(body)
1191	decoder.UseNumber()
1192	var shape interface{}
1193	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1194		var snapshot bytes.Buffer
1195		io.Copy(&snapshot, ringBuffer)
1196		err = &smithy.DeserializationError{
1197			Err:      fmt.Errorf("failed to decode response body, %w", err),
1198			Snapshot: snapshot.Bytes(),
1199		}
1200		return out, metadata, err
1201	}
1202
1203	err = awsAwsjson11_deserializeOpDocumentCreateSqlInjectionMatchSetOutput(&output, shape)
1204	if err != nil {
1205		var snapshot bytes.Buffer
1206		io.Copy(&snapshot, ringBuffer)
1207		err = &smithy.DeserializationError{
1208			Err:      fmt.Errorf("failed to decode response body, %w", err),
1209			Snapshot: snapshot.Bytes(),
1210		}
1211		return out, metadata, err
1212	}
1213
1214	return out, metadata, err
1215}
1216
1217func awsAwsjson11_deserializeOpErrorCreateSqlInjectionMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1218	var errorBuffer bytes.Buffer
1219	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1220		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1221	}
1222	errorBody := bytes.NewReader(errorBuffer.Bytes())
1223
1224	errorCode := "UnknownError"
1225	errorMessage := errorCode
1226
1227	code := response.Header.Get("X-Amzn-ErrorType")
1228	if len(code) != 0 {
1229		errorCode = restjson.SanitizeErrorCode(code)
1230	}
1231
1232	var buff [1024]byte
1233	ringBuffer := smithyio.NewRingBuffer(buff[:])
1234
1235	body := io.TeeReader(errorBody, ringBuffer)
1236	decoder := json.NewDecoder(body)
1237	decoder.UseNumber()
1238	code, message, err := restjson.GetErrorInfo(decoder)
1239	if err != nil {
1240		var snapshot bytes.Buffer
1241		io.Copy(&snapshot, ringBuffer)
1242		err = &smithy.DeserializationError{
1243			Err:      fmt.Errorf("failed to decode response body, %w", err),
1244			Snapshot: snapshot.Bytes(),
1245		}
1246		return err
1247	}
1248
1249	errorBody.Seek(0, io.SeekStart)
1250	if len(code) != 0 {
1251		errorCode = restjson.SanitizeErrorCode(code)
1252	}
1253	if len(message) != 0 {
1254		errorMessage = message
1255	}
1256
1257	switch {
1258	case strings.EqualFold("WAFDisallowedNameException", errorCode):
1259		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
1260
1261	case strings.EqualFold("WAFInternalErrorException", errorCode):
1262		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1263
1264	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1265		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1266
1267	case strings.EqualFold("WAFInvalidParameterException", errorCode):
1268		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
1269
1270	case strings.EqualFold("WAFLimitsExceededException", errorCode):
1271		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
1272
1273	case strings.EqualFold("WAFStaleDataException", errorCode):
1274		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1275
1276	default:
1277		genericError := &smithy.GenericAPIError{
1278			Code:    errorCode,
1279			Message: errorMessage,
1280		}
1281		return genericError
1282
1283	}
1284}
1285
1286type awsAwsjson11_deserializeOpCreateWebACL struct {
1287}
1288
1289func (*awsAwsjson11_deserializeOpCreateWebACL) ID() string {
1290	return "OperationDeserializer"
1291}
1292
1293func (m *awsAwsjson11_deserializeOpCreateWebACL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1294	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	out, metadata, err = next.HandleDeserialize(ctx, in)
1297	if err != nil {
1298		return out, metadata, err
1299	}
1300
1301	response, ok := out.RawResponse.(*smithyhttp.Response)
1302	if !ok {
1303		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1304	}
1305
1306	if response.StatusCode < 200 || response.StatusCode >= 300 {
1307		return out, metadata, awsAwsjson11_deserializeOpErrorCreateWebACL(response, &metadata)
1308	}
1309	output := &CreateWebACLOutput{}
1310	out.Result = output
1311
1312	var buff [1024]byte
1313	ringBuffer := smithyio.NewRingBuffer(buff[:])
1314
1315	body := io.TeeReader(response.Body, ringBuffer)
1316	decoder := json.NewDecoder(body)
1317	decoder.UseNumber()
1318	var shape interface{}
1319	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1320		var snapshot bytes.Buffer
1321		io.Copy(&snapshot, ringBuffer)
1322		err = &smithy.DeserializationError{
1323			Err:      fmt.Errorf("failed to decode response body, %w", err),
1324			Snapshot: snapshot.Bytes(),
1325		}
1326		return out, metadata, err
1327	}
1328
1329	err = awsAwsjson11_deserializeOpDocumentCreateWebACLOutput(&output, shape)
1330	if err != nil {
1331		var snapshot bytes.Buffer
1332		io.Copy(&snapshot, ringBuffer)
1333		err = &smithy.DeserializationError{
1334			Err:      fmt.Errorf("failed to decode response body, %w", err),
1335			Snapshot: snapshot.Bytes(),
1336		}
1337		return out, metadata, err
1338	}
1339
1340	return out, metadata, err
1341}
1342
1343func awsAwsjson11_deserializeOpErrorCreateWebACL(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1344	var errorBuffer bytes.Buffer
1345	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1346		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1347	}
1348	errorBody := bytes.NewReader(errorBuffer.Bytes())
1349
1350	errorCode := "UnknownError"
1351	errorMessage := errorCode
1352
1353	code := response.Header.Get("X-Amzn-ErrorType")
1354	if len(code) != 0 {
1355		errorCode = restjson.SanitizeErrorCode(code)
1356	}
1357
1358	var buff [1024]byte
1359	ringBuffer := smithyio.NewRingBuffer(buff[:])
1360
1361	body := io.TeeReader(errorBody, ringBuffer)
1362	decoder := json.NewDecoder(body)
1363	decoder.UseNumber()
1364	code, message, err := restjson.GetErrorInfo(decoder)
1365	if err != nil {
1366		var snapshot bytes.Buffer
1367		io.Copy(&snapshot, ringBuffer)
1368		err = &smithy.DeserializationError{
1369			Err:      fmt.Errorf("failed to decode response body, %w", err),
1370			Snapshot: snapshot.Bytes(),
1371		}
1372		return err
1373	}
1374
1375	errorBody.Seek(0, io.SeekStart)
1376	if len(code) != 0 {
1377		errorCode = restjson.SanitizeErrorCode(code)
1378	}
1379	if len(message) != 0 {
1380		errorMessage = message
1381	}
1382
1383	switch {
1384	case strings.EqualFold("WAFBadRequestException", errorCode):
1385		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
1386
1387	case strings.EqualFold("WAFDisallowedNameException", errorCode):
1388		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
1389
1390	case strings.EqualFold("WAFInternalErrorException", errorCode):
1391		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1392
1393	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1394		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1395
1396	case strings.EqualFold("WAFInvalidParameterException", errorCode):
1397		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
1398
1399	case strings.EqualFold("WAFLimitsExceededException", errorCode):
1400		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
1401
1402	case strings.EqualFold("WAFStaleDataException", errorCode):
1403		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1404
1405	case strings.EqualFold("WAFTagOperationException", errorCode):
1406		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
1407
1408	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
1409		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
1410
1411	default:
1412		genericError := &smithy.GenericAPIError{
1413			Code:    errorCode,
1414			Message: errorMessage,
1415		}
1416		return genericError
1417
1418	}
1419}
1420
1421type awsAwsjson11_deserializeOpCreateWebACLMigrationStack struct {
1422}
1423
1424func (*awsAwsjson11_deserializeOpCreateWebACLMigrationStack) ID() string {
1425	return "OperationDeserializer"
1426}
1427
1428func (m *awsAwsjson11_deserializeOpCreateWebACLMigrationStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1429	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1430) {
1431	out, metadata, err = next.HandleDeserialize(ctx, in)
1432	if err != nil {
1433		return out, metadata, err
1434	}
1435
1436	response, ok := out.RawResponse.(*smithyhttp.Response)
1437	if !ok {
1438		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1439	}
1440
1441	if response.StatusCode < 200 || response.StatusCode >= 300 {
1442		return out, metadata, awsAwsjson11_deserializeOpErrorCreateWebACLMigrationStack(response, &metadata)
1443	}
1444	output := &CreateWebACLMigrationStackOutput{}
1445	out.Result = output
1446
1447	var buff [1024]byte
1448	ringBuffer := smithyio.NewRingBuffer(buff[:])
1449
1450	body := io.TeeReader(response.Body, ringBuffer)
1451	decoder := json.NewDecoder(body)
1452	decoder.UseNumber()
1453	var shape interface{}
1454	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1455		var snapshot bytes.Buffer
1456		io.Copy(&snapshot, ringBuffer)
1457		err = &smithy.DeserializationError{
1458			Err:      fmt.Errorf("failed to decode response body, %w", err),
1459			Snapshot: snapshot.Bytes(),
1460		}
1461		return out, metadata, err
1462	}
1463
1464	err = awsAwsjson11_deserializeOpDocumentCreateWebACLMigrationStackOutput(&output, shape)
1465	if err != nil {
1466		var snapshot bytes.Buffer
1467		io.Copy(&snapshot, ringBuffer)
1468		err = &smithy.DeserializationError{
1469			Err:      fmt.Errorf("failed to decode response body, %w", err),
1470			Snapshot: snapshot.Bytes(),
1471		}
1472		return out, metadata, err
1473	}
1474
1475	return out, metadata, err
1476}
1477
1478func awsAwsjson11_deserializeOpErrorCreateWebACLMigrationStack(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1479	var errorBuffer bytes.Buffer
1480	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1481		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1482	}
1483	errorBody := bytes.NewReader(errorBuffer.Bytes())
1484
1485	errorCode := "UnknownError"
1486	errorMessage := errorCode
1487
1488	code := response.Header.Get("X-Amzn-ErrorType")
1489	if len(code) != 0 {
1490		errorCode = restjson.SanitizeErrorCode(code)
1491	}
1492
1493	var buff [1024]byte
1494	ringBuffer := smithyio.NewRingBuffer(buff[:])
1495
1496	body := io.TeeReader(errorBody, ringBuffer)
1497	decoder := json.NewDecoder(body)
1498	decoder.UseNumber()
1499	code, message, err := restjson.GetErrorInfo(decoder)
1500	if err != nil {
1501		var snapshot bytes.Buffer
1502		io.Copy(&snapshot, ringBuffer)
1503		err = &smithy.DeserializationError{
1504			Err:      fmt.Errorf("failed to decode response body, %w", err),
1505			Snapshot: snapshot.Bytes(),
1506		}
1507		return err
1508	}
1509
1510	errorBody.Seek(0, io.SeekStart)
1511	if len(code) != 0 {
1512		errorCode = restjson.SanitizeErrorCode(code)
1513	}
1514	if len(message) != 0 {
1515		errorMessage = message
1516	}
1517
1518	switch {
1519	case strings.EqualFold("WAFEntityMigrationException", errorCode):
1520		return awsAwsjson11_deserializeErrorWAFEntityMigrationException(response, errorBody)
1521
1522	case strings.EqualFold("WAFInternalErrorException", errorCode):
1523		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1524
1525	case strings.EqualFold("WAFInvalidOperationException", errorCode):
1526		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
1527
1528	case strings.EqualFold("WAFInvalidParameterException", errorCode):
1529		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
1530
1531	case strings.EqualFold("WAFNonexistentItemException", errorCode):
1532		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
1533
1534	default:
1535		genericError := &smithy.GenericAPIError{
1536			Code:    errorCode,
1537			Message: errorMessage,
1538		}
1539		return genericError
1540
1541	}
1542}
1543
1544type awsAwsjson11_deserializeOpCreateXssMatchSet struct {
1545}
1546
1547func (*awsAwsjson11_deserializeOpCreateXssMatchSet) ID() string {
1548	return "OperationDeserializer"
1549}
1550
1551func (m *awsAwsjson11_deserializeOpCreateXssMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1552	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1553) {
1554	out, metadata, err = next.HandleDeserialize(ctx, in)
1555	if err != nil {
1556		return out, metadata, err
1557	}
1558
1559	response, ok := out.RawResponse.(*smithyhttp.Response)
1560	if !ok {
1561		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1562	}
1563
1564	if response.StatusCode < 200 || response.StatusCode >= 300 {
1565		return out, metadata, awsAwsjson11_deserializeOpErrorCreateXssMatchSet(response, &metadata)
1566	}
1567	output := &CreateXssMatchSetOutput{}
1568	out.Result = output
1569
1570	var buff [1024]byte
1571	ringBuffer := smithyio.NewRingBuffer(buff[:])
1572
1573	body := io.TeeReader(response.Body, ringBuffer)
1574	decoder := json.NewDecoder(body)
1575	decoder.UseNumber()
1576	var shape interface{}
1577	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1578		var snapshot bytes.Buffer
1579		io.Copy(&snapshot, ringBuffer)
1580		err = &smithy.DeserializationError{
1581			Err:      fmt.Errorf("failed to decode response body, %w", err),
1582			Snapshot: snapshot.Bytes(),
1583		}
1584		return out, metadata, err
1585	}
1586
1587	err = awsAwsjson11_deserializeOpDocumentCreateXssMatchSetOutput(&output, shape)
1588	if err != nil {
1589		var snapshot bytes.Buffer
1590		io.Copy(&snapshot, ringBuffer)
1591		err = &smithy.DeserializationError{
1592			Err:      fmt.Errorf("failed to decode response body, %w", err),
1593			Snapshot: snapshot.Bytes(),
1594		}
1595		return out, metadata, err
1596	}
1597
1598	return out, metadata, err
1599}
1600
1601func awsAwsjson11_deserializeOpErrorCreateXssMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1602	var errorBuffer bytes.Buffer
1603	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1604		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1605	}
1606	errorBody := bytes.NewReader(errorBuffer.Bytes())
1607
1608	errorCode := "UnknownError"
1609	errorMessage := errorCode
1610
1611	code := response.Header.Get("X-Amzn-ErrorType")
1612	if len(code) != 0 {
1613		errorCode = restjson.SanitizeErrorCode(code)
1614	}
1615
1616	var buff [1024]byte
1617	ringBuffer := smithyio.NewRingBuffer(buff[:])
1618
1619	body := io.TeeReader(errorBody, ringBuffer)
1620	decoder := json.NewDecoder(body)
1621	decoder.UseNumber()
1622	code, message, err := restjson.GetErrorInfo(decoder)
1623	if err != nil {
1624		var snapshot bytes.Buffer
1625		io.Copy(&snapshot, ringBuffer)
1626		err = &smithy.DeserializationError{
1627			Err:      fmt.Errorf("failed to decode response body, %w", err),
1628			Snapshot: snapshot.Bytes(),
1629		}
1630		return err
1631	}
1632
1633	errorBody.Seek(0, io.SeekStart)
1634	if len(code) != 0 {
1635		errorCode = restjson.SanitizeErrorCode(code)
1636	}
1637	if len(message) != 0 {
1638		errorMessage = message
1639	}
1640
1641	switch {
1642	case strings.EqualFold("WAFDisallowedNameException", errorCode):
1643		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
1644
1645	case strings.EqualFold("WAFInternalErrorException", errorCode):
1646		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1647
1648	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1649		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1650
1651	case strings.EqualFold("WAFInvalidParameterException", errorCode):
1652		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
1653
1654	case strings.EqualFold("WAFLimitsExceededException", errorCode):
1655		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
1656
1657	case strings.EqualFold("WAFStaleDataException", errorCode):
1658		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1659
1660	default:
1661		genericError := &smithy.GenericAPIError{
1662			Code:    errorCode,
1663			Message: errorMessage,
1664		}
1665		return genericError
1666
1667	}
1668}
1669
1670type awsAwsjson11_deserializeOpDeleteByteMatchSet struct {
1671}
1672
1673func (*awsAwsjson11_deserializeOpDeleteByteMatchSet) ID() string {
1674	return "OperationDeserializer"
1675}
1676
1677func (m *awsAwsjson11_deserializeOpDeleteByteMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1678	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1679) {
1680	out, metadata, err = next.HandleDeserialize(ctx, in)
1681	if err != nil {
1682		return out, metadata, err
1683	}
1684
1685	response, ok := out.RawResponse.(*smithyhttp.Response)
1686	if !ok {
1687		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1688	}
1689
1690	if response.StatusCode < 200 || response.StatusCode >= 300 {
1691		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteByteMatchSet(response, &metadata)
1692	}
1693	output := &DeleteByteMatchSetOutput{}
1694	out.Result = output
1695
1696	var buff [1024]byte
1697	ringBuffer := smithyio.NewRingBuffer(buff[:])
1698
1699	body := io.TeeReader(response.Body, ringBuffer)
1700	decoder := json.NewDecoder(body)
1701	decoder.UseNumber()
1702	var shape interface{}
1703	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1704		var snapshot bytes.Buffer
1705		io.Copy(&snapshot, ringBuffer)
1706		err = &smithy.DeserializationError{
1707			Err:      fmt.Errorf("failed to decode response body, %w", err),
1708			Snapshot: snapshot.Bytes(),
1709		}
1710		return out, metadata, err
1711	}
1712
1713	err = awsAwsjson11_deserializeOpDocumentDeleteByteMatchSetOutput(&output, shape)
1714	if err != nil {
1715		var snapshot bytes.Buffer
1716		io.Copy(&snapshot, ringBuffer)
1717		err = &smithy.DeserializationError{
1718			Err:      fmt.Errorf("failed to decode response body, %w", err),
1719			Snapshot: snapshot.Bytes(),
1720		}
1721		return out, metadata, err
1722	}
1723
1724	return out, metadata, err
1725}
1726
1727func awsAwsjson11_deserializeOpErrorDeleteByteMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1728	var errorBuffer bytes.Buffer
1729	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1730		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1731	}
1732	errorBody := bytes.NewReader(errorBuffer.Bytes())
1733
1734	errorCode := "UnknownError"
1735	errorMessage := errorCode
1736
1737	code := response.Header.Get("X-Amzn-ErrorType")
1738	if len(code) != 0 {
1739		errorCode = restjson.SanitizeErrorCode(code)
1740	}
1741
1742	var buff [1024]byte
1743	ringBuffer := smithyio.NewRingBuffer(buff[:])
1744
1745	body := io.TeeReader(errorBody, ringBuffer)
1746	decoder := json.NewDecoder(body)
1747	decoder.UseNumber()
1748	code, message, err := restjson.GetErrorInfo(decoder)
1749	if err != nil {
1750		var snapshot bytes.Buffer
1751		io.Copy(&snapshot, ringBuffer)
1752		err = &smithy.DeserializationError{
1753			Err:      fmt.Errorf("failed to decode response body, %w", err),
1754			Snapshot: snapshot.Bytes(),
1755		}
1756		return err
1757	}
1758
1759	errorBody.Seek(0, io.SeekStart)
1760	if len(code) != 0 {
1761		errorCode = restjson.SanitizeErrorCode(code)
1762	}
1763	if len(message) != 0 {
1764		errorMessage = message
1765	}
1766
1767	switch {
1768	case strings.EqualFold("WAFInternalErrorException", errorCode):
1769		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1770
1771	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1772		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1773
1774	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
1775		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
1776
1777	case strings.EqualFold("WAFNonexistentItemException", errorCode):
1778		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
1779
1780	case strings.EqualFold("WAFReferencedItemException", errorCode):
1781		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
1782
1783	case strings.EqualFold("WAFStaleDataException", errorCode):
1784		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1785
1786	default:
1787		genericError := &smithy.GenericAPIError{
1788			Code:    errorCode,
1789			Message: errorMessage,
1790		}
1791		return genericError
1792
1793	}
1794}
1795
1796type awsAwsjson11_deserializeOpDeleteGeoMatchSet struct {
1797}
1798
1799func (*awsAwsjson11_deserializeOpDeleteGeoMatchSet) ID() string {
1800	return "OperationDeserializer"
1801}
1802
1803func (m *awsAwsjson11_deserializeOpDeleteGeoMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1804	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1805) {
1806	out, metadata, err = next.HandleDeserialize(ctx, in)
1807	if err != nil {
1808		return out, metadata, err
1809	}
1810
1811	response, ok := out.RawResponse.(*smithyhttp.Response)
1812	if !ok {
1813		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1814	}
1815
1816	if response.StatusCode < 200 || response.StatusCode >= 300 {
1817		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteGeoMatchSet(response, &metadata)
1818	}
1819	output := &DeleteGeoMatchSetOutput{}
1820	out.Result = output
1821
1822	var buff [1024]byte
1823	ringBuffer := smithyio.NewRingBuffer(buff[:])
1824
1825	body := io.TeeReader(response.Body, ringBuffer)
1826	decoder := json.NewDecoder(body)
1827	decoder.UseNumber()
1828	var shape interface{}
1829	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1830		var snapshot bytes.Buffer
1831		io.Copy(&snapshot, ringBuffer)
1832		err = &smithy.DeserializationError{
1833			Err:      fmt.Errorf("failed to decode response body, %w", err),
1834			Snapshot: snapshot.Bytes(),
1835		}
1836		return out, metadata, err
1837	}
1838
1839	err = awsAwsjson11_deserializeOpDocumentDeleteGeoMatchSetOutput(&output, shape)
1840	if err != nil {
1841		var snapshot bytes.Buffer
1842		io.Copy(&snapshot, ringBuffer)
1843		err = &smithy.DeserializationError{
1844			Err:      fmt.Errorf("failed to decode response body, %w", err),
1845			Snapshot: snapshot.Bytes(),
1846		}
1847		return out, metadata, err
1848	}
1849
1850	return out, metadata, err
1851}
1852
1853func awsAwsjson11_deserializeOpErrorDeleteGeoMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1854	var errorBuffer bytes.Buffer
1855	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1856		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1857	}
1858	errorBody := bytes.NewReader(errorBuffer.Bytes())
1859
1860	errorCode := "UnknownError"
1861	errorMessage := errorCode
1862
1863	code := response.Header.Get("X-Amzn-ErrorType")
1864	if len(code) != 0 {
1865		errorCode = restjson.SanitizeErrorCode(code)
1866	}
1867
1868	var buff [1024]byte
1869	ringBuffer := smithyio.NewRingBuffer(buff[:])
1870
1871	body := io.TeeReader(errorBody, ringBuffer)
1872	decoder := json.NewDecoder(body)
1873	decoder.UseNumber()
1874	code, message, err := restjson.GetErrorInfo(decoder)
1875	if err != nil {
1876		var snapshot bytes.Buffer
1877		io.Copy(&snapshot, ringBuffer)
1878		err = &smithy.DeserializationError{
1879			Err:      fmt.Errorf("failed to decode response body, %w", err),
1880			Snapshot: snapshot.Bytes(),
1881		}
1882		return err
1883	}
1884
1885	errorBody.Seek(0, io.SeekStart)
1886	if len(code) != 0 {
1887		errorCode = restjson.SanitizeErrorCode(code)
1888	}
1889	if len(message) != 0 {
1890		errorMessage = message
1891	}
1892
1893	switch {
1894	case strings.EqualFold("WAFInternalErrorException", errorCode):
1895		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
1896
1897	case strings.EqualFold("WAFInvalidAccountException", errorCode):
1898		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
1899
1900	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
1901		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
1902
1903	case strings.EqualFold("WAFNonexistentItemException", errorCode):
1904		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
1905
1906	case strings.EqualFold("WAFReferencedItemException", errorCode):
1907		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
1908
1909	case strings.EqualFold("WAFStaleDataException", errorCode):
1910		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
1911
1912	default:
1913		genericError := &smithy.GenericAPIError{
1914			Code:    errorCode,
1915			Message: errorMessage,
1916		}
1917		return genericError
1918
1919	}
1920}
1921
1922type awsAwsjson11_deserializeOpDeleteIPSet struct {
1923}
1924
1925func (*awsAwsjson11_deserializeOpDeleteIPSet) ID() string {
1926	return "OperationDeserializer"
1927}
1928
1929func (m *awsAwsjson11_deserializeOpDeleteIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1930	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1931) {
1932	out, metadata, err = next.HandleDeserialize(ctx, in)
1933	if err != nil {
1934		return out, metadata, err
1935	}
1936
1937	response, ok := out.RawResponse.(*smithyhttp.Response)
1938	if !ok {
1939		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1940	}
1941
1942	if response.StatusCode < 200 || response.StatusCode >= 300 {
1943		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteIPSet(response, &metadata)
1944	}
1945	output := &DeleteIPSetOutput{}
1946	out.Result = output
1947
1948	var buff [1024]byte
1949	ringBuffer := smithyio.NewRingBuffer(buff[:])
1950
1951	body := io.TeeReader(response.Body, ringBuffer)
1952	decoder := json.NewDecoder(body)
1953	decoder.UseNumber()
1954	var shape interface{}
1955	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1956		var snapshot bytes.Buffer
1957		io.Copy(&snapshot, ringBuffer)
1958		err = &smithy.DeserializationError{
1959			Err:      fmt.Errorf("failed to decode response body, %w", err),
1960			Snapshot: snapshot.Bytes(),
1961		}
1962		return out, metadata, err
1963	}
1964
1965	err = awsAwsjson11_deserializeOpDocumentDeleteIPSetOutput(&output, shape)
1966	if err != nil {
1967		var snapshot bytes.Buffer
1968		io.Copy(&snapshot, ringBuffer)
1969		err = &smithy.DeserializationError{
1970			Err:      fmt.Errorf("failed to decode response body, %w", err),
1971			Snapshot: snapshot.Bytes(),
1972		}
1973		return out, metadata, err
1974	}
1975
1976	return out, metadata, err
1977}
1978
1979func awsAwsjson11_deserializeOpErrorDeleteIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1980	var errorBuffer bytes.Buffer
1981	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1982		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1983	}
1984	errorBody := bytes.NewReader(errorBuffer.Bytes())
1985
1986	errorCode := "UnknownError"
1987	errorMessage := errorCode
1988
1989	code := response.Header.Get("X-Amzn-ErrorType")
1990	if len(code) != 0 {
1991		errorCode = restjson.SanitizeErrorCode(code)
1992	}
1993
1994	var buff [1024]byte
1995	ringBuffer := smithyio.NewRingBuffer(buff[:])
1996
1997	body := io.TeeReader(errorBody, ringBuffer)
1998	decoder := json.NewDecoder(body)
1999	decoder.UseNumber()
2000	code, message, err := restjson.GetErrorInfo(decoder)
2001	if err != nil {
2002		var snapshot bytes.Buffer
2003		io.Copy(&snapshot, ringBuffer)
2004		err = &smithy.DeserializationError{
2005			Err:      fmt.Errorf("failed to decode response body, %w", err),
2006			Snapshot: snapshot.Bytes(),
2007		}
2008		return err
2009	}
2010
2011	errorBody.Seek(0, io.SeekStart)
2012	if len(code) != 0 {
2013		errorCode = restjson.SanitizeErrorCode(code)
2014	}
2015	if len(message) != 0 {
2016		errorMessage = message
2017	}
2018
2019	switch {
2020	case strings.EqualFold("WAFInternalErrorException", errorCode):
2021		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2022
2023	case strings.EqualFold("WAFInvalidAccountException", errorCode):
2024		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
2025
2026	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2027		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2028
2029	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2030		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2031
2032	case strings.EqualFold("WAFReferencedItemException", errorCode):
2033		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2034
2035	case strings.EqualFold("WAFStaleDataException", errorCode):
2036		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2037
2038	default:
2039		genericError := &smithy.GenericAPIError{
2040			Code:    errorCode,
2041			Message: errorMessage,
2042		}
2043		return genericError
2044
2045	}
2046}
2047
2048type awsAwsjson11_deserializeOpDeleteLoggingConfiguration struct {
2049}
2050
2051func (*awsAwsjson11_deserializeOpDeleteLoggingConfiguration) ID() string {
2052	return "OperationDeserializer"
2053}
2054
2055func (m *awsAwsjson11_deserializeOpDeleteLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2056	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2057) {
2058	out, metadata, err = next.HandleDeserialize(ctx, in)
2059	if err != nil {
2060		return out, metadata, err
2061	}
2062
2063	response, ok := out.RawResponse.(*smithyhttp.Response)
2064	if !ok {
2065		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2066	}
2067
2068	if response.StatusCode < 200 || response.StatusCode >= 300 {
2069		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLoggingConfiguration(response, &metadata)
2070	}
2071	output := &DeleteLoggingConfigurationOutput{}
2072	out.Result = output
2073
2074	var buff [1024]byte
2075	ringBuffer := smithyio.NewRingBuffer(buff[:])
2076
2077	body := io.TeeReader(response.Body, ringBuffer)
2078	decoder := json.NewDecoder(body)
2079	decoder.UseNumber()
2080	var shape interface{}
2081	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2082		var snapshot bytes.Buffer
2083		io.Copy(&snapshot, ringBuffer)
2084		err = &smithy.DeserializationError{
2085			Err:      fmt.Errorf("failed to decode response body, %w", err),
2086			Snapshot: snapshot.Bytes(),
2087		}
2088		return out, metadata, err
2089	}
2090
2091	err = awsAwsjson11_deserializeOpDocumentDeleteLoggingConfigurationOutput(&output, shape)
2092	if err != nil {
2093		var snapshot bytes.Buffer
2094		io.Copy(&snapshot, ringBuffer)
2095		err = &smithy.DeserializationError{
2096			Err:      fmt.Errorf("failed to decode response body, %w", err),
2097			Snapshot: snapshot.Bytes(),
2098		}
2099		return out, metadata, err
2100	}
2101
2102	return out, metadata, err
2103}
2104
2105func awsAwsjson11_deserializeOpErrorDeleteLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2106	var errorBuffer bytes.Buffer
2107	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2108		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2109	}
2110	errorBody := bytes.NewReader(errorBuffer.Bytes())
2111
2112	errorCode := "UnknownError"
2113	errorMessage := errorCode
2114
2115	code := response.Header.Get("X-Amzn-ErrorType")
2116	if len(code) != 0 {
2117		errorCode = restjson.SanitizeErrorCode(code)
2118	}
2119
2120	var buff [1024]byte
2121	ringBuffer := smithyio.NewRingBuffer(buff[:])
2122
2123	body := io.TeeReader(errorBody, ringBuffer)
2124	decoder := json.NewDecoder(body)
2125	decoder.UseNumber()
2126	code, message, err := restjson.GetErrorInfo(decoder)
2127	if err != nil {
2128		var snapshot bytes.Buffer
2129		io.Copy(&snapshot, ringBuffer)
2130		err = &smithy.DeserializationError{
2131			Err:      fmt.Errorf("failed to decode response body, %w", err),
2132			Snapshot: snapshot.Bytes(),
2133		}
2134		return err
2135	}
2136
2137	errorBody.Seek(0, io.SeekStart)
2138	if len(code) != 0 {
2139		errorCode = restjson.SanitizeErrorCode(code)
2140	}
2141	if len(message) != 0 {
2142		errorMessage = message
2143	}
2144
2145	switch {
2146	case strings.EqualFold("WAFInternalErrorException", errorCode):
2147		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2148
2149	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2150		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2151
2152	case strings.EqualFold("WAFStaleDataException", errorCode):
2153		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2154
2155	default:
2156		genericError := &smithy.GenericAPIError{
2157			Code:    errorCode,
2158			Message: errorMessage,
2159		}
2160		return genericError
2161
2162	}
2163}
2164
2165type awsAwsjson11_deserializeOpDeletePermissionPolicy struct {
2166}
2167
2168func (*awsAwsjson11_deserializeOpDeletePermissionPolicy) ID() string {
2169	return "OperationDeserializer"
2170}
2171
2172func (m *awsAwsjson11_deserializeOpDeletePermissionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2173	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2174) {
2175	out, metadata, err = next.HandleDeserialize(ctx, in)
2176	if err != nil {
2177		return out, metadata, err
2178	}
2179
2180	response, ok := out.RawResponse.(*smithyhttp.Response)
2181	if !ok {
2182		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2183	}
2184
2185	if response.StatusCode < 200 || response.StatusCode >= 300 {
2186		return out, metadata, awsAwsjson11_deserializeOpErrorDeletePermissionPolicy(response, &metadata)
2187	}
2188	output := &DeletePermissionPolicyOutput{}
2189	out.Result = output
2190
2191	var buff [1024]byte
2192	ringBuffer := smithyio.NewRingBuffer(buff[:])
2193
2194	body := io.TeeReader(response.Body, ringBuffer)
2195	decoder := json.NewDecoder(body)
2196	decoder.UseNumber()
2197	var shape interface{}
2198	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2199		var snapshot bytes.Buffer
2200		io.Copy(&snapshot, ringBuffer)
2201		err = &smithy.DeserializationError{
2202			Err:      fmt.Errorf("failed to decode response body, %w", err),
2203			Snapshot: snapshot.Bytes(),
2204		}
2205		return out, metadata, err
2206	}
2207
2208	err = awsAwsjson11_deserializeOpDocumentDeletePermissionPolicyOutput(&output, shape)
2209	if err != nil {
2210		var snapshot bytes.Buffer
2211		io.Copy(&snapshot, ringBuffer)
2212		err = &smithy.DeserializationError{
2213			Err:      fmt.Errorf("failed to decode response body, %w", err),
2214			Snapshot: snapshot.Bytes(),
2215		}
2216		return out, metadata, err
2217	}
2218
2219	return out, metadata, err
2220}
2221
2222func awsAwsjson11_deserializeOpErrorDeletePermissionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2223	var errorBuffer bytes.Buffer
2224	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2225		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2226	}
2227	errorBody := bytes.NewReader(errorBuffer.Bytes())
2228
2229	errorCode := "UnknownError"
2230	errorMessage := errorCode
2231
2232	code := response.Header.Get("X-Amzn-ErrorType")
2233	if len(code) != 0 {
2234		errorCode = restjson.SanitizeErrorCode(code)
2235	}
2236
2237	var buff [1024]byte
2238	ringBuffer := smithyio.NewRingBuffer(buff[:])
2239
2240	body := io.TeeReader(errorBody, ringBuffer)
2241	decoder := json.NewDecoder(body)
2242	decoder.UseNumber()
2243	code, message, err := restjson.GetErrorInfo(decoder)
2244	if err != nil {
2245		var snapshot bytes.Buffer
2246		io.Copy(&snapshot, ringBuffer)
2247		err = &smithy.DeserializationError{
2248			Err:      fmt.Errorf("failed to decode response body, %w", err),
2249			Snapshot: snapshot.Bytes(),
2250		}
2251		return err
2252	}
2253
2254	errorBody.Seek(0, io.SeekStart)
2255	if len(code) != 0 {
2256		errorCode = restjson.SanitizeErrorCode(code)
2257	}
2258	if len(message) != 0 {
2259		errorMessage = message
2260	}
2261
2262	switch {
2263	case strings.EqualFold("WAFInternalErrorException", errorCode):
2264		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2265
2266	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2267		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2268
2269	case strings.EqualFold("WAFStaleDataException", errorCode):
2270		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2271
2272	default:
2273		genericError := &smithy.GenericAPIError{
2274			Code:    errorCode,
2275			Message: errorMessage,
2276		}
2277		return genericError
2278
2279	}
2280}
2281
2282type awsAwsjson11_deserializeOpDeleteRateBasedRule struct {
2283}
2284
2285func (*awsAwsjson11_deserializeOpDeleteRateBasedRule) ID() string {
2286	return "OperationDeserializer"
2287}
2288
2289func (m *awsAwsjson11_deserializeOpDeleteRateBasedRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2290	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2291) {
2292	out, metadata, err = next.HandleDeserialize(ctx, in)
2293	if err != nil {
2294		return out, metadata, err
2295	}
2296
2297	response, ok := out.RawResponse.(*smithyhttp.Response)
2298	if !ok {
2299		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2300	}
2301
2302	if response.StatusCode < 200 || response.StatusCode >= 300 {
2303		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRateBasedRule(response, &metadata)
2304	}
2305	output := &DeleteRateBasedRuleOutput{}
2306	out.Result = output
2307
2308	var buff [1024]byte
2309	ringBuffer := smithyio.NewRingBuffer(buff[:])
2310
2311	body := io.TeeReader(response.Body, ringBuffer)
2312	decoder := json.NewDecoder(body)
2313	decoder.UseNumber()
2314	var shape interface{}
2315	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2316		var snapshot bytes.Buffer
2317		io.Copy(&snapshot, ringBuffer)
2318		err = &smithy.DeserializationError{
2319			Err:      fmt.Errorf("failed to decode response body, %w", err),
2320			Snapshot: snapshot.Bytes(),
2321		}
2322		return out, metadata, err
2323	}
2324
2325	err = awsAwsjson11_deserializeOpDocumentDeleteRateBasedRuleOutput(&output, shape)
2326	if err != nil {
2327		var snapshot bytes.Buffer
2328		io.Copy(&snapshot, ringBuffer)
2329		err = &smithy.DeserializationError{
2330			Err:      fmt.Errorf("failed to decode response body, %w", err),
2331			Snapshot: snapshot.Bytes(),
2332		}
2333		return out, metadata, err
2334	}
2335
2336	return out, metadata, err
2337}
2338
2339func awsAwsjson11_deserializeOpErrorDeleteRateBasedRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2340	var errorBuffer bytes.Buffer
2341	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2342		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2343	}
2344	errorBody := bytes.NewReader(errorBuffer.Bytes())
2345
2346	errorCode := "UnknownError"
2347	errorMessage := errorCode
2348
2349	code := response.Header.Get("X-Amzn-ErrorType")
2350	if len(code) != 0 {
2351		errorCode = restjson.SanitizeErrorCode(code)
2352	}
2353
2354	var buff [1024]byte
2355	ringBuffer := smithyio.NewRingBuffer(buff[:])
2356
2357	body := io.TeeReader(errorBody, ringBuffer)
2358	decoder := json.NewDecoder(body)
2359	decoder.UseNumber()
2360	code, message, err := restjson.GetErrorInfo(decoder)
2361	if err != nil {
2362		var snapshot bytes.Buffer
2363		io.Copy(&snapshot, ringBuffer)
2364		err = &smithy.DeserializationError{
2365			Err:      fmt.Errorf("failed to decode response body, %w", err),
2366			Snapshot: snapshot.Bytes(),
2367		}
2368		return err
2369	}
2370
2371	errorBody.Seek(0, io.SeekStart)
2372	if len(code) != 0 {
2373		errorCode = restjson.SanitizeErrorCode(code)
2374	}
2375	if len(message) != 0 {
2376		errorMessage = message
2377	}
2378
2379	switch {
2380	case strings.EqualFold("WAFInternalErrorException", errorCode):
2381		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2382
2383	case strings.EqualFold("WAFInvalidAccountException", errorCode):
2384		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
2385
2386	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2387		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2388
2389	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2390		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2391
2392	case strings.EqualFold("WAFReferencedItemException", errorCode):
2393		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2394
2395	case strings.EqualFold("WAFStaleDataException", errorCode):
2396		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2397
2398	case strings.EqualFold("WAFTagOperationException", errorCode):
2399		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
2400
2401	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
2402		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
2403
2404	default:
2405		genericError := &smithy.GenericAPIError{
2406			Code:    errorCode,
2407			Message: errorMessage,
2408		}
2409		return genericError
2410
2411	}
2412}
2413
2414type awsAwsjson11_deserializeOpDeleteRegexMatchSet struct {
2415}
2416
2417func (*awsAwsjson11_deserializeOpDeleteRegexMatchSet) ID() string {
2418	return "OperationDeserializer"
2419}
2420
2421func (m *awsAwsjson11_deserializeOpDeleteRegexMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2422	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2423) {
2424	out, metadata, err = next.HandleDeserialize(ctx, in)
2425	if err != nil {
2426		return out, metadata, err
2427	}
2428
2429	response, ok := out.RawResponse.(*smithyhttp.Response)
2430	if !ok {
2431		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2432	}
2433
2434	if response.StatusCode < 200 || response.StatusCode >= 300 {
2435		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRegexMatchSet(response, &metadata)
2436	}
2437	output := &DeleteRegexMatchSetOutput{}
2438	out.Result = output
2439
2440	var buff [1024]byte
2441	ringBuffer := smithyio.NewRingBuffer(buff[:])
2442
2443	body := io.TeeReader(response.Body, ringBuffer)
2444	decoder := json.NewDecoder(body)
2445	decoder.UseNumber()
2446	var shape interface{}
2447	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2448		var snapshot bytes.Buffer
2449		io.Copy(&snapshot, ringBuffer)
2450		err = &smithy.DeserializationError{
2451			Err:      fmt.Errorf("failed to decode response body, %w", err),
2452			Snapshot: snapshot.Bytes(),
2453		}
2454		return out, metadata, err
2455	}
2456
2457	err = awsAwsjson11_deserializeOpDocumentDeleteRegexMatchSetOutput(&output, shape)
2458	if err != nil {
2459		var snapshot bytes.Buffer
2460		io.Copy(&snapshot, ringBuffer)
2461		err = &smithy.DeserializationError{
2462			Err:      fmt.Errorf("failed to decode response body, %w", err),
2463			Snapshot: snapshot.Bytes(),
2464		}
2465		return out, metadata, err
2466	}
2467
2468	return out, metadata, err
2469}
2470
2471func awsAwsjson11_deserializeOpErrorDeleteRegexMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2472	var errorBuffer bytes.Buffer
2473	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2474		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2475	}
2476	errorBody := bytes.NewReader(errorBuffer.Bytes())
2477
2478	errorCode := "UnknownError"
2479	errorMessage := errorCode
2480
2481	code := response.Header.Get("X-Amzn-ErrorType")
2482	if len(code) != 0 {
2483		errorCode = restjson.SanitizeErrorCode(code)
2484	}
2485
2486	var buff [1024]byte
2487	ringBuffer := smithyio.NewRingBuffer(buff[:])
2488
2489	body := io.TeeReader(errorBody, ringBuffer)
2490	decoder := json.NewDecoder(body)
2491	decoder.UseNumber()
2492	code, message, err := restjson.GetErrorInfo(decoder)
2493	if err != nil {
2494		var snapshot bytes.Buffer
2495		io.Copy(&snapshot, ringBuffer)
2496		err = &smithy.DeserializationError{
2497			Err:      fmt.Errorf("failed to decode response body, %w", err),
2498			Snapshot: snapshot.Bytes(),
2499		}
2500		return err
2501	}
2502
2503	errorBody.Seek(0, io.SeekStart)
2504	if len(code) != 0 {
2505		errorCode = restjson.SanitizeErrorCode(code)
2506	}
2507	if len(message) != 0 {
2508		errorMessage = message
2509	}
2510
2511	switch {
2512	case strings.EqualFold("WAFInternalErrorException", errorCode):
2513		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2514
2515	case strings.EqualFold("WAFInvalidAccountException", errorCode):
2516		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
2517
2518	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2519		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2520
2521	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2522		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2523
2524	case strings.EqualFold("WAFReferencedItemException", errorCode):
2525		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2526
2527	case strings.EqualFold("WAFStaleDataException", errorCode):
2528		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2529
2530	default:
2531		genericError := &smithy.GenericAPIError{
2532			Code:    errorCode,
2533			Message: errorMessage,
2534		}
2535		return genericError
2536
2537	}
2538}
2539
2540type awsAwsjson11_deserializeOpDeleteRegexPatternSet struct {
2541}
2542
2543func (*awsAwsjson11_deserializeOpDeleteRegexPatternSet) ID() string {
2544	return "OperationDeserializer"
2545}
2546
2547func (m *awsAwsjson11_deserializeOpDeleteRegexPatternSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2548	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2549) {
2550	out, metadata, err = next.HandleDeserialize(ctx, in)
2551	if err != nil {
2552		return out, metadata, err
2553	}
2554
2555	response, ok := out.RawResponse.(*smithyhttp.Response)
2556	if !ok {
2557		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2558	}
2559
2560	if response.StatusCode < 200 || response.StatusCode >= 300 {
2561		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRegexPatternSet(response, &metadata)
2562	}
2563	output := &DeleteRegexPatternSetOutput{}
2564	out.Result = output
2565
2566	var buff [1024]byte
2567	ringBuffer := smithyio.NewRingBuffer(buff[:])
2568
2569	body := io.TeeReader(response.Body, ringBuffer)
2570	decoder := json.NewDecoder(body)
2571	decoder.UseNumber()
2572	var shape interface{}
2573	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2574		var snapshot bytes.Buffer
2575		io.Copy(&snapshot, ringBuffer)
2576		err = &smithy.DeserializationError{
2577			Err:      fmt.Errorf("failed to decode response body, %w", err),
2578			Snapshot: snapshot.Bytes(),
2579		}
2580		return out, metadata, err
2581	}
2582
2583	err = awsAwsjson11_deserializeOpDocumentDeleteRegexPatternSetOutput(&output, shape)
2584	if err != nil {
2585		var snapshot bytes.Buffer
2586		io.Copy(&snapshot, ringBuffer)
2587		err = &smithy.DeserializationError{
2588			Err:      fmt.Errorf("failed to decode response body, %w", err),
2589			Snapshot: snapshot.Bytes(),
2590		}
2591		return out, metadata, err
2592	}
2593
2594	return out, metadata, err
2595}
2596
2597func awsAwsjson11_deserializeOpErrorDeleteRegexPatternSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2598	var errorBuffer bytes.Buffer
2599	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2600		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2601	}
2602	errorBody := bytes.NewReader(errorBuffer.Bytes())
2603
2604	errorCode := "UnknownError"
2605	errorMessage := errorCode
2606
2607	code := response.Header.Get("X-Amzn-ErrorType")
2608	if len(code) != 0 {
2609		errorCode = restjson.SanitizeErrorCode(code)
2610	}
2611
2612	var buff [1024]byte
2613	ringBuffer := smithyio.NewRingBuffer(buff[:])
2614
2615	body := io.TeeReader(errorBody, ringBuffer)
2616	decoder := json.NewDecoder(body)
2617	decoder.UseNumber()
2618	code, message, err := restjson.GetErrorInfo(decoder)
2619	if err != nil {
2620		var snapshot bytes.Buffer
2621		io.Copy(&snapshot, ringBuffer)
2622		err = &smithy.DeserializationError{
2623			Err:      fmt.Errorf("failed to decode response body, %w", err),
2624			Snapshot: snapshot.Bytes(),
2625		}
2626		return err
2627	}
2628
2629	errorBody.Seek(0, io.SeekStart)
2630	if len(code) != 0 {
2631		errorCode = restjson.SanitizeErrorCode(code)
2632	}
2633	if len(message) != 0 {
2634		errorMessage = message
2635	}
2636
2637	switch {
2638	case strings.EqualFold("WAFInternalErrorException", errorCode):
2639		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2640
2641	case strings.EqualFold("WAFInvalidAccountException", errorCode):
2642		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
2643
2644	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2645		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2646
2647	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2648		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2649
2650	case strings.EqualFold("WAFReferencedItemException", errorCode):
2651		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2652
2653	case strings.EqualFold("WAFStaleDataException", errorCode):
2654		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2655
2656	default:
2657		genericError := &smithy.GenericAPIError{
2658			Code:    errorCode,
2659			Message: errorMessage,
2660		}
2661		return genericError
2662
2663	}
2664}
2665
2666type awsAwsjson11_deserializeOpDeleteRule struct {
2667}
2668
2669func (*awsAwsjson11_deserializeOpDeleteRule) ID() string {
2670	return "OperationDeserializer"
2671}
2672
2673func (m *awsAwsjson11_deserializeOpDeleteRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2674	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2675) {
2676	out, metadata, err = next.HandleDeserialize(ctx, in)
2677	if err != nil {
2678		return out, metadata, err
2679	}
2680
2681	response, ok := out.RawResponse.(*smithyhttp.Response)
2682	if !ok {
2683		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2684	}
2685
2686	if response.StatusCode < 200 || response.StatusCode >= 300 {
2687		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRule(response, &metadata)
2688	}
2689	output := &DeleteRuleOutput{}
2690	out.Result = output
2691
2692	var buff [1024]byte
2693	ringBuffer := smithyio.NewRingBuffer(buff[:])
2694
2695	body := io.TeeReader(response.Body, ringBuffer)
2696	decoder := json.NewDecoder(body)
2697	decoder.UseNumber()
2698	var shape interface{}
2699	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2700		var snapshot bytes.Buffer
2701		io.Copy(&snapshot, ringBuffer)
2702		err = &smithy.DeserializationError{
2703			Err:      fmt.Errorf("failed to decode response body, %w", err),
2704			Snapshot: snapshot.Bytes(),
2705		}
2706		return out, metadata, err
2707	}
2708
2709	err = awsAwsjson11_deserializeOpDocumentDeleteRuleOutput(&output, shape)
2710	if err != nil {
2711		var snapshot bytes.Buffer
2712		io.Copy(&snapshot, ringBuffer)
2713		err = &smithy.DeserializationError{
2714			Err:      fmt.Errorf("failed to decode response body, %w", err),
2715			Snapshot: snapshot.Bytes(),
2716		}
2717		return out, metadata, err
2718	}
2719
2720	return out, metadata, err
2721}
2722
2723func awsAwsjson11_deserializeOpErrorDeleteRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2724	var errorBuffer bytes.Buffer
2725	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2726		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2727	}
2728	errorBody := bytes.NewReader(errorBuffer.Bytes())
2729
2730	errorCode := "UnknownError"
2731	errorMessage := errorCode
2732
2733	code := response.Header.Get("X-Amzn-ErrorType")
2734	if len(code) != 0 {
2735		errorCode = restjson.SanitizeErrorCode(code)
2736	}
2737
2738	var buff [1024]byte
2739	ringBuffer := smithyio.NewRingBuffer(buff[:])
2740
2741	body := io.TeeReader(errorBody, ringBuffer)
2742	decoder := json.NewDecoder(body)
2743	decoder.UseNumber()
2744	code, message, err := restjson.GetErrorInfo(decoder)
2745	if err != nil {
2746		var snapshot bytes.Buffer
2747		io.Copy(&snapshot, ringBuffer)
2748		err = &smithy.DeserializationError{
2749			Err:      fmt.Errorf("failed to decode response body, %w", err),
2750			Snapshot: snapshot.Bytes(),
2751		}
2752		return err
2753	}
2754
2755	errorBody.Seek(0, io.SeekStart)
2756	if len(code) != 0 {
2757		errorCode = restjson.SanitizeErrorCode(code)
2758	}
2759	if len(message) != 0 {
2760		errorMessage = message
2761	}
2762
2763	switch {
2764	case strings.EqualFold("WAFInternalErrorException", errorCode):
2765		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2766
2767	case strings.EqualFold("WAFInvalidAccountException", errorCode):
2768		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
2769
2770	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2771		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2772
2773	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2774		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2775
2776	case strings.EqualFold("WAFReferencedItemException", errorCode):
2777		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2778
2779	case strings.EqualFold("WAFStaleDataException", errorCode):
2780		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2781
2782	case strings.EqualFold("WAFTagOperationException", errorCode):
2783		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
2784
2785	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
2786		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
2787
2788	default:
2789		genericError := &smithy.GenericAPIError{
2790			Code:    errorCode,
2791			Message: errorMessage,
2792		}
2793		return genericError
2794
2795	}
2796}
2797
2798type awsAwsjson11_deserializeOpDeleteRuleGroup struct {
2799}
2800
2801func (*awsAwsjson11_deserializeOpDeleteRuleGroup) ID() string {
2802	return "OperationDeserializer"
2803}
2804
2805func (m *awsAwsjson11_deserializeOpDeleteRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2806	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2807) {
2808	out, metadata, err = next.HandleDeserialize(ctx, in)
2809	if err != nil {
2810		return out, metadata, err
2811	}
2812
2813	response, ok := out.RawResponse.(*smithyhttp.Response)
2814	if !ok {
2815		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2816	}
2817
2818	if response.StatusCode < 200 || response.StatusCode >= 300 {
2819		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteRuleGroup(response, &metadata)
2820	}
2821	output := &DeleteRuleGroupOutput{}
2822	out.Result = output
2823
2824	var buff [1024]byte
2825	ringBuffer := smithyio.NewRingBuffer(buff[:])
2826
2827	body := io.TeeReader(response.Body, ringBuffer)
2828	decoder := json.NewDecoder(body)
2829	decoder.UseNumber()
2830	var shape interface{}
2831	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2832		var snapshot bytes.Buffer
2833		io.Copy(&snapshot, ringBuffer)
2834		err = &smithy.DeserializationError{
2835			Err:      fmt.Errorf("failed to decode response body, %w", err),
2836			Snapshot: snapshot.Bytes(),
2837		}
2838		return out, metadata, err
2839	}
2840
2841	err = awsAwsjson11_deserializeOpDocumentDeleteRuleGroupOutput(&output, shape)
2842	if err != nil {
2843		var snapshot bytes.Buffer
2844		io.Copy(&snapshot, ringBuffer)
2845		err = &smithy.DeserializationError{
2846			Err:      fmt.Errorf("failed to decode response body, %w", err),
2847			Snapshot: snapshot.Bytes(),
2848		}
2849		return out, metadata, err
2850	}
2851
2852	return out, metadata, err
2853}
2854
2855func awsAwsjson11_deserializeOpErrorDeleteRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2856	var errorBuffer bytes.Buffer
2857	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2858		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2859	}
2860	errorBody := bytes.NewReader(errorBuffer.Bytes())
2861
2862	errorCode := "UnknownError"
2863	errorMessage := errorCode
2864
2865	code := response.Header.Get("X-Amzn-ErrorType")
2866	if len(code) != 0 {
2867		errorCode = restjson.SanitizeErrorCode(code)
2868	}
2869
2870	var buff [1024]byte
2871	ringBuffer := smithyio.NewRingBuffer(buff[:])
2872
2873	body := io.TeeReader(errorBody, ringBuffer)
2874	decoder := json.NewDecoder(body)
2875	decoder.UseNumber()
2876	code, message, err := restjson.GetErrorInfo(decoder)
2877	if err != nil {
2878		var snapshot bytes.Buffer
2879		io.Copy(&snapshot, ringBuffer)
2880		err = &smithy.DeserializationError{
2881			Err:      fmt.Errorf("failed to decode response body, %w", err),
2882			Snapshot: snapshot.Bytes(),
2883		}
2884		return err
2885	}
2886
2887	errorBody.Seek(0, io.SeekStart)
2888	if len(code) != 0 {
2889		errorCode = restjson.SanitizeErrorCode(code)
2890	}
2891	if len(message) != 0 {
2892		errorMessage = message
2893	}
2894
2895	switch {
2896	case strings.EqualFold("WAFInternalErrorException", errorCode):
2897		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
2898
2899	case strings.EqualFold("WAFInvalidOperationException", errorCode):
2900		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
2901
2902	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
2903		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
2904
2905	case strings.EqualFold("WAFNonexistentItemException", errorCode):
2906		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
2907
2908	case strings.EqualFold("WAFReferencedItemException", errorCode):
2909		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
2910
2911	case strings.EqualFold("WAFStaleDataException", errorCode):
2912		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
2913
2914	case strings.EqualFold("WAFTagOperationException", errorCode):
2915		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
2916
2917	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
2918		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
2919
2920	default:
2921		genericError := &smithy.GenericAPIError{
2922			Code:    errorCode,
2923			Message: errorMessage,
2924		}
2925		return genericError
2926
2927	}
2928}
2929
2930type awsAwsjson11_deserializeOpDeleteSizeConstraintSet struct {
2931}
2932
2933func (*awsAwsjson11_deserializeOpDeleteSizeConstraintSet) ID() string {
2934	return "OperationDeserializer"
2935}
2936
2937func (m *awsAwsjson11_deserializeOpDeleteSizeConstraintSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2938	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2939) {
2940	out, metadata, err = next.HandleDeserialize(ctx, in)
2941	if err != nil {
2942		return out, metadata, err
2943	}
2944
2945	response, ok := out.RawResponse.(*smithyhttp.Response)
2946	if !ok {
2947		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2948	}
2949
2950	if response.StatusCode < 200 || response.StatusCode >= 300 {
2951		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSizeConstraintSet(response, &metadata)
2952	}
2953	output := &DeleteSizeConstraintSetOutput{}
2954	out.Result = output
2955
2956	var buff [1024]byte
2957	ringBuffer := smithyio.NewRingBuffer(buff[:])
2958
2959	body := io.TeeReader(response.Body, ringBuffer)
2960	decoder := json.NewDecoder(body)
2961	decoder.UseNumber()
2962	var shape interface{}
2963	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2964		var snapshot bytes.Buffer
2965		io.Copy(&snapshot, ringBuffer)
2966		err = &smithy.DeserializationError{
2967			Err:      fmt.Errorf("failed to decode response body, %w", err),
2968			Snapshot: snapshot.Bytes(),
2969		}
2970		return out, metadata, err
2971	}
2972
2973	err = awsAwsjson11_deserializeOpDocumentDeleteSizeConstraintSetOutput(&output, shape)
2974	if err != nil {
2975		var snapshot bytes.Buffer
2976		io.Copy(&snapshot, ringBuffer)
2977		err = &smithy.DeserializationError{
2978			Err:      fmt.Errorf("failed to decode response body, %w", err),
2979			Snapshot: snapshot.Bytes(),
2980		}
2981		return out, metadata, err
2982	}
2983
2984	return out, metadata, err
2985}
2986
2987func awsAwsjson11_deserializeOpErrorDeleteSizeConstraintSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2988	var errorBuffer bytes.Buffer
2989	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2990		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2991	}
2992	errorBody := bytes.NewReader(errorBuffer.Bytes())
2993
2994	errorCode := "UnknownError"
2995	errorMessage := errorCode
2996
2997	code := response.Header.Get("X-Amzn-ErrorType")
2998	if len(code) != 0 {
2999		errorCode = restjson.SanitizeErrorCode(code)
3000	}
3001
3002	var buff [1024]byte
3003	ringBuffer := smithyio.NewRingBuffer(buff[:])
3004
3005	body := io.TeeReader(errorBody, ringBuffer)
3006	decoder := json.NewDecoder(body)
3007	decoder.UseNumber()
3008	code, message, err := restjson.GetErrorInfo(decoder)
3009	if err != nil {
3010		var snapshot bytes.Buffer
3011		io.Copy(&snapshot, ringBuffer)
3012		err = &smithy.DeserializationError{
3013			Err:      fmt.Errorf("failed to decode response body, %w", err),
3014			Snapshot: snapshot.Bytes(),
3015		}
3016		return err
3017	}
3018
3019	errorBody.Seek(0, io.SeekStart)
3020	if len(code) != 0 {
3021		errorCode = restjson.SanitizeErrorCode(code)
3022	}
3023	if len(message) != 0 {
3024		errorMessage = message
3025	}
3026
3027	switch {
3028	case strings.EqualFold("WAFInternalErrorException", errorCode):
3029		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3030
3031	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3032		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3033
3034	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
3035		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
3036
3037	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3038		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3039
3040	case strings.EqualFold("WAFReferencedItemException", errorCode):
3041		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
3042
3043	case strings.EqualFold("WAFStaleDataException", errorCode):
3044		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
3045
3046	default:
3047		genericError := &smithy.GenericAPIError{
3048			Code:    errorCode,
3049			Message: errorMessage,
3050		}
3051		return genericError
3052
3053	}
3054}
3055
3056type awsAwsjson11_deserializeOpDeleteSqlInjectionMatchSet struct {
3057}
3058
3059func (*awsAwsjson11_deserializeOpDeleteSqlInjectionMatchSet) ID() string {
3060	return "OperationDeserializer"
3061}
3062
3063func (m *awsAwsjson11_deserializeOpDeleteSqlInjectionMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3064	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3065) {
3066	out, metadata, err = next.HandleDeserialize(ctx, in)
3067	if err != nil {
3068		return out, metadata, err
3069	}
3070
3071	response, ok := out.RawResponse.(*smithyhttp.Response)
3072	if !ok {
3073		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3074	}
3075
3076	if response.StatusCode < 200 || response.StatusCode >= 300 {
3077		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSqlInjectionMatchSet(response, &metadata)
3078	}
3079	output := &DeleteSqlInjectionMatchSetOutput{}
3080	out.Result = output
3081
3082	var buff [1024]byte
3083	ringBuffer := smithyio.NewRingBuffer(buff[:])
3084
3085	body := io.TeeReader(response.Body, ringBuffer)
3086	decoder := json.NewDecoder(body)
3087	decoder.UseNumber()
3088	var shape interface{}
3089	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3090		var snapshot bytes.Buffer
3091		io.Copy(&snapshot, ringBuffer)
3092		err = &smithy.DeserializationError{
3093			Err:      fmt.Errorf("failed to decode response body, %w", err),
3094			Snapshot: snapshot.Bytes(),
3095		}
3096		return out, metadata, err
3097	}
3098
3099	err = awsAwsjson11_deserializeOpDocumentDeleteSqlInjectionMatchSetOutput(&output, shape)
3100	if err != nil {
3101		var snapshot bytes.Buffer
3102		io.Copy(&snapshot, ringBuffer)
3103		err = &smithy.DeserializationError{
3104			Err:      fmt.Errorf("failed to decode response body, %w", err),
3105			Snapshot: snapshot.Bytes(),
3106		}
3107		return out, metadata, err
3108	}
3109
3110	return out, metadata, err
3111}
3112
3113func awsAwsjson11_deserializeOpErrorDeleteSqlInjectionMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3114	var errorBuffer bytes.Buffer
3115	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3116		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3117	}
3118	errorBody := bytes.NewReader(errorBuffer.Bytes())
3119
3120	errorCode := "UnknownError"
3121	errorMessage := errorCode
3122
3123	code := response.Header.Get("X-Amzn-ErrorType")
3124	if len(code) != 0 {
3125		errorCode = restjson.SanitizeErrorCode(code)
3126	}
3127
3128	var buff [1024]byte
3129	ringBuffer := smithyio.NewRingBuffer(buff[:])
3130
3131	body := io.TeeReader(errorBody, ringBuffer)
3132	decoder := json.NewDecoder(body)
3133	decoder.UseNumber()
3134	code, message, err := restjson.GetErrorInfo(decoder)
3135	if err != nil {
3136		var snapshot bytes.Buffer
3137		io.Copy(&snapshot, ringBuffer)
3138		err = &smithy.DeserializationError{
3139			Err:      fmt.Errorf("failed to decode response body, %w", err),
3140			Snapshot: snapshot.Bytes(),
3141		}
3142		return err
3143	}
3144
3145	errorBody.Seek(0, io.SeekStart)
3146	if len(code) != 0 {
3147		errorCode = restjson.SanitizeErrorCode(code)
3148	}
3149	if len(message) != 0 {
3150		errorMessage = message
3151	}
3152
3153	switch {
3154	case strings.EqualFold("WAFInternalErrorException", errorCode):
3155		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3156
3157	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3158		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3159
3160	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
3161		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
3162
3163	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3164		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3165
3166	case strings.EqualFold("WAFReferencedItemException", errorCode):
3167		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
3168
3169	case strings.EqualFold("WAFStaleDataException", errorCode):
3170		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
3171
3172	default:
3173		genericError := &smithy.GenericAPIError{
3174			Code:    errorCode,
3175			Message: errorMessage,
3176		}
3177		return genericError
3178
3179	}
3180}
3181
3182type awsAwsjson11_deserializeOpDeleteWebACL struct {
3183}
3184
3185func (*awsAwsjson11_deserializeOpDeleteWebACL) ID() string {
3186	return "OperationDeserializer"
3187}
3188
3189func (m *awsAwsjson11_deserializeOpDeleteWebACL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3190	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3191) {
3192	out, metadata, err = next.HandleDeserialize(ctx, in)
3193	if err != nil {
3194		return out, metadata, err
3195	}
3196
3197	response, ok := out.RawResponse.(*smithyhttp.Response)
3198	if !ok {
3199		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3200	}
3201
3202	if response.StatusCode < 200 || response.StatusCode >= 300 {
3203		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWebACL(response, &metadata)
3204	}
3205	output := &DeleteWebACLOutput{}
3206	out.Result = output
3207
3208	var buff [1024]byte
3209	ringBuffer := smithyio.NewRingBuffer(buff[:])
3210
3211	body := io.TeeReader(response.Body, ringBuffer)
3212	decoder := json.NewDecoder(body)
3213	decoder.UseNumber()
3214	var shape interface{}
3215	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3216		var snapshot bytes.Buffer
3217		io.Copy(&snapshot, ringBuffer)
3218		err = &smithy.DeserializationError{
3219			Err:      fmt.Errorf("failed to decode response body, %w", err),
3220			Snapshot: snapshot.Bytes(),
3221		}
3222		return out, metadata, err
3223	}
3224
3225	err = awsAwsjson11_deserializeOpDocumentDeleteWebACLOutput(&output, shape)
3226	if err != nil {
3227		var snapshot bytes.Buffer
3228		io.Copy(&snapshot, ringBuffer)
3229		err = &smithy.DeserializationError{
3230			Err:      fmt.Errorf("failed to decode response body, %w", err),
3231			Snapshot: snapshot.Bytes(),
3232		}
3233		return out, metadata, err
3234	}
3235
3236	return out, metadata, err
3237}
3238
3239func awsAwsjson11_deserializeOpErrorDeleteWebACL(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3240	var errorBuffer bytes.Buffer
3241	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3242		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3243	}
3244	errorBody := bytes.NewReader(errorBuffer.Bytes())
3245
3246	errorCode := "UnknownError"
3247	errorMessage := errorCode
3248
3249	code := response.Header.Get("X-Amzn-ErrorType")
3250	if len(code) != 0 {
3251		errorCode = restjson.SanitizeErrorCode(code)
3252	}
3253
3254	var buff [1024]byte
3255	ringBuffer := smithyio.NewRingBuffer(buff[:])
3256
3257	body := io.TeeReader(errorBody, ringBuffer)
3258	decoder := json.NewDecoder(body)
3259	decoder.UseNumber()
3260	code, message, err := restjson.GetErrorInfo(decoder)
3261	if err != nil {
3262		var snapshot bytes.Buffer
3263		io.Copy(&snapshot, ringBuffer)
3264		err = &smithy.DeserializationError{
3265			Err:      fmt.Errorf("failed to decode response body, %w", err),
3266			Snapshot: snapshot.Bytes(),
3267		}
3268		return err
3269	}
3270
3271	errorBody.Seek(0, io.SeekStart)
3272	if len(code) != 0 {
3273		errorCode = restjson.SanitizeErrorCode(code)
3274	}
3275	if len(message) != 0 {
3276		errorMessage = message
3277	}
3278
3279	switch {
3280	case strings.EqualFold("WAFInternalErrorException", errorCode):
3281		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3282
3283	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3284		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3285
3286	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
3287		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
3288
3289	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3290		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3291
3292	case strings.EqualFold("WAFReferencedItemException", errorCode):
3293		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
3294
3295	case strings.EqualFold("WAFStaleDataException", errorCode):
3296		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
3297
3298	case strings.EqualFold("WAFTagOperationException", errorCode):
3299		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
3300
3301	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
3302		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
3303
3304	default:
3305		genericError := &smithy.GenericAPIError{
3306			Code:    errorCode,
3307			Message: errorMessage,
3308		}
3309		return genericError
3310
3311	}
3312}
3313
3314type awsAwsjson11_deserializeOpDeleteXssMatchSet struct {
3315}
3316
3317func (*awsAwsjson11_deserializeOpDeleteXssMatchSet) ID() string {
3318	return "OperationDeserializer"
3319}
3320
3321func (m *awsAwsjson11_deserializeOpDeleteXssMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3322	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3323) {
3324	out, metadata, err = next.HandleDeserialize(ctx, in)
3325	if err != nil {
3326		return out, metadata, err
3327	}
3328
3329	response, ok := out.RawResponse.(*smithyhttp.Response)
3330	if !ok {
3331		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3332	}
3333
3334	if response.StatusCode < 200 || response.StatusCode >= 300 {
3335		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteXssMatchSet(response, &metadata)
3336	}
3337	output := &DeleteXssMatchSetOutput{}
3338	out.Result = output
3339
3340	var buff [1024]byte
3341	ringBuffer := smithyio.NewRingBuffer(buff[:])
3342
3343	body := io.TeeReader(response.Body, ringBuffer)
3344	decoder := json.NewDecoder(body)
3345	decoder.UseNumber()
3346	var shape interface{}
3347	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3348		var snapshot bytes.Buffer
3349		io.Copy(&snapshot, ringBuffer)
3350		err = &smithy.DeserializationError{
3351			Err:      fmt.Errorf("failed to decode response body, %w", err),
3352			Snapshot: snapshot.Bytes(),
3353		}
3354		return out, metadata, err
3355	}
3356
3357	err = awsAwsjson11_deserializeOpDocumentDeleteXssMatchSetOutput(&output, shape)
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 out, metadata, err
3366	}
3367
3368	return out, metadata, err
3369}
3370
3371func awsAwsjson11_deserializeOpErrorDeleteXssMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3372	var errorBuffer bytes.Buffer
3373	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3374		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3375	}
3376	errorBody := bytes.NewReader(errorBuffer.Bytes())
3377
3378	errorCode := "UnknownError"
3379	errorMessage := errorCode
3380
3381	code := response.Header.Get("X-Amzn-ErrorType")
3382	if len(code) != 0 {
3383		errorCode = restjson.SanitizeErrorCode(code)
3384	}
3385
3386	var buff [1024]byte
3387	ringBuffer := smithyio.NewRingBuffer(buff[:])
3388
3389	body := io.TeeReader(errorBody, ringBuffer)
3390	decoder := json.NewDecoder(body)
3391	decoder.UseNumber()
3392	code, message, err := restjson.GetErrorInfo(decoder)
3393	if err != nil {
3394		var snapshot bytes.Buffer
3395		io.Copy(&snapshot, ringBuffer)
3396		err = &smithy.DeserializationError{
3397			Err:      fmt.Errorf("failed to decode response body, %w", err),
3398			Snapshot: snapshot.Bytes(),
3399		}
3400		return err
3401	}
3402
3403	errorBody.Seek(0, io.SeekStart)
3404	if len(code) != 0 {
3405		errorCode = restjson.SanitizeErrorCode(code)
3406	}
3407	if len(message) != 0 {
3408		errorMessage = message
3409	}
3410
3411	switch {
3412	case strings.EqualFold("WAFInternalErrorException", errorCode):
3413		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3414
3415	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3416		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3417
3418	case strings.EqualFold("WAFNonEmptyEntityException", errorCode):
3419		return awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response, errorBody)
3420
3421	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3422		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3423
3424	case strings.EqualFold("WAFReferencedItemException", errorCode):
3425		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
3426
3427	case strings.EqualFold("WAFStaleDataException", errorCode):
3428		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
3429
3430	default:
3431		genericError := &smithy.GenericAPIError{
3432			Code:    errorCode,
3433			Message: errorMessage,
3434		}
3435		return genericError
3436
3437	}
3438}
3439
3440type awsAwsjson11_deserializeOpGetByteMatchSet struct {
3441}
3442
3443func (*awsAwsjson11_deserializeOpGetByteMatchSet) ID() string {
3444	return "OperationDeserializer"
3445}
3446
3447func (m *awsAwsjson11_deserializeOpGetByteMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3448	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3449) {
3450	out, metadata, err = next.HandleDeserialize(ctx, in)
3451	if err != nil {
3452		return out, metadata, err
3453	}
3454
3455	response, ok := out.RawResponse.(*smithyhttp.Response)
3456	if !ok {
3457		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3458	}
3459
3460	if response.StatusCode < 200 || response.StatusCode >= 300 {
3461		return out, metadata, awsAwsjson11_deserializeOpErrorGetByteMatchSet(response, &metadata)
3462	}
3463	output := &GetByteMatchSetOutput{}
3464	out.Result = output
3465
3466	var buff [1024]byte
3467	ringBuffer := smithyio.NewRingBuffer(buff[:])
3468
3469	body := io.TeeReader(response.Body, ringBuffer)
3470	decoder := json.NewDecoder(body)
3471	decoder.UseNumber()
3472	var shape interface{}
3473	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3474		var snapshot bytes.Buffer
3475		io.Copy(&snapshot, ringBuffer)
3476		err = &smithy.DeserializationError{
3477			Err:      fmt.Errorf("failed to decode response body, %w", err),
3478			Snapshot: snapshot.Bytes(),
3479		}
3480		return out, metadata, err
3481	}
3482
3483	err = awsAwsjson11_deserializeOpDocumentGetByteMatchSetOutput(&output, shape)
3484	if err != nil {
3485		var snapshot bytes.Buffer
3486		io.Copy(&snapshot, ringBuffer)
3487		err = &smithy.DeserializationError{
3488			Err:      fmt.Errorf("failed to decode response body, %w", err),
3489			Snapshot: snapshot.Bytes(),
3490		}
3491		return out, metadata, err
3492	}
3493
3494	return out, metadata, err
3495}
3496
3497func awsAwsjson11_deserializeOpErrorGetByteMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3498	var errorBuffer bytes.Buffer
3499	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3500		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3501	}
3502	errorBody := bytes.NewReader(errorBuffer.Bytes())
3503
3504	errorCode := "UnknownError"
3505	errorMessage := errorCode
3506
3507	code := response.Header.Get("X-Amzn-ErrorType")
3508	if len(code) != 0 {
3509		errorCode = restjson.SanitizeErrorCode(code)
3510	}
3511
3512	var buff [1024]byte
3513	ringBuffer := smithyio.NewRingBuffer(buff[:])
3514
3515	body := io.TeeReader(errorBody, ringBuffer)
3516	decoder := json.NewDecoder(body)
3517	decoder.UseNumber()
3518	code, message, err := restjson.GetErrorInfo(decoder)
3519	if err != nil {
3520		var snapshot bytes.Buffer
3521		io.Copy(&snapshot, ringBuffer)
3522		err = &smithy.DeserializationError{
3523			Err:      fmt.Errorf("failed to decode response body, %w", err),
3524			Snapshot: snapshot.Bytes(),
3525		}
3526		return err
3527	}
3528
3529	errorBody.Seek(0, io.SeekStart)
3530	if len(code) != 0 {
3531		errorCode = restjson.SanitizeErrorCode(code)
3532	}
3533	if len(message) != 0 {
3534		errorMessage = message
3535	}
3536
3537	switch {
3538	case strings.EqualFold("WAFInternalErrorException", errorCode):
3539		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3540
3541	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3542		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3543
3544	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3545		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3546
3547	default:
3548		genericError := &smithy.GenericAPIError{
3549			Code:    errorCode,
3550			Message: errorMessage,
3551		}
3552		return genericError
3553
3554	}
3555}
3556
3557type awsAwsjson11_deserializeOpGetChangeToken struct {
3558}
3559
3560func (*awsAwsjson11_deserializeOpGetChangeToken) ID() string {
3561	return "OperationDeserializer"
3562}
3563
3564func (m *awsAwsjson11_deserializeOpGetChangeToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3565	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3566) {
3567	out, metadata, err = next.HandleDeserialize(ctx, in)
3568	if err != nil {
3569		return out, metadata, err
3570	}
3571
3572	response, ok := out.RawResponse.(*smithyhttp.Response)
3573	if !ok {
3574		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3575	}
3576
3577	if response.StatusCode < 200 || response.StatusCode >= 300 {
3578		return out, metadata, awsAwsjson11_deserializeOpErrorGetChangeToken(response, &metadata)
3579	}
3580	output := &GetChangeTokenOutput{}
3581	out.Result = output
3582
3583	var buff [1024]byte
3584	ringBuffer := smithyio.NewRingBuffer(buff[:])
3585
3586	body := io.TeeReader(response.Body, ringBuffer)
3587	decoder := json.NewDecoder(body)
3588	decoder.UseNumber()
3589	var shape interface{}
3590	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3591		var snapshot bytes.Buffer
3592		io.Copy(&snapshot, ringBuffer)
3593		err = &smithy.DeserializationError{
3594			Err:      fmt.Errorf("failed to decode response body, %w", err),
3595			Snapshot: snapshot.Bytes(),
3596		}
3597		return out, metadata, err
3598	}
3599
3600	err = awsAwsjson11_deserializeOpDocumentGetChangeTokenOutput(&output, shape)
3601	if err != nil {
3602		var snapshot bytes.Buffer
3603		io.Copy(&snapshot, ringBuffer)
3604		err = &smithy.DeserializationError{
3605			Err:      fmt.Errorf("failed to decode response body, %w", err),
3606			Snapshot: snapshot.Bytes(),
3607		}
3608		return out, metadata, err
3609	}
3610
3611	return out, metadata, err
3612}
3613
3614func awsAwsjson11_deserializeOpErrorGetChangeToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3615	var errorBuffer bytes.Buffer
3616	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3617		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3618	}
3619	errorBody := bytes.NewReader(errorBuffer.Bytes())
3620
3621	errorCode := "UnknownError"
3622	errorMessage := errorCode
3623
3624	code := response.Header.Get("X-Amzn-ErrorType")
3625	if len(code) != 0 {
3626		errorCode = restjson.SanitizeErrorCode(code)
3627	}
3628
3629	var buff [1024]byte
3630	ringBuffer := smithyio.NewRingBuffer(buff[:])
3631
3632	body := io.TeeReader(errorBody, ringBuffer)
3633	decoder := json.NewDecoder(body)
3634	decoder.UseNumber()
3635	code, message, err := restjson.GetErrorInfo(decoder)
3636	if err != nil {
3637		var snapshot bytes.Buffer
3638		io.Copy(&snapshot, ringBuffer)
3639		err = &smithy.DeserializationError{
3640			Err:      fmt.Errorf("failed to decode response body, %w", err),
3641			Snapshot: snapshot.Bytes(),
3642		}
3643		return err
3644	}
3645
3646	errorBody.Seek(0, io.SeekStart)
3647	if len(code) != 0 {
3648		errorCode = restjson.SanitizeErrorCode(code)
3649	}
3650	if len(message) != 0 {
3651		errorMessage = message
3652	}
3653
3654	switch {
3655	case strings.EqualFold("WAFInternalErrorException", errorCode):
3656		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3657
3658	default:
3659		genericError := &smithy.GenericAPIError{
3660			Code:    errorCode,
3661			Message: errorMessage,
3662		}
3663		return genericError
3664
3665	}
3666}
3667
3668type awsAwsjson11_deserializeOpGetChangeTokenStatus struct {
3669}
3670
3671func (*awsAwsjson11_deserializeOpGetChangeTokenStatus) ID() string {
3672	return "OperationDeserializer"
3673}
3674
3675func (m *awsAwsjson11_deserializeOpGetChangeTokenStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3676	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3677) {
3678	out, metadata, err = next.HandleDeserialize(ctx, in)
3679	if err != nil {
3680		return out, metadata, err
3681	}
3682
3683	response, ok := out.RawResponse.(*smithyhttp.Response)
3684	if !ok {
3685		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3686	}
3687
3688	if response.StatusCode < 200 || response.StatusCode >= 300 {
3689		return out, metadata, awsAwsjson11_deserializeOpErrorGetChangeTokenStatus(response, &metadata)
3690	}
3691	output := &GetChangeTokenStatusOutput{}
3692	out.Result = output
3693
3694	var buff [1024]byte
3695	ringBuffer := smithyio.NewRingBuffer(buff[:])
3696
3697	body := io.TeeReader(response.Body, ringBuffer)
3698	decoder := json.NewDecoder(body)
3699	decoder.UseNumber()
3700	var shape interface{}
3701	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3702		var snapshot bytes.Buffer
3703		io.Copy(&snapshot, ringBuffer)
3704		err = &smithy.DeserializationError{
3705			Err:      fmt.Errorf("failed to decode response body, %w", err),
3706			Snapshot: snapshot.Bytes(),
3707		}
3708		return out, metadata, err
3709	}
3710
3711	err = awsAwsjson11_deserializeOpDocumentGetChangeTokenStatusOutput(&output, shape)
3712	if err != nil {
3713		var snapshot bytes.Buffer
3714		io.Copy(&snapshot, ringBuffer)
3715		err = &smithy.DeserializationError{
3716			Err:      fmt.Errorf("failed to decode response body, %w", err),
3717			Snapshot: snapshot.Bytes(),
3718		}
3719		return out, metadata, err
3720	}
3721
3722	return out, metadata, err
3723}
3724
3725func awsAwsjson11_deserializeOpErrorGetChangeTokenStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3726	var errorBuffer bytes.Buffer
3727	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3728		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3729	}
3730	errorBody := bytes.NewReader(errorBuffer.Bytes())
3731
3732	errorCode := "UnknownError"
3733	errorMessage := errorCode
3734
3735	code := response.Header.Get("X-Amzn-ErrorType")
3736	if len(code) != 0 {
3737		errorCode = restjson.SanitizeErrorCode(code)
3738	}
3739
3740	var buff [1024]byte
3741	ringBuffer := smithyio.NewRingBuffer(buff[:])
3742
3743	body := io.TeeReader(errorBody, ringBuffer)
3744	decoder := json.NewDecoder(body)
3745	decoder.UseNumber()
3746	code, message, err := restjson.GetErrorInfo(decoder)
3747	if err != nil {
3748		var snapshot bytes.Buffer
3749		io.Copy(&snapshot, ringBuffer)
3750		err = &smithy.DeserializationError{
3751			Err:      fmt.Errorf("failed to decode response body, %w", err),
3752			Snapshot: snapshot.Bytes(),
3753		}
3754		return err
3755	}
3756
3757	errorBody.Seek(0, io.SeekStart)
3758	if len(code) != 0 {
3759		errorCode = restjson.SanitizeErrorCode(code)
3760	}
3761	if len(message) != 0 {
3762		errorMessage = message
3763	}
3764
3765	switch {
3766	case strings.EqualFold("WAFInternalErrorException", errorCode):
3767		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3768
3769	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3770		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3771
3772	default:
3773		genericError := &smithy.GenericAPIError{
3774			Code:    errorCode,
3775			Message: errorMessage,
3776		}
3777		return genericError
3778
3779	}
3780}
3781
3782type awsAwsjson11_deserializeOpGetGeoMatchSet struct {
3783}
3784
3785func (*awsAwsjson11_deserializeOpGetGeoMatchSet) ID() string {
3786	return "OperationDeserializer"
3787}
3788
3789func (m *awsAwsjson11_deserializeOpGetGeoMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3790	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3791) {
3792	out, metadata, err = next.HandleDeserialize(ctx, in)
3793	if err != nil {
3794		return out, metadata, err
3795	}
3796
3797	response, ok := out.RawResponse.(*smithyhttp.Response)
3798	if !ok {
3799		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3800	}
3801
3802	if response.StatusCode < 200 || response.StatusCode >= 300 {
3803		return out, metadata, awsAwsjson11_deserializeOpErrorGetGeoMatchSet(response, &metadata)
3804	}
3805	output := &GetGeoMatchSetOutput{}
3806	out.Result = output
3807
3808	var buff [1024]byte
3809	ringBuffer := smithyio.NewRingBuffer(buff[:])
3810
3811	body := io.TeeReader(response.Body, ringBuffer)
3812	decoder := json.NewDecoder(body)
3813	decoder.UseNumber()
3814	var shape interface{}
3815	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3816		var snapshot bytes.Buffer
3817		io.Copy(&snapshot, ringBuffer)
3818		err = &smithy.DeserializationError{
3819			Err:      fmt.Errorf("failed to decode response body, %w", err),
3820			Snapshot: snapshot.Bytes(),
3821		}
3822		return out, metadata, err
3823	}
3824
3825	err = awsAwsjson11_deserializeOpDocumentGetGeoMatchSetOutput(&output, shape)
3826	if err != nil {
3827		var snapshot bytes.Buffer
3828		io.Copy(&snapshot, ringBuffer)
3829		err = &smithy.DeserializationError{
3830			Err:      fmt.Errorf("failed to decode response body, %w", err),
3831			Snapshot: snapshot.Bytes(),
3832		}
3833		return out, metadata, err
3834	}
3835
3836	return out, metadata, err
3837}
3838
3839func awsAwsjson11_deserializeOpErrorGetGeoMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3840	var errorBuffer bytes.Buffer
3841	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3842		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3843	}
3844	errorBody := bytes.NewReader(errorBuffer.Bytes())
3845
3846	errorCode := "UnknownError"
3847	errorMessage := errorCode
3848
3849	code := response.Header.Get("X-Amzn-ErrorType")
3850	if len(code) != 0 {
3851		errorCode = restjson.SanitizeErrorCode(code)
3852	}
3853
3854	var buff [1024]byte
3855	ringBuffer := smithyio.NewRingBuffer(buff[:])
3856
3857	body := io.TeeReader(errorBody, ringBuffer)
3858	decoder := json.NewDecoder(body)
3859	decoder.UseNumber()
3860	code, message, err := restjson.GetErrorInfo(decoder)
3861	if err != nil {
3862		var snapshot bytes.Buffer
3863		io.Copy(&snapshot, ringBuffer)
3864		err = &smithy.DeserializationError{
3865			Err:      fmt.Errorf("failed to decode response body, %w", err),
3866			Snapshot: snapshot.Bytes(),
3867		}
3868		return err
3869	}
3870
3871	errorBody.Seek(0, io.SeekStart)
3872	if len(code) != 0 {
3873		errorCode = restjson.SanitizeErrorCode(code)
3874	}
3875	if len(message) != 0 {
3876		errorMessage = message
3877	}
3878
3879	switch {
3880	case strings.EqualFold("WAFInternalErrorException", errorCode):
3881		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3882
3883	case strings.EqualFold("WAFInvalidAccountException", errorCode):
3884		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
3885
3886	case strings.EqualFold("WAFNonexistentItemException", errorCode):
3887		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
3888
3889	default:
3890		genericError := &smithy.GenericAPIError{
3891			Code:    errorCode,
3892			Message: errorMessage,
3893		}
3894		return genericError
3895
3896	}
3897}
3898
3899type awsAwsjson11_deserializeOpGetIPSet struct {
3900}
3901
3902func (*awsAwsjson11_deserializeOpGetIPSet) ID() string {
3903	return "OperationDeserializer"
3904}
3905
3906func (m *awsAwsjson11_deserializeOpGetIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3907	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3908) {
3909	out, metadata, err = next.HandleDeserialize(ctx, in)
3910	if err != nil {
3911		return out, metadata, err
3912	}
3913
3914	response, ok := out.RawResponse.(*smithyhttp.Response)
3915	if !ok {
3916		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3917	}
3918
3919	if response.StatusCode < 200 || response.StatusCode >= 300 {
3920		return out, metadata, awsAwsjson11_deserializeOpErrorGetIPSet(response, &metadata)
3921	}
3922	output := &GetIPSetOutput{}
3923	out.Result = output
3924
3925	var buff [1024]byte
3926	ringBuffer := smithyio.NewRingBuffer(buff[:])
3927
3928	body := io.TeeReader(response.Body, ringBuffer)
3929	decoder := json.NewDecoder(body)
3930	decoder.UseNumber()
3931	var shape interface{}
3932	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3933		var snapshot bytes.Buffer
3934		io.Copy(&snapshot, ringBuffer)
3935		err = &smithy.DeserializationError{
3936			Err:      fmt.Errorf("failed to decode response body, %w", err),
3937			Snapshot: snapshot.Bytes(),
3938		}
3939		return out, metadata, err
3940	}
3941
3942	err = awsAwsjson11_deserializeOpDocumentGetIPSetOutput(&output, shape)
3943	if err != nil {
3944		var snapshot bytes.Buffer
3945		io.Copy(&snapshot, ringBuffer)
3946		err = &smithy.DeserializationError{
3947			Err:      fmt.Errorf("failed to decode response body, %w", err),
3948			Snapshot: snapshot.Bytes(),
3949		}
3950		return out, metadata, err
3951	}
3952
3953	return out, metadata, err
3954}
3955
3956func awsAwsjson11_deserializeOpErrorGetIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3957	var errorBuffer bytes.Buffer
3958	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3959		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3960	}
3961	errorBody := bytes.NewReader(errorBuffer.Bytes())
3962
3963	errorCode := "UnknownError"
3964	errorMessage := errorCode
3965
3966	code := response.Header.Get("X-Amzn-ErrorType")
3967	if len(code) != 0 {
3968		errorCode = restjson.SanitizeErrorCode(code)
3969	}
3970
3971	var buff [1024]byte
3972	ringBuffer := smithyio.NewRingBuffer(buff[:])
3973
3974	body := io.TeeReader(errorBody, ringBuffer)
3975	decoder := json.NewDecoder(body)
3976	decoder.UseNumber()
3977	code, message, err := restjson.GetErrorInfo(decoder)
3978	if err != nil {
3979		var snapshot bytes.Buffer
3980		io.Copy(&snapshot, ringBuffer)
3981		err = &smithy.DeserializationError{
3982			Err:      fmt.Errorf("failed to decode response body, %w", err),
3983			Snapshot: snapshot.Bytes(),
3984		}
3985		return err
3986	}
3987
3988	errorBody.Seek(0, io.SeekStart)
3989	if len(code) != 0 {
3990		errorCode = restjson.SanitizeErrorCode(code)
3991	}
3992	if len(message) != 0 {
3993		errorMessage = message
3994	}
3995
3996	switch {
3997	case strings.EqualFold("WAFInternalErrorException", errorCode):
3998		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
3999
4000	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4001		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4002
4003	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4004		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4005
4006	default:
4007		genericError := &smithy.GenericAPIError{
4008			Code:    errorCode,
4009			Message: errorMessage,
4010		}
4011		return genericError
4012
4013	}
4014}
4015
4016type awsAwsjson11_deserializeOpGetLoggingConfiguration struct {
4017}
4018
4019func (*awsAwsjson11_deserializeOpGetLoggingConfiguration) ID() string {
4020	return "OperationDeserializer"
4021}
4022
4023func (m *awsAwsjson11_deserializeOpGetLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4024	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4025) {
4026	out, metadata, err = next.HandleDeserialize(ctx, in)
4027	if err != nil {
4028		return out, metadata, err
4029	}
4030
4031	response, ok := out.RawResponse.(*smithyhttp.Response)
4032	if !ok {
4033		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4034	}
4035
4036	if response.StatusCode < 200 || response.StatusCode >= 300 {
4037		return out, metadata, awsAwsjson11_deserializeOpErrorGetLoggingConfiguration(response, &metadata)
4038	}
4039	output := &GetLoggingConfigurationOutput{}
4040	out.Result = output
4041
4042	var buff [1024]byte
4043	ringBuffer := smithyio.NewRingBuffer(buff[:])
4044
4045	body := io.TeeReader(response.Body, ringBuffer)
4046	decoder := json.NewDecoder(body)
4047	decoder.UseNumber()
4048	var shape interface{}
4049	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4050		var snapshot bytes.Buffer
4051		io.Copy(&snapshot, ringBuffer)
4052		err = &smithy.DeserializationError{
4053			Err:      fmt.Errorf("failed to decode response body, %w", err),
4054			Snapshot: snapshot.Bytes(),
4055		}
4056		return out, metadata, err
4057	}
4058
4059	err = awsAwsjson11_deserializeOpDocumentGetLoggingConfigurationOutput(&output, shape)
4060	if err != nil {
4061		var snapshot bytes.Buffer
4062		io.Copy(&snapshot, ringBuffer)
4063		err = &smithy.DeserializationError{
4064			Err:      fmt.Errorf("failed to decode response body, %w", err),
4065			Snapshot: snapshot.Bytes(),
4066		}
4067		return out, metadata, err
4068	}
4069
4070	return out, metadata, err
4071}
4072
4073func awsAwsjson11_deserializeOpErrorGetLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4074	var errorBuffer bytes.Buffer
4075	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4076		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4077	}
4078	errorBody := bytes.NewReader(errorBuffer.Bytes())
4079
4080	errorCode := "UnknownError"
4081	errorMessage := errorCode
4082
4083	code := response.Header.Get("X-Amzn-ErrorType")
4084	if len(code) != 0 {
4085		errorCode = restjson.SanitizeErrorCode(code)
4086	}
4087
4088	var buff [1024]byte
4089	ringBuffer := smithyio.NewRingBuffer(buff[:])
4090
4091	body := io.TeeReader(errorBody, ringBuffer)
4092	decoder := json.NewDecoder(body)
4093	decoder.UseNumber()
4094	code, message, err := restjson.GetErrorInfo(decoder)
4095	if err != nil {
4096		var snapshot bytes.Buffer
4097		io.Copy(&snapshot, ringBuffer)
4098		err = &smithy.DeserializationError{
4099			Err:      fmt.Errorf("failed to decode response body, %w", err),
4100			Snapshot: snapshot.Bytes(),
4101		}
4102		return err
4103	}
4104
4105	errorBody.Seek(0, io.SeekStart)
4106	if len(code) != 0 {
4107		errorCode = restjson.SanitizeErrorCode(code)
4108	}
4109	if len(message) != 0 {
4110		errorMessage = message
4111	}
4112
4113	switch {
4114	case strings.EqualFold("WAFInternalErrorException", errorCode):
4115		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4116
4117	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4118		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4119
4120	default:
4121		genericError := &smithy.GenericAPIError{
4122			Code:    errorCode,
4123			Message: errorMessage,
4124		}
4125		return genericError
4126
4127	}
4128}
4129
4130type awsAwsjson11_deserializeOpGetPermissionPolicy struct {
4131}
4132
4133func (*awsAwsjson11_deserializeOpGetPermissionPolicy) ID() string {
4134	return "OperationDeserializer"
4135}
4136
4137func (m *awsAwsjson11_deserializeOpGetPermissionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4138	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4139) {
4140	out, metadata, err = next.HandleDeserialize(ctx, in)
4141	if err != nil {
4142		return out, metadata, err
4143	}
4144
4145	response, ok := out.RawResponse.(*smithyhttp.Response)
4146	if !ok {
4147		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4148	}
4149
4150	if response.StatusCode < 200 || response.StatusCode >= 300 {
4151		return out, metadata, awsAwsjson11_deserializeOpErrorGetPermissionPolicy(response, &metadata)
4152	}
4153	output := &GetPermissionPolicyOutput{}
4154	out.Result = output
4155
4156	var buff [1024]byte
4157	ringBuffer := smithyio.NewRingBuffer(buff[:])
4158
4159	body := io.TeeReader(response.Body, ringBuffer)
4160	decoder := json.NewDecoder(body)
4161	decoder.UseNumber()
4162	var shape interface{}
4163	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4164		var snapshot bytes.Buffer
4165		io.Copy(&snapshot, ringBuffer)
4166		err = &smithy.DeserializationError{
4167			Err:      fmt.Errorf("failed to decode response body, %w", err),
4168			Snapshot: snapshot.Bytes(),
4169		}
4170		return out, metadata, err
4171	}
4172
4173	err = awsAwsjson11_deserializeOpDocumentGetPermissionPolicyOutput(&output, shape)
4174	if err != nil {
4175		var snapshot bytes.Buffer
4176		io.Copy(&snapshot, ringBuffer)
4177		err = &smithy.DeserializationError{
4178			Err:      fmt.Errorf("failed to decode response body, %w", err),
4179			Snapshot: snapshot.Bytes(),
4180		}
4181		return out, metadata, err
4182	}
4183
4184	return out, metadata, err
4185}
4186
4187func awsAwsjson11_deserializeOpErrorGetPermissionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4188	var errorBuffer bytes.Buffer
4189	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4190		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4191	}
4192	errorBody := bytes.NewReader(errorBuffer.Bytes())
4193
4194	errorCode := "UnknownError"
4195	errorMessage := errorCode
4196
4197	code := response.Header.Get("X-Amzn-ErrorType")
4198	if len(code) != 0 {
4199		errorCode = restjson.SanitizeErrorCode(code)
4200	}
4201
4202	var buff [1024]byte
4203	ringBuffer := smithyio.NewRingBuffer(buff[:])
4204
4205	body := io.TeeReader(errorBody, ringBuffer)
4206	decoder := json.NewDecoder(body)
4207	decoder.UseNumber()
4208	code, message, err := restjson.GetErrorInfo(decoder)
4209	if err != nil {
4210		var snapshot bytes.Buffer
4211		io.Copy(&snapshot, ringBuffer)
4212		err = &smithy.DeserializationError{
4213			Err:      fmt.Errorf("failed to decode response body, %w", err),
4214			Snapshot: snapshot.Bytes(),
4215		}
4216		return err
4217	}
4218
4219	errorBody.Seek(0, io.SeekStart)
4220	if len(code) != 0 {
4221		errorCode = restjson.SanitizeErrorCode(code)
4222	}
4223	if len(message) != 0 {
4224		errorMessage = message
4225	}
4226
4227	switch {
4228	case strings.EqualFold("WAFInternalErrorException", errorCode):
4229		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4230
4231	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4232		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4233
4234	default:
4235		genericError := &smithy.GenericAPIError{
4236			Code:    errorCode,
4237			Message: errorMessage,
4238		}
4239		return genericError
4240
4241	}
4242}
4243
4244type awsAwsjson11_deserializeOpGetRateBasedRule struct {
4245}
4246
4247func (*awsAwsjson11_deserializeOpGetRateBasedRule) ID() string {
4248	return "OperationDeserializer"
4249}
4250
4251func (m *awsAwsjson11_deserializeOpGetRateBasedRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4252	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4253) {
4254	out, metadata, err = next.HandleDeserialize(ctx, in)
4255	if err != nil {
4256		return out, metadata, err
4257	}
4258
4259	response, ok := out.RawResponse.(*smithyhttp.Response)
4260	if !ok {
4261		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4262	}
4263
4264	if response.StatusCode < 200 || response.StatusCode >= 300 {
4265		return out, metadata, awsAwsjson11_deserializeOpErrorGetRateBasedRule(response, &metadata)
4266	}
4267	output := &GetRateBasedRuleOutput{}
4268	out.Result = output
4269
4270	var buff [1024]byte
4271	ringBuffer := smithyio.NewRingBuffer(buff[:])
4272
4273	body := io.TeeReader(response.Body, ringBuffer)
4274	decoder := json.NewDecoder(body)
4275	decoder.UseNumber()
4276	var shape interface{}
4277	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4278		var snapshot bytes.Buffer
4279		io.Copy(&snapshot, ringBuffer)
4280		err = &smithy.DeserializationError{
4281			Err:      fmt.Errorf("failed to decode response body, %w", err),
4282			Snapshot: snapshot.Bytes(),
4283		}
4284		return out, metadata, err
4285	}
4286
4287	err = awsAwsjson11_deserializeOpDocumentGetRateBasedRuleOutput(&output, shape)
4288	if err != nil {
4289		var snapshot bytes.Buffer
4290		io.Copy(&snapshot, ringBuffer)
4291		err = &smithy.DeserializationError{
4292			Err:      fmt.Errorf("failed to decode response body, %w", err),
4293			Snapshot: snapshot.Bytes(),
4294		}
4295		return out, metadata, err
4296	}
4297
4298	return out, metadata, err
4299}
4300
4301func awsAwsjson11_deserializeOpErrorGetRateBasedRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4302	var errorBuffer bytes.Buffer
4303	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4304		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4305	}
4306	errorBody := bytes.NewReader(errorBuffer.Bytes())
4307
4308	errorCode := "UnknownError"
4309	errorMessage := errorCode
4310
4311	code := response.Header.Get("X-Amzn-ErrorType")
4312	if len(code) != 0 {
4313		errorCode = restjson.SanitizeErrorCode(code)
4314	}
4315
4316	var buff [1024]byte
4317	ringBuffer := smithyio.NewRingBuffer(buff[:])
4318
4319	body := io.TeeReader(errorBody, ringBuffer)
4320	decoder := json.NewDecoder(body)
4321	decoder.UseNumber()
4322	code, message, err := restjson.GetErrorInfo(decoder)
4323	if err != nil {
4324		var snapshot bytes.Buffer
4325		io.Copy(&snapshot, ringBuffer)
4326		err = &smithy.DeserializationError{
4327			Err:      fmt.Errorf("failed to decode response body, %w", err),
4328			Snapshot: snapshot.Bytes(),
4329		}
4330		return err
4331	}
4332
4333	errorBody.Seek(0, io.SeekStart)
4334	if len(code) != 0 {
4335		errorCode = restjson.SanitizeErrorCode(code)
4336	}
4337	if len(message) != 0 {
4338		errorMessage = message
4339	}
4340
4341	switch {
4342	case strings.EqualFold("WAFInternalErrorException", errorCode):
4343		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4344
4345	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4346		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4347
4348	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4349		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4350
4351	default:
4352		genericError := &smithy.GenericAPIError{
4353			Code:    errorCode,
4354			Message: errorMessage,
4355		}
4356		return genericError
4357
4358	}
4359}
4360
4361type awsAwsjson11_deserializeOpGetRateBasedRuleManagedKeys struct {
4362}
4363
4364func (*awsAwsjson11_deserializeOpGetRateBasedRuleManagedKeys) ID() string {
4365	return "OperationDeserializer"
4366}
4367
4368func (m *awsAwsjson11_deserializeOpGetRateBasedRuleManagedKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4369	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4370) {
4371	out, metadata, err = next.HandleDeserialize(ctx, in)
4372	if err != nil {
4373		return out, metadata, err
4374	}
4375
4376	response, ok := out.RawResponse.(*smithyhttp.Response)
4377	if !ok {
4378		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4379	}
4380
4381	if response.StatusCode < 200 || response.StatusCode >= 300 {
4382		return out, metadata, awsAwsjson11_deserializeOpErrorGetRateBasedRuleManagedKeys(response, &metadata)
4383	}
4384	output := &GetRateBasedRuleManagedKeysOutput{}
4385	out.Result = output
4386
4387	var buff [1024]byte
4388	ringBuffer := smithyio.NewRingBuffer(buff[:])
4389
4390	body := io.TeeReader(response.Body, ringBuffer)
4391	decoder := json.NewDecoder(body)
4392	decoder.UseNumber()
4393	var shape interface{}
4394	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4395		var snapshot bytes.Buffer
4396		io.Copy(&snapshot, ringBuffer)
4397		err = &smithy.DeserializationError{
4398			Err:      fmt.Errorf("failed to decode response body, %w", err),
4399			Snapshot: snapshot.Bytes(),
4400		}
4401		return out, metadata, err
4402	}
4403
4404	err = awsAwsjson11_deserializeOpDocumentGetRateBasedRuleManagedKeysOutput(&output, shape)
4405	if err != nil {
4406		var snapshot bytes.Buffer
4407		io.Copy(&snapshot, ringBuffer)
4408		err = &smithy.DeserializationError{
4409			Err:      fmt.Errorf("failed to decode response body, %w", err),
4410			Snapshot: snapshot.Bytes(),
4411		}
4412		return out, metadata, err
4413	}
4414
4415	return out, metadata, err
4416}
4417
4418func awsAwsjson11_deserializeOpErrorGetRateBasedRuleManagedKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4419	var errorBuffer bytes.Buffer
4420	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4421		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4422	}
4423	errorBody := bytes.NewReader(errorBuffer.Bytes())
4424
4425	errorCode := "UnknownError"
4426	errorMessage := errorCode
4427
4428	code := response.Header.Get("X-Amzn-ErrorType")
4429	if len(code) != 0 {
4430		errorCode = restjson.SanitizeErrorCode(code)
4431	}
4432
4433	var buff [1024]byte
4434	ringBuffer := smithyio.NewRingBuffer(buff[:])
4435
4436	body := io.TeeReader(errorBody, ringBuffer)
4437	decoder := json.NewDecoder(body)
4438	decoder.UseNumber()
4439	code, message, err := restjson.GetErrorInfo(decoder)
4440	if err != nil {
4441		var snapshot bytes.Buffer
4442		io.Copy(&snapshot, ringBuffer)
4443		err = &smithy.DeserializationError{
4444			Err:      fmt.Errorf("failed to decode response body, %w", err),
4445			Snapshot: snapshot.Bytes(),
4446		}
4447		return err
4448	}
4449
4450	errorBody.Seek(0, io.SeekStart)
4451	if len(code) != 0 {
4452		errorCode = restjson.SanitizeErrorCode(code)
4453	}
4454	if len(message) != 0 {
4455		errorMessage = message
4456	}
4457
4458	switch {
4459	case strings.EqualFold("WAFInternalErrorException", errorCode):
4460		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4461
4462	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4463		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4464
4465	case strings.EqualFold("WAFInvalidParameterException", errorCode):
4466		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
4467
4468	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4469		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4470
4471	default:
4472		genericError := &smithy.GenericAPIError{
4473			Code:    errorCode,
4474			Message: errorMessage,
4475		}
4476		return genericError
4477
4478	}
4479}
4480
4481type awsAwsjson11_deserializeOpGetRegexMatchSet struct {
4482}
4483
4484func (*awsAwsjson11_deserializeOpGetRegexMatchSet) ID() string {
4485	return "OperationDeserializer"
4486}
4487
4488func (m *awsAwsjson11_deserializeOpGetRegexMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4489	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4490) {
4491	out, metadata, err = next.HandleDeserialize(ctx, in)
4492	if err != nil {
4493		return out, metadata, err
4494	}
4495
4496	response, ok := out.RawResponse.(*smithyhttp.Response)
4497	if !ok {
4498		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4499	}
4500
4501	if response.StatusCode < 200 || response.StatusCode >= 300 {
4502		return out, metadata, awsAwsjson11_deserializeOpErrorGetRegexMatchSet(response, &metadata)
4503	}
4504	output := &GetRegexMatchSetOutput{}
4505	out.Result = output
4506
4507	var buff [1024]byte
4508	ringBuffer := smithyio.NewRingBuffer(buff[:])
4509
4510	body := io.TeeReader(response.Body, ringBuffer)
4511	decoder := json.NewDecoder(body)
4512	decoder.UseNumber()
4513	var shape interface{}
4514	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4515		var snapshot bytes.Buffer
4516		io.Copy(&snapshot, ringBuffer)
4517		err = &smithy.DeserializationError{
4518			Err:      fmt.Errorf("failed to decode response body, %w", err),
4519			Snapshot: snapshot.Bytes(),
4520		}
4521		return out, metadata, err
4522	}
4523
4524	err = awsAwsjson11_deserializeOpDocumentGetRegexMatchSetOutput(&output, shape)
4525	if err != nil {
4526		var snapshot bytes.Buffer
4527		io.Copy(&snapshot, ringBuffer)
4528		err = &smithy.DeserializationError{
4529			Err:      fmt.Errorf("failed to decode response body, %w", err),
4530			Snapshot: snapshot.Bytes(),
4531		}
4532		return out, metadata, err
4533	}
4534
4535	return out, metadata, err
4536}
4537
4538func awsAwsjson11_deserializeOpErrorGetRegexMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4539	var errorBuffer bytes.Buffer
4540	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4541		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4542	}
4543	errorBody := bytes.NewReader(errorBuffer.Bytes())
4544
4545	errorCode := "UnknownError"
4546	errorMessage := errorCode
4547
4548	code := response.Header.Get("X-Amzn-ErrorType")
4549	if len(code) != 0 {
4550		errorCode = restjson.SanitizeErrorCode(code)
4551	}
4552
4553	var buff [1024]byte
4554	ringBuffer := smithyio.NewRingBuffer(buff[:])
4555
4556	body := io.TeeReader(errorBody, ringBuffer)
4557	decoder := json.NewDecoder(body)
4558	decoder.UseNumber()
4559	code, message, err := restjson.GetErrorInfo(decoder)
4560	if err != nil {
4561		var snapshot bytes.Buffer
4562		io.Copy(&snapshot, ringBuffer)
4563		err = &smithy.DeserializationError{
4564			Err:      fmt.Errorf("failed to decode response body, %w", err),
4565			Snapshot: snapshot.Bytes(),
4566		}
4567		return err
4568	}
4569
4570	errorBody.Seek(0, io.SeekStart)
4571	if len(code) != 0 {
4572		errorCode = restjson.SanitizeErrorCode(code)
4573	}
4574	if len(message) != 0 {
4575		errorMessage = message
4576	}
4577
4578	switch {
4579	case strings.EqualFold("WAFInternalErrorException", errorCode):
4580		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4581
4582	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4583		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4584
4585	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4586		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4587
4588	default:
4589		genericError := &smithy.GenericAPIError{
4590			Code:    errorCode,
4591			Message: errorMessage,
4592		}
4593		return genericError
4594
4595	}
4596}
4597
4598type awsAwsjson11_deserializeOpGetRegexPatternSet struct {
4599}
4600
4601func (*awsAwsjson11_deserializeOpGetRegexPatternSet) ID() string {
4602	return "OperationDeserializer"
4603}
4604
4605func (m *awsAwsjson11_deserializeOpGetRegexPatternSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4606	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4607) {
4608	out, metadata, err = next.HandleDeserialize(ctx, in)
4609	if err != nil {
4610		return out, metadata, err
4611	}
4612
4613	response, ok := out.RawResponse.(*smithyhttp.Response)
4614	if !ok {
4615		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4616	}
4617
4618	if response.StatusCode < 200 || response.StatusCode >= 300 {
4619		return out, metadata, awsAwsjson11_deserializeOpErrorGetRegexPatternSet(response, &metadata)
4620	}
4621	output := &GetRegexPatternSetOutput{}
4622	out.Result = output
4623
4624	var buff [1024]byte
4625	ringBuffer := smithyio.NewRingBuffer(buff[:])
4626
4627	body := io.TeeReader(response.Body, ringBuffer)
4628	decoder := json.NewDecoder(body)
4629	decoder.UseNumber()
4630	var shape interface{}
4631	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4632		var snapshot bytes.Buffer
4633		io.Copy(&snapshot, ringBuffer)
4634		err = &smithy.DeserializationError{
4635			Err:      fmt.Errorf("failed to decode response body, %w", err),
4636			Snapshot: snapshot.Bytes(),
4637		}
4638		return out, metadata, err
4639	}
4640
4641	err = awsAwsjson11_deserializeOpDocumentGetRegexPatternSetOutput(&output, shape)
4642	if err != nil {
4643		var snapshot bytes.Buffer
4644		io.Copy(&snapshot, ringBuffer)
4645		err = &smithy.DeserializationError{
4646			Err:      fmt.Errorf("failed to decode response body, %w", err),
4647			Snapshot: snapshot.Bytes(),
4648		}
4649		return out, metadata, err
4650	}
4651
4652	return out, metadata, err
4653}
4654
4655func awsAwsjson11_deserializeOpErrorGetRegexPatternSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4656	var errorBuffer bytes.Buffer
4657	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4658		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4659	}
4660	errorBody := bytes.NewReader(errorBuffer.Bytes())
4661
4662	errorCode := "UnknownError"
4663	errorMessage := errorCode
4664
4665	code := response.Header.Get("X-Amzn-ErrorType")
4666	if len(code) != 0 {
4667		errorCode = restjson.SanitizeErrorCode(code)
4668	}
4669
4670	var buff [1024]byte
4671	ringBuffer := smithyio.NewRingBuffer(buff[:])
4672
4673	body := io.TeeReader(errorBody, ringBuffer)
4674	decoder := json.NewDecoder(body)
4675	decoder.UseNumber()
4676	code, message, err := restjson.GetErrorInfo(decoder)
4677	if err != nil {
4678		var snapshot bytes.Buffer
4679		io.Copy(&snapshot, ringBuffer)
4680		err = &smithy.DeserializationError{
4681			Err:      fmt.Errorf("failed to decode response body, %w", err),
4682			Snapshot: snapshot.Bytes(),
4683		}
4684		return err
4685	}
4686
4687	errorBody.Seek(0, io.SeekStart)
4688	if len(code) != 0 {
4689		errorCode = restjson.SanitizeErrorCode(code)
4690	}
4691	if len(message) != 0 {
4692		errorMessage = message
4693	}
4694
4695	switch {
4696	case strings.EqualFold("WAFInternalErrorException", errorCode):
4697		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4698
4699	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4700		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4701
4702	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4703		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4704
4705	default:
4706		genericError := &smithy.GenericAPIError{
4707			Code:    errorCode,
4708			Message: errorMessage,
4709		}
4710		return genericError
4711
4712	}
4713}
4714
4715type awsAwsjson11_deserializeOpGetRule struct {
4716}
4717
4718func (*awsAwsjson11_deserializeOpGetRule) ID() string {
4719	return "OperationDeserializer"
4720}
4721
4722func (m *awsAwsjson11_deserializeOpGetRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4723	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4724) {
4725	out, metadata, err = next.HandleDeserialize(ctx, in)
4726	if err != nil {
4727		return out, metadata, err
4728	}
4729
4730	response, ok := out.RawResponse.(*smithyhttp.Response)
4731	if !ok {
4732		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4733	}
4734
4735	if response.StatusCode < 200 || response.StatusCode >= 300 {
4736		return out, metadata, awsAwsjson11_deserializeOpErrorGetRule(response, &metadata)
4737	}
4738	output := &GetRuleOutput{}
4739	out.Result = output
4740
4741	var buff [1024]byte
4742	ringBuffer := smithyio.NewRingBuffer(buff[:])
4743
4744	body := io.TeeReader(response.Body, ringBuffer)
4745	decoder := json.NewDecoder(body)
4746	decoder.UseNumber()
4747	var shape interface{}
4748	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4749		var snapshot bytes.Buffer
4750		io.Copy(&snapshot, ringBuffer)
4751		err = &smithy.DeserializationError{
4752			Err:      fmt.Errorf("failed to decode response body, %w", err),
4753			Snapshot: snapshot.Bytes(),
4754		}
4755		return out, metadata, err
4756	}
4757
4758	err = awsAwsjson11_deserializeOpDocumentGetRuleOutput(&output, shape)
4759	if err != nil {
4760		var snapshot bytes.Buffer
4761		io.Copy(&snapshot, ringBuffer)
4762		err = &smithy.DeserializationError{
4763			Err:      fmt.Errorf("failed to decode response body, %w", err),
4764			Snapshot: snapshot.Bytes(),
4765		}
4766		return out, metadata, err
4767	}
4768
4769	return out, metadata, err
4770}
4771
4772func awsAwsjson11_deserializeOpErrorGetRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4773	var errorBuffer bytes.Buffer
4774	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4775		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4776	}
4777	errorBody := bytes.NewReader(errorBuffer.Bytes())
4778
4779	errorCode := "UnknownError"
4780	errorMessage := errorCode
4781
4782	code := response.Header.Get("X-Amzn-ErrorType")
4783	if len(code) != 0 {
4784		errorCode = restjson.SanitizeErrorCode(code)
4785	}
4786
4787	var buff [1024]byte
4788	ringBuffer := smithyio.NewRingBuffer(buff[:])
4789
4790	body := io.TeeReader(errorBody, ringBuffer)
4791	decoder := json.NewDecoder(body)
4792	decoder.UseNumber()
4793	code, message, err := restjson.GetErrorInfo(decoder)
4794	if err != nil {
4795		var snapshot bytes.Buffer
4796		io.Copy(&snapshot, ringBuffer)
4797		err = &smithy.DeserializationError{
4798			Err:      fmt.Errorf("failed to decode response body, %w", err),
4799			Snapshot: snapshot.Bytes(),
4800		}
4801		return err
4802	}
4803
4804	errorBody.Seek(0, io.SeekStart)
4805	if len(code) != 0 {
4806		errorCode = restjson.SanitizeErrorCode(code)
4807	}
4808	if len(message) != 0 {
4809		errorMessage = message
4810	}
4811
4812	switch {
4813	case strings.EqualFold("WAFInternalErrorException", errorCode):
4814		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4815
4816	case strings.EqualFold("WAFInvalidAccountException", errorCode):
4817		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
4818
4819	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4820		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4821
4822	default:
4823		genericError := &smithy.GenericAPIError{
4824			Code:    errorCode,
4825			Message: errorMessage,
4826		}
4827		return genericError
4828
4829	}
4830}
4831
4832type awsAwsjson11_deserializeOpGetRuleGroup struct {
4833}
4834
4835func (*awsAwsjson11_deserializeOpGetRuleGroup) ID() string {
4836	return "OperationDeserializer"
4837}
4838
4839func (m *awsAwsjson11_deserializeOpGetRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4840	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4841) {
4842	out, metadata, err = next.HandleDeserialize(ctx, in)
4843	if err != nil {
4844		return out, metadata, err
4845	}
4846
4847	response, ok := out.RawResponse.(*smithyhttp.Response)
4848	if !ok {
4849		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4850	}
4851
4852	if response.StatusCode < 200 || response.StatusCode >= 300 {
4853		return out, metadata, awsAwsjson11_deserializeOpErrorGetRuleGroup(response, &metadata)
4854	}
4855	output := &GetRuleGroupOutput{}
4856	out.Result = output
4857
4858	var buff [1024]byte
4859	ringBuffer := smithyio.NewRingBuffer(buff[:])
4860
4861	body := io.TeeReader(response.Body, ringBuffer)
4862	decoder := json.NewDecoder(body)
4863	decoder.UseNumber()
4864	var shape interface{}
4865	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4866		var snapshot bytes.Buffer
4867		io.Copy(&snapshot, ringBuffer)
4868		err = &smithy.DeserializationError{
4869			Err:      fmt.Errorf("failed to decode response body, %w", err),
4870			Snapshot: snapshot.Bytes(),
4871		}
4872		return out, metadata, err
4873	}
4874
4875	err = awsAwsjson11_deserializeOpDocumentGetRuleGroupOutput(&output, shape)
4876	if err != nil {
4877		var snapshot bytes.Buffer
4878		io.Copy(&snapshot, ringBuffer)
4879		err = &smithy.DeserializationError{
4880			Err:      fmt.Errorf("failed to decode response body, %w", err),
4881			Snapshot: snapshot.Bytes(),
4882		}
4883		return out, metadata, err
4884	}
4885
4886	return out, metadata, err
4887}
4888
4889func awsAwsjson11_deserializeOpErrorGetRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4890	var errorBuffer bytes.Buffer
4891	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4892		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4893	}
4894	errorBody := bytes.NewReader(errorBuffer.Bytes())
4895
4896	errorCode := "UnknownError"
4897	errorMessage := errorCode
4898
4899	code := response.Header.Get("X-Amzn-ErrorType")
4900	if len(code) != 0 {
4901		errorCode = restjson.SanitizeErrorCode(code)
4902	}
4903
4904	var buff [1024]byte
4905	ringBuffer := smithyio.NewRingBuffer(buff[:])
4906
4907	body := io.TeeReader(errorBody, ringBuffer)
4908	decoder := json.NewDecoder(body)
4909	decoder.UseNumber()
4910	code, message, err := restjson.GetErrorInfo(decoder)
4911	if err != nil {
4912		var snapshot bytes.Buffer
4913		io.Copy(&snapshot, ringBuffer)
4914		err = &smithy.DeserializationError{
4915			Err:      fmt.Errorf("failed to decode response body, %w", err),
4916			Snapshot: snapshot.Bytes(),
4917		}
4918		return err
4919	}
4920
4921	errorBody.Seek(0, io.SeekStart)
4922	if len(code) != 0 {
4923		errorCode = restjson.SanitizeErrorCode(code)
4924	}
4925	if len(message) != 0 {
4926		errorMessage = message
4927	}
4928
4929	switch {
4930	case strings.EqualFold("WAFInternalErrorException", errorCode):
4931		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
4932
4933	case strings.EqualFold("WAFNonexistentItemException", errorCode):
4934		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
4935
4936	default:
4937		genericError := &smithy.GenericAPIError{
4938			Code:    errorCode,
4939			Message: errorMessage,
4940		}
4941		return genericError
4942
4943	}
4944}
4945
4946type awsAwsjson11_deserializeOpGetSampledRequests struct {
4947}
4948
4949func (*awsAwsjson11_deserializeOpGetSampledRequests) ID() string {
4950	return "OperationDeserializer"
4951}
4952
4953func (m *awsAwsjson11_deserializeOpGetSampledRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4954	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4955) {
4956	out, metadata, err = next.HandleDeserialize(ctx, in)
4957	if err != nil {
4958		return out, metadata, err
4959	}
4960
4961	response, ok := out.RawResponse.(*smithyhttp.Response)
4962	if !ok {
4963		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4964	}
4965
4966	if response.StatusCode < 200 || response.StatusCode >= 300 {
4967		return out, metadata, awsAwsjson11_deserializeOpErrorGetSampledRequests(response, &metadata)
4968	}
4969	output := &GetSampledRequestsOutput{}
4970	out.Result = output
4971
4972	var buff [1024]byte
4973	ringBuffer := smithyio.NewRingBuffer(buff[:])
4974
4975	body := io.TeeReader(response.Body, ringBuffer)
4976	decoder := json.NewDecoder(body)
4977	decoder.UseNumber()
4978	var shape interface{}
4979	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4980		var snapshot bytes.Buffer
4981		io.Copy(&snapshot, ringBuffer)
4982		err = &smithy.DeserializationError{
4983			Err:      fmt.Errorf("failed to decode response body, %w", err),
4984			Snapshot: snapshot.Bytes(),
4985		}
4986		return out, metadata, err
4987	}
4988
4989	err = awsAwsjson11_deserializeOpDocumentGetSampledRequestsOutput(&output, shape)
4990	if err != nil {
4991		var snapshot bytes.Buffer
4992		io.Copy(&snapshot, ringBuffer)
4993		err = &smithy.DeserializationError{
4994			Err:      fmt.Errorf("failed to decode response body, %w", err),
4995			Snapshot: snapshot.Bytes(),
4996		}
4997		return out, metadata, err
4998	}
4999
5000	return out, metadata, err
5001}
5002
5003func awsAwsjson11_deserializeOpErrorGetSampledRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5004	var errorBuffer bytes.Buffer
5005	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5006		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5007	}
5008	errorBody := bytes.NewReader(errorBuffer.Bytes())
5009
5010	errorCode := "UnknownError"
5011	errorMessage := errorCode
5012
5013	code := response.Header.Get("X-Amzn-ErrorType")
5014	if len(code) != 0 {
5015		errorCode = restjson.SanitizeErrorCode(code)
5016	}
5017
5018	var buff [1024]byte
5019	ringBuffer := smithyio.NewRingBuffer(buff[:])
5020
5021	body := io.TeeReader(errorBody, ringBuffer)
5022	decoder := json.NewDecoder(body)
5023	decoder.UseNumber()
5024	code, message, err := restjson.GetErrorInfo(decoder)
5025	if err != nil {
5026		var snapshot bytes.Buffer
5027		io.Copy(&snapshot, ringBuffer)
5028		err = &smithy.DeserializationError{
5029			Err:      fmt.Errorf("failed to decode response body, %w", err),
5030			Snapshot: snapshot.Bytes(),
5031		}
5032		return err
5033	}
5034
5035	errorBody.Seek(0, io.SeekStart)
5036	if len(code) != 0 {
5037		errorCode = restjson.SanitizeErrorCode(code)
5038	}
5039	if len(message) != 0 {
5040		errorMessage = message
5041	}
5042
5043	switch {
5044	case strings.EqualFold("WAFInternalErrorException", errorCode):
5045		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5046
5047	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5048		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5049
5050	default:
5051		genericError := &smithy.GenericAPIError{
5052			Code:    errorCode,
5053			Message: errorMessage,
5054		}
5055		return genericError
5056
5057	}
5058}
5059
5060type awsAwsjson11_deserializeOpGetSizeConstraintSet struct {
5061}
5062
5063func (*awsAwsjson11_deserializeOpGetSizeConstraintSet) ID() string {
5064	return "OperationDeserializer"
5065}
5066
5067func (m *awsAwsjson11_deserializeOpGetSizeConstraintSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5068	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5069) {
5070	out, metadata, err = next.HandleDeserialize(ctx, in)
5071	if err != nil {
5072		return out, metadata, err
5073	}
5074
5075	response, ok := out.RawResponse.(*smithyhttp.Response)
5076	if !ok {
5077		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5078	}
5079
5080	if response.StatusCode < 200 || response.StatusCode >= 300 {
5081		return out, metadata, awsAwsjson11_deserializeOpErrorGetSizeConstraintSet(response, &metadata)
5082	}
5083	output := &GetSizeConstraintSetOutput{}
5084	out.Result = output
5085
5086	var buff [1024]byte
5087	ringBuffer := smithyio.NewRingBuffer(buff[:])
5088
5089	body := io.TeeReader(response.Body, ringBuffer)
5090	decoder := json.NewDecoder(body)
5091	decoder.UseNumber()
5092	var shape interface{}
5093	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5094		var snapshot bytes.Buffer
5095		io.Copy(&snapshot, ringBuffer)
5096		err = &smithy.DeserializationError{
5097			Err:      fmt.Errorf("failed to decode response body, %w", err),
5098			Snapshot: snapshot.Bytes(),
5099		}
5100		return out, metadata, err
5101	}
5102
5103	err = awsAwsjson11_deserializeOpDocumentGetSizeConstraintSetOutput(&output, shape)
5104	if err != nil {
5105		var snapshot bytes.Buffer
5106		io.Copy(&snapshot, ringBuffer)
5107		err = &smithy.DeserializationError{
5108			Err:      fmt.Errorf("failed to decode response body, %w", err),
5109			Snapshot: snapshot.Bytes(),
5110		}
5111		return out, metadata, err
5112	}
5113
5114	return out, metadata, err
5115}
5116
5117func awsAwsjson11_deserializeOpErrorGetSizeConstraintSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5118	var errorBuffer bytes.Buffer
5119	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5120		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5121	}
5122	errorBody := bytes.NewReader(errorBuffer.Bytes())
5123
5124	errorCode := "UnknownError"
5125	errorMessage := errorCode
5126
5127	code := response.Header.Get("X-Amzn-ErrorType")
5128	if len(code) != 0 {
5129		errorCode = restjson.SanitizeErrorCode(code)
5130	}
5131
5132	var buff [1024]byte
5133	ringBuffer := smithyio.NewRingBuffer(buff[:])
5134
5135	body := io.TeeReader(errorBody, ringBuffer)
5136	decoder := json.NewDecoder(body)
5137	decoder.UseNumber()
5138	code, message, err := restjson.GetErrorInfo(decoder)
5139	if err != nil {
5140		var snapshot bytes.Buffer
5141		io.Copy(&snapshot, ringBuffer)
5142		err = &smithy.DeserializationError{
5143			Err:      fmt.Errorf("failed to decode response body, %w", err),
5144			Snapshot: snapshot.Bytes(),
5145		}
5146		return err
5147	}
5148
5149	errorBody.Seek(0, io.SeekStart)
5150	if len(code) != 0 {
5151		errorCode = restjson.SanitizeErrorCode(code)
5152	}
5153	if len(message) != 0 {
5154		errorMessage = message
5155	}
5156
5157	switch {
5158	case strings.EqualFold("WAFInternalErrorException", errorCode):
5159		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5160
5161	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5162		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5163
5164	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5165		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5166
5167	default:
5168		genericError := &smithy.GenericAPIError{
5169			Code:    errorCode,
5170			Message: errorMessage,
5171		}
5172		return genericError
5173
5174	}
5175}
5176
5177type awsAwsjson11_deserializeOpGetSqlInjectionMatchSet struct {
5178}
5179
5180func (*awsAwsjson11_deserializeOpGetSqlInjectionMatchSet) ID() string {
5181	return "OperationDeserializer"
5182}
5183
5184func (m *awsAwsjson11_deserializeOpGetSqlInjectionMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5185	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5186) {
5187	out, metadata, err = next.HandleDeserialize(ctx, in)
5188	if err != nil {
5189		return out, metadata, err
5190	}
5191
5192	response, ok := out.RawResponse.(*smithyhttp.Response)
5193	if !ok {
5194		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5195	}
5196
5197	if response.StatusCode < 200 || response.StatusCode >= 300 {
5198		return out, metadata, awsAwsjson11_deserializeOpErrorGetSqlInjectionMatchSet(response, &metadata)
5199	}
5200	output := &GetSqlInjectionMatchSetOutput{}
5201	out.Result = output
5202
5203	var buff [1024]byte
5204	ringBuffer := smithyio.NewRingBuffer(buff[:])
5205
5206	body := io.TeeReader(response.Body, ringBuffer)
5207	decoder := json.NewDecoder(body)
5208	decoder.UseNumber()
5209	var shape interface{}
5210	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5211		var snapshot bytes.Buffer
5212		io.Copy(&snapshot, ringBuffer)
5213		err = &smithy.DeserializationError{
5214			Err:      fmt.Errorf("failed to decode response body, %w", err),
5215			Snapshot: snapshot.Bytes(),
5216		}
5217		return out, metadata, err
5218	}
5219
5220	err = awsAwsjson11_deserializeOpDocumentGetSqlInjectionMatchSetOutput(&output, shape)
5221	if err != nil {
5222		var snapshot bytes.Buffer
5223		io.Copy(&snapshot, ringBuffer)
5224		err = &smithy.DeserializationError{
5225			Err:      fmt.Errorf("failed to decode response body, %w", err),
5226			Snapshot: snapshot.Bytes(),
5227		}
5228		return out, metadata, err
5229	}
5230
5231	return out, metadata, err
5232}
5233
5234func awsAwsjson11_deserializeOpErrorGetSqlInjectionMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5235	var errorBuffer bytes.Buffer
5236	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5237		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5238	}
5239	errorBody := bytes.NewReader(errorBuffer.Bytes())
5240
5241	errorCode := "UnknownError"
5242	errorMessage := errorCode
5243
5244	code := response.Header.Get("X-Amzn-ErrorType")
5245	if len(code) != 0 {
5246		errorCode = restjson.SanitizeErrorCode(code)
5247	}
5248
5249	var buff [1024]byte
5250	ringBuffer := smithyio.NewRingBuffer(buff[:])
5251
5252	body := io.TeeReader(errorBody, ringBuffer)
5253	decoder := json.NewDecoder(body)
5254	decoder.UseNumber()
5255	code, message, err := restjson.GetErrorInfo(decoder)
5256	if err != nil {
5257		var snapshot bytes.Buffer
5258		io.Copy(&snapshot, ringBuffer)
5259		err = &smithy.DeserializationError{
5260			Err:      fmt.Errorf("failed to decode response body, %w", err),
5261			Snapshot: snapshot.Bytes(),
5262		}
5263		return err
5264	}
5265
5266	errorBody.Seek(0, io.SeekStart)
5267	if len(code) != 0 {
5268		errorCode = restjson.SanitizeErrorCode(code)
5269	}
5270	if len(message) != 0 {
5271		errorMessage = message
5272	}
5273
5274	switch {
5275	case strings.EqualFold("WAFInternalErrorException", errorCode):
5276		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5277
5278	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5279		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5280
5281	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5282		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5283
5284	default:
5285		genericError := &smithy.GenericAPIError{
5286			Code:    errorCode,
5287			Message: errorMessage,
5288		}
5289		return genericError
5290
5291	}
5292}
5293
5294type awsAwsjson11_deserializeOpGetWebACL struct {
5295}
5296
5297func (*awsAwsjson11_deserializeOpGetWebACL) ID() string {
5298	return "OperationDeserializer"
5299}
5300
5301func (m *awsAwsjson11_deserializeOpGetWebACL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5302	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5303) {
5304	out, metadata, err = next.HandleDeserialize(ctx, in)
5305	if err != nil {
5306		return out, metadata, err
5307	}
5308
5309	response, ok := out.RawResponse.(*smithyhttp.Response)
5310	if !ok {
5311		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5312	}
5313
5314	if response.StatusCode < 200 || response.StatusCode >= 300 {
5315		return out, metadata, awsAwsjson11_deserializeOpErrorGetWebACL(response, &metadata)
5316	}
5317	output := &GetWebACLOutput{}
5318	out.Result = output
5319
5320	var buff [1024]byte
5321	ringBuffer := smithyio.NewRingBuffer(buff[:])
5322
5323	body := io.TeeReader(response.Body, ringBuffer)
5324	decoder := json.NewDecoder(body)
5325	decoder.UseNumber()
5326	var shape interface{}
5327	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5328		var snapshot bytes.Buffer
5329		io.Copy(&snapshot, ringBuffer)
5330		err = &smithy.DeserializationError{
5331			Err:      fmt.Errorf("failed to decode response body, %w", err),
5332			Snapshot: snapshot.Bytes(),
5333		}
5334		return out, metadata, err
5335	}
5336
5337	err = awsAwsjson11_deserializeOpDocumentGetWebACLOutput(&output, shape)
5338	if err != nil {
5339		var snapshot bytes.Buffer
5340		io.Copy(&snapshot, ringBuffer)
5341		err = &smithy.DeserializationError{
5342			Err:      fmt.Errorf("failed to decode response body, %w", err),
5343			Snapshot: snapshot.Bytes(),
5344		}
5345		return out, metadata, err
5346	}
5347
5348	return out, metadata, err
5349}
5350
5351func awsAwsjson11_deserializeOpErrorGetWebACL(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5352	var errorBuffer bytes.Buffer
5353	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5354		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5355	}
5356	errorBody := bytes.NewReader(errorBuffer.Bytes())
5357
5358	errorCode := "UnknownError"
5359	errorMessage := errorCode
5360
5361	code := response.Header.Get("X-Amzn-ErrorType")
5362	if len(code) != 0 {
5363		errorCode = restjson.SanitizeErrorCode(code)
5364	}
5365
5366	var buff [1024]byte
5367	ringBuffer := smithyio.NewRingBuffer(buff[:])
5368
5369	body := io.TeeReader(errorBody, ringBuffer)
5370	decoder := json.NewDecoder(body)
5371	decoder.UseNumber()
5372	code, message, err := restjson.GetErrorInfo(decoder)
5373	if err != nil {
5374		var snapshot bytes.Buffer
5375		io.Copy(&snapshot, ringBuffer)
5376		err = &smithy.DeserializationError{
5377			Err:      fmt.Errorf("failed to decode response body, %w", err),
5378			Snapshot: snapshot.Bytes(),
5379		}
5380		return err
5381	}
5382
5383	errorBody.Seek(0, io.SeekStart)
5384	if len(code) != 0 {
5385		errorCode = restjson.SanitizeErrorCode(code)
5386	}
5387	if len(message) != 0 {
5388		errorMessage = message
5389	}
5390
5391	switch {
5392	case strings.EqualFold("WAFInternalErrorException", errorCode):
5393		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5394
5395	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5396		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5397
5398	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5399		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5400
5401	default:
5402		genericError := &smithy.GenericAPIError{
5403			Code:    errorCode,
5404			Message: errorMessage,
5405		}
5406		return genericError
5407
5408	}
5409}
5410
5411type awsAwsjson11_deserializeOpGetXssMatchSet struct {
5412}
5413
5414func (*awsAwsjson11_deserializeOpGetXssMatchSet) ID() string {
5415	return "OperationDeserializer"
5416}
5417
5418func (m *awsAwsjson11_deserializeOpGetXssMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5419	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5420) {
5421	out, metadata, err = next.HandleDeserialize(ctx, in)
5422	if err != nil {
5423		return out, metadata, err
5424	}
5425
5426	response, ok := out.RawResponse.(*smithyhttp.Response)
5427	if !ok {
5428		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5429	}
5430
5431	if response.StatusCode < 200 || response.StatusCode >= 300 {
5432		return out, metadata, awsAwsjson11_deserializeOpErrorGetXssMatchSet(response, &metadata)
5433	}
5434	output := &GetXssMatchSetOutput{}
5435	out.Result = output
5436
5437	var buff [1024]byte
5438	ringBuffer := smithyio.NewRingBuffer(buff[:])
5439
5440	body := io.TeeReader(response.Body, ringBuffer)
5441	decoder := json.NewDecoder(body)
5442	decoder.UseNumber()
5443	var shape interface{}
5444	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5445		var snapshot bytes.Buffer
5446		io.Copy(&snapshot, ringBuffer)
5447		err = &smithy.DeserializationError{
5448			Err:      fmt.Errorf("failed to decode response body, %w", err),
5449			Snapshot: snapshot.Bytes(),
5450		}
5451		return out, metadata, err
5452	}
5453
5454	err = awsAwsjson11_deserializeOpDocumentGetXssMatchSetOutput(&output, shape)
5455	if err != nil {
5456		var snapshot bytes.Buffer
5457		io.Copy(&snapshot, ringBuffer)
5458		err = &smithy.DeserializationError{
5459			Err:      fmt.Errorf("failed to decode response body, %w", err),
5460			Snapshot: snapshot.Bytes(),
5461		}
5462		return out, metadata, err
5463	}
5464
5465	return out, metadata, err
5466}
5467
5468func awsAwsjson11_deserializeOpErrorGetXssMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5469	var errorBuffer bytes.Buffer
5470	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5471		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5472	}
5473	errorBody := bytes.NewReader(errorBuffer.Bytes())
5474
5475	errorCode := "UnknownError"
5476	errorMessage := errorCode
5477
5478	code := response.Header.Get("X-Amzn-ErrorType")
5479	if len(code) != 0 {
5480		errorCode = restjson.SanitizeErrorCode(code)
5481	}
5482
5483	var buff [1024]byte
5484	ringBuffer := smithyio.NewRingBuffer(buff[:])
5485
5486	body := io.TeeReader(errorBody, ringBuffer)
5487	decoder := json.NewDecoder(body)
5488	decoder.UseNumber()
5489	code, message, err := restjson.GetErrorInfo(decoder)
5490	if err != nil {
5491		var snapshot bytes.Buffer
5492		io.Copy(&snapshot, ringBuffer)
5493		err = &smithy.DeserializationError{
5494			Err:      fmt.Errorf("failed to decode response body, %w", err),
5495			Snapshot: snapshot.Bytes(),
5496		}
5497		return err
5498	}
5499
5500	errorBody.Seek(0, io.SeekStart)
5501	if len(code) != 0 {
5502		errorCode = restjson.SanitizeErrorCode(code)
5503	}
5504	if len(message) != 0 {
5505		errorMessage = message
5506	}
5507
5508	switch {
5509	case strings.EqualFold("WAFInternalErrorException", errorCode):
5510		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5511
5512	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5513		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5514
5515	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5516		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5517
5518	default:
5519		genericError := &smithy.GenericAPIError{
5520			Code:    errorCode,
5521			Message: errorMessage,
5522		}
5523		return genericError
5524
5525	}
5526}
5527
5528type awsAwsjson11_deserializeOpListActivatedRulesInRuleGroup struct {
5529}
5530
5531func (*awsAwsjson11_deserializeOpListActivatedRulesInRuleGroup) ID() string {
5532	return "OperationDeserializer"
5533}
5534
5535func (m *awsAwsjson11_deserializeOpListActivatedRulesInRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5536	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5537) {
5538	out, metadata, err = next.HandleDeserialize(ctx, in)
5539	if err != nil {
5540		return out, metadata, err
5541	}
5542
5543	response, ok := out.RawResponse.(*smithyhttp.Response)
5544	if !ok {
5545		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5546	}
5547
5548	if response.StatusCode < 200 || response.StatusCode >= 300 {
5549		return out, metadata, awsAwsjson11_deserializeOpErrorListActivatedRulesInRuleGroup(response, &metadata)
5550	}
5551	output := &ListActivatedRulesInRuleGroupOutput{}
5552	out.Result = output
5553
5554	var buff [1024]byte
5555	ringBuffer := smithyio.NewRingBuffer(buff[:])
5556
5557	body := io.TeeReader(response.Body, ringBuffer)
5558	decoder := json.NewDecoder(body)
5559	decoder.UseNumber()
5560	var shape interface{}
5561	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5562		var snapshot bytes.Buffer
5563		io.Copy(&snapshot, ringBuffer)
5564		err = &smithy.DeserializationError{
5565			Err:      fmt.Errorf("failed to decode response body, %w", err),
5566			Snapshot: snapshot.Bytes(),
5567		}
5568		return out, metadata, err
5569	}
5570
5571	err = awsAwsjson11_deserializeOpDocumentListActivatedRulesInRuleGroupOutput(&output, shape)
5572	if err != nil {
5573		var snapshot bytes.Buffer
5574		io.Copy(&snapshot, ringBuffer)
5575		err = &smithy.DeserializationError{
5576			Err:      fmt.Errorf("failed to decode response body, %w", err),
5577			Snapshot: snapshot.Bytes(),
5578		}
5579		return out, metadata, err
5580	}
5581
5582	return out, metadata, err
5583}
5584
5585func awsAwsjson11_deserializeOpErrorListActivatedRulesInRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5586	var errorBuffer bytes.Buffer
5587	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5588		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5589	}
5590	errorBody := bytes.NewReader(errorBuffer.Bytes())
5591
5592	errorCode := "UnknownError"
5593	errorMessage := errorCode
5594
5595	code := response.Header.Get("X-Amzn-ErrorType")
5596	if len(code) != 0 {
5597		errorCode = restjson.SanitizeErrorCode(code)
5598	}
5599
5600	var buff [1024]byte
5601	ringBuffer := smithyio.NewRingBuffer(buff[:])
5602
5603	body := io.TeeReader(errorBody, ringBuffer)
5604	decoder := json.NewDecoder(body)
5605	decoder.UseNumber()
5606	code, message, err := restjson.GetErrorInfo(decoder)
5607	if err != nil {
5608		var snapshot bytes.Buffer
5609		io.Copy(&snapshot, ringBuffer)
5610		err = &smithy.DeserializationError{
5611			Err:      fmt.Errorf("failed to decode response body, %w", err),
5612			Snapshot: snapshot.Bytes(),
5613		}
5614		return err
5615	}
5616
5617	errorBody.Seek(0, io.SeekStart)
5618	if len(code) != 0 {
5619		errorCode = restjson.SanitizeErrorCode(code)
5620	}
5621	if len(message) != 0 {
5622		errorMessage = message
5623	}
5624
5625	switch {
5626	case strings.EqualFold("WAFInternalErrorException", errorCode):
5627		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5628
5629	case strings.EqualFold("WAFInvalidParameterException", errorCode):
5630		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
5631
5632	case strings.EqualFold("WAFNonexistentItemException", errorCode):
5633		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
5634
5635	default:
5636		genericError := &smithy.GenericAPIError{
5637			Code:    errorCode,
5638			Message: errorMessage,
5639		}
5640		return genericError
5641
5642	}
5643}
5644
5645type awsAwsjson11_deserializeOpListByteMatchSets struct {
5646}
5647
5648func (*awsAwsjson11_deserializeOpListByteMatchSets) ID() string {
5649	return "OperationDeserializer"
5650}
5651
5652func (m *awsAwsjson11_deserializeOpListByteMatchSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5653	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5654) {
5655	out, metadata, err = next.HandleDeserialize(ctx, in)
5656	if err != nil {
5657		return out, metadata, err
5658	}
5659
5660	response, ok := out.RawResponse.(*smithyhttp.Response)
5661	if !ok {
5662		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5663	}
5664
5665	if response.StatusCode < 200 || response.StatusCode >= 300 {
5666		return out, metadata, awsAwsjson11_deserializeOpErrorListByteMatchSets(response, &metadata)
5667	}
5668	output := &ListByteMatchSetsOutput{}
5669	out.Result = output
5670
5671	var buff [1024]byte
5672	ringBuffer := smithyio.NewRingBuffer(buff[:])
5673
5674	body := io.TeeReader(response.Body, ringBuffer)
5675	decoder := json.NewDecoder(body)
5676	decoder.UseNumber()
5677	var shape interface{}
5678	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5679		var snapshot bytes.Buffer
5680		io.Copy(&snapshot, ringBuffer)
5681		err = &smithy.DeserializationError{
5682			Err:      fmt.Errorf("failed to decode response body, %w", err),
5683			Snapshot: snapshot.Bytes(),
5684		}
5685		return out, metadata, err
5686	}
5687
5688	err = awsAwsjson11_deserializeOpDocumentListByteMatchSetsOutput(&output, shape)
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 out, metadata, err
5697	}
5698
5699	return out, metadata, err
5700}
5701
5702func awsAwsjson11_deserializeOpErrorListByteMatchSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5703	var errorBuffer bytes.Buffer
5704	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5705		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5706	}
5707	errorBody := bytes.NewReader(errorBuffer.Bytes())
5708
5709	errorCode := "UnknownError"
5710	errorMessage := errorCode
5711
5712	code := response.Header.Get("X-Amzn-ErrorType")
5713	if len(code) != 0 {
5714		errorCode = restjson.SanitizeErrorCode(code)
5715	}
5716
5717	var buff [1024]byte
5718	ringBuffer := smithyio.NewRingBuffer(buff[:])
5719
5720	body := io.TeeReader(errorBody, ringBuffer)
5721	decoder := json.NewDecoder(body)
5722	decoder.UseNumber()
5723	code, message, err := restjson.GetErrorInfo(decoder)
5724	if err != nil {
5725		var snapshot bytes.Buffer
5726		io.Copy(&snapshot, ringBuffer)
5727		err = &smithy.DeserializationError{
5728			Err:      fmt.Errorf("failed to decode response body, %w", err),
5729			Snapshot: snapshot.Bytes(),
5730		}
5731		return err
5732	}
5733
5734	errorBody.Seek(0, io.SeekStart)
5735	if len(code) != 0 {
5736		errorCode = restjson.SanitizeErrorCode(code)
5737	}
5738	if len(message) != 0 {
5739		errorMessage = message
5740	}
5741
5742	switch {
5743	case strings.EqualFold("WAFInternalErrorException", errorCode):
5744		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5745
5746	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5747		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5748
5749	default:
5750		genericError := &smithy.GenericAPIError{
5751			Code:    errorCode,
5752			Message: errorMessage,
5753		}
5754		return genericError
5755
5756	}
5757}
5758
5759type awsAwsjson11_deserializeOpListGeoMatchSets struct {
5760}
5761
5762func (*awsAwsjson11_deserializeOpListGeoMatchSets) ID() string {
5763	return "OperationDeserializer"
5764}
5765
5766func (m *awsAwsjson11_deserializeOpListGeoMatchSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5767	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5768) {
5769	out, metadata, err = next.HandleDeserialize(ctx, in)
5770	if err != nil {
5771		return out, metadata, err
5772	}
5773
5774	response, ok := out.RawResponse.(*smithyhttp.Response)
5775	if !ok {
5776		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5777	}
5778
5779	if response.StatusCode < 200 || response.StatusCode >= 300 {
5780		return out, metadata, awsAwsjson11_deserializeOpErrorListGeoMatchSets(response, &metadata)
5781	}
5782	output := &ListGeoMatchSetsOutput{}
5783	out.Result = output
5784
5785	var buff [1024]byte
5786	ringBuffer := smithyio.NewRingBuffer(buff[:])
5787
5788	body := io.TeeReader(response.Body, ringBuffer)
5789	decoder := json.NewDecoder(body)
5790	decoder.UseNumber()
5791	var shape interface{}
5792	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5793		var snapshot bytes.Buffer
5794		io.Copy(&snapshot, ringBuffer)
5795		err = &smithy.DeserializationError{
5796			Err:      fmt.Errorf("failed to decode response body, %w", err),
5797			Snapshot: snapshot.Bytes(),
5798		}
5799		return out, metadata, err
5800	}
5801
5802	err = awsAwsjson11_deserializeOpDocumentListGeoMatchSetsOutput(&output, shape)
5803	if err != nil {
5804		var snapshot bytes.Buffer
5805		io.Copy(&snapshot, ringBuffer)
5806		err = &smithy.DeserializationError{
5807			Err:      fmt.Errorf("failed to decode response body, %w", err),
5808			Snapshot: snapshot.Bytes(),
5809		}
5810		return out, metadata, err
5811	}
5812
5813	return out, metadata, err
5814}
5815
5816func awsAwsjson11_deserializeOpErrorListGeoMatchSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5817	var errorBuffer bytes.Buffer
5818	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5819		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5820	}
5821	errorBody := bytes.NewReader(errorBuffer.Bytes())
5822
5823	errorCode := "UnknownError"
5824	errorMessage := errorCode
5825
5826	code := response.Header.Get("X-Amzn-ErrorType")
5827	if len(code) != 0 {
5828		errorCode = restjson.SanitizeErrorCode(code)
5829	}
5830
5831	var buff [1024]byte
5832	ringBuffer := smithyio.NewRingBuffer(buff[:])
5833
5834	body := io.TeeReader(errorBody, ringBuffer)
5835	decoder := json.NewDecoder(body)
5836	decoder.UseNumber()
5837	code, message, err := restjson.GetErrorInfo(decoder)
5838	if err != nil {
5839		var snapshot bytes.Buffer
5840		io.Copy(&snapshot, ringBuffer)
5841		err = &smithy.DeserializationError{
5842			Err:      fmt.Errorf("failed to decode response body, %w", err),
5843			Snapshot: snapshot.Bytes(),
5844		}
5845		return err
5846	}
5847
5848	errorBody.Seek(0, io.SeekStart)
5849	if len(code) != 0 {
5850		errorCode = restjson.SanitizeErrorCode(code)
5851	}
5852	if len(message) != 0 {
5853		errorMessage = message
5854	}
5855
5856	switch {
5857	case strings.EqualFold("WAFInternalErrorException", errorCode):
5858		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5859
5860	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5861		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5862
5863	default:
5864		genericError := &smithy.GenericAPIError{
5865			Code:    errorCode,
5866			Message: errorMessage,
5867		}
5868		return genericError
5869
5870	}
5871}
5872
5873type awsAwsjson11_deserializeOpListIPSets struct {
5874}
5875
5876func (*awsAwsjson11_deserializeOpListIPSets) ID() string {
5877	return "OperationDeserializer"
5878}
5879
5880func (m *awsAwsjson11_deserializeOpListIPSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5881	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5882) {
5883	out, metadata, err = next.HandleDeserialize(ctx, in)
5884	if err != nil {
5885		return out, metadata, err
5886	}
5887
5888	response, ok := out.RawResponse.(*smithyhttp.Response)
5889	if !ok {
5890		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5891	}
5892
5893	if response.StatusCode < 200 || response.StatusCode >= 300 {
5894		return out, metadata, awsAwsjson11_deserializeOpErrorListIPSets(response, &metadata)
5895	}
5896	output := &ListIPSetsOutput{}
5897	out.Result = output
5898
5899	var buff [1024]byte
5900	ringBuffer := smithyio.NewRingBuffer(buff[:])
5901
5902	body := io.TeeReader(response.Body, ringBuffer)
5903	decoder := json.NewDecoder(body)
5904	decoder.UseNumber()
5905	var shape interface{}
5906	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5907		var snapshot bytes.Buffer
5908		io.Copy(&snapshot, ringBuffer)
5909		err = &smithy.DeserializationError{
5910			Err:      fmt.Errorf("failed to decode response body, %w", err),
5911			Snapshot: snapshot.Bytes(),
5912		}
5913		return out, metadata, err
5914	}
5915
5916	err = awsAwsjson11_deserializeOpDocumentListIPSetsOutput(&output, shape)
5917	if err != nil {
5918		var snapshot bytes.Buffer
5919		io.Copy(&snapshot, ringBuffer)
5920		err = &smithy.DeserializationError{
5921			Err:      fmt.Errorf("failed to decode response body, %w", err),
5922			Snapshot: snapshot.Bytes(),
5923		}
5924		return out, metadata, err
5925	}
5926
5927	return out, metadata, err
5928}
5929
5930func awsAwsjson11_deserializeOpErrorListIPSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5931	var errorBuffer bytes.Buffer
5932	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5933		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5934	}
5935	errorBody := bytes.NewReader(errorBuffer.Bytes())
5936
5937	errorCode := "UnknownError"
5938	errorMessage := errorCode
5939
5940	code := response.Header.Get("X-Amzn-ErrorType")
5941	if len(code) != 0 {
5942		errorCode = restjson.SanitizeErrorCode(code)
5943	}
5944
5945	var buff [1024]byte
5946	ringBuffer := smithyio.NewRingBuffer(buff[:])
5947
5948	body := io.TeeReader(errorBody, ringBuffer)
5949	decoder := json.NewDecoder(body)
5950	decoder.UseNumber()
5951	code, message, err := restjson.GetErrorInfo(decoder)
5952	if err != nil {
5953		var snapshot bytes.Buffer
5954		io.Copy(&snapshot, ringBuffer)
5955		err = &smithy.DeserializationError{
5956			Err:      fmt.Errorf("failed to decode response body, %w", err),
5957			Snapshot: snapshot.Bytes(),
5958		}
5959		return err
5960	}
5961
5962	errorBody.Seek(0, io.SeekStart)
5963	if len(code) != 0 {
5964		errorCode = restjson.SanitizeErrorCode(code)
5965	}
5966	if len(message) != 0 {
5967		errorMessage = message
5968	}
5969
5970	switch {
5971	case strings.EqualFold("WAFInternalErrorException", errorCode):
5972		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
5973
5974	case strings.EqualFold("WAFInvalidAccountException", errorCode):
5975		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
5976
5977	default:
5978		genericError := &smithy.GenericAPIError{
5979			Code:    errorCode,
5980			Message: errorMessage,
5981		}
5982		return genericError
5983
5984	}
5985}
5986
5987type awsAwsjson11_deserializeOpListLoggingConfigurations struct {
5988}
5989
5990func (*awsAwsjson11_deserializeOpListLoggingConfigurations) ID() string {
5991	return "OperationDeserializer"
5992}
5993
5994func (m *awsAwsjson11_deserializeOpListLoggingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5995	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5996) {
5997	out, metadata, err = next.HandleDeserialize(ctx, in)
5998	if err != nil {
5999		return out, metadata, err
6000	}
6001
6002	response, ok := out.RawResponse.(*smithyhttp.Response)
6003	if !ok {
6004		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6005	}
6006
6007	if response.StatusCode < 200 || response.StatusCode >= 300 {
6008		return out, metadata, awsAwsjson11_deserializeOpErrorListLoggingConfigurations(response, &metadata)
6009	}
6010	output := &ListLoggingConfigurationsOutput{}
6011	out.Result = output
6012
6013	var buff [1024]byte
6014	ringBuffer := smithyio.NewRingBuffer(buff[:])
6015
6016	body := io.TeeReader(response.Body, ringBuffer)
6017	decoder := json.NewDecoder(body)
6018	decoder.UseNumber()
6019	var shape interface{}
6020	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6021		var snapshot bytes.Buffer
6022		io.Copy(&snapshot, ringBuffer)
6023		err = &smithy.DeserializationError{
6024			Err:      fmt.Errorf("failed to decode response body, %w", err),
6025			Snapshot: snapshot.Bytes(),
6026		}
6027		return out, metadata, err
6028	}
6029
6030	err = awsAwsjson11_deserializeOpDocumentListLoggingConfigurationsOutput(&output, shape)
6031	if err != nil {
6032		var snapshot bytes.Buffer
6033		io.Copy(&snapshot, ringBuffer)
6034		err = &smithy.DeserializationError{
6035			Err:      fmt.Errorf("failed to decode response body, %w", err),
6036			Snapshot: snapshot.Bytes(),
6037		}
6038		return out, metadata, err
6039	}
6040
6041	return out, metadata, err
6042}
6043
6044func awsAwsjson11_deserializeOpErrorListLoggingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6045	var errorBuffer bytes.Buffer
6046	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6047		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6048	}
6049	errorBody := bytes.NewReader(errorBuffer.Bytes())
6050
6051	errorCode := "UnknownError"
6052	errorMessage := errorCode
6053
6054	code := response.Header.Get("X-Amzn-ErrorType")
6055	if len(code) != 0 {
6056		errorCode = restjson.SanitizeErrorCode(code)
6057	}
6058
6059	var buff [1024]byte
6060	ringBuffer := smithyio.NewRingBuffer(buff[:])
6061
6062	body := io.TeeReader(errorBody, ringBuffer)
6063	decoder := json.NewDecoder(body)
6064	decoder.UseNumber()
6065	code, message, err := restjson.GetErrorInfo(decoder)
6066	if err != nil {
6067		var snapshot bytes.Buffer
6068		io.Copy(&snapshot, ringBuffer)
6069		err = &smithy.DeserializationError{
6070			Err:      fmt.Errorf("failed to decode response body, %w", err),
6071			Snapshot: snapshot.Bytes(),
6072		}
6073		return err
6074	}
6075
6076	errorBody.Seek(0, io.SeekStart)
6077	if len(code) != 0 {
6078		errorCode = restjson.SanitizeErrorCode(code)
6079	}
6080	if len(message) != 0 {
6081		errorMessage = message
6082	}
6083
6084	switch {
6085	case strings.EqualFold("WAFInternalErrorException", errorCode):
6086		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6087
6088	case strings.EqualFold("WAFInvalidParameterException", errorCode):
6089		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
6090
6091	case strings.EqualFold("WAFNonexistentItemException", errorCode):
6092		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
6093
6094	default:
6095		genericError := &smithy.GenericAPIError{
6096			Code:    errorCode,
6097			Message: errorMessage,
6098		}
6099		return genericError
6100
6101	}
6102}
6103
6104type awsAwsjson11_deserializeOpListRateBasedRules struct {
6105}
6106
6107func (*awsAwsjson11_deserializeOpListRateBasedRules) ID() string {
6108	return "OperationDeserializer"
6109}
6110
6111func (m *awsAwsjson11_deserializeOpListRateBasedRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6112	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6113) {
6114	out, metadata, err = next.HandleDeserialize(ctx, in)
6115	if err != nil {
6116		return out, metadata, err
6117	}
6118
6119	response, ok := out.RawResponse.(*smithyhttp.Response)
6120	if !ok {
6121		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6122	}
6123
6124	if response.StatusCode < 200 || response.StatusCode >= 300 {
6125		return out, metadata, awsAwsjson11_deserializeOpErrorListRateBasedRules(response, &metadata)
6126	}
6127	output := &ListRateBasedRulesOutput{}
6128	out.Result = output
6129
6130	var buff [1024]byte
6131	ringBuffer := smithyio.NewRingBuffer(buff[:])
6132
6133	body := io.TeeReader(response.Body, ringBuffer)
6134	decoder := json.NewDecoder(body)
6135	decoder.UseNumber()
6136	var shape interface{}
6137	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6138		var snapshot bytes.Buffer
6139		io.Copy(&snapshot, ringBuffer)
6140		err = &smithy.DeserializationError{
6141			Err:      fmt.Errorf("failed to decode response body, %w", err),
6142			Snapshot: snapshot.Bytes(),
6143		}
6144		return out, metadata, err
6145	}
6146
6147	err = awsAwsjson11_deserializeOpDocumentListRateBasedRulesOutput(&output, shape)
6148	if err != nil {
6149		var snapshot bytes.Buffer
6150		io.Copy(&snapshot, ringBuffer)
6151		err = &smithy.DeserializationError{
6152			Err:      fmt.Errorf("failed to decode response body, %w", err),
6153			Snapshot: snapshot.Bytes(),
6154		}
6155		return out, metadata, err
6156	}
6157
6158	return out, metadata, err
6159}
6160
6161func awsAwsjson11_deserializeOpErrorListRateBasedRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6162	var errorBuffer bytes.Buffer
6163	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6164		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6165	}
6166	errorBody := bytes.NewReader(errorBuffer.Bytes())
6167
6168	errorCode := "UnknownError"
6169	errorMessage := errorCode
6170
6171	code := response.Header.Get("X-Amzn-ErrorType")
6172	if len(code) != 0 {
6173		errorCode = restjson.SanitizeErrorCode(code)
6174	}
6175
6176	var buff [1024]byte
6177	ringBuffer := smithyio.NewRingBuffer(buff[:])
6178
6179	body := io.TeeReader(errorBody, ringBuffer)
6180	decoder := json.NewDecoder(body)
6181	decoder.UseNumber()
6182	code, message, err := restjson.GetErrorInfo(decoder)
6183	if err != nil {
6184		var snapshot bytes.Buffer
6185		io.Copy(&snapshot, ringBuffer)
6186		err = &smithy.DeserializationError{
6187			Err:      fmt.Errorf("failed to decode response body, %w", err),
6188			Snapshot: snapshot.Bytes(),
6189		}
6190		return err
6191	}
6192
6193	errorBody.Seek(0, io.SeekStart)
6194	if len(code) != 0 {
6195		errorCode = restjson.SanitizeErrorCode(code)
6196	}
6197	if len(message) != 0 {
6198		errorMessage = message
6199	}
6200
6201	switch {
6202	case strings.EqualFold("WAFInternalErrorException", errorCode):
6203		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6204
6205	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6206		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6207
6208	default:
6209		genericError := &smithy.GenericAPIError{
6210			Code:    errorCode,
6211			Message: errorMessage,
6212		}
6213		return genericError
6214
6215	}
6216}
6217
6218type awsAwsjson11_deserializeOpListRegexMatchSets struct {
6219}
6220
6221func (*awsAwsjson11_deserializeOpListRegexMatchSets) ID() string {
6222	return "OperationDeserializer"
6223}
6224
6225func (m *awsAwsjson11_deserializeOpListRegexMatchSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6226	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6227) {
6228	out, metadata, err = next.HandleDeserialize(ctx, in)
6229	if err != nil {
6230		return out, metadata, err
6231	}
6232
6233	response, ok := out.RawResponse.(*smithyhttp.Response)
6234	if !ok {
6235		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6236	}
6237
6238	if response.StatusCode < 200 || response.StatusCode >= 300 {
6239		return out, metadata, awsAwsjson11_deserializeOpErrorListRegexMatchSets(response, &metadata)
6240	}
6241	output := &ListRegexMatchSetsOutput{}
6242	out.Result = output
6243
6244	var buff [1024]byte
6245	ringBuffer := smithyio.NewRingBuffer(buff[:])
6246
6247	body := io.TeeReader(response.Body, ringBuffer)
6248	decoder := json.NewDecoder(body)
6249	decoder.UseNumber()
6250	var shape interface{}
6251	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6252		var snapshot bytes.Buffer
6253		io.Copy(&snapshot, ringBuffer)
6254		err = &smithy.DeserializationError{
6255			Err:      fmt.Errorf("failed to decode response body, %w", err),
6256			Snapshot: snapshot.Bytes(),
6257		}
6258		return out, metadata, err
6259	}
6260
6261	err = awsAwsjson11_deserializeOpDocumentListRegexMatchSetsOutput(&output, shape)
6262	if err != nil {
6263		var snapshot bytes.Buffer
6264		io.Copy(&snapshot, ringBuffer)
6265		err = &smithy.DeserializationError{
6266			Err:      fmt.Errorf("failed to decode response body, %w", err),
6267			Snapshot: snapshot.Bytes(),
6268		}
6269		return out, metadata, err
6270	}
6271
6272	return out, metadata, err
6273}
6274
6275func awsAwsjson11_deserializeOpErrorListRegexMatchSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6276	var errorBuffer bytes.Buffer
6277	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6278		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6279	}
6280	errorBody := bytes.NewReader(errorBuffer.Bytes())
6281
6282	errorCode := "UnknownError"
6283	errorMessage := errorCode
6284
6285	code := response.Header.Get("X-Amzn-ErrorType")
6286	if len(code) != 0 {
6287		errorCode = restjson.SanitizeErrorCode(code)
6288	}
6289
6290	var buff [1024]byte
6291	ringBuffer := smithyio.NewRingBuffer(buff[:])
6292
6293	body := io.TeeReader(errorBody, ringBuffer)
6294	decoder := json.NewDecoder(body)
6295	decoder.UseNumber()
6296	code, message, err := restjson.GetErrorInfo(decoder)
6297	if err != nil {
6298		var snapshot bytes.Buffer
6299		io.Copy(&snapshot, ringBuffer)
6300		err = &smithy.DeserializationError{
6301			Err:      fmt.Errorf("failed to decode response body, %w", err),
6302			Snapshot: snapshot.Bytes(),
6303		}
6304		return err
6305	}
6306
6307	errorBody.Seek(0, io.SeekStart)
6308	if len(code) != 0 {
6309		errorCode = restjson.SanitizeErrorCode(code)
6310	}
6311	if len(message) != 0 {
6312		errorMessage = message
6313	}
6314
6315	switch {
6316	case strings.EqualFold("WAFInternalErrorException", errorCode):
6317		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6318
6319	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6320		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6321
6322	default:
6323		genericError := &smithy.GenericAPIError{
6324			Code:    errorCode,
6325			Message: errorMessage,
6326		}
6327		return genericError
6328
6329	}
6330}
6331
6332type awsAwsjson11_deserializeOpListRegexPatternSets struct {
6333}
6334
6335func (*awsAwsjson11_deserializeOpListRegexPatternSets) ID() string {
6336	return "OperationDeserializer"
6337}
6338
6339func (m *awsAwsjson11_deserializeOpListRegexPatternSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6340	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6341) {
6342	out, metadata, err = next.HandleDeserialize(ctx, in)
6343	if err != nil {
6344		return out, metadata, err
6345	}
6346
6347	response, ok := out.RawResponse.(*smithyhttp.Response)
6348	if !ok {
6349		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6350	}
6351
6352	if response.StatusCode < 200 || response.StatusCode >= 300 {
6353		return out, metadata, awsAwsjson11_deserializeOpErrorListRegexPatternSets(response, &metadata)
6354	}
6355	output := &ListRegexPatternSetsOutput{}
6356	out.Result = output
6357
6358	var buff [1024]byte
6359	ringBuffer := smithyio.NewRingBuffer(buff[:])
6360
6361	body := io.TeeReader(response.Body, ringBuffer)
6362	decoder := json.NewDecoder(body)
6363	decoder.UseNumber()
6364	var shape interface{}
6365	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6366		var snapshot bytes.Buffer
6367		io.Copy(&snapshot, ringBuffer)
6368		err = &smithy.DeserializationError{
6369			Err:      fmt.Errorf("failed to decode response body, %w", err),
6370			Snapshot: snapshot.Bytes(),
6371		}
6372		return out, metadata, err
6373	}
6374
6375	err = awsAwsjson11_deserializeOpDocumentListRegexPatternSetsOutput(&output, shape)
6376	if err != nil {
6377		var snapshot bytes.Buffer
6378		io.Copy(&snapshot, ringBuffer)
6379		err = &smithy.DeserializationError{
6380			Err:      fmt.Errorf("failed to decode response body, %w", err),
6381			Snapshot: snapshot.Bytes(),
6382		}
6383		return out, metadata, err
6384	}
6385
6386	return out, metadata, err
6387}
6388
6389func awsAwsjson11_deserializeOpErrorListRegexPatternSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6390	var errorBuffer bytes.Buffer
6391	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6392		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6393	}
6394	errorBody := bytes.NewReader(errorBuffer.Bytes())
6395
6396	errorCode := "UnknownError"
6397	errorMessage := errorCode
6398
6399	code := response.Header.Get("X-Amzn-ErrorType")
6400	if len(code) != 0 {
6401		errorCode = restjson.SanitizeErrorCode(code)
6402	}
6403
6404	var buff [1024]byte
6405	ringBuffer := smithyio.NewRingBuffer(buff[:])
6406
6407	body := io.TeeReader(errorBody, ringBuffer)
6408	decoder := json.NewDecoder(body)
6409	decoder.UseNumber()
6410	code, message, err := restjson.GetErrorInfo(decoder)
6411	if err != nil {
6412		var snapshot bytes.Buffer
6413		io.Copy(&snapshot, ringBuffer)
6414		err = &smithy.DeserializationError{
6415			Err:      fmt.Errorf("failed to decode response body, %w", err),
6416			Snapshot: snapshot.Bytes(),
6417		}
6418		return err
6419	}
6420
6421	errorBody.Seek(0, io.SeekStart)
6422	if len(code) != 0 {
6423		errorCode = restjson.SanitizeErrorCode(code)
6424	}
6425	if len(message) != 0 {
6426		errorMessage = message
6427	}
6428
6429	switch {
6430	case strings.EqualFold("WAFInternalErrorException", errorCode):
6431		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6432
6433	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6434		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6435
6436	default:
6437		genericError := &smithy.GenericAPIError{
6438			Code:    errorCode,
6439			Message: errorMessage,
6440		}
6441		return genericError
6442
6443	}
6444}
6445
6446type awsAwsjson11_deserializeOpListRuleGroups struct {
6447}
6448
6449func (*awsAwsjson11_deserializeOpListRuleGroups) ID() string {
6450	return "OperationDeserializer"
6451}
6452
6453func (m *awsAwsjson11_deserializeOpListRuleGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6454	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6455) {
6456	out, metadata, err = next.HandleDeserialize(ctx, in)
6457	if err != nil {
6458		return out, metadata, err
6459	}
6460
6461	response, ok := out.RawResponse.(*smithyhttp.Response)
6462	if !ok {
6463		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6464	}
6465
6466	if response.StatusCode < 200 || response.StatusCode >= 300 {
6467		return out, metadata, awsAwsjson11_deserializeOpErrorListRuleGroups(response, &metadata)
6468	}
6469	output := &ListRuleGroupsOutput{}
6470	out.Result = output
6471
6472	var buff [1024]byte
6473	ringBuffer := smithyio.NewRingBuffer(buff[:])
6474
6475	body := io.TeeReader(response.Body, ringBuffer)
6476	decoder := json.NewDecoder(body)
6477	decoder.UseNumber()
6478	var shape interface{}
6479	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6480		var snapshot bytes.Buffer
6481		io.Copy(&snapshot, ringBuffer)
6482		err = &smithy.DeserializationError{
6483			Err:      fmt.Errorf("failed to decode response body, %w", err),
6484			Snapshot: snapshot.Bytes(),
6485		}
6486		return out, metadata, err
6487	}
6488
6489	err = awsAwsjson11_deserializeOpDocumentListRuleGroupsOutput(&output, shape)
6490	if err != nil {
6491		var snapshot bytes.Buffer
6492		io.Copy(&snapshot, ringBuffer)
6493		err = &smithy.DeserializationError{
6494			Err:      fmt.Errorf("failed to decode response body, %w", err),
6495			Snapshot: snapshot.Bytes(),
6496		}
6497		return out, metadata, err
6498	}
6499
6500	return out, metadata, err
6501}
6502
6503func awsAwsjson11_deserializeOpErrorListRuleGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6504	var errorBuffer bytes.Buffer
6505	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6506		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6507	}
6508	errorBody := bytes.NewReader(errorBuffer.Bytes())
6509
6510	errorCode := "UnknownError"
6511	errorMessage := errorCode
6512
6513	code := response.Header.Get("X-Amzn-ErrorType")
6514	if len(code) != 0 {
6515		errorCode = restjson.SanitizeErrorCode(code)
6516	}
6517
6518	var buff [1024]byte
6519	ringBuffer := smithyio.NewRingBuffer(buff[:])
6520
6521	body := io.TeeReader(errorBody, ringBuffer)
6522	decoder := json.NewDecoder(body)
6523	decoder.UseNumber()
6524	code, message, err := restjson.GetErrorInfo(decoder)
6525	if err != nil {
6526		var snapshot bytes.Buffer
6527		io.Copy(&snapshot, ringBuffer)
6528		err = &smithy.DeserializationError{
6529			Err:      fmt.Errorf("failed to decode response body, %w", err),
6530			Snapshot: snapshot.Bytes(),
6531		}
6532		return err
6533	}
6534
6535	errorBody.Seek(0, io.SeekStart)
6536	if len(code) != 0 {
6537		errorCode = restjson.SanitizeErrorCode(code)
6538	}
6539	if len(message) != 0 {
6540		errorMessage = message
6541	}
6542
6543	switch {
6544	case strings.EqualFold("WAFInternalErrorException", errorCode):
6545		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6546
6547	default:
6548		genericError := &smithy.GenericAPIError{
6549			Code:    errorCode,
6550			Message: errorMessage,
6551		}
6552		return genericError
6553
6554	}
6555}
6556
6557type awsAwsjson11_deserializeOpListRules struct {
6558}
6559
6560func (*awsAwsjson11_deserializeOpListRules) ID() string {
6561	return "OperationDeserializer"
6562}
6563
6564func (m *awsAwsjson11_deserializeOpListRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6565	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6566) {
6567	out, metadata, err = next.HandleDeserialize(ctx, in)
6568	if err != nil {
6569		return out, metadata, err
6570	}
6571
6572	response, ok := out.RawResponse.(*smithyhttp.Response)
6573	if !ok {
6574		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6575	}
6576
6577	if response.StatusCode < 200 || response.StatusCode >= 300 {
6578		return out, metadata, awsAwsjson11_deserializeOpErrorListRules(response, &metadata)
6579	}
6580	output := &ListRulesOutput{}
6581	out.Result = output
6582
6583	var buff [1024]byte
6584	ringBuffer := smithyio.NewRingBuffer(buff[:])
6585
6586	body := io.TeeReader(response.Body, ringBuffer)
6587	decoder := json.NewDecoder(body)
6588	decoder.UseNumber()
6589	var shape interface{}
6590	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6591		var snapshot bytes.Buffer
6592		io.Copy(&snapshot, ringBuffer)
6593		err = &smithy.DeserializationError{
6594			Err:      fmt.Errorf("failed to decode response body, %w", err),
6595			Snapshot: snapshot.Bytes(),
6596		}
6597		return out, metadata, err
6598	}
6599
6600	err = awsAwsjson11_deserializeOpDocumentListRulesOutput(&output, shape)
6601	if err != nil {
6602		var snapshot bytes.Buffer
6603		io.Copy(&snapshot, ringBuffer)
6604		err = &smithy.DeserializationError{
6605			Err:      fmt.Errorf("failed to decode response body, %w", err),
6606			Snapshot: snapshot.Bytes(),
6607		}
6608		return out, metadata, err
6609	}
6610
6611	return out, metadata, err
6612}
6613
6614func awsAwsjson11_deserializeOpErrorListRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6615	var errorBuffer bytes.Buffer
6616	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6617		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6618	}
6619	errorBody := bytes.NewReader(errorBuffer.Bytes())
6620
6621	errorCode := "UnknownError"
6622	errorMessage := errorCode
6623
6624	code := response.Header.Get("X-Amzn-ErrorType")
6625	if len(code) != 0 {
6626		errorCode = restjson.SanitizeErrorCode(code)
6627	}
6628
6629	var buff [1024]byte
6630	ringBuffer := smithyio.NewRingBuffer(buff[:])
6631
6632	body := io.TeeReader(errorBody, ringBuffer)
6633	decoder := json.NewDecoder(body)
6634	decoder.UseNumber()
6635	code, message, err := restjson.GetErrorInfo(decoder)
6636	if err != nil {
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 err
6644	}
6645
6646	errorBody.Seek(0, io.SeekStart)
6647	if len(code) != 0 {
6648		errorCode = restjson.SanitizeErrorCode(code)
6649	}
6650	if len(message) != 0 {
6651		errorMessage = message
6652	}
6653
6654	switch {
6655	case strings.EqualFold("WAFInternalErrorException", errorCode):
6656		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6657
6658	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6659		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6660
6661	default:
6662		genericError := &smithy.GenericAPIError{
6663			Code:    errorCode,
6664			Message: errorMessage,
6665		}
6666		return genericError
6667
6668	}
6669}
6670
6671type awsAwsjson11_deserializeOpListSizeConstraintSets struct {
6672}
6673
6674func (*awsAwsjson11_deserializeOpListSizeConstraintSets) ID() string {
6675	return "OperationDeserializer"
6676}
6677
6678func (m *awsAwsjson11_deserializeOpListSizeConstraintSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6679	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6680) {
6681	out, metadata, err = next.HandleDeserialize(ctx, in)
6682	if err != nil {
6683		return out, metadata, err
6684	}
6685
6686	response, ok := out.RawResponse.(*smithyhttp.Response)
6687	if !ok {
6688		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6689	}
6690
6691	if response.StatusCode < 200 || response.StatusCode >= 300 {
6692		return out, metadata, awsAwsjson11_deserializeOpErrorListSizeConstraintSets(response, &metadata)
6693	}
6694	output := &ListSizeConstraintSetsOutput{}
6695	out.Result = output
6696
6697	var buff [1024]byte
6698	ringBuffer := smithyio.NewRingBuffer(buff[:])
6699
6700	body := io.TeeReader(response.Body, ringBuffer)
6701	decoder := json.NewDecoder(body)
6702	decoder.UseNumber()
6703	var shape interface{}
6704	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6705		var snapshot bytes.Buffer
6706		io.Copy(&snapshot, ringBuffer)
6707		err = &smithy.DeserializationError{
6708			Err:      fmt.Errorf("failed to decode response body, %w", err),
6709			Snapshot: snapshot.Bytes(),
6710		}
6711		return out, metadata, err
6712	}
6713
6714	err = awsAwsjson11_deserializeOpDocumentListSizeConstraintSetsOutput(&output, shape)
6715	if err != nil {
6716		var snapshot bytes.Buffer
6717		io.Copy(&snapshot, ringBuffer)
6718		err = &smithy.DeserializationError{
6719			Err:      fmt.Errorf("failed to decode response body, %w", err),
6720			Snapshot: snapshot.Bytes(),
6721		}
6722		return out, metadata, err
6723	}
6724
6725	return out, metadata, err
6726}
6727
6728func awsAwsjson11_deserializeOpErrorListSizeConstraintSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6729	var errorBuffer bytes.Buffer
6730	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6731		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6732	}
6733	errorBody := bytes.NewReader(errorBuffer.Bytes())
6734
6735	errorCode := "UnknownError"
6736	errorMessage := errorCode
6737
6738	code := response.Header.Get("X-Amzn-ErrorType")
6739	if len(code) != 0 {
6740		errorCode = restjson.SanitizeErrorCode(code)
6741	}
6742
6743	var buff [1024]byte
6744	ringBuffer := smithyio.NewRingBuffer(buff[:])
6745
6746	body := io.TeeReader(errorBody, ringBuffer)
6747	decoder := json.NewDecoder(body)
6748	decoder.UseNumber()
6749	code, message, err := restjson.GetErrorInfo(decoder)
6750	if err != nil {
6751		var snapshot bytes.Buffer
6752		io.Copy(&snapshot, ringBuffer)
6753		err = &smithy.DeserializationError{
6754			Err:      fmt.Errorf("failed to decode response body, %w", err),
6755			Snapshot: snapshot.Bytes(),
6756		}
6757		return err
6758	}
6759
6760	errorBody.Seek(0, io.SeekStart)
6761	if len(code) != 0 {
6762		errorCode = restjson.SanitizeErrorCode(code)
6763	}
6764	if len(message) != 0 {
6765		errorMessage = message
6766	}
6767
6768	switch {
6769	case strings.EqualFold("WAFInternalErrorException", errorCode):
6770		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6771
6772	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6773		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6774
6775	default:
6776		genericError := &smithy.GenericAPIError{
6777			Code:    errorCode,
6778			Message: errorMessage,
6779		}
6780		return genericError
6781
6782	}
6783}
6784
6785type awsAwsjson11_deserializeOpListSqlInjectionMatchSets struct {
6786}
6787
6788func (*awsAwsjson11_deserializeOpListSqlInjectionMatchSets) ID() string {
6789	return "OperationDeserializer"
6790}
6791
6792func (m *awsAwsjson11_deserializeOpListSqlInjectionMatchSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6793	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6794) {
6795	out, metadata, err = next.HandleDeserialize(ctx, in)
6796	if err != nil {
6797		return out, metadata, err
6798	}
6799
6800	response, ok := out.RawResponse.(*smithyhttp.Response)
6801	if !ok {
6802		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6803	}
6804
6805	if response.StatusCode < 200 || response.StatusCode >= 300 {
6806		return out, metadata, awsAwsjson11_deserializeOpErrorListSqlInjectionMatchSets(response, &metadata)
6807	}
6808	output := &ListSqlInjectionMatchSetsOutput{}
6809	out.Result = output
6810
6811	var buff [1024]byte
6812	ringBuffer := smithyio.NewRingBuffer(buff[:])
6813
6814	body := io.TeeReader(response.Body, ringBuffer)
6815	decoder := json.NewDecoder(body)
6816	decoder.UseNumber()
6817	var shape interface{}
6818	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6819		var snapshot bytes.Buffer
6820		io.Copy(&snapshot, ringBuffer)
6821		err = &smithy.DeserializationError{
6822			Err:      fmt.Errorf("failed to decode response body, %w", err),
6823			Snapshot: snapshot.Bytes(),
6824		}
6825		return out, metadata, err
6826	}
6827
6828	err = awsAwsjson11_deserializeOpDocumentListSqlInjectionMatchSetsOutput(&output, shape)
6829	if err != nil {
6830		var snapshot bytes.Buffer
6831		io.Copy(&snapshot, ringBuffer)
6832		err = &smithy.DeserializationError{
6833			Err:      fmt.Errorf("failed to decode response body, %w", err),
6834			Snapshot: snapshot.Bytes(),
6835		}
6836		return out, metadata, err
6837	}
6838
6839	return out, metadata, err
6840}
6841
6842func awsAwsjson11_deserializeOpErrorListSqlInjectionMatchSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6843	var errorBuffer bytes.Buffer
6844	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6845		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6846	}
6847	errorBody := bytes.NewReader(errorBuffer.Bytes())
6848
6849	errorCode := "UnknownError"
6850	errorMessage := errorCode
6851
6852	code := response.Header.Get("X-Amzn-ErrorType")
6853	if len(code) != 0 {
6854		errorCode = restjson.SanitizeErrorCode(code)
6855	}
6856
6857	var buff [1024]byte
6858	ringBuffer := smithyio.NewRingBuffer(buff[:])
6859
6860	body := io.TeeReader(errorBody, ringBuffer)
6861	decoder := json.NewDecoder(body)
6862	decoder.UseNumber()
6863	code, message, err := restjson.GetErrorInfo(decoder)
6864	if err != nil {
6865		var snapshot bytes.Buffer
6866		io.Copy(&snapshot, ringBuffer)
6867		err = &smithy.DeserializationError{
6868			Err:      fmt.Errorf("failed to decode response body, %w", err),
6869			Snapshot: snapshot.Bytes(),
6870		}
6871		return err
6872	}
6873
6874	errorBody.Seek(0, io.SeekStart)
6875	if len(code) != 0 {
6876		errorCode = restjson.SanitizeErrorCode(code)
6877	}
6878	if len(message) != 0 {
6879		errorMessage = message
6880	}
6881
6882	switch {
6883	case strings.EqualFold("WAFInternalErrorException", errorCode):
6884		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6885
6886	case strings.EqualFold("WAFInvalidAccountException", errorCode):
6887		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
6888
6889	default:
6890		genericError := &smithy.GenericAPIError{
6891			Code:    errorCode,
6892			Message: errorMessage,
6893		}
6894		return genericError
6895
6896	}
6897}
6898
6899type awsAwsjson11_deserializeOpListSubscribedRuleGroups struct {
6900}
6901
6902func (*awsAwsjson11_deserializeOpListSubscribedRuleGroups) ID() string {
6903	return "OperationDeserializer"
6904}
6905
6906func (m *awsAwsjson11_deserializeOpListSubscribedRuleGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6907	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6908) {
6909	out, metadata, err = next.HandleDeserialize(ctx, in)
6910	if err != nil {
6911		return out, metadata, err
6912	}
6913
6914	response, ok := out.RawResponse.(*smithyhttp.Response)
6915	if !ok {
6916		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6917	}
6918
6919	if response.StatusCode < 200 || response.StatusCode >= 300 {
6920		return out, metadata, awsAwsjson11_deserializeOpErrorListSubscribedRuleGroups(response, &metadata)
6921	}
6922	output := &ListSubscribedRuleGroupsOutput{}
6923	out.Result = output
6924
6925	var buff [1024]byte
6926	ringBuffer := smithyio.NewRingBuffer(buff[:])
6927
6928	body := io.TeeReader(response.Body, ringBuffer)
6929	decoder := json.NewDecoder(body)
6930	decoder.UseNumber()
6931	var shape interface{}
6932	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6933		var snapshot bytes.Buffer
6934		io.Copy(&snapshot, ringBuffer)
6935		err = &smithy.DeserializationError{
6936			Err:      fmt.Errorf("failed to decode response body, %w", err),
6937			Snapshot: snapshot.Bytes(),
6938		}
6939		return out, metadata, err
6940	}
6941
6942	err = awsAwsjson11_deserializeOpDocumentListSubscribedRuleGroupsOutput(&output, shape)
6943	if err != nil {
6944		var snapshot bytes.Buffer
6945		io.Copy(&snapshot, ringBuffer)
6946		err = &smithy.DeserializationError{
6947			Err:      fmt.Errorf("failed to decode response body, %w", err),
6948			Snapshot: snapshot.Bytes(),
6949		}
6950		return out, metadata, err
6951	}
6952
6953	return out, metadata, err
6954}
6955
6956func awsAwsjson11_deserializeOpErrorListSubscribedRuleGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6957	var errorBuffer bytes.Buffer
6958	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6959		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6960	}
6961	errorBody := bytes.NewReader(errorBuffer.Bytes())
6962
6963	errorCode := "UnknownError"
6964	errorMessage := errorCode
6965
6966	code := response.Header.Get("X-Amzn-ErrorType")
6967	if len(code) != 0 {
6968		errorCode = restjson.SanitizeErrorCode(code)
6969	}
6970
6971	var buff [1024]byte
6972	ringBuffer := smithyio.NewRingBuffer(buff[:])
6973
6974	body := io.TeeReader(errorBody, ringBuffer)
6975	decoder := json.NewDecoder(body)
6976	decoder.UseNumber()
6977	code, message, err := restjson.GetErrorInfo(decoder)
6978	if err != nil {
6979		var snapshot bytes.Buffer
6980		io.Copy(&snapshot, ringBuffer)
6981		err = &smithy.DeserializationError{
6982			Err:      fmt.Errorf("failed to decode response body, %w", err),
6983			Snapshot: snapshot.Bytes(),
6984		}
6985		return err
6986	}
6987
6988	errorBody.Seek(0, io.SeekStart)
6989	if len(code) != 0 {
6990		errorCode = restjson.SanitizeErrorCode(code)
6991	}
6992	if len(message) != 0 {
6993		errorMessage = message
6994	}
6995
6996	switch {
6997	case strings.EqualFold("WAFInternalErrorException", errorCode):
6998		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
6999
7000	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7001		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7002
7003	default:
7004		genericError := &smithy.GenericAPIError{
7005			Code:    errorCode,
7006			Message: errorMessage,
7007		}
7008		return genericError
7009
7010	}
7011}
7012
7013type awsAwsjson11_deserializeOpListTagsForResource struct {
7014}
7015
7016func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
7017	return "OperationDeserializer"
7018}
7019
7020func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7021	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7022) {
7023	out, metadata, err = next.HandleDeserialize(ctx, in)
7024	if err != nil {
7025		return out, metadata, err
7026	}
7027
7028	response, ok := out.RawResponse.(*smithyhttp.Response)
7029	if !ok {
7030		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7031	}
7032
7033	if response.StatusCode < 200 || response.StatusCode >= 300 {
7034		return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
7035	}
7036	output := &ListTagsForResourceOutput{}
7037	out.Result = output
7038
7039	var buff [1024]byte
7040	ringBuffer := smithyio.NewRingBuffer(buff[:])
7041
7042	body := io.TeeReader(response.Body, ringBuffer)
7043	decoder := json.NewDecoder(body)
7044	decoder.UseNumber()
7045	var shape interface{}
7046	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7047		var snapshot bytes.Buffer
7048		io.Copy(&snapshot, ringBuffer)
7049		err = &smithy.DeserializationError{
7050			Err:      fmt.Errorf("failed to decode response body, %w", err),
7051			Snapshot: snapshot.Bytes(),
7052		}
7053		return out, metadata, err
7054	}
7055
7056	err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
7057	if err != nil {
7058		var snapshot bytes.Buffer
7059		io.Copy(&snapshot, ringBuffer)
7060		err = &smithy.DeserializationError{
7061			Err:      fmt.Errorf("failed to decode response body, %w", err),
7062			Snapshot: snapshot.Bytes(),
7063		}
7064		return out, metadata, err
7065	}
7066
7067	return out, metadata, err
7068}
7069
7070func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7071	var errorBuffer bytes.Buffer
7072	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7073		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7074	}
7075	errorBody := bytes.NewReader(errorBuffer.Bytes())
7076
7077	errorCode := "UnknownError"
7078	errorMessage := errorCode
7079
7080	code := response.Header.Get("X-Amzn-ErrorType")
7081	if len(code) != 0 {
7082		errorCode = restjson.SanitizeErrorCode(code)
7083	}
7084
7085	var buff [1024]byte
7086	ringBuffer := smithyio.NewRingBuffer(buff[:])
7087
7088	body := io.TeeReader(errorBody, ringBuffer)
7089	decoder := json.NewDecoder(body)
7090	decoder.UseNumber()
7091	code, message, err := restjson.GetErrorInfo(decoder)
7092	if err != nil {
7093		var snapshot bytes.Buffer
7094		io.Copy(&snapshot, ringBuffer)
7095		err = &smithy.DeserializationError{
7096			Err:      fmt.Errorf("failed to decode response body, %w", err),
7097			Snapshot: snapshot.Bytes(),
7098		}
7099		return err
7100	}
7101
7102	errorBody.Seek(0, io.SeekStart)
7103	if len(code) != 0 {
7104		errorCode = restjson.SanitizeErrorCode(code)
7105	}
7106	if len(message) != 0 {
7107		errorMessage = message
7108	}
7109
7110	switch {
7111	case strings.EqualFold("WAFBadRequestException", errorCode):
7112		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
7113
7114	case strings.EqualFold("WAFInternalErrorException", errorCode):
7115		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7116
7117	case strings.EqualFold("WAFInvalidParameterException", errorCode):
7118		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
7119
7120	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7121		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7122
7123	case strings.EqualFold("WAFTagOperationException", errorCode):
7124		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
7125
7126	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
7127		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
7128
7129	default:
7130		genericError := &smithy.GenericAPIError{
7131			Code:    errorCode,
7132			Message: errorMessage,
7133		}
7134		return genericError
7135
7136	}
7137}
7138
7139type awsAwsjson11_deserializeOpListWebACLs struct {
7140}
7141
7142func (*awsAwsjson11_deserializeOpListWebACLs) ID() string {
7143	return "OperationDeserializer"
7144}
7145
7146func (m *awsAwsjson11_deserializeOpListWebACLs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7147	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7148) {
7149	out, metadata, err = next.HandleDeserialize(ctx, in)
7150	if err != nil {
7151		return out, metadata, err
7152	}
7153
7154	response, ok := out.RawResponse.(*smithyhttp.Response)
7155	if !ok {
7156		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7157	}
7158
7159	if response.StatusCode < 200 || response.StatusCode >= 300 {
7160		return out, metadata, awsAwsjson11_deserializeOpErrorListWebACLs(response, &metadata)
7161	}
7162	output := &ListWebACLsOutput{}
7163	out.Result = output
7164
7165	var buff [1024]byte
7166	ringBuffer := smithyio.NewRingBuffer(buff[:])
7167
7168	body := io.TeeReader(response.Body, ringBuffer)
7169	decoder := json.NewDecoder(body)
7170	decoder.UseNumber()
7171	var shape interface{}
7172	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7173		var snapshot bytes.Buffer
7174		io.Copy(&snapshot, ringBuffer)
7175		err = &smithy.DeserializationError{
7176			Err:      fmt.Errorf("failed to decode response body, %w", err),
7177			Snapshot: snapshot.Bytes(),
7178		}
7179		return out, metadata, err
7180	}
7181
7182	err = awsAwsjson11_deserializeOpDocumentListWebACLsOutput(&output, shape)
7183	if err != nil {
7184		var snapshot bytes.Buffer
7185		io.Copy(&snapshot, ringBuffer)
7186		err = &smithy.DeserializationError{
7187			Err:      fmt.Errorf("failed to decode response body, %w", err),
7188			Snapshot: snapshot.Bytes(),
7189		}
7190		return out, metadata, err
7191	}
7192
7193	return out, metadata, err
7194}
7195
7196func awsAwsjson11_deserializeOpErrorListWebACLs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7197	var errorBuffer bytes.Buffer
7198	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7199		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7200	}
7201	errorBody := bytes.NewReader(errorBuffer.Bytes())
7202
7203	errorCode := "UnknownError"
7204	errorMessage := errorCode
7205
7206	code := response.Header.Get("X-Amzn-ErrorType")
7207	if len(code) != 0 {
7208		errorCode = restjson.SanitizeErrorCode(code)
7209	}
7210
7211	var buff [1024]byte
7212	ringBuffer := smithyio.NewRingBuffer(buff[:])
7213
7214	body := io.TeeReader(errorBody, ringBuffer)
7215	decoder := json.NewDecoder(body)
7216	decoder.UseNumber()
7217	code, message, err := restjson.GetErrorInfo(decoder)
7218	if err != nil {
7219		var snapshot bytes.Buffer
7220		io.Copy(&snapshot, ringBuffer)
7221		err = &smithy.DeserializationError{
7222			Err:      fmt.Errorf("failed to decode response body, %w", err),
7223			Snapshot: snapshot.Bytes(),
7224		}
7225		return err
7226	}
7227
7228	errorBody.Seek(0, io.SeekStart)
7229	if len(code) != 0 {
7230		errorCode = restjson.SanitizeErrorCode(code)
7231	}
7232	if len(message) != 0 {
7233		errorMessage = message
7234	}
7235
7236	switch {
7237	case strings.EqualFold("WAFInternalErrorException", errorCode):
7238		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7239
7240	case strings.EqualFold("WAFInvalidAccountException", errorCode):
7241		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
7242
7243	default:
7244		genericError := &smithy.GenericAPIError{
7245			Code:    errorCode,
7246			Message: errorMessage,
7247		}
7248		return genericError
7249
7250	}
7251}
7252
7253type awsAwsjson11_deserializeOpListXssMatchSets struct {
7254}
7255
7256func (*awsAwsjson11_deserializeOpListXssMatchSets) ID() string {
7257	return "OperationDeserializer"
7258}
7259
7260func (m *awsAwsjson11_deserializeOpListXssMatchSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7261	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7262) {
7263	out, metadata, err = next.HandleDeserialize(ctx, in)
7264	if err != nil {
7265		return out, metadata, err
7266	}
7267
7268	response, ok := out.RawResponse.(*smithyhttp.Response)
7269	if !ok {
7270		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7271	}
7272
7273	if response.StatusCode < 200 || response.StatusCode >= 300 {
7274		return out, metadata, awsAwsjson11_deserializeOpErrorListXssMatchSets(response, &metadata)
7275	}
7276	output := &ListXssMatchSetsOutput{}
7277	out.Result = output
7278
7279	var buff [1024]byte
7280	ringBuffer := smithyio.NewRingBuffer(buff[:])
7281
7282	body := io.TeeReader(response.Body, ringBuffer)
7283	decoder := json.NewDecoder(body)
7284	decoder.UseNumber()
7285	var shape interface{}
7286	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7287		var snapshot bytes.Buffer
7288		io.Copy(&snapshot, ringBuffer)
7289		err = &smithy.DeserializationError{
7290			Err:      fmt.Errorf("failed to decode response body, %w", err),
7291			Snapshot: snapshot.Bytes(),
7292		}
7293		return out, metadata, err
7294	}
7295
7296	err = awsAwsjson11_deserializeOpDocumentListXssMatchSetsOutput(&output, shape)
7297	if err != nil {
7298		var snapshot bytes.Buffer
7299		io.Copy(&snapshot, ringBuffer)
7300		err = &smithy.DeserializationError{
7301			Err:      fmt.Errorf("failed to decode response body, %w", err),
7302			Snapshot: snapshot.Bytes(),
7303		}
7304		return out, metadata, err
7305	}
7306
7307	return out, metadata, err
7308}
7309
7310func awsAwsjson11_deserializeOpErrorListXssMatchSets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7311	var errorBuffer bytes.Buffer
7312	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7313		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7314	}
7315	errorBody := bytes.NewReader(errorBuffer.Bytes())
7316
7317	errorCode := "UnknownError"
7318	errorMessage := errorCode
7319
7320	code := response.Header.Get("X-Amzn-ErrorType")
7321	if len(code) != 0 {
7322		errorCode = restjson.SanitizeErrorCode(code)
7323	}
7324
7325	var buff [1024]byte
7326	ringBuffer := smithyio.NewRingBuffer(buff[:])
7327
7328	body := io.TeeReader(errorBody, ringBuffer)
7329	decoder := json.NewDecoder(body)
7330	decoder.UseNumber()
7331	code, message, err := restjson.GetErrorInfo(decoder)
7332	if err != nil {
7333		var snapshot bytes.Buffer
7334		io.Copy(&snapshot, ringBuffer)
7335		err = &smithy.DeserializationError{
7336			Err:      fmt.Errorf("failed to decode response body, %w", err),
7337			Snapshot: snapshot.Bytes(),
7338		}
7339		return err
7340	}
7341
7342	errorBody.Seek(0, io.SeekStart)
7343	if len(code) != 0 {
7344		errorCode = restjson.SanitizeErrorCode(code)
7345	}
7346	if len(message) != 0 {
7347		errorMessage = message
7348	}
7349
7350	switch {
7351	case strings.EqualFold("WAFInternalErrorException", errorCode):
7352		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7353
7354	case strings.EqualFold("WAFInvalidAccountException", errorCode):
7355		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
7356
7357	default:
7358		genericError := &smithy.GenericAPIError{
7359			Code:    errorCode,
7360			Message: errorMessage,
7361		}
7362		return genericError
7363
7364	}
7365}
7366
7367type awsAwsjson11_deserializeOpPutLoggingConfiguration struct {
7368}
7369
7370func (*awsAwsjson11_deserializeOpPutLoggingConfiguration) ID() string {
7371	return "OperationDeserializer"
7372}
7373
7374func (m *awsAwsjson11_deserializeOpPutLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7375	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7376) {
7377	out, metadata, err = next.HandleDeserialize(ctx, in)
7378	if err != nil {
7379		return out, metadata, err
7380	}
7381
7382	response, ok := out.RawResponse.(*smithyhttp.Response)
7383	if !ok {
7384		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7385	}
7386
7387	if response.StatusCode < 200 || response.StatusCode >= 300 {
7388		return out, metadata, awsAwsjson11_deserializeOpErrorPutLoggingConfiguration(response, &metadata)
7389	}
7390	output := &PutLoggingConfigurationOutput{}
7391	out.Result = output
7392
7393	var buff [1024]byte
7394	ringBuffer := smithyio.NewRingBuffer(buff[:])
7395
7396	body := io.TeeReader(response.Body, ringBuffer)
7397	decoder := json.NewDecoder(body)
7398	decoder.UseNumber()
7399	var shape interface{}
7400	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentPutLoggingConfigurationOutput(&output, shape)
7411	if err != nil {
7412		var snapshot bytes.Buffer
7413		io.Copy(&snapshot, ringBuffer)
7414		err = &smithy.DeserializationError{
7415			Err:      fmt.Errorf("failed to decode response body, %w", err),
7416			Snapshot: snapshot.Bytes(),
7417		}
7418		return out, metadata, err
7419	}
7420
7421	return out, metadata, err
7422}
7423
7424func awsAwsjson11_deserializeOpErrorPutLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7425	var errorBuffer bytes.Buffer
7426	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7427		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7428	}
7429	errorBody := bytes.NewReader(errorBuffer.Bytes())
7430
7431	errorCode := "UnknownError"
7432	errorMessage := errorCode
7433
7434	code := response.Header.Get("X-Amzn-ErrorType")
7435	if len(code) != 0 {
7436		errorCode = restjson.SanitizeErrorCode(code)
7437	}
7438
7439	var buff [1024]byte
7440	ringBuffer := smithyio.NewRingBuffer(buff[:])
7441
7442	body := io.TeeReader(errorBody, ringBuffer)
7443	decoder := json.NewDecoder(body)
7444	decoder.UseNumber()
7445	code, message, err := restjson.GetErrorInfo(decoder)
7446	if err != nil {
7447		var snapshot bytes.Buffer
7448		io.Copy(&snapshot, ringBuffer)
7449		err = &smithy.DeserializationError{
7450			Err:      fmt.Errorf("failed to decode response body, %w", err),
7451			Snapshot: snapshot.Bytes(),
7452		}
7453		return err
7454	}
7455
7456	errorBody.Seek(0, io.SeekStart)
7457	if len(code) != 0 {
7458		errorCode = restjson.SanitizeErrorCode(code)
7459	}
7460	if len(message) != 0 {
7461		errorMessage = message
7462	}
7463
7464	switch {
7465	case strings.EqualFold("WAFInternalErrorException", errorCode):
7466		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7467
7468	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7469		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7470
7471	case strings.EqualFold("WAFServiceLinkedRoleErrorException", errorCode):
7472		return awsAwsjson11_deserializeErrorWAFServiceLinkedRoleErrorException(response, errorBody)
7473
7474	case strings.EqualFold("WAFStaleDataException", errorCode):
7475		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
7476
7477	default:
7478		genericError := &smithy.GenericAPIError{
7479			Code:    errorCode,
7480			Message: errorMessage,
7481		}
7482		return genericError
7483
7484	}
7485}
7486
7487type awsAwsjson11_deserializeOpPutPermissionPolicy struct {
7488}
7489
7490func (*awsAwsjson11_deserializeOpPutPermissionPolicy) ID() string {
7491	return "OperationDeserializer"
7492}
7493
7494func (m *awsAwsjson11_deserializeOpPutPermissionPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7495	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7496) {
7497	out, metadata, err = next.HandleDeserialize(ctx, in)
7498	if err != nil {
7499		return out, metadata, err
7500	}
7501
7502	response, ok := out.RawResponse.(*smithyhttp.Response)
7503	if !ok {
7504		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7505	}
7506
7507	if response.StatusCode < 200 || response.StatusCode >= 300 {
7508		return out, metadata, awsAwsjson11_deserializeOpErrorPutPermissionPolicy(response, &metadata)
7509	}
7510	output := &PutPermissionPolicyOutput{}
7511	out.Result = output
7512
7513	var buff [1024]byte
7514	ringBuffer := smithyio.NewRingBuffer(buff[:])
7515
7516	body := io.TeeReader(response.Body, ringBuffer)
7517	decoder := json.NewDecoder(body)
7518	decoder.UseNumber()
7519	var shape interface{}
7520	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7521		var snapshot bytes.Buffer
7522		io.Copy(&snapshot, ringBuffer)
7523		err = &smithy.DeserializationError{
7524			Err:      fmt.Errorf("failed to decode response body, %w", err),
7525			Snapshot: snapshot.Bytes(),
7526		}
7527		return out, metadata, err
7528	}
7529
7530	err = awsAwsjson11_deserializeOpDocumentPutPermissionPolicyOutput(&output, shape)
7531	if err != nil {
7532		var snapshot bytes.Buffer
7533		io.Copy(&snapshot, ringBuffer)
7534		err = &smithy.DeserializationError{
7535			Err:      fmt.Errorf("failed to decode response body, %w", err),
7536			Snapshot: snapshot.Bytes(),
7537		}
7538		return out, metadata, err
7539	}
7540
7541	return out, metadata, err
7542}
7543
7544func awsAwsjson11_deserializeOpErrorPutPermissionPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7545	var errorBuffer bytes.Buffer
7546	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7547		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7548	}
7549	errorBody := bytes.NewReader(errorBuffer.Bytes())
7550
7551	errorCode := "UnknownError"
7552	errorMessage := errorCode
7553
7554	code := response.Header.Get("X-Amzn-ErrorType")
7555	if len(code) != 0 {
7556		errorCode = restjson.SanitizeErrorCode(code)
7557	}
7558
7559	var buff [1024]byte
7560	ringBuffer := smithyio.NewRingBuffer(buff[:])
7561
7562	body := io.TeeReader(errorBody, ringBuffer)
7563	decoder := json.NewDecoder(body)
7564	decoder.UseNumber()
7565	code, message, err := restjson.GetErrorInfo(decoder)
7566	if err != nil {
7567		var snapshot bytes.Buffer
7568		io.Copy(&snapshot, ringBuffer)
7569		err = &smithy.DeserializationError{
7570			Err:      fmt.Errorf("failed to decode response body, %w", err),
7571			Snapshot: snapshot.Bytes(),
7572		}
7573		return err
7574	}
7575
7576	errorBody.Seek(0, io.SeekStart)
7577	if len(code) != 0 {
7578		errorCode = restjson.SanitizeErrorCode(code)
7579	}
7580	if len(message) != 0 {
7581		errorMessage = message
7582	}
7583
7584	switch {
7585	case strings.EqualFold("WAFInternalErrorException", errorCode):
7586		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7587
7588	case strings.EqualFold("WAFInvalidPermissionPolicyException", errorCode):
7589		return awsAwsjson11_deserializeErrorWAFInvalidPermissionPolicyException(response, errorBody)
7590
7591	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7592		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7593
7594	case strings.EqualFold("WAFStaleDataException", errorCode):
7595		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
7596
7597	default:
7598		genericError := &smithy.GenericAPIError{
7599			Code:    errorCode,
7600			Message: errorMessage,
7601		}
7602		return genericError
7603
7604	}
7605}
7606
7607type awsAwsjson11_deserializeOpTagResource struct {
7608}
7609
7610func (*awsAwsjson11_deserializeOpTagResource) ID() string {
7611	return "OperationDeserializer"
7612}
7613
7614func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7615	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7616) {
7617	out, metadata, err = next.HandleDeserialize(ctx, in)
7618	if err != nil {
7619		return out, metadata, err
7620	}
7621
7622	response, ok := out.RawResponse.(*smithyhttp.Response)
7623	if !ok {
7624		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7625	}
7626
7627	if response.StatusCode < 200 || response.StatusCode >= 300 {
7628		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
7629	}
7630	output := &TagResourceOutput{}
7631	out.Result = output
7632
7633	var buff [1024]byte
7634	ringBuffer := smithyio.NewRingBuffer(buff[:])
7635
7636	body := io.TeeReader(response.Body, ringBuffer)
7637	decoder := json.NewDecoder(body)
7638	decoder.UseNumber()
7639	var shape interface{}
7640	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7641		var snapshot bytes.Buffer
7642		io.Copy(&snapshot, ringBuffer)
7643		err = &smithy.DeserializationError{
7644			Err:      fmt.Errorf("failed to decode response body, %w", err),
7645			Snapshot: snapshot.Bytes(),
7646		}
7647		return out, metadata, err
7648	}
7649
7650	err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
7651	if err != nil {
7652		var snapshot bytes.Buffer
7653		io.Copy(&snapshot, ringBuffer)
7654		err = &smithy.DeserializationError{
7655			Err:      fmt.Errorf("failed to decode response body, %w", err),
7656			Snapshot: snapshot.Bytes(),
7657		}
7658		return out, metadata, err
7659	}
7660
7661	return out, metadata, err
7662}
7663
7664func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7665	var errorBuffer bytes.Buffer
7666	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7667		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7668	}
7669	errorBody := bytes.NewReader(errorBuffer.Bytes())
7670
7671	errorCode := "UnknownError"
7672	errorMessage := errorCode
7673
7674	code := response.Header.Get("X-Amzn-ErrorType")
7675	if len(code) != 0 {
7676		errorCode = restjson.SanitizeErrorCode(code)
7677	}
7678
7679	var buff [1024]byte
7680	ringBuffer := smithyio.NewRingBuffer(buff[:])
7681
7682	body := io.TeeReader(errorBody, ringBuffer)
7683	decoder := json.NewDecoder(body)
7684	decoder.UseNumber()
7685	code, message, err := restjson.GetErrorInfo(decoder)
7686	if err != nil {
7687		var snapshot bytes.Buffer
7688		io.Copy(&snapshot, ringBuffer)
7689		err = &smithy.DeserializationError{
7690			Err:      fmt.Errorf("failed to decode response body, %w", err),
7691			Snapshot: snapshot.Bytes(),
7692		}
7693		return err
7694	}
7695
7696	errorBody.Seek(0, io.SeekStart)
7697	if len(code) != 0 {
7698		errorCode = restjson.SanitizeErrorCode(code)
7699	}
7700	if len(message) != 0 {
7701		errorMessage = message
7702	}
7703
7704	switch {
7705	case strings.EqualFold("WAFBadRequestException", errorCode):
7706		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
7707
7708	case strings.EqualFold("WAFInternalErrorException", errorCode):
7709		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7710
7711	case strings.EqualFold("WAFInvalidParameterException", errorCode):
7712		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
7713
7714	case strings.EqualFold("WAFLimitsExceededException", errorCode):
7715		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
7716
7717	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7718		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7719
7720	case strings.EqualFold("WAFTagOperationException", errorCode):
7721		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
7722
7723	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
7724		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
7725
7726	default:
7727		genericError := &smithy.GenericAPIError{
7728			Code:    errorCode,
7729			Message: errorMessage,
7730		}
7731		return genericError
7732
7733	}
7734}
7735
7736type awsAwsjson11_deserializeOpUntagResource struct {
7737}
7738
7739func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
7740	return "OperationDeserializer"
7741}
7742
7743func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7744	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7745) {
7746	out, metadata, err = next.HandleDeserialize(ctx, in)
7747	if err != nil {
7748		return out, metadata, err
7749	}
7750
7751	response, ok := out.RawResponse.(*smithyhttp.Response)
7752	if !ok {
7753		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7754	}
7755
7756	if response.StatusCode < 200 || response.StatusCode >= 300 {
7757		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
7758	}
7759	output := &UntagResourceOutput{}
7760	out.Result = output
7761
7762	var buff [1024]byte
7763	ringBuffer := smithyio.NewRingBuffer(buff[:])
7764
7765	body := io.TeeReader(response.Body, ringBuffer)
7766	decoder := json.NewDecoder(body)
7767	decoder.UseNumber()
7768	var shape interface{}
7769	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7770		var snapshot bytes.Buffer
7771		io.Copy(&snapshot, ringBuffer)
7772		err = &smithy.DeserializationError{
7773			Err:      fmt.Errorf("failed to decode response body, %w", err),
7774			Snapshot: snapshot.Bytes(),
7775		}
7776		return out, metadata, err
7777	}
7778
7779	err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
7780	if err != nil {
7781		var snapshot bytes.Buffer
7782		io.Copy(&snapshot, ringBuffer)
7783		err = &smithy.DeserializationError{
7784			Err:      fmt.Errorf("failed to decode response body, %w", err),
7785			Snapshot: snapshot.Bytes(),
7786		}
7787		return out, metadata, err
7788	}
7789
7790	return out, metadata, err
7791}
7792
7793func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7794	var errorBuffer bytes.Buffer
7795	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7796		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7797	}
7798	errorBody := bytes.NewReader(errorBuffer.Bytes())
7799
7800	errorCode := "UnknownError"
7801	errorMessage := errorCode
7802
7803	code := response.Header.Get("X-Amzn-ErrorType")
7804	if len(code) != 0 {
7805		errorCode = restjson.SanitizeErrorCode(code)
7806	}
7807
7808	var buff [1024]byte
7809	ringBuffer := smithyio.NewRingBuffer(buff[:])
7810
7811	body := io.TeeReader(errorBody, ringBuffer)
7812	decoder := json.NewDecoder(body)
7813	decoder.UseNumber()
7814	code, message, err := restjson.GetErrorInfo(decoder)
7815	if err != nil {
7816		var snapshot bytes.Buffer
7817		io.Copy(&snapshot, ringBuffer)
7818		err = &smithy.DeserializationError{
7819			Err:      fmt.Errorf("failed to decode response body, %w", err),
7820			Snapshot: snapshot.Bytes(),
7821		}
7822		return err
7823	}
7824
7825	errorBody.Seek(0, io.SeekStart)
7826	if len(code) != 0 {
7827		errorCode = restjson.SanitizeErrorCode(code)
7828	}
7829	if len(message) != 0 {
7830		errorMessage = message
7831	}
7832
7833	switch {
7834	case strings.EqualFold("WAFBadRequestException", errorCode):
7835		return awsAwsjson11_deserializeErrorWAFBadRequestException(response, errorBody)
7836
7837	case strings.EqualFold("WAFInternalErrorException", errorCode):
7838		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7839
7840	case strings.EqualFold("WAFInvalidParameterException", errorCode):
7841		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
7842
7843	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7844		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7845
7846	case strings.EqualFold("WAFTagOperationException", errorCode):
7847		return awsAwsjson11_deserializeErrorWAFTagOperationException(response, errorBody)
7848
7849	case strings.EqualFold("WAFTagOperationInternalErrorException", errorCode):
7850		return awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response, errorBody)
7851
7852	default:
7853		genericError := &smithy.GenericAPIError{
7854			Code:    errorCode,
7855			Message: errorMessage,
7856		}
7857		return genericError
7858
7859	}
7860}
7861
7862type awsAwsjson11_deserializeOpUpdateByteMatchSet struct {
7863}
7864
7865func (*awsAwsjson11_deserializeOpUpdateByteMatchSet) ID() string {
7866	return "OperationDeserializer"
7867}
7868
7869func (m *awsAwsjson11_deserializeOpUpdateByteMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7870	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7871) {
7872	out, metadata, err = next.HandleDeserialize(ctx, in)
7873	if err != nil {
7874		return out, metadata, err
7875	}
7876
7877	response, ok := out.RawResponse.(*smithyhttp.Response)
7878	if !ok {
7879		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7880	}
7881
7882	if response.StatusCode < 200 || response.StatusCode >= 300 {
7883		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateByteMatchSet(response, &metadata)
7884	}
7885	output := &UpdateByteMatchSetOutput{}
7886	out.Result = output
7887
7888	var buff [1024]byte
7889	ringBuffer := smithyio.NewRingBuffer(buff[:])
7890
7891	body := io.TeeReader(response.Body, ringBuffer)
7892	decoder := json.NewDecoder(body)
7893	decoder.UseNumber()
7894	var shape interface{}
7895	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7896		var snapshot bytes.Buffer
7897		io.Copy(&snapshot, ringBuffer)
7898		err = &smithy.DeserializationError{
7899			Err:      fmt.Errorf("failed to decode response body, %w", err),
7900			Snapshot: snapshot.Bytes(),
7901		}
7902		return out, metadata, err
7903	}
7904
7905	err = awsAwsjson11_deserializeOpDocumentUpdateByteMatchSetOutput(&output, shape)
7906	if err != nil {
7907		var snapshot bytes.Buffer
7908		io.Copy(&snapshot, ringBuffer)
7909		err = &smithy.DeserializationError{
7910			Err:      fmt.Errorf("failed to decode response body, %w", err),
7911			Snapshot: snapshot.Bytes(),
7912		}
7913		return out, metadata, err
7914	}
7915
7916	return out, metadata, err
7917}
7918
7919func awsAwsjson11_deserializeOpErrorUpdateByteMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7920	var errorBuffer bytes.Buffer
7921	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7922		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7923	}
7924	errorBody := bytes.NewReader(errorBuffer.Bytes())
7925
7926	errorCode := "UnknownError"
7927	errorMessage := errorCode
7928
7929	code := response.Header.Get("X-Amzn-ErrorType")
7930	if len(code) != 0 {
7931		errorCode = restjson.SanitizeErrorCode(code)
7932	}
7933
7934	var buff [1024]byte
7935	ringBuffer := smithyio.NewRingBuffer(buff[:])
7936
7937	body := io.TeeReader(errorBody, ringBuffer)
7938	decoder := json.NewDecoder(body)
7939	decoder.UseNumber()
7940	code, message, err := restjson.GetErrorInfo(decoder)
7941	if err != nil {
7942		var snapshot bytes.Buffer
7943		io.Copy(&snapshot, ringBuffer)
7944		err = &smithy.DeserializationError{
7945			Err:      fmt.Errorf("failed to decode response body, %w", err),
7946			Snapshot: snapshot.Bytes(),
7947		}
7948		return err
7949	}
7950
7951	errorBody.Seek(0, io.SeekStart)
7952	if len(code) != 0 {
7953		errorCode = restjson.SanitizeErrorCode(code)
7954	}
7955	if len(message) != 0 {
7956		errorMessage = message
7957	}
7958
7959	switch {
7960	case strings.EqualFold("WAFInternalErrorException", errorCode):
7961		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
7962
7963	case strings.EqualFold("WAFInvalidAccountException", errorCode):
7964		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
7965
7966	case strings.EqualFold("WAFInvalidOperationException", errorCode):
7967		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
7968
7969	case strings.EqualFold("WAFInvalidParameterException", errorCode):
7970		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
7971
7972	case strings.EqualFold("WAFLimitsExceededException", errorCode):
7973		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
7974
7975	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
7976		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
7977
7978	case strings.EqualFold("WAFNonexistentItemException", errorCode):
7979		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
7980
7981	case strings.EqualFold("WAFStaleDataException", errorCode):
7982		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
7983
7984	default:
7985		genericError := &smithy.GenericAPIError{
7986			Code:    errorCode,
7987			Message: errorMessage,
7988		}
7989		return genericError
7990
7991	}
7992}
7993
7994type awsAwsjson11_deserializeOpUpdateGeoMatchSet struct {
7995}
7996
7997func (*awsAwsjson11_deserializeOpUpdateGeoMatchSet) ID() string {
7998	return "OperationDeserializer"
7999}
8000
8001func (m *awsAwsjson11_deserializeOpUpdateGeoMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8002	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8003) {
8004	out, metadata, err = next.HandleDeserialize(ctx, in)
8005	if err != nil {
8006		return out, metadata, err
8007	}
8008
8009	response, ok := out.RawResponse.(*smithyhttp.Response)
8010	if !ok {
8011		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8012	}
8013
8014	if response.StatusCode < 200 || response.StatusCode >= 300 {
8015		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateGeoMatchSet(response, &metadata)
8016	}
8017	output := &UpdateGeoMatchSetOutput{}
8018	out.Result = output
8019
8020	var buff [1024]byte
8021	ringBuffer := smithyio.NewRingBuffer(buff[:])
8022
8023	body := io.TeeReader(response.Body, ringBuffer)
8024	decoder := json.NewDecoder(body)
8025	decoder.UseNumber()
8026	var shape interface{}
8027	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8028		var snapshot bytes.Buffer
8029		io.Copy(&snapshot, ringBuffer)
8030		err = &smithy.DeserializationError{
8031			Err:      fmt.Errorf("failed to decode response body, %w", err),
8032			Snapshot: snapshot.Bytes(),
8033		}
8034		return out, metadata, err
8035	}
8036
8037	err = awsAwsjson11_deserializeOpDocumentUpdateGeoMatchSetOutput(&output, shape)
8038	if err != nil {
8039		var snapshot bytes.Buffer
8040		io.Copy(&snapshot, ringBuffer)
8041		err = &smithy.DeserializationError{
8042			Err:      fmt.Errorf("failed to decode response body, %w", err),
8043			Snapshot: snapshot.Bytes(),
8044		}
8045		return out, metadata, err
8046	}
8047
8048	return out, metadata, err
8049}
8050
8051func awsAwsjson11_deserializeOpErrorUpdateGeoMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8052	var errorBuffer bytes.Buffer
8053	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8054		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8055	}
8056	errorBody := bytes.NewReader(errorBuffer.Bytes())
8057
8058	errorCode := "UnknownError"
8059	errorMessage := errorCode
8060
8061	code := response.Header.Get("X-Amzn-ErrorType")
8062	if len(code) != 0 {
8063		errorCode = restjson.SanitizeErrorCode(code)
8064	}
8065
8066	var buff [1024]byte
8067	ringBuffer := smithyio.NewRingBuffer(buff[:])
8068
8069	body := io.TeeReader(errorBody, ringBuffer)
8070	decoder := json.NewDecoder(body)
8071	decoder.UseNumber()
8072	code, message, err := restjson.GetErrorInfo(decoder)
8073	if err != nil {
8074		var snapshot bytes.Buffer
8075		io.Copy(&snapshot, ringBuffer)
8076		err = &smithy.DeserializationError{
8077			Err:      fmt.Errorf("failed to decode response body, %w", err),
8078			Snapshot: snapshot.Bytes(),
8079		}
8080		return err
8081	}
8082
8083	errorBody.Seek(0, io.SeekStart)
8084	if len(code) != 0 {
8085		errorCode = restjson.SanitizeErrorCode(code)
8086	}
8087	if len(message) != 0 {
8088		errorMessage = message
8089	}
8090
8091	switch {
8092	case strings.EqualFold("WAFInternalErrorException", errorCode):
8093		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8094
8095	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8096		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8097
8098	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8099		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8100
8101	case strings.EqualFold("WAFInvalidParameterException", errorCode):
8102		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
8103
8104	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8105		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8106
8107	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8108		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8109
8110	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8111		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8112
8113	case strings.EqualFold("WAFReferencedItemException", errorCode):
8114		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
8115
8116	case strings.EqualFold("WAFStaleDataException", errorCode):
8117		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8118
8119	default:
8120		genericError := &smithy.GenericAPIError{
8121			Code:    errorCode,
8122			Message: errorMessage,
8123		}
8124		return genericError
8125
8126	}
8127}
8128
8129type awsAwsjson11_deserializeOpUpdateIPSet struct {
8130}
8131
8132func (*awsAwsjson11_deserializeOpUpdateIPSet) ID() string {
8133	return "OperationDeserializer"
8134}
8135
8136func (m *awsAwsjson11_deserializeOpUpdateIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8137	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8138) {
8139	out, metadata, err = next.HandleDeserialize(ctx, in)
8140	if err != nil {
8141		return out, metadata, err
8142	}
8143
8144	response, ok := out.RawResponse.(*smithyhttp.Response)
8145	if !ok {
8146		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8147	}
8148
8149	if response.StatusCode < 200 || response.StatusCode >= 300 {
8150		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateIPSet(response, &metadata)
8151	}
8152	output := &UpdateIPSetOutput{}
8153	out.Result = output
8154
8155	var buff [1024]byte
8156	ringBuffer := smithyio.NewRingBuffer(buff[:])
8157
8158	body := io.TeeReader(response.Body, ringBuffer)
8159	decoder := json.NewDecoder(body)
8160	decoder.UseNumber()
8161	var shape interface{}
8162	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8163		var snapshot bytes.Buffer
8164		io.Copy(&snapshot, ringBuffer)
8165		err = &smithy.DeserializationError{
8166			Err:      fmt.Errorf("failed to decode response body, %w", err),
8167			Snapshot: snapshot.Bytes(),
8168		}
8169		return out, metadata, err
8170	}
8171
8172	err = awsAwsjson11_deserializeOpDocumentUpdateIPSetOutput(&output, shape)
8173	if err != nil {
8174		var snapshot bytes.Buffer
8175		io.Copy(&snapshot, ringBuffer)
8176		err = &smithy.DeserializationError{
8177			Err:      fmt.Errorf("failed to decode response body, %w", err),
8178			Snapshot: snapshot.Bytes(),
8179		}
8180		return out, metadata, err
8181	}
8182
8183	return out, metadata, err
8184}
8185
8186func awsAwsjson11_deserializeOpErrorUpdateIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8187	var errorBuffer bytes.Buffer
8188	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8189		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8190	}
8191	errorBody := bytes.NewReader(errorBuffer.Bytes())
8192
8193	errorCode := "UnknownError"
8194	errorMessage := errorCode
8195
8196	code := response.Header.Get("X-Amzn-ErrorType")
8197	if len(code) != 0 {
8198		errorCode = restjson.SanitizeErrorCode(code)
8199	}
8200
8201	var buff [1024]byte
8202	ringBuffer := smithyio.NewRingBuffer(buff[:])
8203
8204	body := io.TeeReader(errorBody, ringBuffer)
8205	decoder := json.NewDecoder(body)
8206	decoder.UseNumber()
8207	code, message, err := restjson.GetErrorInfo(decoder)
8208	if err != nil {
8209		var snapshot bytes.Buffer
8210		io.Copy(&snapshot, ringBuffer)
8211		err = &smithy.DeserializationError{
8212			Err:      fmt.Errorf("failed to decode response body, %w", err),
8213			Snapshot: snapshot.Bytes(),
8214		}
8215		return err
8216	}
8217
8218	errorBody.Seek(0, io.SeekStart)
8219	if len(code) != 0 {
8220		errorCode = restjson.SanitizeErrorCode(code)
8221	}
8222	if len(message) != 0 {
8223		errorMessage = message
8224	}
8225
8226	switch {
8227	case strings.EqualFold("WAFInternalErrorException", errorCode):
8228		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8229
8230	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8231		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8232
8233	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8234		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8235
8236	case strings.EqualFold("WAFInvalidParameterException", errorCode):
8237		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
8238
8239	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8240		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8241
8242	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8243		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8244
8245	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8246		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8247
8248	case strings.EqualFold("WAFReferencedItemException", errorCode):
8249		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
8250
8251	case strings.EqualFold("WAFStaleDataException", errorCode):
8252		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8253
8254	default:
8255		genericError := &smithy.GenericAPIError{
8256			Code:    errorCode,
8257			Message: errorMessage,
8258		}
8259		return genericError
8260
8261	}
8262}
8263
8264type awsAwsjson11_deserializeOpUpdateRateBasedRule struct {
8265}
8266
8267func (*awsAwsjson11_deserializeOpUpdateRateBasedRule) ID() string {
8268	return "OperationDeserializer"
8269}
8270
8271func (m *awsAwsjson11_deserializeOpUpdateRateBasedRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8272	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8273) {
8274	out, metadata, err = next.HandleDeserialize(ctx, in)
8275	if err != nil {
8276		return out, metadata, err
8277	}
8278
8279	response, ok := out.RawResponse.(*smithyhttp.Response)
8280	if !ok {
8281		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8282	}
8283
8284	if response.StatusCode < 200 || response.StatusCode >= 300 {
8285		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRateBasedRule(response, &metadata)
8286	}
8287	output := &UpdateRateBasedRuleOutput{}
8288	out.Result = output
8289
8290	var buff [1024]byte
8291	ringBuffer := smithyio.NewRingBuffer(buff[:])
8292
8293	body := io.TeeReader(response.Body, ringBuffer)
8294	decoder := json.NewDecoder(body)
8295	decoder.UseNumber()
8296	var shape interface{}
8297	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8298		var snapshot bytes.Buffer
8299		io.Copy(&snapshot, ringBuffer)
8300		err = &smithy.DeserializationError{
8301			Err:      fmt.Errorf("failed to decode response body, %w", err),
8302			Snapshot: snapshot.Bytes(),
8303		}
8304		return out, metadata, err
8305	}
8306
8307	err = awsAwsjson11_deserializeOpDocumentUpdateRateBasedRuleOutput(&output, shape)
8308	if err != nil {
8309		var snapshot bytes.Buffer
8310		io.Copy(&snapshot, ringBuffer)
8311		err = &smithy.DeserializationError{
8312			Err:      fmt.Errorf("failed to decode response body, %w", err),
8313			Snapshot: snapshot.Bytes(),
8314		}
8315		return out, metadata, err
8316	}
8317
8318	return out, metadata, err
8319}
8320
8321func awsAwsjson11_deserializeOpErrorUpdateRateBasedRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8322	var errorBuffer bytes.Buffer
8323	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8324		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8325	}
8326	errorBody := bytes.NewReader(errorBuffer.Bytes())
8327
8328	errorCode := "UnknownError"
8329	errorMessage := errorCode
8330
8331	code := response.Header.Get("X-Amzn-ErrorType")
8332	if len(code) != 0 {
8333		errorCode = restjson.SanitizeErrorCode(code)
8334	}
8335
8336	var buff [1024]byte
8337	ringBuffer := smithyio.NewRingBuffer(buff[:])
8338
8339	body := io.TeeReader(errorBody, ringBuffer)
8340	decoder := json.NewDecoder(body)
8341	decoder.UseNumber()
8342	code, message, err := restjson.GetErrorInfo(decoder)
8343	if err != nil {
8344		var snapshot bytes.Buffer
8345		io.Copy(&snapshot, ringBuffer)
8346		err = &smithy.DeserializationError{
8347			Err:      fmt.Errorf("failed to decode response body, %w", err),
8348			Snapshot: snapshot.Bytes(),
8349		}
8350		return err
8351	}
8352
8353	errorBody.Seek(0, io.SeekStart)
8354	if len(code) != 0 {
8355		errorCode = restjson.SanitizeErrorCode(code)
8356	}
8357	if len(message) != 0 {
8358		errorMessage = message
8359	}
8360
8361	switch {
8362	case strings.EqualFold("WAFInternalErrorException", errorCode):
8363		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8364
8365	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8366		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8367
8368	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8369		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8370
8371	case strings.EqualFold("WAFInvalidParameterException", errorCode):
8372		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
8373
8374	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8375		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8376
8377	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8378		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8379
8380	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8381		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8382
8383	case strings.EqualFold("WAFReferencedItemException", errorCode):
8384		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
8385
8386	case strings.EqualFold("WAFStaleDataException", errorCode):
8387		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8388
8389	default:
8390		genericError := &smithy.GenericAPIError{
8391			Code:    errorCode,
8392			Message: errorMessage,
8393		}
8394		return genericError
8395
8396	}
8397}
8398
8399type awsAwsjson11_deserializeOpUpdateRegexMatchSet struct {
8400}
8401
8402func (*awsAwsjson11_deserializeOpUpdateRegexMatchSet) ID() string {
8403	return "OperationDeserializer"
8404}
8405
8406func (m *awsAwsjson11_deserializeOpUpdateRegexMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8407	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8408) {
8409	out, metadata, err = next.HandleDeserialize(ctx, in)
8410	if err != nil {
8411		return out, metadata, err
8412	}
8413
8414	response, ok := out.RawResponse.(*smithyhttp.Response)
8415	if !ok {
8416		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8417	}
8418
8419	if response.StatusCode < 200 || response.StatusCode >= 300 {
8420		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRegexMatchSet(response, &metadata)
8421	}
8422	output := &UpdateRegexMatchSetOutput{}
8423	out.Result = output
8424
8425	var buff [1024]byte
8426	ringBuffer := smithyio.NewRingBuffer(buff[:])
8427
8428	body := io.TeeReader(response.Body, ringBuffer)
8429	decoder := json.NewDecoder(body)
8430	decoder.UseNumber()
8431	var shape interface{}
8432	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8433		var snapshot bytes.Buffer
8434		io.Copy(&snapshot, ringBuffer)
8435		err = &smithy.DeserializationError{
8436			Err:      fmt.Errorf("failed to decode response body, %w", err),
8437			Snapshot: snapshot.Bytes(),
8438		}
8439		return out, metadata, err
8440	}
8441
8442	err = awsAwsjson11_deserializeOpDocumentUpdateRegexMatchSetOutput(&output, shape)
8443	if err != nil {
8444		var snapshot bytes.Buffer
8445		io.Copy(&snapshot, ringBuffer)
8446		err = &smithy.DeserializationError{
8447			Err:      fmt.Errorf("failed to decode response body, %w", err),
8448			Snapshot: snapshot.Bytes(),
8449		}
8450		return out, metadata, err
8451	}
8452
8453	return out, metadata, err
8454}
8455
8456func awsAwsjson11_deserializeOpErrorUpdateRegexMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8457	var errorBuffer bytes.Buffer
8458	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8459		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8460	}
8461	errorBody := bytes.NewReader(errorBuffer.Bytes())
8462
8463	errorCode := "UnknownError"
8464	errorMessage := errorCode
8465
8466	code := response.Header.Get("X-Amzn-ErrorType")
8467	if len(code) != 0 {
8468		errorCode = restjson.SanitizeErrorCode(code)
8469	}
8470
8471	var buff [1024]byte
8472	ringBuffer := smithyio.NewRingBuffer(buff[:])
8473
8474	body := io.TeeReader(errorBody, ringBuffer)
8475	decoder := json.NewDecoder(body)
8476	decoder.UseNumber()
8477	code, message, err := restjson.GetErrorInfo(decoder)
8478	if err != nil {
8479		var snapshot bytes.Buffer
8480		io.Copy(&snapshot, ringBuffer)
8481		err = &smithy.DeserializationError{
8482			Err:      fmt.Errorf("failed to decode response body, %w", err),
8483			Snapshot: snapshot.Bytes(),
8484		}
8485		return err
8486	}
8487
8488	errorBody.Seek(0, io.SeekStart)
8489	if len(code) != 0 {
8490		errorCode = restjson.SanitizeErrorCode(code)
8491	}
8492	if len(message) != 0 {
8493		errorMessage = message
8494	}
8495
8496	switch {
8497	case strings.EqualFold("WAFDisallowedNameException", errorCode):
8498		return awsAwsjson11_deserializeErrorWAFDisallowedNameException(response, errorBody)
8499
8500	case strings.EqualFold("WAFInternalErrorException", errorCode):
8501		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8502
8503	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8504		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8505
8506	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8507		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8508
8509	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8510		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8511
8512	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8513		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8514
8515	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8516		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8517
8518	case strings.EqualFold("WAFStaleDataException", errorCode):
8519		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8520
8521	default:
8522		genericError := &smithy.GenericAPIError{
8523			Code:    errorCode,
8524			Message: errorMessage,
8525		}
8526		return genericError
8527
8528	}
8529}
8530
8531type awsAwsjson11_deserializeOpUpdateRegexPatternSet struct {
8532}
8533
8534func (*awsAwsjson11_deserializeOpUpdateRegexPatternSet) ID() string {
8535	return "OperationDeserializer"
8536}
8537
8538func (m *awsAwsjson11_deserializeOpUpdateRegexPatternSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8539	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8540) {
8541	out, metadata, err = next.HandleDeserialize(ctx, in)
8542	if err != nil {
8543		return out, metadata, err
8544	}
8545
8546	response, ok := out.RawResponse.(*smithyhttp.Response)
8547	if !ok {
8548		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8549	}
8550
8551	if response.StatusCode < 200 || response.StatusCode >= 300 {
8552		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRegexPatternSet(response, &metadata)
8553	}
8554	output := &UpdateRegexPatternSetOutput{}
8555	out.Result = output
8556
8557	var buff [1024]byte
8558	ringBuffer := smithyio.NewRingBuffer(buff[:])
8559
8560	body := io.TeeReader(response.Body, ringBuffer)
8561	decoder := json.NewDecoder(body)
8562	decoder.UseNumber()
8563	var shape interface{}
8564	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8565		var snapshot bytes.Buffer
8566		io.Copy(&snapshot, ringBuffer)
8567		err = &smithy.DeserializationError{
8568			Err:      fmt.Errorf("failed to decode response body, %w", err),
8569			Snapshot: snapshot.Bytes(),
8570		}
8571		return out, metadata, err
8572	}
8573
8574	err = awsAwsjson11_deserializeOpDocumentUpdateRegexPatternSetOutput(&output, shape)
8575	if err != nil {
8576		var snapshot bytes.Buffer
8577		io.Copy(&snapshot, ringBuffer)
8578		err = &smithy.DeserializationError{
8579			Err:      fmt.Errorf("failed to decode response body, %w", err),
8580			Snapshot: snapshot.Bytes(),
8581		}
8582		return out, metadata, err
8583	}
8584
8585	return out, metadata, err
8586}
8587
8588func awsAwsjson11_deserializeOpErrorUpdateRegexPatternSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8589	var errorBuffer bytes.Buffer
8590	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8591		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8592	}
8593	errorBody := bytes.NewReader(errorBuffer.Bytes())
8594
8595	errorCode := "UnknownError"
8596	errorMessage := errorCode
8597
8598	code := response.Header.Get("X-Amzn-ErrorType")
8599	if len(code) != 0 {
8600		errorCode = restjson.SanitizeErrorCode(code)
8601	}
8602
8603	var buff [1024]byte
8604	ringBuffer := smithyio.NewRingBuffer(buff[:])
8605
8606	body := io.TeeReader(errorBody, ringBuffer)
8607	decoder := json.NewDecoder(body)
8608	decoder.UseNumber()
8609	code, message, err := restjson.GetErrorInfo(decoder)
8610	if err != nil {
8611		var snapshot bytes.Buffer
8612		io.Copy(&snapshot, ringBuffer)
8613		err = &smithy.DeserializationError{
8614			Err:      fmt.Errorf("failed to decode response body, %w", err),
8615			Snapshot: snapshot.Bytes(),
8616		}
8617		return err
8618	}
8619
8620	errorBody.Seek(0, io.SeekStart)
8621	if len(code) != 0 {
8622		errorCode = restjson.SanitizeErrorCode(code)
8623	}
8624	if len(message) != 0 {
8625		errorMessage = message
8626	}
8627
8628	switch {
8629	case strings.EqualFold("WAFInternalErrorException", errorCode):
8630		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8631
8632	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8633		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8634
8635	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8636		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8637
8638	case strings.EqualFold("WAFInvalidRegexPatternException", errorCode):
8639		return awsAwsjson11_deserializeErrorWAFInvalidRegexPatternException(response, errorBody)
8640
8641	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8642		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8643
8644	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8645		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8646
8647	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8648		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8649
8650	case strings.EqualFold("WAFStaleDataException", errorCode):
8651		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8652
8653	default:
8654		genericError := &smithy.GenericAPIError{
8655			Code:    errorCode,
8656			Message: errorMessage,
8657		}
8658		return genericError
8659
8660	}
8661}
8662
8663type awsAwsjson11_deserializeOpUpdateRule struct {
8664}
8665
8666func (*awsAwsjson11_deserializeOpUpdateRule) ID() string {
8667	return "OperationDeserializer"
8668}
8669
8670func (m *awsAwsjson11_deserializeOpUpdateRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8671	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8672) {
8673	out, metadata, err = next.HandleDeserialize(ctx, in)
8674	if err != nil {
8675		return out, metadata, err
8676	}
8677
8678	response, ok := out.RawResponse.(*smithyhttp.Response)
8679	if !ok {
8680		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8681	}
8682
8683	if response.StatusCode < 200 || response.StatusCode >= 300 {
8684		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRule(response, &metadata)
8685	}
8686	output := &UpdateRuleOutput{}
8687	out.Result = output
8688
8689	var buff [1024]byte
8690	ringBuffer := smithyio.NewRingBuffer(buff[:])
8691
8692	body := io.TeeReader(response.Body, ringBuffer)
8693	decoder := json.NewDecoder(body)
8694	decoder.UseNumber()
8695	var shape interface{}
8696	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8697		var snapshot bytes.Buffer
8698		io.Copy(&snapshot, ringBuffer)
8699		err = &smithy.DeserializationError{
8700			Err:      fmt.Errorf("failed to decode response body, %w", err),
8701			Snapshot: snapshot.Bytes(),
8702		}
8703		return out, metadata, err
8704	}
8705
8706	err = awsAwsjson11_deserializeOpDocumentUpdateRuleOutput(&output, shape)
8707	if err != nil {
8708		var snapshot bytes.Buffer
8709		io.Copy(&snapshot, ringBuffer)
8710		err = &smithy.DeserializationError{
8711			Err:      fmt.Errorf("failed to decode response body, %w", err),
8712			Snapshot: snapshot.Bytes(),
8713		}
8714		return out, metadata, err
8715	}
8716
8717	return out, metadata, err
8718}
8719
8720func awsAwsjson11_deserializeOpErrorUpdateRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8721	var errorBuffer bytes.Buffer
8722	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8723		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8724	}
8725	errorBody := bytes.NewReader(errorBuffer.Bytes())
8726
8727	errorCode := "UnknownError"
8728	errorMessage := errorCode
8729
8730	code := response.Header.Get("X-Amzn-ErrorType")
8731	if len(code) != 0 {
8732		errorCode = restjson.SanitizeErrorCode(code)
8733	}
8734
8735	var buff [1024]byte
8736	ringBuffer := smithyio.NewRingBuffer(buff[:])
8737
8738	body := io.TeeReader(errorBody, ringBuffer)
8739	decoder := json.NewDecoder(body)
8740	decoder.UseNumber()
8741	code, message, err := restjson.GetErrorInfo(decoder)
8742	if err != nil {
8743		var snapshot bytes.Buffer
8744		io.Copy(&snapshot, ringBuffer)
8745		err = &smithy.DeserializationError{
8746			Err:      fmt.Errorf("failed to decode response body, %w", err),
8747			Snapshot: snapshot.Bytes(),
8748		}
8749		return err
8750	}
8751
8752	errorBody.Seek(0, io.SeekStart)
8753	if len(code) != 0 {
8754		errorCode = restjson.SanitizeErrorCode(code)
8755	}
8756	if len(message) != 0 {
8757		errorMessage = message
8758	}
8759
8760	switch {
8761	case strings.EqualFold("WAFInternalErrorException", errorCode):
8762		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8763
8764	case strings.EqualFold("WAFInvalidAccountException", errorCode):
8765		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
8766
8767	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8768		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8769
8770	case strings.EqualFold("WAFInvalidParameterException", errorCode):
8771		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
8772
8773	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8774		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8775
8776	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8777		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8778
8779	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8780		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8781
8782	case strings.EqualFold("WAFReferencedItemException", errorCode):
8783		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
8784
8785	case strings.EqualFold("WAFStaleDataException", errorCode):
8786		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8787
8788	default:
8789		genericError := &smithy.GenericAPIError{
8790			Code:    errorCode,
8791			Message: errorMessage,
8792		}
8793		return genericError
8794
8795	}
8796}
8797
8798type awsAwsjson11_deserializeOpUpdateRuleGroup struct {
8799}
8800
8801func (*awsAwsjson11_deserializeOpUpdateRuleGroup) ID() string {
8802	return "OperationDeserializer"
8803}
8804
8805func (m *awsAwsjson11_deserializeOpUpdateRuleGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8806	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8807) {
8808	out, metadata, err = next.HandleDeserialize(ctx, in)
8809	if err != nil {
8810		return out, metadata, err
8811	}
8812
8813	response, ok := out.RawResponse.(*smithyhttp.Response)
8814	if !ok {
8815		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8816	}
8817
8818	if response.StatusCode < 200 || response.StatusCode >= 300 {
8819		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateRuleGroup(response, &metadata)
8820	}
8821	output := &UpdateRuleGroupOutput{}
8822	out.Result = output
8823
8824	var buff [1024]byte
8825	ringBuffer := smithyio.NewRingBuffer(buff[:])
8826
8827	body := io.TeeReader(response.Body, ringBuffer)
8828	decoder := json.NewDecoder(body)
8829	decoder.UseNumber()
8830	var shape interface{}
8831	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8832		var snapshot bytes.Buffer
8833		io.Copy(&snapshot, ringBuffer)
8834		err = &smithy.DeserializationError{
8835			Err:      fmt.Errorf("failed to decode response body, %w", err),
8836			Snapshot: snapshot.Bytes(),
8837		}
8838		return out, metadata, err
8839	}
8840
8841	err = awsAwsjson11_deserializeOpDocumentUpdateRuleGroupOutput(&output, shape)
8842	if err != nil {
8843		var snapshot bytes.Buffer
8844		io.Copy(&snapshot, ringBuffer)
8845		err = &smithy.DeserializationError{
8846			Err:      fmt.Errorf("failed to decode response body, %w", err),
8847			Snapshot: snapshot.Bytes(),
8848		}
8849		return out, metadata, err
8850	}
8851
8852	return out, metadata, err
8853}
8854
8855func awsAwsjson11_deserializeOpErrorUpdateRuleGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8856	var errorBuffer bytes.Buffer
8857	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8858		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8859	}
8860	errorBody := bytes.NewReader(errorBuffer.Bytes())
8861
8862	errorCode := "UnknownError"
8863	errorMessage := errorCode
8864
8865	code := response.Header.Get("X-Amzn-ErrorType")
8866	if len(code) != 0 {
8867		errorCode = restjson.SanitizeErrorCode(code)
8868	}
8869
8870	var buff [1024]byte
8871	ringBuffer := smithyio.NewRingBuffer(buff[:])
8872
8873	body := io.TeeReader(errorBody, ringBuffer)
8874	decoder := json.NewDecoder(body)
8875	decoder.UseNumber()
8876	code, message, err := restjson.GetErrorInfo(decoder)
8877	if err != nil {
8878		var snapshot bytes.Buffer
8879		io.Copy(&snapshot, ringBuffer)
8880		err = &smithy.DeserializationError{
8881			Err:      fmt.Errorf("failed to decode response body, %w", err),
8882			Snapshot: snapshot.Bytes(),
8883		}
8884		return err
8885	}
8886
8887	errorBody.Seek(0, io.SeekStart)
8888	if len(code) != 0 {
8889		errorCode = restjson.SanitizeErrorCode(code)
8890	}
8891	if len(message) != 0 {
8892		errorMessage = message
8893	}
8894
8895	switch {
8896	case strings.EqualFold("WAFInternalErrorException", errorCode):
8897		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
8898
8899	case strings.EqualFold("WAFInvalidOperationException", errorCode):
8900		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
8901
8902	case strings.EqualFold("WAFInvalidParameterException", errorCode):
8903		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
8904
8905	case strings.EqualFold("WAFLimitsExceededException", errorCode):
8906		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
8907
8908	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
8909		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
8910
8911	case strings.EqualFold("WAFNonexistentItemException", errorCode):
8912		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
8913
8914	case strings.EqualFold("WAFStaleDataException", errorCode):
8915		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
8916
8917	default:
8918		genericError := &smithy.GenericAPIError{
8919			Code:    errorCode,
8920			Message: errorMessage,
8921		}
8922		return genericError
8923
8924	}
8925}
8926
8927type awsAwsjson11_deserializeOpUpdateSizeConstraintSet struct {
8928}
8929
8930func (*awsAwsjson11_deserializeOpUpdateSizeConstraintSet) ID() string {
8931	return "OperationDeserializer"
8932}
8933
8934func (m *awsAwsjson11_deserializeOpUpdateSizeConstraintSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8935	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8936) {
8937	out, metadata, err = next.HandleDeserialize(ctx, in)
8938	if err != nil {
8939		return out, metadata, err
8940	}
8941
8942	response, ok := out.RawResponse.(*smithyhttp.Response)
8943	if !ok {
8944		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8945	}
8946
8947	if response.StatusCode < 200 || response.StatusCode >= 300 {
8948		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateSizeConstraintSet(response, &metadata)
8949	}
8950	output := &UpdateSizeConstraintSetOutput{}
8951	out.Result = output
8952
8953	var buff [1024]byte
8954	ringBuffer := smithyio.NewRingBuffer(buff[:])
8955
8956	body := io.TeeReader(response.Body, ringBuffer)
8957	decoder := json.NewDecoder(body)
8958	decoder.UseNumber()
8959	var shape interface{}
8960	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8961		var snapshot bytes.Buffer
8962		io.Copy(&snapshot, ringBuffer)
8963		err = &smithy.DeserializationError{
8964			Err:      fmt.Errorf("failed to decode response body, %w", err),
8965			Snapshot: snapshot.Bytes(),
8966		}
8967		return out, metadata, err
8968	}
8969
8970	err = awsAwsjson11_deserializeOpDocumentUpdateSizeConstraintSetOutput(&output, shape)
8971	if err != nil {
8972		var snapshot bytes.Buffer
8973		io.Copy(&snapshot, ringBuffer)
8974		err = &smithy.DeserializationError{
8975			Err:      fmt.Errorf("failed to decode response body, %w", err),
8976			Snapshot: snapshot.Bytes(),
8977		}
8978		return out, metadata, err
8979	}
8980
8981	return out, metadata, err
8982}
8983
8984func awsAwsjson11_deserializeOpErrorUpdateSizeConstraintSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8985	var errorBuffer bytes.Buffer
8986	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8987		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8988	}
8989	errorBody := bytes.NewReader(errorBuffer.Bytes())
8990
8991	errorCode := "UnknownError"
8992	errorMessage := errorCode
8993
8994	code := response.Header.Get("X-Amzn-ErrorType")
8995	if len(code) != 0 {
8996		errorCode = restjson.SanitizeErrorCode(code)
8997	}
8998
8999	var buff [1024]byte
9000	ringBuffer := smithyio.NewRingBuffer(buff[:])
9001
9002	body := io.TeeReader(errorBody, ringBuffer)
9003	decoder := json.NewDecoder(body)
9004	decoder.UseNumber()
9005	code, message, err := restjson.GetErrorInfo(decoder)
9006	if err != nil {
9007		var snapshot bytes.Buffer
9008		io.Copy(&snapshot, ringBuffer)
9009		err = &smithy.DeserializationError{
9010			Err:      fmt.Errorf("failed to decode response body, %w", err),
9011			Snapshot: snapshot.Bytes(),
9012		}
9013		return err
9014	}
9015
9016	errorBody.Seek(0, io.SeekStart)
9017	if len(code) != 0 {
9018		errorCode = restjson.SanitizeErrorCode(code)
9019	}
9020	if len(message) != 0 {
9021		errorMessage = message
9022	}
9023
9024	switch {
9025	case strings.EqualFold("WAFInternalErrorException", errorCode):
9026		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
9027
9028	case strings.EqualFold("WAFInvalidAccountException", errorCode):
9029		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
9030
9031	case strings.EqualFold("WAFInvalidOperationException", errorCode):
9032		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
9033
9034	case strings.EqualFold("WAFInvalidParameterException", errorCode):
9035		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
9036
9037	case strings.EqualFold("WAFLimitsExceededException", errorCode):
9038		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
9039
9040	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
9041		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
9042
9043	case strings.EqualFold("WAFNonexistentItemException", errorCode):
9044		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
9045
9046	case strings.EqualFold("WAFReferencedItemException", errorCode):
9047		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
9048
9049	case strings.EqualFold("WAFStaleDataException", errorCode):
9050		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
9051
9052	default:
9053		genericError := &smithy.GenericAPIError{
9054			Code:    errorCode,
9055			Message: errorMessage,
9056		}
9057		return genericError
9058
9059	}
9060}
9061
9062type awsAwsjson11_deserializeOpUpdateSqlInjectionMatchSet struct {
9063}
9064
9065func (*awsAwsjson11_deserializeOpUpdateSqlInjectionMatchSet) ID() string {
9066	return "OperationDeserializer"
9067}
9068
9069func (m *awsAwsjson11_deserializeOpUpdateSqlInjectionMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9070	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9071) {
9072	out, metadata, err = next.HandleDeserialize(ctx, in)
9073	if err != nil {
9074		return out, metadata, err
9075	}
9076
9077	response, ok := out.RawResponse.(*smithyhttp.Response)
9078	if !ok {
9079		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9080	}
9081
9082	if response.StatusCode < 200 || response.StatusCode >= 300 {
9083		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateSqlInjectionMatchSet(response, &metadata)
9084	}
9085	output := &UpdateSqlInjectionMatchSetOutput{}
9086	out.Result = output
9087
9088	var buff [1024]byte
9089	ringBuffer := smithyio.NewRingBuffer(buff[:])
9090
9091	body := io.TeeReader(response.Body, ringBuffer)
9092	decoder := json.NewDecoder(body)
9093	decoder.UseNumber()
9094	var shape interface{}
9095	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9096		var snapshot bytes.Buffer
9097		io.Copy(&snapshot, ringBuffer)
9098		err = &smithy.DeserializationError{
9099			Err:      fmt.Errorf("failed to decode response body, %w", err),
9100			Snapshot: snapshot.Bytes(),
9101		}
9102		return out, metadata, err
9103	}
9104
9105	err = awsAwsjson11_deserializeOpDocumentUpdateSqlInjectionMatchSetOutput(&output, shape)
9106	if err != nil {
9107		var snapshot bytes.Buffer
9108		io.Copy(&snapshot, ringBuffer)
9109		err = &smithy.DeserializationError{
9110			Err:      fmt.Errorf("failed to decode response body, %w", err),
9111			Snapshot: snapshot.Bytes(),
9112		}
9113		return out, metadata, err
9114	}
9115
9116	return out, metadata, err
9117}
9118
9119func awsAwsjson11_deserializeOpErrorUpdateSqlInjectionMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9120	var errorBuffer bytes.Buffer
9121	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9122		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9123	}
9124	errorBody := bytes.NewReader(errorBuffer.Bytes())
9125
9126	errorCode := "UnknownError"
9127	errorMessage := errorCode
9128
9129	code := response.Header.Get("X-Amzn-ErrorType")
9130	if len(code) != 0 {
9131		errorCode = restjson.SanitizeErrorCode(code)
9132	}
9133
9134	var buff [1024]byte
9135	ringBuffer := smithyio.NewRingBuffer(buff[:])
9136
9137	body := io.TeeReader(errorBody, ringBuffer)
9138	decoder := json.NewDecoder(body)
9139	decoder.UseNumber()
9140	code, message, err := restjson.GetErrorInfo(decoder)
9141	if err != nil {
9142		var snapshot bytes.Buffer
9143		io.Copy(&snapshot, ringBuffer)
9144		err = &smithy.DeserializationError{
9145			Err:      fmt.Errorf("failed to decode response body, %w", err),
9146			Snapshot: snapshot.Bytes(),
9147		}
9148		return err
9149	}
9150
9151	errorBody.Seek(0, io.SeekStart)
9152	if len(code) != 0 {
9153		errorCode = restjson.SanitizeErrorCode(code)
9154	}
9155	if len(message) != 0 {
9156		errorMessage = message
9157	}
9158
9159	switch {
9160	case strings.EqualFold("WAFInternalErrorException", errorCode):
9161		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
9162
9163	case strings.EqualFold("WAFInvalidAccountException", errorCode):
9164		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
9165
9166	case strings.EqualFold("WAFInvalidOperationException", errorCode):
9167		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
9168
9169	case strings.EqualFold("WAFInvalidParameterException", errorCode):
9170		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
9171
9172	case strings.EqualFold("WAFLimitsExceededException", errorCode):
9173		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
9174
9175	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
9176		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
9177
9178	case strings.EqualFold("WAFNonexistentItemException", errorCode):
9179		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
9180
9181	case strings.EqualFold("WAFStaleDataException", errorCode):
9182		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
9183
9184	default:
9185		genericError := &smithy.GenericAPIError{
9186			Code:    errorCode,
9187			Message: errorMessage,
9188		}
9189		return genericError
9190
9191	}
9192}
9193
9194type awsAwsjson11_deserializeOpUpdateWebACL struct {
9195}
9196
9197func (*awsAwsjson11_deserializeOpUpdateWebACL) ID() string {
9198	return "OperationDeserializer"
9199}
9200
9201func (m *awsAwsjson11_deserializeOpUpdateWebACL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9202	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9203) {
9204	out, metadata, err = next.HandleDeserialize(ctx, in)
9205	if err != nil {
9206		return out, metadata, err
9207	}
9208
9209	response, ok := out.RawResponse.(*smithyhttp.Response)
9210	if !ok {
9211		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9212	}
9213
9214	if response.StatusCode < 200 || response.StatusCode >= 300 {
9215		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateWebACL(response, &metadata)
9216	}
9217	output := &UpdateWebACLOutput{}
9218	out.Result = output
9219
9220	var buff [1024]byte
9221	ringBuffer := smithyio.NewRingBuffer(buff[:])
9222
9223	body := io.TeeReader(response.Body, ringBuffer)
9224	decoder := json.NewDecoder(body)
9225	decoder.UseNumber()
9226	var shape interface{}
9227	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9228		var snapshot bytes.Buffer
9229		io.Copy(&snapshot, ringBuffer)
9230		err = &smithy.DeserializationError{
9231			Err:      fmt.Errorf("failed to decode response body, %w", err),
9232			Snapshot: snapshot.Bytes(),
9233		}
9234		return out, metadata, err
9235	}
9236
9237	err = awsAwsjson11_deserializeOpDocumentUpdateWebACLOutput(&output, shape)
9238	if err != nil {
9239		var snapshot bytes.Buffer
9240		io.Copy(&snapshot, ringBuffer)
9241		err = &smithy.DeserializationError{
9242			Err:      fmt.Errorf("failed to decode response body, %w", err),
9243			Snapshot: snapshot.Bytes(),
9244		}
9245		return out, metadata, err
9246	}
9247
9248	return out, metadata, err
9249}
9250
9251func awsAwsjson11_deserializeOpErrorUpdateWebACL(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9252	var errorBuffer bytes.Buffer
9253	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9254		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9255	}
9256	errorBody := bytes.NewReader(errorBuffer.Bytes())
9257
9258	errorCode := "UnknownError"
9259	errorMessage := errorCode
9260
9261	code := response.Header.Get("X-Amzn-ErrorType")
9262	if len(code) != 0 {
9263		errorCode = restjson.SanitizeErrorCode(code)
9264	}
9265
9266	var buff [1024]byte
9267	ringBuffer := smithyio.NewRingBuffer(buff[:])
9268
9269	body := io.TeeReader(errorBody, ringBuffer)
9270	decoder := json.NewDecoder(body)
9271	decoder.UseNumber()
9272	code, message, err := restjson.GetErrorInfo(decoder)
9273	if err != nil {
9274		var snapshot bytes.Buffer
9275		io.Copy(&snapshot, ringBuffer)
9276		err = &smithy.DeserializationError{
9277			Err:      fmt.Errorf("failed to decode response body, %w", err),
9278			Snapshot: snapshot.Bytes(),
9279		}
9280		return err
9281	}
9282
9283	errorBody.Seek(0, io.SeekStart)
9284	if len(code) != 0 {
9285		errorCode = restjson.SanitizeErrorCode(code)
9286	}
9287	if len(message) != 0 {
9288		errorMessage = message
9289	}
9290
9291	switch {
9292	case strings.EqualFold("WAFInternalErrorException", errorCode):
9293		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
9294
9295	case strings.EqualFold("WAFInvalidAccountException", errorCode):
9296		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
9297
9298	case strings.EqualFold("WAFInvalidOperationException", errorCode):
9299		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
9300
9301	case strings.EqualFold("WAFInvalidParameterException", errorCode):
9302		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
9303
9304	case strings.EqualFold("WAFLimitsExceededException", errorCode):
9305		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
9306
9307	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
9308		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
9309
9310	case strings.EqualFold("WAFNonexistentItemException", errorCode):
9311		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
9312
9313	case strings.EqualFold("WAFReferencedItemException", errorCode):
9314		return awsAwsjson11_deserializeErrorWAFReferencedItemException(response, errorBody)
9315
9316	case strings.EqualFold("WAFStaleDataException", errorCode):
9317		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
9318
9319	case strings.EqualFold("WAFSubscriptionNotFoundException", errorCode):
9320		return awsAwsjson11_deserializeErrorWAFSubscriptionNotFoundException(response, errorBody)
9321
9322	default:
9323		genericError := &smithy.GenericAPIError{
9324			Code:    errorCode,
9325			Message: errorMessage,
9326		}
9327		return genericError
9328
9329	}
9330}
9331
9332type awsAwsjson11_deserializeOpUpdateXssMatchSet struct {
9333}
9334
9335func (*awsAwsjson11_deserializeOpUpdateXssMatchSet) ID() string {
9336	return "OperationDeserializer"
9337}
9338
9339func (m *awsAwsjson11_deserializeOpUpdateXssMatchSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9340	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9341) {
9342	out, metadata, err = next.HandleDeserialize(ctx, in)
9343	if err != nil {
9344		return out, metadata, err
9345	}
9346
9347	response, ok := out.RawResponse.(*smithyhttp.Response)
9348	if !ok {
9349		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9350	}
9351
9352	if response.StatusCode < 200 || response.StatusCode >= 300 {
9353		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateXssMatchSet(response, &metadata)
9354	}
9355	output := &UpdateXssMatchSetOutput{}
9356	out.Result = output
9357
9358	var buff [1024]byte
9359	ringBuffer := smithyio.NewRingBuffer(buff[:])
9360
9361	body := io.TeeReader(response.Body, ringBuffer)
9362	decoder := json.NewDecoder(body)
9363	decoder.UseNumber()
9364	var shape interface{}
9365	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9366		var snapshot bytes.Buffer
9367		io.Copy(&snapshot, ringBuffer)
9368		err = &smithy.DeserializationError{
9369			Err:      fmt.Errorf("failed to decode response body, %w", err),
9370			Snapshot: snapshot.Bytes(),
9371		}
9372		return out, metadata, err
9373	}
9374
9375	err = awsAwsjson11_deserializeOpDocumentUpdateXssMatchSetOutput(&output, shape)
9376	if err != nil {
9377		var snapshot bytes.Buffer
9378		io.Copy(&snapshot, ringBuffer)
9379		err = &smithy.DeserializationError{
9380			Err:      fmt.Errorf("failed to decode response body, %w", err),
9381			Snapshot: snapshot.Bytes(),
9382		}
9383		return out, metadata, err
9384	}
9385
9386	return out, metadata, err
9387}
9388
9389func awsAwsjson11_deserializeOpErrorUpdateXssMatchSet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9390	var errorBuffer bytes.Buffer
9391	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9392		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9393	}
9394	errorBody := bytes.NewReader(errorBuffer.Bytes())
9395
9396	errorCode := "UnknownError"
9397	errorMessage := errorCode
9398
9399	code := response.Header.Get("X-Amzn-ErrorType")
9400	if len(code) != 0 {
9401		errorCode = restjson.SanitizeErrorCode(code)
9402	}
9403
9404	var buff [1024]byte
9405	ringBuffer := smithyio.NewRingBuffer(buff[:])
9406
9407	body := io.TeeReader(errorBody, ringBuffer)
9408	decoder := json.NewDecoder(body)
9409	decoder.UseNumber()
9410	code, message, err := restjson.GetErrorInfo(decoder)
9411	if err != nil {
9412		var snapshot bytes.Buffer
9413		io.Copy(&snapshot, ringBuffer)
9414		err = &smithy.DeserializationError{
9415			Err:      fmt.Errorf("failed to decode response body, %w", err),
9416			Snapshot: snapshot.Bytes(),
9417		}
9418		return err
9419	}
9420
9421	errorBody.Seek(0, io.SeekStart)
9422	if len(code) != 0 {
9423		errorCode = restjson.SanitizeErrorCode(code)
9424	}
9425	if len(message) != 0 {
9426		errorMessage = message
9427	}
9428
9429	switch {
9430	case strings.EqualFold("WAFInternalErrorException", errorCode):
9431		return awsAwsjson11_deserializeErrorWAFInternalErrorException(response, errorBody)
9432
9433	case strings.EqualFold("WAFInvalidAccountException", errorCode):
9434		return awsAwsjson11_deserializeErrorWAFInvalidAccountException(response, errorBody)
9435
9436	case strings.EqualFold("WAFInvalidOperationException", errorCode):
9437		return awsAwsjson11_deserializeErrorWAFInvalidOperationException(response, errorBody)
9438
9439	case strings.EqualFold("WAFInvalidParameterException", errorCode):
9440		return awsAwsjson11_deserializeErrorWAFInvalidParameterException(response, errorBody)
9441
9442	case strings.EqualFold("WAFLimitsExceededException", errorCode):
9443		return awsAwsjson11_deserializeErrorWAFLimitsExceededException(response, errorBody)
9444
9445	case strings.EqualFold("WAFNonexistentContainerException", errorCode):
9446		return awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response, errorBody)
9447
9448	case strings.EqualFold("WAFNonexistentItemException", errorCode):
9449		return awsAwsjson11_deserializeErrorWAFNonexistentItemException(response, errorBody)
9450
9451	case strings.EqualFold("WAFStaleDataException", errorCode):
9452		return awsAwsjson11_deserializeErrorWAFStaleDataException(response, errorBody)
9453
9454	default:
9455		genericError := &smithy.GenericAPIError{
9456			Code:    errorCode,
9457			Message: errorMessage,
9458		}
9459		return genericError
9460
9461	}
9462}
9463
9464func awsAwsjson11_deserializeErrorWAFBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9465	var buff [1024]byte
9466	ringBuffer := smithyio.NewRingBuffer(buff[:])
9467
9468	body := io.TeeReader(errorBody, ringBuffer)
9469	decoder := json.NewDecoder(body)
9470	decoder.UseNumber()
9471	var shape interface{}
9472	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9473		var snapshot bytes.Buffer
9474		io.Copy(&snapshot, ringBuffer)
9475		err = &smithy.DeserializationError{
9476			Err:      fmt.Errorf("failed to decode response body, %w", err),
9477			Snapshot: snapshot.Bytes(),
9478		}
9479		return err
9480	}
9481
9482	output := &types.WAFBadRequestException{}
9483	err := awsAwsjson11_deserializeDocumentWAFBadRequestException(&output, shape)
9484
9485	if err != nil {
9486		var snapshot bytes.Buffer
9487		io.Copy(&snapshot, ringBuffer)
9488		err = &smithy.DeserializationError{
9489			Err:      fmt.Errorf("failed to decode response body, %w", err),
9490			Snapshot: snapshot.Bytes(),
9491		}
9492		return err
9493	}
9494
9495	errorBody.Seek(0, io.SeekStart)
9496	return output
9497}
9498
9499func awsAwsjson11_deserializeErrorWAFDisallowedNameException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9500	var buff [1024]byte
9501	ringBuffer := smithyio.NewRingBuffer(buff[:])
9502
9503	body := io.TeeReader(errorBody, ringBuffer)
9504	decoder := json.NewDecoder(body)
9505	decoder.UseNumber()
9506	var shape interface{}
9507	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9508		var snapshot bytes.Buffer
9509		io.Copy(&snapshot, ringBuffer)
9510		err = &smithy.DeserializationError{
9511			Err:      fmt.Errorf("failed to decode response body, %w", err),
9512			Snapshot: snapshot.Bytes(),
9513		}
9514		return err
9515	}
9516
9517	output := &types.WAFDisallowedNameException{}
9518	err := awsAwsjson11_deserializeDocumentWAFDisallowedNameException(&output, shape)
9519
9520	if err != nil {
9521		var snapshot bytes.Buffer
9522		io.Copy(&snapshot, ringBuffer)
9523		err = &smithy.DeserializationError{
9524			Err:      fmt.Errorf("failed to decode response body, %w", err),
9525			Snapshot: snapshot.Bytes(),
9526		}
9527		return err
9528	}
9529
9530	errorBody.Seek(0, io.SeekStart)
9531	return output
9532}
9533
9534func awsAwsjson11_deserializeErrorWAFEntityMigrationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9535	var buff [1024]byte
9536	ringBuffer := smithyio.NewRingBuffer(buff[:])
9537
9538	body := io.TeeReader(errorBody, ringBuffer)
9539	decoder := json.NewDecoder(body)
9540	decoder.UseNumber()
9541	var shape interface{}
9542	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9543		var snapshot bytes.Buffer
9544		io.Copy(&snapshot, ringBuffer)
9545		err = &smithy.DeserializationError{
9546			Err:      fmt.Errorf("failed to decode response body, %w", err),
9547			Snapshot: snapshot.Bytes(),
9548		}
9549		return err
9550	}
9551
9552	output := &types.WAFEntityMigrationException{}
9553	err := awsAwsjson11_deserializeDocumentWAFEntityMigrationException(&output, shape)
9554
9555	if err != nil {
9556		var snapshot bytes.Buffer
9557		io.Copy(&snapshot, ringBuffer)
9558		err = &smithy.DeserializationError{
9559			Err:      fmt.Errorf("failed to decode response body, %w", err),
9560			Snapshot: snapshot.Bytes(),
9561		}
9562		return err
9563	}
9564
9565	errorBody.Seek(0, io.SeekStart)
9566	return output
9567}
9568
9569func awsAwsjson11_deserializeErrorWAFInternalErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9570	var buff [1024]byte
9571	ringBuffer := smithyio.NewRingBuffer(buff[:])
9572
9573	body := io.TeeReader(errorBody, ringBuffer)
9574	decoder := json.NewDecoder(body)
9575	decoder.UseNumber()
9576	var shape interface{}
9577	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9578		var snapshot bytes.Buffer
9579		io.Copy(&snapshot, ringBuffer)
9580		err = &smithy.DeserializationError{
9581			Err:      fmt.Errorf("failed to decode response body, %w", err),
9582			Snapshot: snapshot.Bytes(),
9583		}
9584		return err
9585	}
9586
9587	output := &types.WAFInternalErrorException{}
9588	err := awsAwsjson11_deserializeDocumentWAFInternalErrorException(&output, shape)
9589
9590	if err != nil {
9591		var snapshot bytes.Buffer
9592		io.Copy(&snapshot, ringBuffer)
9593		err = &smithy.DeserializationError{
9594			Err:      fmt.Errorf("failed to decode response body, %w", err),
9595			Snapshot: snapshot.Bytes(),
9596		}
9597		return err
9598	}
9599
9600	errorBody.Seek(0, io.SeekStart)
9601	return output
9602}
9603
9604func awsAwsjson11_deserializeErrorWAFInvalidAccountException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9605	var buff [1024]byte
9606	ringBuffer := smithyio.NewRingBuffer(buff[:])
9607
9608	body := io.TeeReader(errorBody, ringBuffer)
9609	decoder := json.NewDecoder(body)
9610	decoder.UseNumber()
9611	var shape interface{}
9612	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9613		var snapshot bytes.Buffer
9614		io.Copy(&snapshot, ringBuffer)
9615		err = &smithy.DeserializationError{
9616			Err:      fmt.Errorf("failed to decode response body, %w", err),
9617			Snapshot: snapshot.Bytes(),
9618		}
9619		return err
9620	}
9621
9622	output := &types.WAFInvalidAccountException{}
9623	err := awsAwsjson11_deserializeDocumentWAFInvalidAccountException(&output, shape)
9624
9625	if err != nil {
9626		var snapshot bytes.Buffer
9627		io.Copy(&snapshot, ringBuffer)
9628		err = &smithy.DeserializationError{
9629			Err:      fmt.Errorf("failed to decode response body, %w", err),
9630			Snapshot: snapshot.Bytes(),
9631		}
9632		return err
9633	}
9634
9635	errorBody.Seek(0, io.SeekStart)
9636	return output
9637}
9638
9639func awsAwsjson11_deserializeErrorWAFInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9640	var buff [1024]byte
9641	ringBuffer := smithyio.NewRingBuffer(buff[:])
9642
9643	body := io.TeeReader(errorBody, ringBuffer)
9644	decoder := json.NewDecoder(body)
9645	decoder.UseNumber()
9646	var shape interface{}
9647	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9648		var snapshot bytes.Buffer
9649		io.Copy(&snapshot, ringBuffer)
9650		err = &smithy.DeserializationError{
9651			Err:      fmt.Errorf("failed to decode response body, %w", err),
9652			Snapshot: snapshot.Bytes(),
9653		}
9654		return err
9655	}
9656
9657	output := &types.WAFInvalidOperationException{}
9658	err := awsAwsjson11_deserializeDocumentWAFInvalidOperationException(&output, shape)
9659
9660	if err != nil {
9661		var snapshot bytes.Buffer
9662		io.Copy(&snapshot, ringBuffer)
9663		err = &smithy.DeserializationError{
9664			Err:      fmt.Errorf("failed to decode response body, %w", err),
9665			Snapshot: snapshot.Bytes(),
9666		}
9667		return err
9668	}
9669
9670	errorBody.Seek(0, io.SeekStart)
9671	return output
9672}
9673
9674func awsAwsjson11_deserializeErrorWAFInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9675	var buff [1024]byte
9676	ringBuffer := smithyio.NewRingBuffer(buff[:])
9677
9678	body := io.TeeReader(errorBody, ringBuffer)
9679	decoder := json.NewDecoder(body)
9680	decoder.UseNumber()
9681	var shape interface{}
9682	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9683		var snapshot bytes.Buffer
9684		io.Copy(&snapshot, ringBuffer)
9685		err = &smithy.DeserializationError{
9686			Err:      fmt.Errorf("failed to decode response body, %w", err),
9687			Snapshot: snapshot.Bytes(),
9688		}
9689		return err
9690	}
9691
9692	output := &types.WAFInvalidParameterException{}
9693	err := awsAwsjson11_deserializeDocumentWAFInvalidParameterException(&output, shape)
9694
9695	if err != nil {
9696		var snapshot bytes.Buffer
9697		io.Copy(&snapshot, ringBuffer)
9698		err = &smithy.DeserializationError{
9699			Err:      fmt.Errorf("failed to decode response body, %w", err),
9700			Snapshot: snapshot.Bytes(),
9701		}
9702		return err
9703	}
9704
9705	errorBody.Seek(0, io.SeekStart)
9706	return output
9707}
9708
9709func awsAwsjson11_deserializeErrorWAFInvalidPermissionPolicyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9710	var buff [1024]byte
9711	ringBuffer := smithyio.NewRingBuffer(buff[:])
9712
9713	body := io.TeeReader(errorBody, ringBuffer)
9714	decoder := json.NewDecoder(body)
9715	decoder.UseNumber()
9716	var shape interface{}
9717	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9718		var snapshot bytes.Buffer
9719		io.Copy(&snapshot, ringBuffer)
9720		err = &smithy.DeserializationError{
9721			Err:      fmt.Errorf("failed to decode response body, %w", err),
9722			Snapshot: snapshot.Bytes(),
9723		}
9724		return err
9725	}
9726
9727	output := &types.WAFInvalidPermissionPolicyException{}
9728	err := awsAwsjson11_deserializeDocumentWAFInvalidPermissionPolicyException(&output, shape)
9729
9730	if err != nil {
9731		var snapshot bytes.Buffer
9732		io.Copy(&snapshot, ringBuffer)
9733		err = &smithy.DeserializationError{
9734			Err:      fmt.Errorf("failed to decode response body, %w", err),
9735			Snapshot: snapshot.Bytes(),
9736		}
9737		return err
9738	}
9739
9740	errorBody.Seek(0, io.SeekStart)
9741	return output
9742}
9743
9744func awsAwsjson11_deserializeErrorWAFInvalidRegexPatternException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9745	var buff [1024]byte
9746	ringBuffer := smithyio.NewRingBuffer(buff[:])
9747
9748	body := io.TeeReader(errorBody, ringBuffer)
9749	decoder := json.NewDecoder(body)
9750	decoder.UseNumber()
9751	var shape interface{}
9752	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9753		var snapshot bytes.Buffer
9754		io.Copy(&snapshot, ringBuffer)
9755		err = &smithy.DeserializationError{
9756			Err:      fmt.Errorf("failed to decode response body, %w", err),
9757			Snapshot: snapshot.Bytes(),
9758		}
9759		return err
9760	}
9761
9762	output := &types.WAFInvalidRegexPatternException{}
9763	err := awsAwsjson11_deserializeDocumentWAFInvalidRegexPatternException(&output, shape)
9764
9765	if err != nil {
9766		var snapshot bytes.Buffer
9767		io.Copy(&snapshot, ringBuffer)
9768		err = &smithy.DeserializationError{
9769			Err:      fmt.Errorf("failed to decode response body, %w", err),
9770			Snapshot: snapshot.Bytes(),
9771		}
9772		return err
9773	}
9774
9775	errorBody.Seek(0, io.SeekStart)
9776	return output
9777}
9778
9779func awsAwsjson11_deserializeErrorWAFLimitsExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9780	var buff [1024]byte
9781	ringBuffer := smithyio.NewRingBuffer(buff[:])
9782
9783	body := io.TeeReader(errorBody, ringBuffer)
9784	decoder := json.NewDecoder(body)
9785	decoder.UseNumber()
9786	var shape interface{}
9787	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9788		var snapshot bytes.Buffer
9789		io.Copy(&snapshot, ringBuffer)
9790		err = &smithy.DeserializationError{
9791			Err:      fmt.Errorf("failed to decode response body, %w", err),
9792			Snapshot: snapshot.Bytes(),
9793		}
9794		return err
9795	}
9796
9797	output := &types.WAFLimitsExceededException{}
9798	err := awsAwsjson11_deserializeDocumentWAFLimitsExceededException(&output, shape)
9799
9800	if err != nil {
9801		var snapshot bytes.Buffer
9802		io.Copy(&snapshot, ringBuffer)
9803		err = &smithy.DeserializationError{
9804			Err:      fmt.Errorf("failed to decode response body, %w", err),
9805			Snapshot: snapshot.Bytes(),
9806		}
9807		return err
9808	}
9809
9810	errorBody.Seek(0, io.SeekStart)
9811	return output
9812}
9813
9814func awsAwsjson11_deserializeErrorWAFNonEmptyEntityException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9815	var buff [1024]byte
9816	ringBuffer := smithyio.NewRingBuffer(buff[:])
9817
9818	body := io.TeeReader(errorBody, ringBuffer)
9819	decoder := json.NewDecoder(body)
9820	decoder.UseNumber()
9821	var shape interface{}
9822	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9823		var snapshot bytes.Buffer
9824		io.Copy(&snapshot, ringBuffer)
9825		err = &smithy.DeserializationError{
9826			Err:      fmt.Errorf("failed to decode response body, %w", err),
9827			Snapshot: snapshot.Bytes(),
9828		}
9829		return err
9830	}
9831
9832	output := &types.WAFNonEmptyEntityException{}
9833	err := awsAwsjson11_deserializeDocumentWAFNonEmptyEntityException(&output, shape)
9834
9835	if err != nil {
9836		var snapshot bytes.Buffer
9837		io.Copy(&snapshot, ringBuffer)
9838		err = &smithy.DeserializationError{
9839			Err:      fmt.Errorf("failed to decode response body, %w", err),
9840			Snapshot: snapshot.Bytes(),
9841		}
9842		return err
9843	}
9844
9845	errorBody.Seek(0, io.SeekStart)
9846	return output
9847}
9848
9849func awsAwsjson11_deserializeErrorWAFNonexistentContainerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9850	var buff [1024]byte
9851	ringBuffer := smithyio.NewRingBuffer(buff[:])
9852
9853	body := io.TeeReader(errorBody, ringBuffer)
9854	decoder := json.NewDecoder(body)
9855	decoder.UseNumber()
9856	var shape interface{}
9857	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9858		var snapshot bytes.Buffer
9859		io.Copy(&snapshot, ringBuffer)
9860		err = &smithy.DeserializationError{
9861			Err:      fmt.Errorf("failed to decode response body, %w", err),
9862			Snapshot: snapshot.Bytes(),
9863		}
9864		return err
9865	}
9866
9867	output := &types.WAFNonexistentContainerException{}
9868	err := awsAwsjson11_deserializeDocumentWAFNonexistentContainerException(&output, shape)
9869
9870	if err != nil {
9871		var snapshot bytes.Buffer
9872		io.Copy(&snapshot, ringBuffer)
9873		err = &smithy.DeserializationError{
9874			Err:      fmt.Errorf("failed to decode response body, %w", err),
9875			Snapshot: snapshot.Bytes(),
9876		}
9877		return err
9878	}
9879
9880	errorBody.Seek(0, io.SeekStart)
9881	return output
9882}
9883
9884func awsAwsjson11_deserializeErrorWAFNonexistentItemException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9885	var buff [1024]byte
9886	ringBuffer := smithyio.NewRingBuffer(buff[:])
9887
9888	body := io.TeeReader(errorBody, ringBuffer)
9889	decoder := json.NewDecoder(body)
9890	decoder.UseNumber()
9891	var shape interface{}
9892	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9893		var snapshot bytes.Buffer
9894		io.Copy(&snapshot, ringBuffer)
9895		err = &smithy.DeserializationError{
9896			Err:      fmt.Errorf("failed to decode response body, %w", err),
9897			Snapshot: snapshot.Bytes(),
9898		}
9899		return err
9900	}
9901
9902	output := &types.WAFNonexistentItemException{}
9903	err := awsAwsjson11_deserializeDocumentWAFNonexistentItemException(&output, shape)
9904
9905	if err != nil {
9906		var snapshot bytes.Buffer
9907		io.Copy(&snapshot, ringBuffer)
9908		err = &smithy.DeserializationError{
9909			Err:      fmt.Errorf("failed to decode response body, %w", err),
9910			Snapshot: snapshot.Bytes(),
9911		}
9912		return err
9913	}
9914
9915	errorBody.Seek(0, io.SeekStart)
9916	return output
9917}
9918
9919func awsAwsjson11_deserializeErrorWAFReferencedItemException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9920	var buff [1024]byte
9921	ringBuffer := smithyio.NewRingBuffer(buff[:])
9922
9923	body := io.TeeReader(errorBody, ringBuffer)
9924	decoder := json.NewDecoder(body)
9925	decoder.UseNumber()
9926	var shape interface{}
9927	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9928		var snapshot bytes.Buffer
9929		io.Copy(&snapshot, ringBuffer)
9930		err = &smithy.DeserializationError{
9931			Err:      fmt.Errorf("failed to decode response body, %w", err),
9932			Snapshot: snapshot.Bytes(),
9933		}
9934		return err
9935	}
9936
9937	output := &types.WAFReferencedItemException{}
9938	err := awsAwsjson11_deserializeDocumentWAFReferencedItemException(&output, shape)
9939
9940	if err != nil {
9941		var snapshot bytes.Buffer
9942		io.Copy(&snapshot, ringBuffer)
9943		err = &smithy.DeserializationError{
9944			Err:      fmt.Errorf("failed to decode response body, %w", err),
9945			Snapshot: snapshot.Bytes(),
9946		}
9947		return err
9948	}
9949
9950	errorBody.Seek(0, io.SeekStart)
9951	return output
9952}
9953
9954func awsAwsjson11_deserializeErrorWAFServiceLinkedRoleErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9955	var buff [1024]byte
9956	ringBuffer := smithyio.NewRingBuffer(buff[:])
9957
9958	body := io.TeeReader(errorBody, ringBuffer)
9959	decoder := json.NewDecoder(body)
9960	decoder.UseNumber()
9961	var shape interface{}
9962	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9963		var snapshot bytes.Buffer
9964		io.Copy(&snapshot, ringBuffer)
9965		err = &smithy.DeserializationError{
9966			Err:      fmt.Errorf("failed to decode response body, %w", err),
9967			Snapshot: snapshot.Bytes(),
9968		}
9969		return err
9970	}
9971
9972	output := &types.WAFServiceLinkedRoleErrorException{}
9973	err := awsAwsjson11_deserializeDocumentWAFServiceLinkedRoleErrorException(&output, shape)
9974
9975	if err != nil {
9976		var snapshot bytes.Buffer
9977		io.Copy(&snapshot, ringBuffer)
9978		err = &smithy.DeserializationError{
9979			Err:      fmt.Errorf("failed to decode response body, %w", err),
9980			Snapshot: snapshot.Bytes(),
9981		}
9982		return err
9983	}
9984
9985	errorBody.Seek(0, io.SeekStart)
9986	return output
9987}
9988
9989func awsAwsjson11_deserializeErrorWAFStaleDataException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
9990	var buff [1024]byte
9991	ringBuffer := smithyio.NewRingBuffer(buff[:])
9992
9993	body := io.TeeReader(errorBody, ringBuffer)
9994	decoder := json.NewDecoder(body)
9995	decoder.UseNumber()
9996	var shape interface{}
9997	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9998		var snapshot bytes.Buffer
9999		io.Copy(&snapshot, ringBuffer)
10000		err = &smithy.DeserializationError{
10001			Err:      fmt.Errorf("failed to decode response body, %w", err),
10002			Snapshot: snapshot.Bytes(),
10003		}
10004		return err
10005	}
10006
10007	output := &types.WAFStaleDataException{}
10008	err := awsAwsjson11_deserializeDocumentWAFStaleDataException(&output, shape)
10009
10010	if err != nil {
10011		var snapshot bytes.Buffer
10012		io.Copy(&snapshot, ringBuffer)
10013		err = &smithy.DeserializationError{
10014			Err:      fmt.Errorf("failed to decode response body, %w", err),
10015			Snapshot: snapshot.Bytes(),
10016		}
10017		return err
10018	}
10019
10020	errorBody.Seek(0, io.SeekStart)
10021	return output
10022}
10023
10024func awsAwsjson11_deserializeErrorWAFSubscriptionNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10025	var buff [1024]byte
10026	ringBuffer := smithyio.NewRingBuffer(buff[:])
10027
10028	body := io.TeeReader(errorBody, ringBuffer)
10029	decoder := json.NewDecoder(body)
10030	decoder.UseNumber()
10031	var shape interface{}
10032	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10033		var snapshot bytes.Buffer
10034		io.Copy(&snapshot, ringBuffer)
10035		err = &smithy.DeserializationError{
10036			Err:      fmt.Errorf("failed to decode response body, %w", err),
10037			Snapshot: snapshot.Bytes(),
10038		}
10039		return err
10040	}
10041
10042	output := &types.WAFSubscriptionNotFoundException{}
10043	err := awsAwsjson11_deserializeDocumentWAFSubscriptionNotFoundException(&output, shape)
10044
10045	if err != nil {
10046		var snapshot bytes.Buffer
10047		io.Copy(&snapshot, ringBuffer)
10048		err = &smithy.DeserializationError{
10049			Err:      fmt.Errorf("failed to decode response body, %w", err),
10050			Snapshot: snapshot.Bytes(),
10051		}
10052		return err
10053	}
10054
10055	errorBody.Seek(0, io.SeekStart)
10056	return output
10057}
10058
10059func awsAwsjson11_deserializeErrorWAFTagOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10060	var buff [1024]byte
10061	ringBuffer := smithyio.NewRingBuffer(buff[:])
10062
10063	body := io.TeeReader(errorBody, ringBuffer)
10064	decoder := json.NewDecoder(body)
10065	decoder.UseNumber()
10066	var shape interface{}
10067	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10068		var snapshot bytes.Buffer
10069		io.Copy(&snapshot, ringBuffer)
10070		err = &smithy.DeserializationError{
10071			Err:      fmt.Errorf("failed to decode response body, %w", err),
10072			Snapshot: snapshot.Bytes(),
10073		}
10074		return err
10075	}
10076
10077	output := &types.WAFTagOperationException{}
10078	err := awsAwsjson11_deserializeDocumentWAFTagOperationException(&output, shape)
10079
10080	if err != nil {
10081		var snapshot bytes.Buffer
10082		io.Copy(&snapshot, ringBuffer)
10083		err = &smithy.DeserializationError{
10084			Err:      fmt.Errorf("failed to decode response body, %w", err),
10085			Snapshot: snapshot.Bytes(),
10086		}
10087		return err
10088	}
10089
10090	errorBody.Seek(0, io.SeekStart)
10091	return output
10092}
10093
10094func awsAwsjson11_deserializeErrorWAFTagOperationInternalErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10095	var buff [1024]byte
10096	ringBuffer := smithyio.NewRingBuffer(buff[:])
10097
10098	body := io.TeeReader(errorBody, ringBuffer)
10099	decoder := json.NewDecoder(body)
10100	decoder.UseNumber()
10101	var shape interface{}
10102	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10103		var snapshot bytes.Buffer
10104		io.Copy(&snapshot, ringBuffer)
10105		err = &smithy.DeserializationError{
10106			Err:      fmt.Errorf("failed to decode response body, %w", err),
10107			Snapshot: snapshot.Bytes(),
10108		}
10109		return err
10110	}
10111
10112	output := &types.WAFTagOperationInternalErrorException{}
10113	err := awsAwsjson11_deserializeDocumentWAFTagOperationInternalErrorException(&output, shape)
10114
10115	if err != nil {
10116		var snapshot bytes.Buffer
10117		io.Copy(&snapshot, ringBuffer)
10118		err = &smithy.DeserializationError{
10119			Err:      fmt.Errorf("failed to decode response body, %w", err),
10120			Snapshot: snapshot.Bytes(),
10121		}
10122		return err
10123	}
10124
10125	errorBody.Seek(0, io.SeekStart)
10126	return output
10127}
10128
10129func awsAwsjson11_deserializeDocumentActivatedRule(v **types.ActivatedRule, value interface{}) error {
10130	if v == nil {
10131		return fmt.Errorf("unexpected nil of type %T", v)
10132	}
10133	if value == nil {
10134		return nil
10135	}
10136
10137	shape, ok := value.(map[string]interface{})
10138	if !ok {
10139		return fmt.Errorf("unexpected JSON type %v", value)
10140	}
10141
10142	var sv *types.ActivatedRule
10143	if *v == nil {
10144		sv = &types.ActivatedRule{}
10145	} else {
10146		sv = *v
10147	}
10148
10149	for key, value := range shape {
10150		switch key {
10151		case "Action":
10152			if err := awsAwsjson11_deserializeDocumentWafAction(&sv.Action, value); err != nil {
10153				return err
10154			}
10155
10156		case "ExcludedRules":
10157			if err := awsAwsjson11_deserializeDocumentExcludedRules(&sv.ExcludedRules, value); err != nil {
10158				return err
10159			}
10160
10161		case "OverrideAction":
10162			if err := awsAwsjson11_deserializeDocumentWafOverrideAction(&sv.OverrideAction, value); err != nil {
10163				return err
10164			}
10165
10166		case "Priority":
10167			if value != nil {
10168				jtv, ok := value.(json.Number)
10169				if !ok {
10170					return fmt.Errorf("expected RulePriority to be json.Number, got %T instead", value)
10171				}
10172				i64, err := jtv.Int64()
10173				if err != nil {
10174					return err
10175				}
10176				sv.Priority = ptr.Int32(int32(i64))
10177			}
10178
10179		case "RuleId":
10180			if value != nil {
10181				jtv, ok := value.(string)
10182				if !ok {
10183					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10184				}
10185				sv.RuleId = ptr.String(jtv)
10186			}
10187
10188		case "Type":
10189			if value != nil {
10190				jtv, ok := value.(string)
10191				if !ok {
10192					return fmt.Errorf("expected WafRuleType to be of type string, got %T instead", value)
10193				}
10194				sv.Type = types.WafRuleType(jtv)
10195			}
10196
10197		default:
10198			_, _ = key, value
10199
10200		}
10201	}
10202	*v = sv
10203	return nil
10204}
10205
10206func awsAwsjson11_deserializeDocumentActivatedRules(v *[]types.ActivatedRule, value interface{}) error {
10207	if v == nil {
10208		return fmt.Errorf("unexpected nil of type %T", v)
10209	}
10210	if value == nil {
10211		return nil
10212	}
10213
10214	shape, ok := value.([]interface{})
10215	if !ok {
10216		return fmt.Errorf("unexpected JSON type %v", value)
10217	}
10218
10219	var cv []types.ActivatedRule
10220	if *v == nil {
10221		cv = []types.ActivatedRule{}
10222	} else {
10223		cv = *v
10224	}
10225
10226	for _, value := range shape {
10227		var col types.ActivatedRule
10228		destAddr := &col
10229		if err := awsAwsjson11_deserializeDocumentActivatedRule(&destAddr, value); err != nil {
10230			return err
10231		}
10232		col = *destAddr
10233		cv = append(cv, col)
10234
10235	}
10236	*v = cv
10237	return nil
10238}
10239
10240func awsAwsjson11_deserializeDocumentByteMatchSet(v **types.ByteMatchSet, value interface{}) error {
10241	if v == nil {
10242		return fmt.Errorf("unexpected nil of type %T", v)
10243	}
10244	if value == nil {
10245		return nil
10246	}
10247
10248	shape, ok := value.(map[string]interface{})
10249	if !ok {
10250		return fmt.Errorf("unexpected JSON type %v", value)
10251	}
10252
10253	var sv *types.ByteMatchSet
10254	if *v == nil {
10255		sv = &types.ByteMatchSet{}
10256	} else {
10257		sv = *v
10258	}
10259
10260	for key, value := range shape {
10261		switch key {
10262		case "ByteMatchSetId":
10263			if value != nil {
10264				jtv, ok := value.(string)
10265				if !ok {
10266					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10267				}
10268				sv.ByteMatchSetId = ptr.String(jtv)
10269			}
10270
10271		case "ByteMatchTuples":
10272			if err := awsAwsjson11_deserializeDocumentByteMatchTuples(&sv.ByteMatchTuples, value); err != nil {
10273				return err
10274			}
10275
10276		case "Name":
10277			if value != nil {
10278				jtv, ok := value.(string)
10279				if !ok {
10280					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
10281				}
10282				sv.Name = ptr.String(jtv)
10283			}
10284
10285		default:
10286			_, _ = key, value
10287
10288		}
10289	}
10290	*v = sv
10291	return nil
10292}
10293
10294func awsAwsjson11_deserializeDocumentByteMatchSetSummaries(v *[]types.ByteMatchSetSummary, value interface{}) error {
10295	if v == nil {
10296		return fmt.Errorf("unexpected nil of type %T", v)
10297	}
10298	if value == nil {
10299		return nil
10300	}
10301
10302	shape, ok := value.([]interface{})
10303	if !ok {
10304		return fmt.Errorf("unexpected JSON type %v", value)
10305	}
10306
10307	var cv []types.ByteMatchSetSummary
10308	if *v == nil {
10309		cv = []types.ByteMatchSetSummary{}
10310	} else {
10311		cv = *v
10312	}
10313
10314	for _, value := range shape {
10315		var col types.ByteMatchSetSummary
10316		destAddr := &col
10317		if err := awsAwsjson11_deserializeDocumentByteMatchSetSummary(&destAddr, value); err != nil {
10318			return err
10319		}
10320		col = *destAddr
10321		cv = append(cv, col)
10322
10323	}
10324	*v = cv
10325	return nil
10326}
10327
10328func awsAwsjson11_deserializeDocumentByteMatchSetSummary(v **types.ByteMatchSetSummary, value interface{}) error {
10329	if v == nil {
10330		return fmt.Errorf("unexpected nil of type %T", v)
10331	}
10332	if value == nil {
10333		return nil
10334	}
10335
10336	shape, ok := value.(map[string]interface{})
10337	if !ok {
10338		return fmt.Errorf("unexpected JSON type %v", value)
10339	}
10340
10341	var sv *types.ByteMatchSetSummary
10342	if *v == nil {
10343		sv = &types.ByteMatchSetSummary{}
10344	} else {
10345		sv = *v
10346	}
10347
10348	for key, value := range shape {
10349		switch key {
10350		case "ByteMatchSetId":
10351			if value != nil {
10352				jtv, ok := value.(string)
10353				if !ok {
10354					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10355				}
10356				sv.ByteMatchSetId = ptr.String(jtv)
10357			}
10358
10359		case "Name":
10360			if value != nil {
10361				jtv, ok := value.(string)
10362				if !ok {
10363					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
10364				}
10365				sv.Name = ptr.String(jtv)
10366			}
10367
10368		default:
10369			_, _ = key, value
10370
10371		}
10372	}
10373	*v = sv
10374	return nil
10375}
10376
10377func awsAwsjson11_deserializeDocumentByteMatchTuple(v **types.ByteMatchTuple, value interface{}) error {
10378	if v == nil {
10379		return fmt.Errorf("unexpected nil of type %T", v)
10380	}
10381	if value == nil {
10382		return nil
10383	}
10384
10385	shape, ok := value.(map[string]interface{})
10386	if !ok {
10387		return fmt.Errorf("unexpected JSON type %v", value)
10388	}
10389
10390	var sv *types.ByteMatchTuple
10391	if *v == nil {
10392		sv = &types.ByteMatchTuple{}
10393	} else {
10394		sv = *v
10395	}
10396
10397	for key, value := range shape {
10398		switch key {
10399		case "FieldToMatch":
10400			if err := awsAwsjson11_deserializeDocumentFieldToMatch(&sv.FieldToMatch, value); err != nil {
10401				return err
10402			}
10403
10404		case "PositionalConstraint":
10405			if value != nil {
10406				jtv, ok := value.(string)
10407				if !ok {
10408					return fmt.Errorf("expected PositionalConstraint to be of type string, got %T instead", value)
10409				}
10410				sv.PositionalConstraint = types.PositionalConstraint(jtv)
10411			}
10412
10413		case "TargetString":
10414			if value != nil {
10415				jtv, ok := value.(string)
10416				if !ok {
10417					return fmt.Errorf("expected ByteMatchTargetString to be []byte, got %T instead", value)
10418				}
10419				dv, err := base64.StdEncoding.DecodeString(jtv)
10420				if err != nil {
10421					return fmt.Errorf("failed to base64 decode ByteMatchTargetString, %w", err)
10422				}
10423				sv.TargetString = dv
10424			}
10425
10426		case "TextTransformation":
10427			if value != nil {
10428				jtv, ok := value.(string)
10429				if !ok {
10430					return fmt.Errorf("expected TextTransformation to be of type string, got %T instead", value)
10431				}
10432				sv.TextTransformation = types.TextTransformation(jtv)
10433			}
10434
10435		default:
10436			_, _ = key, value
10437
10438		}
10439	}
10440	*v = sv
10441	return nil
10442}
10443
10444func awsAwsjson11_deserializeDocumentByteMatchTuples(v *[]types.ByteMatchTuple, value interface{}) error {
10445	if v == nil {
10446		return fmt.Errorf("unexpected nil of type %T", v)
10447	}
10448	if value == nil {
10449		return nil
10450	}
10451
10452	shape, ok := value.([]interface{})
10453	if !ok {
10454		return fmt.Errorf("unexpected JSON type %v", value)
10455	}
10456
10457	var cv []types.ByteMatchTuple
10458	if *v == nil {
10459		cv = []types.ByteMatchTuple{}
10460	} else {
10461		cv = *v
10462	}
10463
10464	for _, value := range shape {
10465		var col types.ByteMatchTuple
10466		destAddr := &col
10467		if err := awsAwsjson11_deserializeDocumentByteMatchTuple(&destAddr, value); err != nil {
10468			return err
10469		}
10470		col = *destAddr
10471		cv = append(cv, col)
10472
10473	}
10474	*v = cv
10475	return nil
10476}
10477
10478func awsAwsjson11_deserializeDocumentExcludedRule(v **types.ExcludedRule, value interface{}) error {
10479	if v == nil {
10480		return fmt.Errorf("unexpected nil of type %T", v)
10481	}
10482	if value == nil {
10483		return nil
10484	}
10485
10486	shape, ok := value.(map[string]interface{})
10487	if !ok {
10488		return fmt.Errorf("unexpected JSON type %v", value)
10489	}
10490
10491	var sv *types.ExcludedRule
10492	if *v == nil {
10493		sv = &types.ExcludedRule{}
10494	} else {
10495		sv = *v
10496	}
10497
10498	for key, value := range shape {
10499		switch key {
10500		case "RuleId":
10501			if value != nil {
10502				jtv, ok := value.(string)
10503				if !ok {
10504					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10505				}
10506				sv.RuleId = ptr.String(jtv)
10507			}
10508
10509		default:
10510			_, _ = key, value
10511
10512		}
10513	}
10514	*v = sv
10515	return nil
10516}
10517
10518func awsAwsjson11_deserializeDocumentExcludedRules(v *[]types.ExcludedRule, value interface{}) error {
10519	if v == nil {
10520		return fmt.Errorf("unexpected nil of type %T", v)
10521	}
10522	if value == nil {
10523		return nil
10524	}
10525
10526	shape, ok := value.([]interface{})
10527	if !ok {
10528		return fmt.Errorf("unexpected JSON type %v", value)
10529	}
10530
10531	var cv []types.ExcludedRule
10532	if *v == nil {
10533		cv = []types.ExcludedRule{}
10534	} else {
10535		cv = *v
10536	}
10537
10538	for _, value := range shape {
10539		var col types.ExcludedRule
10540		destAddr := &col
10541		if err := awsAwsjson11_deserializeDocumentExcludedRule(&destAddr, value); err != nil {
10542			return err
10543		}
10544		col = *destAddr
10545		cv = append(cv, col)
10546
10547	}
10548	*v = cv
10549	return nil
10550}
10551
10552func awsAwsjson11_deserializeDocumentFieldToMatch(v **types.FieldToMatch, value interface{}) error {
10553	if v == nil {
10554		return fmt.Errorf("unexpected nil of type %T", v)
10555	}
10556	if value == nil {
10557		return nil
10558	}
10559
10560	shape, ok := value.(map[string]interface{})
10561	if !ok {
10562		return fmt.Errorf("unexpected JSON type %v", value)
10563	}
10564
10565	var sv *types.FieldToMatch
10566	if *v == nil {
10567		sv = &types.FieldToMatch{}
10568	} else {
10569		sv = *v
10570	}
10571
10572	for key, value := range shape {
10573		switch key {
10574		case "Data":
10575			if value != nil {
10576				jtv, ok := value.(string)
10577				if !ok {
10578					return fmt.Errorf("expected MatchFieldData to be of type string, got %T instead", value)
10579				}
10580				sv.Data = ptr.String(jtv)
10581			}
10582
10583		case "Type":
10584			if value != nil {
10585				jtv, ok := value.(string)
10586				if !ok {
10587					return fmt.Errorf("expected MatchFieldType to be of type string, got %T instead", value)
10588				}
10589				sv.Type = types.MatchFieldType(jtv)
10590			}
10591
10592		default:
10593			_, _ = key, value
10594
10595		}
10596	}
10597	*v = sv
10598	return nil
10599}
10600
10601func awsAwsjson11_deserializeDocumentGeoMatchConstraint(v **types.GeoMatchConstraint, value interface{}) error {
10602	if v == nil {
10603		return fmt.Errorf("unexpected nil of type %T", v)
10604	}
10605	if value == nil {
10606		return nil
10607	}
10608
10609	shape, ok := value.(map[string]interface{})
10610	if !ok {
10611		return fmt.Errorf("unexpected JSON type %v", value)
10612	}
10613
10614	var sv *types.GeoMatchConstraint
10615	if *v == nil {
10616		sv = &types.GeoMatchConstraint{}
10617	} else {
10618		sv = *v
10619	}
10620
10621	for key, value := range shape {
10622		switch key {
10623		case "Type":
10624			if value != nil {
10625				jtv, ok := value.(string)
10626				if !ok {
10627					return fmt.Errorf("expected GeoMatchConstraintType to be of type string, got %T instead", value)
10628				}
10629				sv.Type = types.GeoMatchConstraintType(jtv)
10630			}
10631
10632		case "Value":
10633			if value != nil {
10634				jtv, ok := value.(string)
10635				if !ok {
10636					return fmt.Errorf("expected GeoMatchConstraintValue to be of type string, got %T instead", value)
10637				}
10638				sv.Value = types.GeoMatchConstraintValue(jtv)
10639			}
10640
10641		default:
10642			_, _ = key, value
10643
10644		}
10645	}
10646	*v = sv
10647	return nil
10648}
10649
10650func awsAwsjson11_deserializeDocumentGeoMatchConstraints(v *[]types.GeoMatchConstraint, value interface{}) error {
10651	if v == nil {
10652		return fmt.Errorf("unexpected nil of type %T", v)
10653	}
10654	if value == nil {
10655		return nil
10656	}
10657
10658	shape, ok := value.([]interface{})
10659	if !ok {
10660		return fmt.Errorf("unexpected JSON type %v", value)
10661	}
10662
10663	var cv []types.GeoMatchConstraint
10664	if *v == nil {
10665		cv = []types.GeoMatchConstraint{}
10666	} else {
10667		cv = *v
10668	}
10669
10670	for _, value := range shape {
10671		var col types.GeoMatchConstraint
10672		destAddr := &col
10673		if err := awsAwsjson11_deserializeDocumentGeoMatchConstraint(&destAddr, value); err != nil {
10674			return err
10675		}
10676		col = *destAddr
10677		cv = append(cv, col)
10678
10679	}
10680	*v = cv
10681	return nil
10682}
10683
10684func awsAwsjson11_deserializeDocumentGeoMatchSet(v **types.GeoMatchSet, value interface{}) error {
10685	if v == nil {
10686		return fmt.Errorf("unexpected nil of type %T", v)
10687	}
10688	if value == nil {
10689		return nil
10690	}
10691
10692	shape, ok := value.(map[string]interface{})
10693	if !ok {
10694		return fmt.Errorf("unexpected JSON type %v", value)
10695	}
10696
10697	var sv *types.GeoMatchSet
10698	if *v == nil {
10699		sv = &types.GeoMatchSet{}
10700	} else {
10701		sv = *v
10702	}
10703
10704	for key, value := range shape {
10705		switch key {
10706		case "GeoMatchConstraints":
10707			if err := awsAwsjson11_deserializeDocumentGeoMatchConstraints(&sv.GeoMatchConstraints, value); err != nil {
10708				return err
10709			}
10710
10711		case "GeoMatchSetId":
10712			if value != nil {
10713				jtv, ok := value.(string)
10714				if !ok {
10715					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10716				}
10717				sv.GeoMatchSetId = ptr.String(jtv)
10718			}
10719
10720		case "Name":
10721			if value != nil {
10722				jtv, ok := value.(string)
10723				if !ok {
10724					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
10725				}
10726				sv.Name = ptr.String(jtv)
10727			}
10728
10729		default:
10730			_, _ = key, value
10731
10732		}
10733	}
10734	*v = sv
10735	return nil
10736}
10737
10738func awsAwsjson11_deserializeDocumentGeoMatchSetSummaries(v *[]types.GeoMatchSetSummary, value interface{}) error {
10739	if v == nil {
10740		return fmt.Errorf("unexpected nil of type %T", v)
10741	}
10742	if value == nil {
10743		return nil
10744	}
10745
10746	shape, ok := value.([]interface{})
10747	if !ok {
10748		return fmt.Errorf("unexpected JSON type %v", value)
10749	}
10750
10751	var cv []types.GeoMatchSetSummary
10752	if *v == nil {
10753		cv = []types.GeoMatchSetSummary{}
10754	} else {
10755		cv = *v
10756	}
10757
10758	for _, value := range shape {
10759		var col types.GeoMatchSetSummary
10760		destAddr := &col
10761		if err := awsAwsjson11_deserializeDocumentGeoMatchSetSummary(&destAddr, value); err != nil {
10762			return err
10763		}
10764		col = *destAddr
10765		cv = append(cv, col)
10766
10767	}
10768	*v = cv
10769	return nil
10770}
10771
10772func awsAwsjson11_deserializeDocumentGeoMatchSetSummary(v **types.GeoMatchSetSummary, value interface{}) error {
10773	if v == nil {
10774		return fmt.Errorf("unexpected nil of type %T", v)
10775	}
10776	if value == nil {
10777		return nil
10778	}
10779
10780	shape, ok := value.(map[string]interface{})
10781	if !ok {
10782		return fmt.Errorf("unexpected JSON type %v", value)
10783	}
10784
10785	var sv *types.GeoMatchSetSummary
10786	if *v == nil {
10787		sv = &types.GeoMatchSetSummary{}
10788	} else {
10789		sv = *v
10790	}
10791
10792	for key, value := range shape {
10793		switch key {
10794		case "GeoMatchSetId":
10795			if value != nil {
10796				jtv, ok := value.(string)
10797				if !ok {
10798					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
10799				}
10800				sv.GeoMatchSetId = ptr.String(jtv)
10801			}
10802
10803		case "Name":
10804			if value != nil {
10805				jtv, ok := value.(string)
10806				if !ok {
10807					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
10808				}
10809				sv.Name = ptr.String(jtv)
10810			}
10811
10812		default:
10813			_, _ = key, value
10814
10815		}
10816	}
10817	*v = sv
10818	return nil
10819}
10820
10821func awsAwsjson11_deserializeDocumentHTTPHeader(v **types.HTTPHeader, value interface{}) error {
10822	if v == nil {
10823		return fmt.Errorf("unexpected nil of type %T", v)
10824	}
10825	if value == nil {
10826		return nil
10827	}
10828
10829	shape, ok := value.(map[string]interface{})
10830	if !ok {
10831		return fmt.Errorf("unexpected JSON type %v", value)
10832	}
10833
10834	var sv *types.HTTPHeader
10835	if *v == nil {
10836		sv = &types.HTTPHeader{}
10837	} else {
10838		sv = *v
10839	}
10840
10841	for key, value := range shape {
10842		switch key {
10843		case "Name":
10844			if value != nil {
10845				jtv, ok := value.(string)
10846				if !ok {
10847					return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value)
10848				}
10849				sv.Name = ptr.String(jtv)
10850			}
10851
10852		case "Value":
10853			if value != nil {
10854				jtv, ok := value.(string)
10855				if !ok {
10856					return fmt.Errorf("expected HeaderValue to be of type string, got %T instead", value)
10857				}
10858				sv.Value = ptr.String(jtv)
10859			}
10860
10861		default:
10862			_, _ = key, value
10863
10864		}
10865	}
10866	*v = sv
10867	return nil
10868}
10869
10870func awsAwsjson11_deserializeDocumentHTTPHeaders(v *[]types.HTTPHeader, value interface{}) error {
10871	if v == nil {
10872		return fmt.Errorf("unexpected nil of type %T", v)
10873	}
10874	if value == nil {
10875		return nil
10876	}
10877
10878	shape, ok := value.([]interface{})
10879	if !ok {
10880		return fmt.Errorf("unexpected JSON type %v", value)
10881	}
10882
10883	var cv []types.HTTPHeader
10884	if *v == nil {
10885		cv = []types.HTTPHeader{}
10886	} else {
10887		cv = *v
10888	}
10889
10890	for _, value := range shape {
10891		var col types.HTTPHeader
10892		destAddr := &col
10893		if err := awsAwsjson11_deserializeDocumentHTTPHeader(&destAddr, value); err != nil {
10894			return err
10895		}
10896		col = *destAddr
10897		cv = append(cv, col)
10898
10899	}
10900	*v = cv
10901	return nil
10902}
10903
10904func awsAwsjson11_deserializeDocumentHTTPRequest(v **types.HTTPRequest, value interface{}) error {
10905	if v == nil {
10906		return fmt.Errorf("unexpected nil of type %T", v)
10907	}
10908	if value == nil {
10909		return nil
10910	}
10911
10912	shape, ok := value.(map[string]interface{})
10913	if !ok {
10914		return fmt.Errorf("unexpected JSON type %v", value)
10915	}
10916
10917	var sv *types.HTTPRequest
10918	if *v == nil {
10919		sv = &types.HTTPRequest{}
10920	} else {
10921		sv = *v
10922	}
10923
10924	for key, value := range shape {
10925		switch key {
10926		case "ClientIP":
10927			if value != nil {
10928				jtv, ok := value.(string)
10929				if !ok {
10930					return fmt.Errorf("expected IPString to be of type string, got %T instead", value)
10931				}
10932				sv.ClientIP = ptr.String(jtv)
10933			}
10934
10935		case "Country":
10936			if value != nil {
10937				jtv, ok := value.(string)
10938				if !ok {
10939					return fmt.Errorf("expected Country to be of type string, got %T instead", value)
10940				}
10941				sv.Country = ptr.String(jtv)
10942			}
10943
10944		case "Headers":
10945			if err := awsAwsjson11_deserializeDocumentHTTPHeaders(&sv.Headers, value); err != nil {
10946				return err
10947			}
10948
10949		case "HTTPVersion":
10950			if value != nil {
10951				jtv, ok := value.(string)
10952				if !ok {
10953					return fmt.Errorf("expected HTTPVersion to be of type string, got %T instead", value)
10954				}
10955				sv.HTTPVersion = ptr.String(jtv)
10956			}
10957
10958		case "Method":
10959			if value != nil {
10960				jtv, ok := value.(string)
10961				if !ok {
10962					return fmt.Errorf("expected HTTPMethod to be of type string, got %T instead", value)
10963				}
10964				sv.Method = ptr.String(jtv)
10965			}
10966
10967		case "URI":
10968			if value != nil {
10969				jtv, ok := value.(string)
10970				if !ok {
10971					return fmt.Errorf("expected URIString to be of type string, got %T instead", value)
10972				}
10973				sv.URI = ptr.String(jtv)
10974			}
10975
10976		default:
10977			_, _ = key, value
10978
10979		}
10980	}
10981	*v = sv
10982	return nil
10983}
10984
10985func awsAwsjson11_deserializeDocumentIPSet(v **types.IPSet, value interface{}) error {
10986	if v == nil {
10987		return fmt.Errorf("unexpected nil of type %T", v)
10988	}
10989	if value == nil {
10990		return nil
10991	}
10992
10993	shape, ok := value.(map[string]interface{})
10994	if !ok {
10995		return fmt.Errorf("unexpected JSON type %v", value)
10996	}
10997
10998	var sv *types.IPSet
10999	if *v == nil {
11000		sv = &types.IPSet{}
11001	} else {
11002		sv = *v
11003	}
11004
11005	for key, value := range shape {
11006		switch key {
11007		case "IPSetDescriptors":
11008			if err := awsAwsjson11_deserializeDocumentIPSetDescriptors(&sv.IPSetDescriptors, value); err != nil {
11009				return err
11010			}
11011
11012		case "IPSetId":
11013			if value != nil {
11014				jtv, ok := value.(string)
11015				if !ok {
11016					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11017				}
11018				sv.IPSetId = ptr.String(jtv)
11019			}
11020
11021		case "Name":
11022			if value != nil {
11023				jtv, ok := value.(string)
11024				if !ok {
11025					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11026				}
11027				sv.Name = ptr.String(jtv)
11028			}
11029
11030		default:
11031			_, _ = key, value
11032
11033		}
11034	}
11035	*v = sv
11036	return nil
11037}
11038
11039func awsAwsjson11_deserializeDocumentIPSetDescriptor(v **types.IPSetDescriptor, value interface{}) error {
11040	if v == nil {
11041		return fmt.Errorf("unexpected nil of type %T", v)
11042	}
11043	if value == nil {
11044		return nil
11045	}
11046
11047	shape, ok := value.(map[string]interface{})
11048	if !ok {
11049		return fmt.Errorf("unexpected JSON type %v", value)
11050	}
11051
11052	var sv *types.IPSetDescriptor
11053	if *v == nil {
11054		sv = &types.IPSetDescriptor{}
11055	} else {
11056		sv = *v
11057	}
11058
11059	for key, value := range shape {
11060		switch key {
11061		case "Type":
11062			if value != nil {
11063				jtv, ok := value.(string)
11064				if !ok {
11065					return fmt.Errorf("expected IPSetDescriptorType to be of type string, got %T instead", value)
11066				}
11067				sv.Type = types.IPSetDescriptorType(jtv)
11068			}
11069
11070		case "Value":
11071			if value != nil {
11072				jtv, ok := value.(string)
11073				if !ok {
11074					return fmt.Errorf("expected IPSetDescriptorValue to be of type string, got %T instead", value)
11075				}
11076				sv.Value = ptr.String(jtv)
11077			}
11078
11079		default:
11080			_, _ = key, value
11081
11082		}
11083	}
11084	*v = sv
11085	return nil
11086}
11087
11088func awsAwsjson11_deserializeDocumentIPSetDescriptors(v *[]types.IPSetDescriptor, value interface{}) error {
11089	if v == nil {
11090		return fmt.Errorf("unexpected nil of type %T", v)
11091	}
11092	if value == nil {
11093		return nil
11094	}
11095
11096	shape, ok := value.([]interface{})
11097	if !ok {
11098		return fmt.Errorf("unexpected JSON type %v", value)
11099	}
11100
11101	var cv []types.IPSetDescriptor
11102	if *v == nil {
11103		cv = []types.IPSetDescriptor{}
11104	} else {
11105		cv = *v
11106	}
11107
11108	for _, value := range shape {
11109		var col types.IPSetDescriptor
11110		destAddr := &col
11111		if err := awsAwsjson11_deserializeDocumentIPSetDescriptor(&destAddr, value); err != nil {
11112			return err
11113		}
11114		col = *destAddr
11115		cv = append(cv, col)
11116
11117	}
11118	*v = cv
11119	return nil
11120}
11121
11122func awsAwsjson11_deserializeDocumentIPSetSummaries(v *[]types.IPSetSummary, value interface{}) error {
11123	if v == nil {
11124		return fmt.Errorf("unexpected nil of type %T", v)
11125	}
11126	if value == nil {
11127		return nil
11128	}
11129
11130	shape, ok := value.([]interface{})
11131	if !ok {
11132		return fmt.Errorf("unexpected JSON type %v", value)
11133	}
11134
11135	var cv []types.IPSetSummary
11136	if *v == nil {
11137		cv = []types.IPSetSummary{}
11138	} else {
11139		cv = *v
11140	}
11141
11142	for _, value := range shape {
11143		var col types.IPSetSummary
11144		destAddr := &col
11145		if err := awsAwsjson11_deserializeDocumentIPSetSummary(&destAddr, value); err != nil {
11146			return err
11147		}
11148		col = *destAddr
11149		cv = append(cv, col)
11150
11151	}
11152	*v = cv
11153	return nil
11154}
11155
11156func awsAwsjson11_deserializeDocumentIPSetSummary(v **types.IPSetSummary, value interface{}) error {
11157	if v == nil {
11158		return fmt.Errorf("unexpected nil of type %T", v)
11159	}
11160	if value == nil {
11161		return nil
11162	}
11163
11164	shape, ok := value.(map[string]interface{})
11165	if !ok {
11166		return fmt.Errorf("unexpected JSON type %v", value)
11167	}
11168
11169	var sv *types.IPSetSummary
11170	if *v == nil {
11171		sv = &types.IPSetSummary{}
11172	} else {
11173		sv = *v
11174	}
11175
11176	for key, value := range shape {
11177		switch key {
11178		case "IPSetId":
11179			if value != nil {
11180				jtv, ok := value.(string)
11181				if !ok {
11182					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11183				}
11184				sv.IPSetId = ptr.String(jtv)
11185			}
11186
11187		case "Name":
11188			if value != nil {
11189				jtv, ok := value.(string)
11190				if !ok {
11191					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11192				}
11193				sv.Name = ptr.String(jtv)
11194			}
11195
11196		default:
11197			_, _ = key, value
11198
11199		}
11200	}
11201	*v = sv
11202	return nil
11203}
11204
11205func awsAwsjson11_deserializeDocumentLogDestinationConfigs(v *[]string, value interface{}) error {
11206	if v == nil {
11207		return fmt.Errorf("unexpected nil of type %T", v)
11208	}
11209	if value == nil {
11210		return nil
11211	}
11212
11213	shape, ok := value.([]interface{})
11214	if !ok {
11215		return fmt.Errorf("unexpected JSON type %v", value)
11216	}
11217
11218	var cv []string
11219	if *v == nil {
11220		cv = []string{}
11221	} else {
11222		cv = *v
11223	}
11224
11225	for _, value := range shape {
11226		var col string
11227		if value != nil {
11228			jtv, ok := value.(string)
11229			if !ok {
11230				return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
11231			}
11232			col = jtv
11233		}
11234		cv = append(cv, col)
11235
11236	}
11237	*v = cv
11238	return nil
11239}
11240
11241func awsAwsjson11_deserializeDocumentLoggingConfiguration(v **types.LoggingConfiguration, value interface{}) error {
11242	if v == nil {
11243		return fmt.Errorf("unexpected nil of type %T", v)
11244	}
11245	if value == nil {
11246		return nil
11247	}
11248
11249	shape, ok := value.(map[string]interface{})
11250	if !ok {
11251		return fmt.Errorf("unexpected JSON type %v", value)
11252	}
11253
11254	var sv *types.LoggingConfiguration
11255	if *v == nil {
11256		sv = &types.LoggingConfiguration{}
11257	} else {
11258		sv = *v
11259	}
11260
11261	for key, value := range shape {
11262		switch key {
11263		case "LogDestinationConfigs":
11264			if err := awsAwsjson11_deserializeDocumentLogDestinationConfigs(&sv.LogDestinationConfigs, value); err != nil {
11265				return err
11266			}
11267
11268		case "RedactedFields":
11269			if err := awsAwsjson11_deserializeDocumentRedactedFields(&sv.RedactedFields, value); err != nil {
11270				return err
11271			}
11272
11273		case "ResourceArn":
11274			if value != nil {
11275				jtv, ok := value.(string)
11276				if !ok {
11277					return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
11278				}
11279				sv.ResourceArn = ptr.String(jtv)
11280			}
11281
11282		default:
11283			_, _ = key, value
11284
11285		}
11286	}
11287	*v = sv
11288	return nil
11289}
11290
11291func awsAwsjson11_deserializeDocumentLoggingConfigurations(v *[]types.LoggingConfiguration, value interface{}) error {
11292	if v == nil {
11293		return fmt.Errorf("unexpected nil of type %T", v)
11294	}
11295	if value == nil {
11296		return nil
11297	}
11298
11299	shape, ok := value.([]interface{})
11300	if !ok {
11301		return fmt.Errorf("unexpected JSON type %v", value)
11302	}
11303
11304	var cv []types.LoggingConfiguration
11305	if *v == nil {
11306		cv = []types.LoggingConfiguration{}
11307	} else {
11308		cv = *v
11309	}
11310
11311	for _, value := range shape {
11312		var col types.LoggingConfiguration
11313		destAddr := &col
11314		if err := awsAwsjson11_deserializeDocumentLoggingConfiguration(&destAddr, value); err != nil {
11315			return err
11316		}
11317		col = *destAddr
11318		cv = append(cv, col)
11319
11320	}
11321	*v = cv
11322	return nil
11323}
11324
11325func awsAwsjson11_deserializeDocumentManagedKeys(v *[]string, value interface{}) error {
11326	if v == nil {
11327		return fmt.Errorf("unexpected nil of type %T", v)
11328	}
11329	if value == nil {
11330		return nil
11331	}
11332
11333	shape, ok := value.([]interface{})
11334	if !ok {
11335		return fmt.Errorf("unexpected JSON type %v", value)
11336	}
11337
11338	var cv []string
11339	if *v == nil {
11340		cv = []string{}
11341	} else {
11342		cv = *v
11343	}
11344
11345	for _, value := range shape {
11346		var col string
11347		if value != nil {
11348			jtv, ok := value.(string)
11349			if !ok {
11350				return fmt.Errorf("expected ManagedKey to be of type string, got %T instead", value)
11351			}
11352			col = jtv
11353		}
11354		cv = append(cv, col)
11355
11356	}
11357	*v = cv
11358	return nil
11359}
11360
11361func awsAwsjson11_deserializeDocumentPredicate(v **types.Predicate, value interface{}) error {
11362	if v == nil {
11363		return fmt.Errorf("unexpected nil of type %T", v)
11364	}
11365	if value == nil {
11366		return nil
11367	}
11368
11369	shape, ok := value.(map[string]interface{})
11370	if !ok {
11371		return fmt.Errorf("unexpected JSON type %v", value)
11372	}
11373
11374	var sv *types.Predicate
11375	if *v == nil {
11376		sv = &types.Predicate{}
11377	} else {
11378		sv = *v
11379	}
11380
11381	for key, value := range shape {
11382		switch key {
11383		case "DataId":
11384			if value != nil {
11385				jtv, ok := value.(string)
11386				if !ok {
11387					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11388				}
11389				sv.DataId = ptr.String(jtv)
11390			}
11391
11392		case "Negated":
11393			if value != nil {
11394				jtv, ok := value.(bool)
11395				if !ok {
11396					return fmt.Errorf("expected Negated to be of type *bool, got %T instead", value)
11397				}
11398				sv.Negated = ptr.Bool(jtv)
11399			}
11400
11401		case "Type":
11402			if value != nil {
11403				jtv, ok := value.(string)
11404				if !ok {
11405					return fmt.Errorf("expected PredicateType to be of type string, got %T instead", value)
11406				}
11407				sv.Type = types.PredicateType(jtv)
11408			}
11409
11410		default:
11411			_, _ = key, value
11412
11413		}
11414	}
11415	*v = sv
11416	return nil
11417}
11418
11419func awsAwsjson11_deserializeDocumentPredicates(v *[]types.Predicate, value interface{}) error {
11420	if v == nil {
11421		return fmt.Errorf("unexpected nil of type %T", v)
11422	}
11423	if value == nil {
11424		return nil
11425	}
11426
11427	shape, ok := value.([]interface{})
11428	if !ok {
11429		return fmt.Errorf("unexpected JSON type %v", value)
11430	}
11431
11432	var cv []types.Predicate
11433	if *v == nil {
11434		cv = []types.Predicate{}
11435	} else {
11436		cv = *v
11437	}
11438
11439	for _, value := range shape {
11440		var col types.Predicate
11441		destAddr := &col
11442		if err := awsAwsjson11_deserializeDocumentPredicate(&destAddr, value); err != nil {
11443			return err
11444		}
11445		col = *destAddr
11446		cv = append(cv, col)
11447
11448	}
11449	*v = cv
11450	return nil
11451}
11452
11453func awsAwsjson11_deserializeDocumentRateBasedRule(v **types.RateBasedRule, value interface{}) error {
11454	if v == nil {
11455		return fmt.Errorf("unexpected nil of type %T", v)
11456	}
11457	if value == nil {
11458		return nil
11459	}
11460
11461	shape, ok := value.(map[string]interface{})
11462	if !ok {
11463		return fmt.Errorf("unexpected JSON type %v", value)
11464	}
11465
11466	var sv *types.RateBasedRule
11467	if *v == nil {
11468		sv = &types.RateBasedRule{}
11469	} else {
11470		sv = *v
11471	}
11472
11473	for key, value := range shape {
11474		switch key {
11475		case "MatchPredicates":
11476			if err := awsAwsjson11_deserializeDocumentPredicates(&sv.MatchPredicates, value); err != nil {
11477				return err
11478			}
11479
11480		case "MetricName":
11481			if value != nil {
11482				jtv, ok := value.(string)
11483				if !ok {
11484					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
11485				}
11486				sv.MetricName = ptr.String(jtv)
11487			}
11488
11489		case "Name":
11490			if value != nil {
11491				jtv, ok := value.(string)
11492				if !ok {
11493					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11494				}
11495				sv.Name = ptr.String(jtv)
11496			}
11497
11498		case "RateKey":
11499			if value != nil {
11500				jtv, ok := value.(string)
11501				if !ok {
11502					return fmt.Errorf("expected RateKey to be of type string, got %T instead", value)
11503				}
11504				sv.RateKey = types.RateKey(jtv)
11505			}
11506
11507		case "RateLimit":
11508			if value != nil {
11509				jtv, ok := value.(json.Number)
11510				if !ok {
11511					return fmt.Errorf("expected RateLimit to be json.Number, got %T instead", value)
11512				}
11513				i64, err := jtv.Int64()
11514				if err != nil {
11515					return err
11516				}
11517				sv.RateLimit = i64
11518			}
11519
11520		case "RuleId":
11521			if value != nil {
11522				jtv, ok := value.(string)
11523				if !ok {
11524					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11525				}
11526				sv.RuleId = ptr.String(jtv)
11527			}
11528
11529		default:
11530			_, _ = key, value
11531
11532		}
11533	}
11534	*v = sv
11535	return nil
11536}
11537
11538func awsAwsjson11_deserializeDocumentRedactedFields(v *[]types.FieldToMatch, value interface{}) error {
11539	if v == nil {
11540		return fmt.Errorf("unexpected nil of type %T", v)
11541	}
11542	if value == nil {
11543		return nil
11544	}
11545
11546	shape, ok := value.([]interface{})
11547	if !ok {
11548		return fmt.Errorf("unexpected JSON type %v", value)
11549	}
11550
11551	var cv []types.FieldToMatch
11552	if *v == nil {
11553		cv = []types.FieldToMatch{}
11554	} else {
11555		cv = *v
11556	}
11557
11558	for _, value := range shape {
11559		var col types.FieldToMatch
11560		destAddr := &col
11561		if err := awsAwsjson11_deserializeDocumentFieldToMatch(&destAddr, value); err != nil {
11562			return err
11563		}
11564		col = *destAddr
11565		cv = append(cv, col)
11566
11567	}
11568	*v = cv
11569	return nil
11570}
11571
11572func awsAwsjson11_deserializeDocumentRegexMatchSet(v **types.RegexMatchSet, value interface{}) error {
11573	if v == nil {
11574		return fmt.Errorf("unexpected nil of type %T", v)
11575	}
11576	if value == nil {
11577		return nil
11578	}
11579
11580	shape, ok := value.(map[string]interface{})
11581	if !ok {
11582		return fmt.Errorf("unexpected JSON type %v", value)
11583	}
11584
11585	var sv *types.RegexMatchSet
11586	if *v == nil {
11587		sv = &types.RegexMatchSet{}
11588	} else {
11589		sv = *v
11590	}
11591
11592	for key, value := range shape {
11593		switch key {
11594		case "Name":
11595			if value != nil {
11596				jtv, ok := value.(string)
11597				if !ok {
11598					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11599				}
11600				sv.Name = ptr.String(jtv)
11601			}
11602
11603		case "RegexMatchSetId":
11604			if value != nil {
11605				jtv, ok := value.(string)
11606				if !ok {
11607					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11608				}
11609				sv.RegexMatchSetId = ptr.String(jtv)
11610			}
11611
11612		case "RegexMatchTuples":
11613			if err := awsAwsjson11_deserializeDocumentRegexMatchTuples(&sv.RegexMatchTuples, value); err != nil {
11614				return err
11615			}
11616
11617		default:
11618			_, _ = key, value
11619
11620		}
11621	}
11622	*v = sv
11623	return nil
11624}
11625
11626func awsAwsjson11_deserializeDocumentRegexMatchSetSummaries(v *[]types.RegexMatchSetSummary, value interface{}) error {
11627	if v == nil {
11628		return fmt.Errorf("unexpected nil of type %T", v)
11629	}
11630	if value == nil {
11631		return nil
11632	}
11633
11634	shape, ok := value.([]interface{})
11635	if !ok {
11636		return fmt.Errorf("unexpected JSON type %v", value)
11637	}
11638
11639	var cv []types.RegexMatchSetSummary
11640	if *v == nil {
11641		cv = []types.RegexMatchSetSummary{}
11642	} else {
11643		cv = *v
11644	}
11645
11646	for _, value := range shape {
11647		var col types.RegexMatchSetSummary
11648		destAddr := &col
11649		if err := awsAwsjson11_deserializeDocumentRegexMatchSetSummary(&destAddr, value); err != nil {
11650			return err
11651		}
11652		col = *destAddr
11653		cv = append(cv, col)
11654
11655	}
11656	*v = cv
11657	return nil
11658}
11659
11660func awsAwsjson11_deserializeDocumentRegexMatchSetSummary(v **types.RegexMatchSetSummary, value interface{}) error {
11661	if v == nil {
11662		return fmt.Errorf("unexpected nil of type %T", v)
11663	}
11664	if value == nil {
11665		return nil
11666	}
11667
11668	shape, ok := value.(map[string]interface{})
11669	if !ok {
11670		return fmt.Errorf("unexpected JSON type %v", value)
11671	}
11672
11673	var sv *types.RegexMatchSetSummary
11674	if *v == nil {
11675		sv = &types.RegexMatchSetSummary{}
11676	} else {
11677		sv = *v
11678	}
11679
11680	for key, value := range shape {
11681		switch key {
11682		case "Name":
11683			if value != nil {
11684				jtv, ok := value.(string)
11685				if !ok {
11686					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11687				}
11688				sv.Name = ptr.String(jtv)
11689			}
11690
11691		case "RegexMatchSetId":
11692			if value != nil {
11693				jtv, ok := value.(string)
11694				if !ok {
11695					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11696				}
11697				sv.RegexMatchSetId = ptr.String(jtv)
11698			}
11699
11700		default:
11701			_, _ = key, value
11702
11703		}
11704	}
11705	*v = sv
11706	return nil
11707}
11708
11709func awsAwsjson11_deserializeDocumentRegexMatchTuple(v **types.RegexMatchTuple, value interface{}) error {
11710	if v == nil {
11711		return fmt.Errorf("unexpected nil of type %T", v)
11712	}
11713	if value == nil {
11714		return nil
11715	}
11716
11717	shape, ok := value.(map[string]interface{})
11718	if !ok {
11719		return fmt.Errorf("unexpected JSON type %v", value)
11720	}
11721
11722	var sv *types.RegexMatchTuple
11723	if *v == nil {
11724		sv = &types.RegexMatchTuple{}
11725	} else {
11726		sv = *v
11727	}
11728
11729	for key, value := range shape {
11730		switch key {
11731		case "FieldToMatch":
11732			if err := awsAwsjson11_deserializeDocumentFieldToMatch(&sv.FieldToMatch, value); err != nil {
11733				return err
11734			}
11735
11736		case "RegexPatternSetId":
11737			if value != nil {
11738				jtv, ok := value.(string)
11739				if !ok {
11740					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11741				}
11742				sv.RegexPatternSetId = ptr.String(jtv)
11743			}
11744
11745		case "TextTransformation":
11746			if value != nil {
11747				jtv, ok := value.(string)
11748				if !ok {
11749					return fmt.Errorf("expected TextTransformation to be of type string, got %T instead", value)
11750				}
11751				sv.TextTransformation = types.TextTransformation(jtv)
11752			}
11753
11754		default:
11755			_, _ = key, value
11756
11757		}
11758	}
11759	*v = sv
11760	return nil
11761}
11762
11763func awsAwsjson11_deserializeDocumentRegexMatchTuples(v *[]types.RegexMatchTuple, value interface{}) error {
11764	if v == nil {
11765		return fmt.Errorf("unexpected nil of type %T", v)
11766	}
11767	if value == nil {
11768		return nil
11769	}
11770
11771	shape, ok := value.([]interface{})
11772	if !ok {
11773		return fmt.Errorf("unexpected JSON type %v", value)
11774	}
11775
11776	var cv []types.RegexMatchTuple
11777	if *v == nil {
11778		cv = []types.RegexMatchTuple{}
11779	} else {
11780		cv = *v
11781	}
11782
11783	for _, value := range shape {
11784		var col types.RegexMatchTuple
11785		destAddr := &col
11786		if err := awsAwsjson11_deserializeDocumentRegexMatchTuple(&destAddr, value); err != nil {
11787			return err
11788		}
11789		col = *destAddr
11790		cv = append(cv, col)
11791
11792	}
11793	*v = cv
11794	return nil
11795}
11796
11797func awsAwsjson11_deserializeDocumentRegexPatternSet(v **types.RegexPatternSet, value interface{}) error {
11798	if v == nil {
11799		return fmt.Errorf("unexpected nil of type %T", v)
11800	}
11801	if value == nil {
11802		return nil
11803	}
11804
11805	shape, ok := value.(map[string]interface{})
11806	if !ok {
11807		return fmt.Errorf("unexpected JSON type %v", value)
11808	}
11809
11810	var sv *types.RegexPatternSet
11811	if *v == nil {
11812		sv = &types.RegexPatternSet{}
11813	} else {
11814		sv = *v
11815	}
11816
11817	for key, value := range shape {
11818		switch key {
11819		case "Name":
11820			if value != nil {
11821				jtv, ok := value.(string)
11822				if !ok {
11823					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11824				}
11825				sv.Name = ptr.String(jtv)
11826			}
11827
11828		case "RegexPatternSetId":
11829			if value != nil {
11830				jtv, ok := value.(string)
11831				if !ok {
11832					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11833				}
11834				sv.RegexPatternSetId = ptr.String(jtv)
11835			}
11836
11837		case "RegexPatternStrings":
11838			if err := awsAwsjson11_deserializeDocumentRegexPatternStrings(&sv.RegexPatternStrings, value); err != nil {
11839				return err
11840			}
11841
11842		default:
11843			_, _ = key, value
11844
11845		}
11846	}
11847	*v = sv
11848	return nil
11849}
11850
11851func awsAwsjson11_deserializeDocumentRegexPatternSetSummaries(v *[]types.RegexPatternSetSummary, value interface{}) error {
11852	if v == nil {
11853		return fmt.Errorf("unexpected nil of type %T", v)
11854	}
11855	if value == nil {
11856		return nil
11857	}
11858
11859	shape, ok := value.([]interface{})
11860	if !ok {
11861		return fmt.Errorf("unexpected JSON type %v", value)
11862	}
11863
11864	var cv []types.RegexPatternSetSummary
11865	if *v == nil {
11866		cv = []types.RegexPatternSetSummary{}
11867	} else {
11868		cv = *v
11869	}
11870
11871	for _, value := range shape {
11872		var col types.RegexPatternSetSummary
11873		destAddr := &col
11874		if err := awsAwsjson11_deserializeDocumentRegexPatternSetSummary(&destAddr, value); err != nil {
11875			return err
11876		}
11877		col = *destAddr
11878		cv = append(cv, col)
11879
11880	}
11881	*v = cv
11882	return nil
11883}
11884
11885func awsAwsjson11_deserializeDocumentRegexPatternSetSummary(v **types.RegexPatternSetSummary, value interface{}) error {
11886	if v == nil {
11887		return fmt.Errorf("unexpected nil of type %T", v)
11888	}
11889	if value == nil {
11890		return nil
11891	}
11892
11893	shape, ok := value.(map[string]interface{})
11894	if !ok {
11895		return fmt.Errorf("unexpected JSON type %v", value)
11896	}
11897
11898	var sv *types.RegexPatternSetSummary
11899	if *v == nil {
11900		sv = &types.RegexPatternSetSummary{}
11901	} else {
11902		sv = *v
11903	}
11904
11905	for key, value := range shape {
11906		switch key {
11907		case "Name":
11908			if value != nil {
11909				jtv, ok := value.(string)
11910				if !ok {
11911					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
11912				}
11913				sv.Name = ptr.String(jtv)
11914			}
11915
11916		case "RegexPatternSetId":
11917			if value != nil {
11918				jtv, ok := value.(string)
11919				if !ok {
11920					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
11921				}
11922				sv.RegexPatternSetId = ptr.String(jtv)
11923			}
11924
11925		default:
11926			_, _ = key, value
11927
11928		}
11929	}
11930	*v = sv
11931	return nil
11932}
11933
11934func awsAwsjson11_deserializeDocumentRegexPatternStrings(v *[]string, value interface{}) error {
11935	if v == nil {
11936		return fmt.Errorf("unexpected nil of type %T", v)
11937	}
11938	if value == nil {
11939		return nil
11940	}
11941
11942	shape, ok := value.([]interface{})
11943	if !ok {
11944		return fmt.Errorf("unexpected JSON type %v", value)
11945	}
11946
11947	var cv []string
11948	if *v == nil {
11949		cv = []string{}
11950	} else {
11951		cv = *v
11952	}
11953
11954	for _, value := range shape {
11955		var col string
11956		if value != nil {
11957			jtv, ok := value.(string)
11958			if !ok {
11959				return fmt.Errorf("expected RegexPatternString to be of type string, got %T instead", value)
11960			}
11961			col = jtv
11962		}
11963		cv = append(cv, col)
11964
11965	}
11966	*v = cv
11967	return nil
11968}
11969
11970func awsAwsjson11_deserializeDocumentRule(v **types.Rule, value interface{}) error {
11971	if v == nil {
11972		return fmt.Errorf("unexpected nil of type %T", v)
11973	}
11974	if value == nil {
11975		return nil
11976	}
11977
11978	shape, ok := value.(map[string]interface{})
11979	if !ok {
11980		return fmt.Errorf("unexpected JSON type %v", value)
11981	}
11982
11983	var sv *types.Rule
11984	if *v == nil {
11985		sv = &types.Rule{}
11986	} else {
11987		sv = *v
11988	}
11989
11990	for key, value := range shape {
11991		switch key {
11992		case "MetricName":
11993			if value != nil {
11994				jtv, ok := value.(string)
11995				if !ok {
11996					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
11997				}
11998				sv.MetricName = ptr.String(jtv)
11999			}
12000
12001		case "Name":
12002			if value != nil {
12003				jtv, ok := value.(string)
12004				if !ok {
12005					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12006				}
12007				sv.Name = ptr.String(jtv)
12008			}
12009
12010		case "Predicates":
12011			if err := awsAwsjson11_deserializeDocumentPredicates(&sv.Predicates, value); err != nil {
12012				return err
12013			}
12014
12015		case "RuleId":
12016			if value != nil {
12017				jtv, ok := value.(string)
12018				if !ok {
12019					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12020				}
12021				sv.RuleId = ptr.String(jtv)
12022			}
12023
12024		default:
12025			_, _ = key, value
12026
12027		}
12028	}
12029	*v = sv
12030	return nil
12031}
12032
12033func awsAwsjson11_deserializeDocumentRuleGroup(v **types.RuleGroup, value interface{}) error {
12034	if v == nil {
12035		return fmt.Errorf("unexpected nil of type %T", v)
12036	}
12037	if value == nil {
12038		return nil
12039	}
12040
12041	shape, ok := value.(map[string]interface{})
12042	if !ok {
12043		return fmt.Errorf("unexpected JSON type %v", value)
12044	}
12045
12046	var sv *types.RuleGroup
12047	if *v == nil {
12048		sv = &types.RuleGroup{}
12049	} else {
12050		sv = *v
12051	}
12052
12053	for key, value := range shape {
12054		switch key {
12055		case "MetricName":
12056			if value != nil {
12057				jtv, ok := value.(string)
12058				if !ok {
12059					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
12060				}
12061				sv.MetricName = ptr.String(jtv)
12062			}
12063
12064		case "Name":
12065			if value != nil {
12066				jtv, ok := value.(string)
12067				if !ok {
12068					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12069				}
12070				sv.Name = ptr.String(jtv)
12071			}
12072
12073		case "RuleGroupId":
12074			if value != nil {
12075				jtv, ok := value.(string)
12076				if !ok {
12077					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12078				}
12079				sv.RuleGroupId = ptr.String(jtv)
12080			}
12081
12082		default:
12083			_, _ = key, value
12084
12085		}
12086	}
12087	*v = sv
12088	return nil
12089}
12090
12091func awsAwsjson11_deserializeDocumentRuleGroupSummaries(v *[]types.RuleGroupSummary, value interface{}) error {
12092	if v == nil {
12093		return fmt.Errorf("unexpected nil of type %T", v)
12094	}
12095	if value == nil {
12096		return nil
12097	}
12098
12099	shape, ok := value.([]interface{})
12100	if !ok {
12101		return fmt.Errorf("unexpected JSON type %v", value)
12102	}
12103
12104	var cv []types.RuleGroupSummary
12105	if *v == nil {
12106		cv = []types.RuleGroupSummary{}
12107	} else {
12108		cv = *v
12109	}
12110
12111	for _, value := range shape {
12112		var col types.RuleGroupSummary
12113		destAddr := &col
12114		if err := awsAwsjson11_deserializeDocumentRuleGroupSummary(&destAddr, value); err != nil {
12115			return err
12116		}
12117		col = *destAddr
12118		cv = append(cv, col)
12119
12120	}
12121	*v = cv
12122	return nil
12123}
12124
12125func awsAwsjson11_deserializeDocumentRuleGroupSummary(v **types.RuleGroupSummary, value interface{}) error {
12126	if v == nil {
12127		return fmt.Errorf("unexpected nil of type %T", v)
12128	}
12129	if value == nil {
12130		return nil
12131	}
12132
12133	shape, ok := value.(map[string]interface{})
12134	if !ok {
12135		return fmt.Errorf("unexpected JSON type %v", value)
12136	}
12137
12138	var sv *types.RuleGroupSummary
12139	if *v == nil {
12140		sv = &types.RuleGroupSummary{}
12141	} else {
12142		sv = *v
12143	}
12144
12145	for key, value := range shape {
12146		switch key {
12147		case "Name":
12148			if value != nil {
12149				jtv, ok := value.(string)
12150				if !ok {
12151					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12152				}
12153				sv.Name = ptr.String(jtv)
12154			}
12155
12156		case "RuleGroupId":
12157			if value != nil {
12158				jtv, ok := value.(string)
12159				if !ok {
12160					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12161				}
12162				sv.RuleGroupId = ptr.String(jtv)
12163			}
12164
12165		default:
12166			_, _ = key, value
12167
12168		}
12169	}
12170	*v = sv
12171	return nil
12172}
12173
12174func awsAwsjson11_deserializeDocumentRuleSummaries(v *[]types.RuleSummary, value interface{}) error {
12175	if v == nil {
12176		return fmt.Errorf("unexpected nil of type %T", v)
12177	}
12178	if value == nil {
12179		return nil
12180	}
12181
12182	shape, ok := value.([]interface{})
12183	if !ok {
12184		return fmt.Errorf("unexpected JSON type %v", value)
12185	}
12186
12187	var cv []types.RuleSummary
12188	if *v == nil {
12189		cv = []types.RuleSummary{}
12190	} else {
12191		cv = *v
12192	}
12193
12194	for _, value := range shape {
12195		var col types.RuleSummary
12196		destAddr := &col
12197		if err := awsAwsjson11_deserializeDocumentRuleSummary(&destAddr, value); err != nil {
12198			return err
12199		}
12200		col = *destAddr
12201		cv = append(cv, col)
12202
12203	}
12204	*v = cv
12205	return nil
12206}
12207
12208func awsAwsjson11_deserializeDocumentRuleSummary(v **types.RuleSummary, value interface{}) error {
12209	if v == nil {
12210		return fmt.Errorf("unexpected nil of type %T", v)
12211	}
12212	if value == nil {
12213		return nil
12214	}
12215
12216	shape, ok := value.(map[string]interface{})
12217	if !ok {
12218		return fmt.Errorf("unexpected JSON type %v", value)
12219	}
12220
12221	var sv *types.RuleSummary
12222	if *v == nil {
12223		sv = &types.RuleSummary{}
12224	} else {
12225		sv = *v
12226	}
12227
12228	for key, value := range shape {
12229		switch key {
12230		case "Name":
12231			if value != nil {
12232				jtv, ok := value.(string)
12233				if !ok {
12234					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12235				}
12236				sv.Name = ptr.String(jtv)
12237			}
12238
12239		case "RuleId":
12240			if value != nil {
12241				jtv, ok := value.(string)
12242				if !ok {
12243					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12244				}
12245				sv.RuleId = ptr.String(jtv)
12246			}
12247
12248		default:
12249			_, _ = key, value
12250
12251		}
12252	}
12253	*v = sv
12254	return nil
12255}
12256
12257func awsAwsjson11_deserializeDocumentSampledHTTPRequest(v **types.SampledHTTPRequest, value interface{}) error {
12258	if v == nil {
12259		return fmt.Errorf("unexpected nil of type %T", v)
12260	}
12261	if value == nil {
12262		return nil
12263	}
12264
12265	shape, ok := value.(map[string]interface{})
12266	if !ok {
12267		return fmt.Errorf("unexpected JSON type %v", value)
12268	}
12269
12270	var sv *types.SampledHTTPRequest
12271	if *v == nil {
12272		sv = &types.SampledHTTPRequest{}
12273	} else {
12274		sv = *v
12275	}
12276
12277	for key, value := range shape {
12278		switch key {
12279		case "Action":
12280			if value != nil {
12281				jtv, ok := value.(string)
12282				if !ok {
12283					return fmt.Errorf("expected Action to be of type string, got %T instead", value)
12284				}
12285				sv.Action = ptr.String(jtv)
12286			}
12287
12288		case "Request":
12289			if err := awsAwsjson11_deserializeDocumentHTTPRequest(&sv.Request, value); err != nil {
12290				return err
12291			}
12292
12293		case "RuleWithinRuleGroup":
12294			if value != nil {
12295				jtv, ok := value.(string)
12296				if !ok {
12297					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12298				}
12299				sv.RuleWithinRuleGroup = ptr.String(jtv)
12300			}
12301
12302		case "Timestamp":
12303			if value != nil {
12304				jtv, ok := value.(json.Number)
12305				if !ok {
12306					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
12307				}
12308				f64, err := jtv.Float64()
12309				if err != nil {
12310					return err
12311				}
12312				sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
12313			}
12314
12315		case "Weight":
12316			if value != nil {
12317				jtv, ok := value.(json.Number)
12318				if !ok {
12319					return fmt.Errorf("expected SampleWeight to be json.Number, got %T instead", value)
12320				}
12321				i64, err := jtv.Int64()
12322				if err != nil {
12323					return err
12324				}
12325				sv.Weight = i64
12326			}
12327
12328		default:
12329			_, _ = key, value
12330
12331		}
12332	}
12333	*v = sv
12334	return nil
12335}
12336
12337func awsAwsjson11_deserializeDocumentSampledHTTPRequests(v *[]types.SampledHTTPRequest, value interface{}) error {
12338	if v == nil {
12339		return fmt.Errorf("unexpected nil of type %T", v)
12340	}
12341	if value == nil {
12342		return nil
12343	}
12344
12345	shape, ok := value.([]interface{})
12346	if !ok {
12347		return fmt.Errorf("unexpected JSON type %v", value)
12348	}
12349
12350	var cv []types.SampledHTTPRequest
12351	if *v == nil {
12352		cv = []types.SampledHTTPRequest{}
12353	} else {
12354		cv = *v
12355	}
12356
12357	for _, value := range shape {
12358		var col types.SampledHTTPRequest
12359		destAddr := &col
12360		if err := awsAwsjson11_deserializeDocumentSampledHTTPRequest(&destAddr, value); err != nil {
12361			return err
12362		}
12363		col = *destAddr
12364		cv = append(cv, col)
12365
12366	}
12367	*v = cv
12368	return nil
12369}
12370
12371func awsAwsjson11_deserializeDocumentSizeConstraint(v **types.SizeConstraint, value interface{}) error {
12372	if v == nil {
12373		return fmt.Errorf("unexpected nil of type %T", v)
12374	}
12375	if value == nil {
12376		return nil
12377	}
12378
12379	shape, ok := value.(map[string]interface{})
12380	if !ok {
12381		return fmt.Errorf("unexpected JSON type %v", value)
12382	}
12383
12384	var sv *types.SizeConstraint
12385	if *v == nil {
12386		sv = &types.SizeConstraint{}
12387	} else {
12388		sv = *v
12389	}
12390
12391	for key, value := range shape {
12392		switch key {
12393		case "ComparisonOperator":
12394			if value != nil {
12395				jtv, ok := value.(string)
12396				if !ok {
12397					return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
12398				}
12399				sv.ComparisonOperator = types.ComparisonOperator(jtv)
12400			}
12401
12402		case "FieldToMatch":
12403			if err := awsAwsjson11_deserializeDocumentFieldToMatch(&sv.FieldToMatch, value); err != nil {
12404				return err
12405			}
12406
12407		case "Size":
12408			if value != nil {
12409				jtv, ok := value.(json.Number)
12410				if !ok {
12411					return fmt.Errorf("expected Size to be json.Number, got %T instead", value)
12412				}
12413				i64, err := jtv.Int64()
12414				if err != nil {
12415					return err
12416				}
12417				sv.Size = i64
12418			}
12419
12420		case "TextTransformation":
12421			if value != nil {
12422				jtv, ok := value.(string)
12423				if !ok {
12424					return fmt.Errorf("expected TextTransformation to be of type string, got %T instead", value)
12425				}
12426				sv.TextTransformation = types.TextTransformation(jtv)
12427			}
12428
12429		default:
12430			_, _ = key, value
12431
12432		}
12433	}
12434	*v = sv
12435	return nil
12436}
12437
12438func awsAwsjson11_deserializeDocumentSizeConstraints(v *[]types.SizeConstraint, value interface{}) error {
12439	if v == nil {
12440		return fmt.Errorf("unexpected nil of type %T", v)
12441	}
12442	if value == nil {
12443		return nil
12444	}
12445
12446	shape, ok := value.([]interface{})
12447	if !ok {
12448		return fmt.Errorf("unexpected JSON type %v", value)
12449	}
12450
12451	var cv []types.SizeConstraint
12452	if *v == nil {
12453		cv = []types.SizeConstraint{}
12454	} else {
12455		cv = *v
12456	}
12457
12458	for _, value := range shape {
12459		var col types.SizeConstraint
12460		destAddr := &col
12461		if err := awsAwsjson11_deserializeDocumentSizeConstraint(&destAddr, value); err != nil {
12462			return err
12463		}
12464		col = *destAddr
12465		cv = append(cv, col)
12466
12467	}
12468	*v = cv
12469	return nil
12470}
12471
12472func awsAwsjson11_deserializeDocumentSizeConstraintSet(v **types.SizeConstraintSet, value interface{}) error {
12473	if v == nil {
12474		return fmt.Errorf("unexpected nil of type %T", v)
12475	}
12476	if value == nil {
12477		return nil
12478	}
12479
12480	shape, ok := value.(map[string]interface{})
12481	if !ok {
12482		return fmt.Errorf("unexpected JSON type %v", value)
12483	}
12484
12485	var sv *types.SizeConstraintSet
12486	if *v == nil {
12487		sv = &types.SizeConstraintSet{}
12488	} else {
12489		sv = *v
12490	}
12491
12492	for key, value := range shape {
12493		switch key {
12494		case "Name":
12495			if value != nil {
12496				jtv, ok := value.(string)
12497				if !ok {
12498					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12499				}
12500				sv.Name = ptr.String(jtv)
12501			}
12502
12503		case "SizeConstraints":
12504			if err := awsAwsjson11_deserializeDocumentSizeConstraints(&sv.SizeConstraints, value); err != nil {
12505				return err
12506			}
12507
12508		case "SizeConstraintSetId":
12509			if value != nil {
12510				jtv, ok := value.(string)
12511				if !ok {
12512					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12513				}
12514				sv.SizeConstraintSetId = ptr.String(jtv)
12515			}
12516
12517		default:
12518			_, _ = key, value
12519
12520		}
12521	}
12522	*v = sv
12523	return nil
12524}
12525
12526func awsAwsjson11_deserializeDocumentSizeConstraintSetSummaries(v *[]types.SizeConstraintSetSummary, value interface{}) error {
12527	if v == nil {
12528		return fmt.Errorf("unexpected nil of type %T", v)
12529	}
12530	if value == nil {
12531		return nil
12532	}
12533
12534	shape, ok := value.([]interface{})
12535	if !ok {
12536		return fmt.Errorf("unexpected JSON type %v", value)
12537	}
12538
12539	var cv []types.SizeConstraintSetSummary
12540	if *v == nil {
12541		cv = []types.SizeConstraintSetSummary{}
12542	} else {
12543		cv = *v
12544	}
12545
12546	for _, value := range shape {
12547		var col types.SizeConstraintSetSummary
12548		destAddr := &col
12549		if err := awsAwsjson11_deserializeDocumentSizeConstraintSetSummary(&destAddr, value); err != nil {
12550			return err
12551		}
12552		col = *destAddr
12553		cv = append(cv, col)
12554
12555	}
12556	*v = cv
12557	return nil
12558}
12559
12560func awsAwsjson11_deserializeDocumentSizeConstraintSetSummary(v **types.SizeConstraintSetSummary, value interface{}) error {
12561	if v == nil {
12562		return fmt.Errorf("unexpected nil of type %T", v)
12563	}
12564	if value == nil {
12565		return nil
12566	}
12567
12568	shape, ok := value.(map[string]interface{})
12569	if !ok {
12570		return fmt.Errorf("unexpected JSON type %v", value)
12571	}
12572
12573	var sv *types.SizeConstraintSetSummary
12574	if *v == nil {
12575		sv = &types.SizeConstraintSetSummary{}
12576	} else {
12577		sv = *v
12578	}
12579
12580	for key, value := range shape {
12581		switch key {
12582		case "Name":
12583			if value != nil {
12584				jtv, ok := value.(string)
12585				if !ok {
12586					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12587				}
12588				sv.Name = ptr.String(jtv)
12589			}
12590
12591		case "SizeConstraintSetId":
12592			if value != nil {
12593				jtv, ok := value.(string)
12594				if !ok {
12595					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12596				}
12597				sv.SizeConstraintSetId = ptr.String(jtv)
12598			}
12599
12600		default:
12601			_, _ = key, value
12602
12603		}
12604	}
12605	*v = sv
12606	return nil
12607}
12608
12609func awsAwsjson11_deserializeDocumentSqlInjectionMatchSet(v **types.SqlInjectionMatchSet, value interface{}) error {
12610	if v == nil {
12611		return fmt.Errorf("unexpected nil of type %T", v)
12612	}
12613	if value == nil {
12614		return nil
12615	}
12616
12617	shape, ok := value.(map[string]interface{})
12618	if !ok {
12619		return fmt.Errorf("unexpected JSON type %v", value)
12620	}
12621
12622	var sv *types.SqlInjectionMatchSet
12623	if *v == nil {
12624		sv = &types.SqlInjectionMatchSet{}
12625	} else {
12626		sv = *v
12627	}
12628
12629	for key, value := range shape {
12630		switch key {
12631		case "Name":
12632			if value != nil {
12633				jtv, ok := value.(string)
12634				if !ok {
12635					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12636				}
12637				sv.Name = ptr.String(jtv)
12638			}
12639
12640		case "SqlInjectionMatchSetId":
12641			if value != nil {
12642				jtv, ok := value.(string)
12643				if !ok {
12644					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12645				}
12646				sv.SqlInjectionMatchSetId = ptr.String(jtv)
12647			}
12648
12649		case "SqlInjectionMatchTuples":
12650			if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchTuples(&sv.SqlInjectionMatchTuples, value); err != nil {
12651				return err
12652			}
12653
12654		default:
12655			_, _ = key, value
12656
12657		}
12658	}
12659	*v = sv
12660	return nil
12661}
12662
12663func awsAwsjson11_deserializeDocumentSqlInjectionMatchSetSummaries(v *[]types.SqlInjectionMatchSetSummary, value interface{}) error {
12664	if v == nil {
12665		return fmt.Errorf("unexpected nil of type %T", v)
12666	}
12667	if value == nil {
12668		return nil
12669	}
12670
12671	shape, ok := value.([]interface{})
12672	if !ok {
12673		return fmt.Errorf("unexpected JSON type %v", value)
12674	}
12675
12676	var cv []types.SqlInjectionMatchSetSummary
12677	if *v == nil {
12678		cv = []types.SqlInjectionMatchSetSummary{}
12679	} else {
12680		cv = *v
12681	}
12682
12683	for _, value := range shape {
12684		var col types.SqlInjectionMatchSetSummary
12685		destAddr := &col
12686		if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchSetSummary(&destAddr, value); err != nil {
12687			return err
12688		}
12689		col = *destAddr
12690		cv = append(cv, col)
12691
12692	}
12693	*v = cv
12694	return nil
12695}
12696
12697func awsAwsjson11_deserializeDocumentSqlInjectionMatchSetSummary(v **types.SqlInjectionMatchSetSummary, value interface{}) error {
12698	if v == nil {
12699		return fmt.Errorf("unexpected nil of type %T", v)
12700	}
12701	if value == nil {
12702		return nil
12703	}
12704
12705	shape, ok := value.(map[string]interface{})
12706	if !ok {
12707		return fmt.Errorf("unexpected JSON type %v", value)
12708	}
12709
12710	var sv *types.SqlInjectionMatchSetSummary
12711	if *v == nil {
12712		sv = &types.SqlInjectionMatchSetSummary{}
12713	} else {
12714		sv = *v
12715	}
12716
12717	for key, value := range shape {
12718		switch key {
12719		case "Name":
12720			if value != nil {
12721				jtv, ok := value.(string)
12722				if !ok {
12723					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12724				}
12725				sv.Name = ptr.String(jtv)
12726			}
12727
12728		case "SqlInjectionMatchSetId":
12729			if value != nil {
12730				jtv, ok := value.(string)
12731				if !ok {
12732					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12733				}
12734				sv.SqlInjectionMatchSetId = ptr.String(jtv)
12735			}
12736
12737		default:
12738			_, _ = key, value
12739
12740		}
12741	}
12742	*v = sv
12743	return nil
12744}
12745
12746func awsAwsjson11_deserializeDocumentSqlInjectionMatchTuple(v **types.SqlInjectionMatchTuple, value interface{}) error {
12747	if v == nil {
12748		return fmt.Errorf("unexpected nil of type %T", v)
12749	}
12750	if value == nil {
12751		return nil
12752	}
12753
12754	shape, ok := value.(map[string]interface{})
12755	if !ok {
12756		return fmt.Errorf("unexpected JSON type %v", value)
12757	}
12758
12759	var sv *types.SqlInjectionMatchTuple
12760	if *v == nil {
12761		sv = &types.SqlInjectionMatchTuple{}
12762	} else {
12763		sv = *v
12764	}
12765
12766	for key, value := range shape {
12767		switch key {
12768		case "FieldToMatch":
12769			if err := awsAwsjson11_deserializeDocumentFieldToMatch(&sv.FieldToMatch, value); err != nil {
12770				return err
12771			}
12772
12773		case "TextTransformation":
12774			if value != nil {
12775				jtv, ok := value.(string)
12776				if !ok {
12777					return fmt.Errorf("expected TextTransformation to be of type string, got %T instead", value)
12778				}
12779				sv.TextTransformation = types.TextTransformation(jtv)
12780			}
12781
12782		default:
12783			_, _ = key, value
12784
12785		}
12786	}
12787	*v = sv
12788	return nil
12789}
12790
12791func awsAwsjson11_deserializeDocumentSqlInjectionMatchTuples(v *[]types.SqlInjectionMatchTuple, value interface{}) error {
12792	if v == nil {
12793		return fmt.Errorf("unexpected nil of type %T", v)
12794	}
12795	if value == nil {
12796		return nil
12797	}
12798
12799	shape, ok := value.([]interface{})
12800	if !ok {
12801		return fmt.Errorf("unexpected JSON type %v", value)
12802	}
12803
12804	var cv []types.SqlInjectionMatchTuple
12805	if *v == nil {
12806		cv = []types.SqlInjectionMatchTuple{}
12807	} else {
12808		cv = *v
12809	}
12810
12811	for _, value := range shape {
12812		var col types.SqlInjectionMatchTuple
12813		destAddr := &col
12814		if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchTuple(&destAddr, value); err != nil {
12815			return err
12816		}
12817		col = *destAddr
12818		cv = append(cv, col)
12819
12820	}
12821	*v = cv
12822	return nil
12823}
12824
12825func awsAwsjson11_deserializeDocumentSubscribedRuleGroupSummaries(v *[]types.SubscribedRuleGroupSummary, value interface{}) error {
12826	if v == nil {
12827		return fmt.Errorf("unexpected nil of type %T", v)
12828	}
12829	if value == nil {
12830		return nil
12831	}
12832
12833	shape, ok := value.([]interface{})
12834	if !ok {
12835		return fmt.Errorf("unexpected JSON type %v", value)
12836	}
12837
12838	var cv []types.SubscribedRuleGroupSummary
12839	if *v == nil {
12840		cv = []types.SubscribedRuleGroupSummary{}
12841	} else {
12842		cv = *v
12843	}
12844
12845	for _, value := range shape {
12846		var col types.SubscribedRuleGroupSummary
12847		destAddr := &col
12848		if err := awsAwsjson11_deserializeDocumentSubscribedRuleGroupSummary(&destAddr, value); err != nil {
12849			return err
12850		}
12851		col = *destAddr
12852		cv = append(cv, col)
12853
12854	}
12855	*v = cv
12856	return nil
12857}
12858
12859func awsAwsjson11_deserializeDocumentSubscribedRuleGroupSummary(v **types.SubscribedRuleGroupSummary, value interface{}) error {
12860	if v == nil {
12861		return fmt.Errorf("unexpected nil of type %T", v)
12862	}
12863	if value == nil {
12864		return nil
12865	}
12866
12867	shape, ok := value.(map[string]interface{})
12868	if !ok {
12869		return fmt.Errorf("unexpected JSON type %v", value)
12870	}
12871
12872	var sv *types.SubscribedRuleGroupSummary
12873	if *v == nil {
12874		sv = &types.SubscribedRuleGroupSummary{}
12875	} else {
12876		sv = *v
12877	}
12878
12879	for key, value := range shape {
12880		switch key {
12881		case "MetricName":
12882			if value != nil {
12883				jtv, ok := value.(string)
12884				if !ok {
12885					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
12886				}
12887				sv.MetricName = ptr.String(jtv)
12888			}
12889
12890		case "Name":
12891			if value != nil {
12892				jtv, ok := value.(string)
12893				if !ok {
12894					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
12895				}
12896				sv.Name = ptr.String(jtv)
12897			}
12898
12899		case "RuleGroupId":
12900			if value != nil {
12901				jtv, ok := value.(string)
12902				if !ok {
12903					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
12904				}
12905				sv.RuleGroupId = ptr.String(jtv)
12906			}
12907
12908		default:
12909			_, _ = key, value
12910
12911		}
12912	}
12913	*v = sv
12914	return nil
12915}
12916
12917func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
12918	if v == nil {
12919		return fmt.Errorf("unexpected nil of type %T", v)
12920	}
12921	if value == nil {
12922		return nil
12923	}
12924
12925	shape, ok := value.(map[string]interface{})
12926	if !ok {
12927		return fmt.Errorf("unexpected JSON type %v", value)
12928	}
12929
12930	var sv *types.Tag
12931	if *v == nil {
12932		sv = &types.Tag{}
12933	} else {
12934		sv = *v
12935	}
12936
12937	for key, value := range shape {
12938		switch key {
12939		case "Key":
12940			if value != nil {
12941				jtv, ok := value.(string)
12942				if !ok {
12943					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
12944				}
12945				sv.Key = ptr.String(jtv)
12946			}
12947
12948		case "Value":
12949			if value != nil {
12950				jtv, ok := value.(string)
12951				if !ok {
12952					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
12953				}
12954				sv.Value = ptr.String(jtv)
12955			}
12956
12957		default:
12958			_, _ = key, value
12959
12960		}
12961	}
12962	*v = sv
12963	return nil
12964}
12965
12966func awsAwsjson11_deserializeDocumentTagInfoForResource(v **types.TagInfoForResource, value interface{}) error {
12967	if v == nil {
12968		return fmt.Errorf("unexpected nil of type %T", v)
12969	}
12970	if value == nil {
12971		return nil
12972	}
12973
12974	shape, ok := value.(map[string]interface{})
12975	if !ok {
12976		return fmt.Errorf("unexpected JSON type %v", value)
12977	}
12978
12979	var sv *types.TagInfoForResource
12980	if *v == nil {
12981		sv = &types.TagInfoForResource{}
12982	} else {
12983		sv = *v
12984	}
12985
12986	for key, value := range shape {
12987		switch key {
12988		case "ResourceARN":
12989			if value != nil {
12990				jtv, ok := value.(string)
12991				if !ok {
12992					return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
12993				}
12994				sv.ResourceARN = ptr.String(jtv)
12995			}
12996
12997		case "TagList":
12998			if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil {
12999				return err
13000			}
13001
13002		default:
13003			_, _ = key, value
13004
13005		}
13006	}
13007	*v = sv
13008	return nil
13009}
13010
13011func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
13012	if v == nil {
13013		return fmt.Errorf("unexpected nil of type %T", v)
13014	}
13015	if value == nil {
13016		return nil
13017	}
13018
13019	shape, ok := value.([]interface{})
13020	if !ok {
13021		return fmt.Errorf("unexpected JSON type %v", value)
13022	}
13023
13024	var cv []types.Tag
13025	if *v == nil {
13026		cv = []types.Tag{}
13027	} else {
13028		cv = *v
13029	}
13030
13031	for _, value := range shape {
13032		var col types.Tag
13033		destAddr := &col
13034		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
13035			return err
13036		}
13037		col = *destAddr
13038		cv = append(cv, col)
13039
13040	}
13041	*v = cv
13042	return nil
13043}
13044
13045func awsAwsjson11_deserializeDocumentTimeWindow(v **types.TimeWindow, value interface{}) error {
13046	if v == nil {
13047		return fmt.Errorf("unexpected nil of type %T", v)
13048	}
13049	if value == nil {
13050		return nil
13051	}
13052
13053	shape, ok := value.(map[string]interface{})
13054	if !ok {
13055		return fmt.Errorf("unexpected JSON type %v", value)
13056	}
13057
13058	var sv *types.TimeWindow
13059	if *v == nil {
13060		sv = &types.TimeWindow{}
13061	} else {
13062		sv = *v
13063	}
13064
13065	for key, value := range shape {
13066		switch key {
13067		case "EndTime":
13068			if value != nil {
13069				jtv, ok := value.(json.Number)
13070				if !ok {
13071					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
13072				}
13073				f64, err := jtv.Float64()
13074				if err != nil {
13075					return err
13076				}
13077				sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13078			}
13079
13080		case "StartTime":
13081			if value != nil {
13082				jtv, ok := value.(json.Number)
13083				if !ok {
13084					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
13085				}
13086				f64, err := jtv.Float64()
13087				if err != nil {
13088					return err
13089				}
13090				sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13091			}
13092
13093		default:
13094			_, _ = key, value
13095
13096		}
13097	}
13098	*v = sv
13099	return nil
13100}
13101
13102func awsAwsjson11_deserializeDocumentWafAction(v **types.WafAction, value interface{}) error {
13103	if v == nil {
13104		return fmt.Errorf("unexpected nil of type %T", v)
13105	}
13106	if value == nil {
13107		return nil
13108	}
13109
13110	shape, ok := value.(map[string]interface{})
13111	if !ok {
13112		return fmt.Errorf("unexpected JSON type %v", value)
13113	}
13114
13115	var sv *types.WafAction
13116	if *v == nil {
13117		sv = &types.WafAction{}
13118	} else {
13119		sv = *v
13120	}
13121
13122	for key, value := range shape {
13123		switch key {
13124		case "Type":
13125			if value != nil {
13126				jtv, ok := value.(string)
13127				if !ok {
13128					return fmt.Errorf("expected WafActionType to be of type string, got %T instead", value)
13129				}
13130				sv.Type = types.WafActionType(jtv)
13131			}
13132
13133		default:
13134			_, _ = key, value
13135
13136		}
13137	}
13138	*v = sv
13139	return nil
13140}
13141
13142func awsAwsjson11_deserializeDocumentWAFBadRequestException(v **types.WAFBadRequestException, value interface{}) error {
13143	if v == nil {
13144		return fmt.Errorf("unexpected nil of type %T", v)
13145	}
13146	if value == nil {
13147		return nil
13148	}
13149
13150	shape, ok := value.(map[string]interface{})
13151	if !ok {
13152		return fmt.Errorf("unexpected JSON type %v", value)
13153	}
13154
13155	var sv *types.WAFBadRequestException
13156	if *v == nil {
13157		sv = &types.WAFBadRequestException{}
13158	} else {
13159		sv = *v
13160	}
13161
13162	for key, value := range shape {
13163		switch key {
13164		case "message":
13165			if value != nil {
13166				jtv, ok := value.(string)
13167				if !ok {
13168					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13169				}
13170				sv.Message = ptr.String(jtv)
13171			}
13172
13173		default:
13174			_, _ = key, value
13175
13176		}
13177	}
13178	*v = sv
13179	return nil
13180}
13181
13182func awsAwsjson11_deserializeDocumentWAFDisallowedNameException(v **types.WAFDisallowedNameException, value interface{}) error {
13183	if v == nil {
13184		return fmt.Errorf("unexpected nil of type %T", v)
13185	}
13186	if value == nil {
13187		return nil
13188	}
13189
13190	shape, ok := value.(map[string]interface{})
13191	if !ok {
13192		return fmt.Errorf("unexpected JSON type %v", value)
13193	}
13194
13195	var sv *types.WAFDisallowedNameException
13196	if *v == nil {
13197		sv = &types.WAFDisallowedNameException{}
13198	} else {
13199		sv = *v
13200	}
13201
13202	for key, value := range shape {
13203		switch key {
13204		case "message":
13205			if value != nil {
13206				jtv, ok := value.(string)
13207				if !ok {
13208					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13209				}
13210				sv.Message = ptr.String(jtv)
13211			}
13212
13213		default:
13214			_, _ = key, value
13215
13216		}
13217	}
13218	*v = sv
13219	return nil
13220}
13221
13222func awsAwsjson11_deserializeDocumentWAFEntityMigrationException(v **types.WAFEntityMigrationException, value interface{}) error {
13223	if v == nil {
13224		return fmt.Errorf("unexpected nil of type %T", v)
13225	}
13226	if value == nil {
13227		return nil
13228	}
13229
13230	shape, ok := value.(map[string]interface{})
13231	if !ok {
13232		return fmt.Errorf("unexpected JSON type %v", value)
13233	}
13234
13235	var sv *types.WAFEntityMigrationException
13236	if *v == nil {
13237		sv = &types.WAFEntityMigrationException{}
13238	} else {
13239		sv = *v
13240	}
13241
13242	for key, value := range shape {
13243		switch key {
13244		case "message":
13245			if value != nil {
13246				jtv, ok := value.(string)
13247				if !ok {
13248					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13249				}
13250				sv.Message = ptr.String(jtv)
13251			}
13252
13253		case "MigrationErrorReason":
13254			if value != nil {
13255				jtv, ok := value.(string)
13256				if !ok {
13257					return fmt.Errorf("expected ErrorReason to be of type string, got %T instead", value)
13258				}
13259				sv.MigrationErrorReason = ptr.String(jtv)
13260			}
13261
13262		case "MigrationErrorType":
13263			if value != nil {
13264				jtv, ok := value.(string)
13265				if !ok {
13266					return fmt.Errorf("expected MigrationErrorType to be of type string, got %T instead", value)
13267				}
13268				sv.MigrationErrorType = types.MigrationErrorType(jtv)
13269			}
13270
13271		default:
13272			_, _ = key, value
13273
13274		}
13275	}
13276	*v = sv
13277	return nil
13278}
13279
13280func awsAwsjson11_deserializeDocumentWAFInternalErrorException(v **types.WAFInternalErrorException, value interface{}) error {
13281	if v == nil {
13282		return fmt.Errorf("unexpected nil of type %T", v)
13283	}
13284	if value == nil {
13285		return nil
13286	}
13287
13288	shape, ok := value.(map[string]interface{})
13289	if !ok {
13290		return fmt.Errorf("unexpected JSON type %v", value)
13291	}
13292
13293	var sv *types.WAFInternalErrorException
13294	if *v == nil {
13295		sv = &types.WAFInternalErrorException{}
13296	} else {
13297		sv = *v
13298	}
13299
13300	for key, value := range shape {
13301		switch key {
13302		case "message":
13303			if value != nil {
13304				jtv, ok := value.(string)
13305				if !ok {
13306					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13307				}
13308				sv.Message = ptr.String(jtv)
13309			}
13310
13311		default:
13312			_, _ = key, value
13313
13314		}
13315	}
13316	*v = sv
13317	return nil
13318}
13319
13320func awsAwsjson11_deserializeDocumentWAFInvalidAccountException(v **types.WAFInvalidAccountException, value interface{}) error {
13321	if v == nil {
13322		return fmt.Errorf("unexpected nil of type %T", v)
13323	}
13324	if value == nil {
13325		return nil
13326	}
13327
13328	shape, ok := value.(map[string]interface{})
13329	if !ok {
13330		return fmt.Errorf("unexpected JSON type %v", value)
13331	}
13332
13333	var sv *types.WAFInvalidAccountException
13334	if *v == nil {
13335		sv = &types.WAFInvalidAccountException{}
13336	} else {
13337		sv = *v
13338	}
13339
13340	for key, value := range shape {
13341		switch key {
13342		default:
13343			_, _ = key, value
13344
13345		}
13346	}
13347	*v = sv
13348	return nil
13349}
13350
13351func awsAwsjson11_deserializeDocumentWAFInvalidOperationException(v **types.WAFInvalidOperationException, value interface{}) error {
13352	if v == nil {
13353		return fmt.Errorf("unexpected nil of type %T", v)
13354	}
13355	if value == nil {
13356		return nil
13357	}
13358
13359	shape, ok := value.(map[string]interface{})
13360	if !ok {
13361		return fmt.Errorf("unexpected JSON type %v", value)
13362	}
13363
13364	var sv *types.WAFInvalidOperationException
13365	if *v == nil {
13366		sv = &types.WAFInvalidOperationException{}
13367	} else {
13368		sv = *v
13369	}
13370
13371	for key, value := range shape {
13372		switch key {
13373		case "message":
13374			if value != nil {
13375				jtv, ok := value.(string)
13376				if !ok {
13377					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13378				}
13379				sv.Message = ptr.String(jtv)
13380			}
13381
13382		default:
13383			_, _ = key, value
13384
13385		}
13386	}
13387	*v = sv
13388	return nil
13389}
13390
13391func awsAwsjson11_deserializeDocumentWAFInvalidParameterException(v **types.WAFInvalidParameterException, value interface{}) error {
13392	if v == nil {
13393		return fmt.Errorf("unexpected nil of type %T", v)
13394	}
13395	if value == nil {
13396		return nil
13397	}
13398
13399	shape, ok := value.(map[string]interface{})
13400	if !ok {
13401		return fmt.Errorf("unexpected JSON type %v", value)
13402	}
13403
13404	var sv *types.WAFInvalidParameterException
13405	if *v == nil {
13406		sv = &types.WAFInvalidParameterException{}
13407	} else {
13408		sv = *v
13409	}
13410
13411	for key, value := range shape {
13412		switch key {
13413		case "field":
13414			if value != nil {
13415				jtv, ok := value.(string)
13416				if !ok {
13417					return fmt.Errorf("expected ParameterExceptionField to be of type string, got %T instead", value)
13418				}
13419				sv.Field = types.ParameterExceptionField(jtv)
13420			}
13421
13422		case "parameter":
13423			if value != nil {
13424				jtv, ok := value.(string)
13425				if !ok {
13426					return fmt.Errorf("expected ParameterExceptionParameter to be of type string, got %T instead", value)
13427				}
13428				sv.Parameter = ptr.String(jtv)
13429			}
13430
13431		case "reason":
13432			if value != nil {
13433				jtv, ok := value.(string)
13434				if !ok {
13435					return fmt.Errorf("expected ParameterExceptionReason to be of type string, got %T instead", value)
13436				}
13437				sv.Reason = types.ParameterExceptionReason(jtv)
13438			}
13439
13440		default:
13441			_, _ = key, value
13442
13443		}
13444	}
13445	*v = sv
13446	return nil
13447}
13448
13449func awsAwsjson11_deserializeDocumentWAFInvalidPermissionPolicyException(v **types.WAFInvalidPermissionPolicyException, value interface{}) error {
13450	if v == nil {
13451		return fmt.Errorf("unexpected nil of type %T", v)
13452	}
13453	if value == nil {
13454		return nil
13455	}
13456
13457	shape, ok := value.(map[string]interface{})
13458	if !ok {
13459		return fmt.Errorf("unexpected JSON type %v", value)
13460	}
13461
13462	var sv *types.WAFInvalidPermissionPolicyException
13463	if *v == nil {
13464		sv = &types.WAFInvalidPermissionPolicyException{}
13465	} else {
13466		sv = *v
13467	}
13468
13469	for key, value := range shape {
13470		switch key {
13471		case "message":
13472			if value != nil {
13473				jtv, ok := value.(string)
13474				if !ok {
13475					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13476				}
13477				sv.Message = ptr.String(jtv)
13478			}
13479
13480		default:
13481			_, _ = key, value
13482
13483		}
13484	}
13485	*v = sv
13486	return nil
13487}
13488
13489func awsAwsjson11_deserializeDocumentWAFInvalidRegexPatternException(v **types.WAFInvalidRegexPatternException, value interface{}) error {
13490	if v == nil {
13491		return fmt.Errorf("unexpected nil of type %T", v)
13492	}
13493	if value == nil {
13494		return nil
13495	}
13496
13497	shape, ok := value.(map[string]interface{})
13498	if !ok {
13499		return fmt.Errorf("unexpected JSON type %v", value)
13500	}
13501
13502	var sv *types.WAFInvalidRegexPatternException
13503	if *v == nil {
13504		sv = &types.WAFInvalidRegexPatternException{}
13505	} else {
13506		sv = *v
13507	}
13508
13509	for key, value := range shape {
13510		switch key {
13511		case "message":
13512			if value != nil {
13513				jtv, ok := value.(string)
13514				if !ok {
13515					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13516				}
13517				sv.Message = ptr.String(jtv)
13518			}
13519
13520		default:
13521			_, _ = key, value
13522
13523		}
13524	}
13525	*v = sv
13526	return nil
13527}
13528
13529func awsAwsjson11_deserializeDocumentWAFLimitsExceededException(v **types.WAFLimitsExceededException, value interface{}) error {
13530	if v == nil {
13531		return fmt.Errorf("unexpected nil of type %T", v)
13532	}
13533	if value == nil {
13534		return nil
13535	}
13536
13537	shape, ok := value.(map[string]interface{})
13538	if !ok {
13539		return fmt.Errorf("unexpected JSON type %v", value)
13540	}
13541
13542	var sv *types.WAFLimitsExceededException
13543	if *v == nil {
13544		sv = &types.WAFLimitsExceededException{}
13545	} else {
13546		sv = *v
13547	}
13548
13549	for key, value := range shape {
13550		switch key {
13551		case "message":
13552			if value != nil {
13553				jtv, ok := value.(string)
13554				if !ok {
13555					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13556				}
13557				sv.Message = ptr.String(jtv)
13558			}
13559
13560		default:
13561			_, _ = key, value
13562
13563		}
13564	}
13565	*v = sv
13566	return nil
13567}
13568
13569func awsAwsjson11_deserializeDocumentWAFNonEmptyEntityException(v **types.WAFNonEmptyEntityException, value interface{}) error {
13570	if v == nil {
13571		return fmt.Errorf("unexpected nil of type %T", v)
13572	}
13573	if value == nil {
13574		return nil
13575	}
13576
13577	shape, ok := value.(map[string]interface{})
13578	if !ok {
13579		return fmt.Errorf("unexpected JSON type %v", value)
13580	}
13581
13582	var sv *types.WAFNonEmptyEntityException
13583	if *v == nil {
13584		sv = &types.WAFNonEmptyEntityException{}
13585	} else {
13586		sv = *v
13587	}
13588
13589	for key, value := range shape {
13590		switch key {
13591		case "message":
13592			if value != nil {
13593				jtv, ok := value.(string)
13594				if !ok {
13595					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13596				}
13597				sv.Message = ptr.String(jtv)
13598			}
13599
13600		default:
13601			_, _ = key, value
13602
13603		}
13604	}
13605	*v = sv
13606	return nil
13607}
13608
13609func awsAwsjson11_deserializeDocumentWAFNonexistentContainerException(v **types.WAFNonexistentContainerException, value interface{}) error {
13610	if v == nil {
13611		return fmt.Errorf("unexpected nil of type %T", v)
13612	}
13613	if value == nil {
13614		return nil
13615	}
13616
13617	shape, ok := value.(map[string]interface{})
13618	if !ok {
13619		return fmt.Errorf("unexpected JSON type %v", value)
13620	}
13621
13622	var sv *types.WAFNonexistentContainerException
13623	if *v == nil {
13624		sv = &types.WAFNonexistentContainerException{}
13625	} else {
13626		sv = *v
13627	}
13628
13629	for key, value := range shape {
13630		switch key {
13631		case "message":
13632			if value != nil {
13633				jtv, ok := value.(string)
13634				if !ok {
13635					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13636				}
13637				sv.Message = ptr.String(jtv)
13638			}
13639
13640		default:
13641			_, _ = key, value
13642
13643		}
13644	}
13645	*v = sv
13646	return nil
13647}
13648
13649func awsAwsjson11_deserializeDocumentWAFNonexistentItemException(v **types.WAFNonexistentItemException, value interface{}) error {
13650	if v == nil {
13651		return fmt.Errorf("unexpected nil of type %T", v)
13652	}
13653	if value == nil {
13654		return nil
13655	}
13656
13657	shape, ok := value.(map[string]interface{})
13658	if !ok {
13659		return fmt.Errorf("unexpected JSON type %v", value)
13660	}
13661
13662	var sv *types.WAFNonexistentItemException
13663	if *v == nil {
13664		sv = &types.WAFNonexistentItemException{}
13665	} else {
13666		sv = *v
13667	}
13668
13669	for key, value := range shape {
13670		switch key {
13671		case "message":
13672			if value != nil {
13673				jtv, ok := value.(string)
13674				if !ok {
13675					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13676				}
13677				sv.Message = ptr.String(jtv)
13678			}
13679
13680		default:
13681			_, _ = key, value
13682
13683		}
13684	}
13685	*v = sv
13686	return nil
13687}
13688
13689func awsAwsjson11_deserializeDocumentWafOverrideAction(v **types.WafOverrideAction, value interface{}) error {
13690	if v == nil {
13691		return fmt.Errorf("unexpected nil of type %T", v)
13692	}
13693	if value == nil {
13694		return nil
13695	}
13696
13697	shape, ok := value.(map[string]interface{})
13698	if !ok {
13699		return fmt.Errorf("unexpected JSON type %v", value)
13700	}
13701
13702	var sv *types.WafOverrideAction
13703	if *v == nil {
13704		sv = &types.WafOverrideAction{}
13705	} else {
13706		sv = *v
13707	}
13708
13709	for key, value := range shape {
13710		switch key {
13711		case "Type":
13712			if value != nil {
13713				jtv, ok := value.(string)
13714				if !ok {
13715					return fmt.Errorf("expected WafOverrideActionType to be of type string, got %T instead", value)
13716				}
13717				sv.Type = types.WafOverrideActionType(jtv)
13718			}
13719
13720		default:
13721			_, _ = key, value
13722
13723		}
13724	}
13725	*v = sv
13726	return nil
13727}
13728
13729func awsAwsjson11_deserializeDocumentWAFReferencedItemException(v **types.WAFReferencedItemException, value interface{}) error {
13730	if v == nil {
13731		return fmt.Errorf("unexpected nil of type %T", v)
13732	}
13733	if value == nil {
13734		return nil
13735	}
13736
13737	shape, ok := value.(map[string]interface{})
13738	if !ok {
13739		return fmt.Errorf("unexpected JSON type %v", value)
13740	}
13741
13742	var sv *types.WAFReferencedItemException
13743	if *v == nil {
13744		sv = &types.WAFReferencedItemException{}
13745	} else {
13746		sv = *v
13747	}
13748
13749	for key, value := range shape {
13750		switch key {
13751		case "message":
13752			if value != nil {
13753				jtv, ok := value.(string)
13754				if !ok {
13755					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13756				}
13757				sv.Message = ptr.String(jtv)
13758			}
13759
13760		default:
13761			_, _ = key, value
13762
13763		}
13764	}
13765	*v = sv
13766	return nil
13767}
13768
13769func awsAwsjson11_deserializeDocumentWAFServiceLinkedRoleErrorException(v **types.WAFServiceLinkedRoleErrorException, value interface{}) error {
13770	if v == nil {
13771		return fmt.Errorf("unexpected nil of type %T", v)
13772	}
13773	if value == nil {
13774		return nil
13775	}
13776
13777	shape, ok := value.(map[string]interface{})
13778	if !ok {
13779		return fmt.Errorf("unexpected JSON type %v", value)
13780	}
13781
13782	var sv *types.WAFServiceLinkedRoleErrorException
13783	if *v == nil {
13784		sv = &types.WAFServiceLinkedRoleErrorException{}
13785	} else {
13786		sv = *v
13787	}
13788
13789	for key, value := range shape {
13790		switch key {
13791		case "message":
13792			if value != nil {
13793				jtv, ok := value.(string)
13794				if !ok {
13795					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13796				}
13797				sv.Message = ptr.String(jtv)
13798			}
13799
13800		default:
13801			_, _ = key, value
13802
13803		}
13804	}
13805	*v = sv
13806	return nil
13807}
13808
13809func awsAwsjson11_deserializeDocumentWAFStaleDataException(v **types.WAFStaleDataException, value interface{}) error {
13810	if v == nil {
13811		return fmt.Errorf("unexpected nil of type %T", v)
13812	}
13813	if value == nil {
13814		return nil
13815	}
13816
13817	shape, ok := value.(map[string]interface{})
13818	if !ok {
13819		return fmt.Errorf("unexpected JSON type %v", value)
13820	}
13821
13822	var sv *types.WAFStaleDataException
13823	if *v == nil {
13824		sv = &types.WAFStaleDataException{}
13825	} else {
13826		sv = *v
13827	}
13828
13829	for key, value := range shape {
13830		switch key {
13831		case "message":
13832			if value != nil {
13833				jtv, ok := value.(string)
13834				if !ok {
13835					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13836				}
13837				sv.Message = ptr.String(jtv)
13838			}
13839
13840		default:
13841			_, _ = key, value
13842
13843		}
13844	}
13845	*v = sv
13846	return nil
13847}
13848
13849func awsAwsjson11_deserializeDocumentWAFSubscriptionNotFoundException(v **types.WAFSubscriptionNotFoundException, value interface{}) error {
13850	if v == nil {
13851		return fmt.Errorf("unexpected nil of type %T", v)
13852	}
13853	if value == nil {
13854		return nil
13855	}
13856
13857	shape, ok := value.(map[string]interface{})
13858	if !ok {
13859		return fmt.Errorf("unexpected JSON type %v", value)
13860	}
13861
13862	var sv *types.WAFSubscriptionNotFoundException
13863	if *v == nil {
13864		sv = &types.WAFSubscriptionNotFoundException{}
13865	} else {
13866		sv = *v
13867	}
13868
13869	for key, value := range shape {
13870		switch key {
13871		case "message":
13872			if value != nil {
13873				jtv, ok := value.(string)
13874				if !ok {
13875					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13876				}
13877				sv.Message = ptr.String(jtv)
13878			}
13879
13880		default:
13881			_, _ = key, value
13882
13883		}
13884	}
13885	*v = sv
13886	return nil
13887}
13888
13889func awsAwsjson11_deserializeDocumentWAFTagOperationException(v **types.WAFTagOperationException, value interface{}) error {
13890	if v == nil {
13891		return fmt.Errorf("unexpected nil of type %T", v)
13892	}
13893	if value == nil {
13894		return nil
13895	}
13896
13897	shape, ok := value.(map[string]interface{})
13898	if !ok {
13899		return fmt.Errorf("unexpected JSON type %v", value)
13900	}
13901
13902	var sv *types.WAFTagOperationException
13903	if *v == nil {
13904		sv = &types.WAFTagOperationException{}
13905	} else {
13906		sv = *v
13907	}
13908
13909	for key, value := range shape {
13910		switch key {
13911		case "message":
13912			if value != nil {
13913				jtv, ok := value.(string)
13914				if !ok {
13915					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13916				}
13917				sv.Message = ptr.String(jtv)
13918			}
13919
13920		default:
13921			_, _ = key, value
13922
13923		}
13924	}
13925	*v = sv
13926	return nil
13927}
13928
13929func awsAwsjson11_deserializeDocumentWAFTagOperationInternalErrorException(v **types.WAFTagOperationInternalErrorException, value interface{}) error {
13930	if v == nil {
13931		return fmt.Errorf("unexpected nil of type %T", v)
13932	}
13933	if value == nil {
13934		return nil
13935	}
13936
13937	shape, ok := value.(map[string]interface{})
13938	if !ok {
13939		return fmt.Errorf("unexpected JSON type %v", value)
13940	}
13941
13942	var sv *types.WAFTagOperationInternalErrorException
13943	if *v == nil {
13944		sv = &types.WAFTagOperationInternalErrorException{}
13945	} else {
13946		sv = *v
13947	}
13948
13949	for key, value := range shape {
13950		switch key {
13951		case "message":
13952			if value != nil {
13953				jtv, ok := value.(string)
13954				if !ok {
13955					return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value)
13956				}
13957				sv.Message = ptr.String(jtv)
13958			}
13959
13960		default:
13961			_, _ = key, value
13962
13963		}
13964	}
13965	*v = sv
13966	return nil
13967}
13968
13969func awsAwsjson11_deserializeDocumentWebACL(v **types.WebACL, value interface{}) error {
13970	if v == nil {
13971		return fmt.Errorf("unexpected nil of type %T", v)
13972	}
13973	if value == nil {
13974		return nil
13975	}
13976
13977	shape, ok := value.(map[string]interface{})
13978	if !ok {
13979		return fmt.Errorf("unexpected JSON type %v", value)
13980	}
13981
13982	var sv *types.WebACL
13983	if *v == nil {
13984		sv = &types.WebACL{}
13985	} else {
13986		sv = *v
13987	}
13988
13989	for key, value := range shape {
13990		switch key {
13991		case "DefaultAction":
13992			if err := awsAwsjson11_deserializeDocumentWafAction(&sv.DefaultAction, value); err != nil {
13993				return err
13994			}
13995
13996		case "MetricName":
13997			if value != nil {
13998				jtv, ok := value.(string)
13999				if !ok {
14000					return fmt.Errorf("expected MetricName to be of type string, got %T instead", value)
14001				}
14002				sv.MetricName = ptr.String(jtv)
14003			}
14004
14005		case "Name":
14006			if value != nil {
14007				jtv, ok := value.(string)
14008				if !ok {
14009					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
14010				}
14011				sv.Name = ptr.String(jtv)
14012			}
14013
14014		case "Rules":
14015			if err := awsAwsjson11_deserializeDocumentActivatedRules(&sv.Rules, value); err != nil {
14016				return err
14017			}
14018
14019		case "WebACLArn":
14020			if value != nil {
14021				jtv, ok := value.(string)
14022				if !ok {
14023					return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
14024				}
14025				sv.WebACLArn = ptr.String(jtv)
14026			}
14027
14028		case "WebACLId":
14029			if value != nil {
14030				jtv, ok := value.(string)
14031				if !ok {
14032					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
14033				}
14034				sv.WebACLId = ptr.String(jtv)
14035			}
14036
14037		default:
14038			_, _ = key, value
14039
14040		}
14041	}
14042	*v = sv
14043	return nil
14044}
14045
14046func awsAwsjson11_deserializeDocumentWebACLSummaries(v *[]types.WebACLSummary, value interface{}) error {
14047	if v == nil {
14048		return fmt.Errorf("unexpected nil of type %T", v)
14049	}
14050	if value == nil {
14051		return nil
14052	}
14053
14054	shape, ok := value.([]interface{})
14055	if !ok {
14056		return fmt.Errorf("unexpected JSON type %v", value)
14057	}
14058
14059	var cv []types.WebACLSummary
14060	if *v == nil {
14061		cv = []types.WebACLSummary{}
14062	} else {
14063		cv = *v
14064	}
14065
14066	for _, value := range shape {
14067		var col types.WebACLSummary
14068		destAddr := &col
14069		if err := awsAwsjson11_deserializeDocumentWebACLSummary(&destAddr, value); err != nil {
14070			return err
14071		}
14072		col = *destAddr
14073		cv = append(cv, col)
14074
14075	}
14076	*v = cv
14077	return nil
14078}
14079
14080func awsAwsjson11_deserializeDocumentWebACLSummary(v **types.WebACLSummary, value interface{}) error {
14081	if v == nil {
14082		return fmt.Errorf("unexpected nil of type %T", v)
14083	}
14084	if value == nil {
14085		return nil
14086	}
14087
14088	shape, ok := value.(map[string]interface{})
14089	if !ok {
14090		return fmt.Errorf("unexpected JSON type %v", value)
14091	}
14092
14093	var sv *types.WebACLSummary
14094	if *v == nil {
14095		sv = &types.WebACLSummary{}
14096	} else {
14097		sv = *v
14098	}
14099
14100	for key, value := range shape {
14101		switch key {
14102		case "Name":
14103			if value != nil {
14104				jtv, ok := value.(string)
14105				if !ok {
14106					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
14107				}
14108				sv.Name = ptr.String(jtv)
14109			}
14110
14111		case "WebACLId":
14112			if value != nil {
14113				jtv, ok := value.(string)
14114				if !ok {
14115					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
14116				}
14117				sv.WebACLId = ptr.String(jtv)
14118			}
14119
14120		default:
14121			_, _ = key, value
14122
14123		}
14124	}
14125	*v = sv
14126	return nil
14127}
14128
14129func awsAwsjson11_deserializeDocumentXssMatchSet(v **types.XssMatchSet, value interface{}) error {
14130	if v == nil {
14131		return fmt.Errorf("unexpected nil of type %T", v)
14132	}
14133	if value == nil {
14134		return nil
14135	}
14136
14137	shape, ok := value.(map[string]interface{})
14138	if !ok {
14139		return fmt.Errorf("unexpected JSON type %v", value)
14140	}
14141
14142	var sv *types.XssMatchSet
14143	if *v == nil {
14144		sv = &types.XssMatchSet{}
14145	} else {
14146		sv = *v
14147	}
14148
14149	for key, value := range shape {
14150		switch key {
14151		case "Name":
14152			if value != nil {
14153				jtv, ok := value.(string)
14154				if !ok {
14155					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
14156				}
14157				sv.Name = ptr.String(jtv)
14158			}
14159
14160		case "XssMatchSetId":
14161			if value != nil {
14162				jtv, ok := value.(string)
14163				if !ok {
14164					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
14165				}
14166				sv.XssMatchSetId = ptr.String(jtv)
14167			}
14168
14169		case "XssMatchTuples":
14170			if err := awsAwsjson11_deserializeDocumentXssMatchTuples(&sv.XssMatchTuples, value); err != nil {
14171				return err
14172			}
14173
14174		default:
14175			_, _ = key, value
14176
14177		}
14178	}
14179	*v = sv
14180	return nil
14181}
14182
14183func awsAwsjson11_deserializeDocumentXssMatchSetSummaries(v *[]types.XssMatchSetSummary, value interface{}) error {
14184	if v == nil {
14185		return fmt.Errorf("unexpected nil of type %T", v)
14186	}
14187	if value == nil {
14188		return nil
14189	}
14190
14191	shape, ok := value.([]interface{})
14192	if !ok {
14193		return fmt.Errorf("unexpected JSON type %v", value)
14194	}
14195
14196	var cv []types.XssMatchSetSummary
14197	if *v == nil {
14198		cv = []types.XssMatchSetSummary{}
14199	} else {
14200		cv = *v
14201	}
14202
14203	for _, value := range shape {
14204		var col types.XssMatchSetSummary
14205		destAddr := &col
14206		if err := awsAwsjson11_deserializeDocumentXssMatchSetSummary(&destAddr, value); err != nil {
14207			return err
14208		}
14209		col = *destAddr
14210		cv = append(cv, col)
14211
14212	}
14213	*v = cv
14214	return nil
14215}
14216
14217func awsAwsjson11_deserializeDocumentXssMatchSetSummary(v **types.XssMatchSetSummary, value interface{}) error {
14218	if v == nil {
14219		return fmt.Errorf("unexpected nil of type %T", v)
14220	}
14221	if value == nil {
14222		return nil
14223	}
14224
14225	shape, ok := value.(map[string]interface{})
14226	if !ok {
14227		return fmt.Errorf("unexpected JSON type %v", value)
14228	}
14229
14230	var sv *types.XssMatchSetSummary
14231	if *v == nil {
14232		sv = &types.XssMatchSetSummary{}
14233	} else {
14234		sv = *v
14235	}
14236
14237	for key, value := range shape {
14238		switch key {
14239		case "Name":
14240			if value != nil {
14241				jtv, ok := value.(string)
14242				if !ok {
14243					return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
14244				}
14245				sv.Name = ptr.String(jtv)
14246			}
14247
14248		case "XssMatchSetId":
14249			if value != nil {
14250				jtv, ok := value.(string)
14251				if !ok {
14252					return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
14253				}
14254				sv.XssMatchSetId = ptr.String(jtv)
14255			}
14256
14257		default:
14258			_, _ = key, value
14259
14260		}
14261	}
14262	*v = sv
14263	return nil
14264}
14265
14266func awsAwsjson11_deserializeDocumentXssMatchTuple(v **types.XssMatchTuple, value interface{}) error {
14267	if v == nil {
14268		return fmt.Errorf("unexpected nil of type %T", v)
14269	}
14270	if value == nil {
14271		return nil
14272	}
14273
14274	shape, ok := value.(map[string]interface{})
14275	if !ok {
14276		return fmt.Errorf("unexpected JSON type %v", value)
14277	}
14278
14279	var sv *types.XssMatchTuple
14280	if *v == nil {
14281		sv = &types.XssMatchTuple{}
14282	} else {
14283		sv = *v
14284	}
14285
14286	for key, value := range shape {
14287		switch key {
14288		case "FieldToMatch":
14289			if err := awsAwsjson11_deserializeDocumentFieldToMatch(&sv.FieldToMatch, value); err != nil {
14290				return err
14291			}
14292
14293		case "TextTransformation":
14294			if value != nil {
14295				jtv, ok := value.(string)
14296				if !ok {
14297					return fmt.Errorf("expected TextTransformation to be of type string, got %T instead", value)
14298				}
14299				sv.TextTransformation = types.TextTransformation(jtv)
14300			}
14301
14302		default:
14303			_, _ = key, value
14304
14305		}
14306	}
14307	*v = sv
14308	return nil
14309}
14310
14311func awsAwsjson11_deserializeDocumentXssMatchTuples(v *[]types.XssMatchTuple, value interface{}) error {
14312	if v == nil {
14313		return fmt.Errorf("unexpected nil of type %T", v)
14314	}
14315	if value == nil {
14316		return nil
14317	}
14318
14319	shape, ok := value.([]interface{})
14320	if !ok {
14321		return fmt.Errorf("unexpected JSON type %v", value)
14322	}
14323
14324	var cv []types.XssMatchTuple
14325	if *v == nil {
14326		cv = []types.XssMatchTuple{}
14327	} else {
14328		cv = *v
14329	}
14330
14331	for _, value := range shape {
14332		var col types.XssMatchTuple
14333		destAddr := &col
14334		if err := awsAwsjson11_deserializeDocumentXssMatchTuple(&destAddr, value); err != nil {
14335			return err
14336		}
14337		col = *destAddr
14338		cv = append(cv, col)
14339
14340	}
14341	*v = cv
14342	return nil
14343}
14344
14345func awsAwsjson11_deserializeOpDocumentCreateByteMatchSetOutput(v **CreateByteMatchSetOutput, value interface{}) error {
14346	if v == nil {
14347		return fmt.Errorf("unexpected nil of type %T", v)
14348	}
14349	if value == nil {
14350		return nil
14351	}
14352
14353	shape, ok := value.(map[string]interface{})
14354	if !ok {
14355		return fmt.Errorf("unexpected JSON type %v", value)
14356	}
14357
14358	var sv *CreateByteMatchSetOutput
14359	if *v == nil {
14360		sv = &CreateByteMatchSetOutput{}
14361	} else {
14362		sv = *v
14363	}
14364
14365	for key, value := range shape {
14366		switch key {
14367		case "ByteMatchSet":
14368			if err := awsAwsjson11_deserializeDocumentByteMatchSet(&sv.ByteMatchSet, value); err != nil {
14369				return err
14370			}
14371
14372		case "ChangeToken":
14373			if value != nil {
14374				jtv, ok := value.(string)
14375				if !ok {
14376					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14377				}
14378				sv.ChangeToken = ptr.String(jtv)
14379			}
14380
14381		default:
14382			_, _ = key, value
14383
14384		}
14385	}
14386	*v = sv
14387	return nil
14388}
14389
14390func awsAwsjson11_deserializeOpDocumentCreateGeoMatchSetOutput(v **CreateGeoMatchSetOutput, value interface{}) error {
14391	if v == nil {
14392		return fmt.Errorf("unexpected nil of type %T", v)
14393	}
14394	if value == nil {
14395		return nil
14396	}
14397
14398	shape, ok := value.(map[string]interface{})
14399	if !ok {
14400		return fmt.Errorf("unexpected JSON type %v", value)
14401	}
14402
14403	var sv *CreateGeoMatchSetOutput
14404	if *v == nil {
14405		sv = &CreateGeoMatchSetOutput{}
14406	} else {
14407		sv = *v
14408	}
14409
14410	for key, value := range shape {
14411		switch key {
14412		case "ChangeToken":
14413			if value != nil {
14414				jtv, ok := value.(string)
14415				if !ok {
14416					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14417				}
14418				sv.ChangeToken = ptr.String(jtv)
14419			}
14420
14421		case "GeoMatchSet":
14422			if err := awsAwsjson11_deserializeDocumentGeoMatchSet(&sv.GeoMatchSet, value); err != nil {
14423				return err
14424			}
14425
14426		default:
14427			_, _ = key, value
14428
14429		}
14430	}
14431	*v = sv
14432	return nil
14433}
14434
14435func awsAwsjson11_deserializeOpDocumentCreateIPSetOutput(v **CreateIPSetOutput, value interface{}) error {
14436	if v == nil {
14437		return fmt.Errorf("unexpected nil of type %T", v)
14438	}
14439	if value == nil {
14440		return nil
14441	}
14442
14443	shape, ok := value.(map[string]interface{})
14444	if !ok {
14445		return fmt.Errorf("unexpected JSON type %v", value)
14446	}
14447
14448	var sv *CreateIPSetOutput
14449	if *v == nil {
14450		sv = &CreateIPSetOutput{}
14451	} else {
14452		sv = *v
14453	}
14454
14455	for key, value := range shape {
14456		switch key {
14457		case "ChangeToken":
14458			if value != nil {
14459				jtv, ok := value.(string)
14460				if !ok {
14461					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14462				}
14463				sv.ChangeToken = ptr.String(jtv)
14464			}
14465
14466		case "IPSet":
14467			if err := awsAwsjson11_deserializeDocumentIPSet(&sv.IPSet, value); err != nil {
14468				return err
14469			}
14470
14471		default:
14472			_, _ = key, value
14473
14474		}
14475	}
14476	*v = sv
14477	return nil
14478}
14479
14480func awsAwsjson11_deserializeOpDocumentCreateRateBasedRuleOutput(v **CreateRateBasedRuleOutput, value interface{}) error {
14481	if v == nil {
14482		return fmt.Errorf("unexpected nil of type %T", v)
14483	}
14484	if value == nil {
14485		return nil
14486	}
14487
14488	shape, ok := value.(map[string]interface{})
14489	if !ok {
14490		return fmt.Errorf("unexpected JSON type %v", value)
14491	}
14492
14493	var sv *CreateRateBasedRuleOutput
14494	if *v == nil {
14495		sv = &CreateRateBasedRuleOutput{}
14496	} else {
14497		sv = *v
14498	}
14499
14500	for key, value := range shape {
14501		switch key {
14502		case "ChangeToken":
14503			if value != nil {
14504				jtv, ok := value.(string)
14505				if !ok {
14506					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14507				}
14508				sv.ChangeToken = ptr.String(jtv)
14509			}
14510
14511		case "Rule":
14512			if err := awsAwsjson11_deserializeDocumentRateBasedRule(&sv.Rule, value); err != nil {
14513				return err
14514			}
14515
14516		default:
14517			_, _ = key, value
14518
14519		}
14520	}
14521	*v = sv
14522	return nil
14523}
14524
14525func awsAwsjson11_deserializeOpDocumentCreateRegexMatchSetOutput(v **CreateRegexMatchSetOutput, value interface{}) error {
14526	if v == nil {
14527		return fmt.Errorf("unexpected nil of type %T", v)
14528	}
14529	if value == nil {
14530		return nil
14531	}
14532
14533	shape, ok := value.(map[string]interface{})
14534	if !ok {
14535		return fmt.Errorf("unexpected JSON type %v", value)
14536	}
14537
14538	var sv *CreateRegexMatchSetOutput
14539	if *v == nil {
14540		sv = &CreateRegexMatchSetOutput{}
14541	} else {
14542		sv = *v
14543	}
14544
14545	for key, value := range shape {
14546		switch key {
14547		case "ChangeToken":
14548			if value != nil {
14549				jtv, ok := value.(string)
14550				if !ok {
14551					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14552				}
14553				sv.ChangeToken = ptr.String(jtv)
14554			}
14555
14556		case "RegexMatchSet":
14557			if err := awsAwsjson11_deserializeDocumentRegexMatchSet(&sv.RegexMatchSet, value); err != nil {
14558				return err
14559			}
14560
14561		default:
14562			_, _ = key, value
14563
14564		}
14565	}
14566	*v = sv
14567	return nil
14568}
14569
14570func awsAwsjson11_deserializeOpDocumentCreateRegexPatternSetOutput(v **CreateRegexPatternSetOutput, value interface{}) error {
14571	if v == nil {
14572		return fmt.Errorf("unexpected nil of type %T", v)
14573	}
14574	if value == nil {
14575		return nil
14576	}
14577
14578	shape, ok := value.(map[string]interface{})
14579	if !ok {
14580		return fmt.Errorf("unexpected JSON type %v", value)
14581	}
14582
14583	var sv *CreateRegexPatternSetOutput
14584	if *v == nil {
14585		sv = &CreateRegexPatternSetOutput{}
14586	} else {
14587		sv = *v
14588	}
14589
14590	for key, value := range shape {
14591		switch key {
14592		case "ChangeToken":
14593			if value != nil {
14594				jtv, ok := value.(string)
14595				if !ok {
14596					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14597				}
14598				sv.ChangeToken = ptr.String(jtv)
14599			}
14600
14601		case "RegexPatternSet":
14602			if err := awsAwsjson11_deserializeDocumentRegexPatternSet(&sv.RegexPatternSet, value); err != nil {
14603				return err
14604			}
14605
14606		default:
14607			_, _ = key, value
14608
14609		}
14610	}
14611	*v = sv
14612	return nil
14613}
14614
14615func awsAwsjson11_deserializeOpDocumentCreateRuleGroupOutput(v **CreateRuleGroupOutput, value interface{}) error {
14616	if v == nil {
14617		return fmt.Errorf("unexpected nil of type %T", v)
14618	}
14619	if value == nil {
14620		return nil
14621	}
14622
14623	shape, ok := value.(map[string]interface{})
14624	if !ok {
14625		return fmt.Errorf("unexpected JSON type %v", value)
14626	}
14627
14628	var sv *CreateRuleGroupOutput
14629	if *v == nil {
14630		sv = &CreateRuleGroupOutput{}
14631	} else {
14632		sv = *v
14633	}
14634
14635	for key, value := range shape {
14636		switch key {
14637		case "ChangeToken":
14638			if value != nil {
14639				jtv, ok := value.(string)
14640				if !ok {
14641					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14642				}
14643				sv.ChangeToken = ptr.String(jtv)
14644			}
14645
14646		case "RuleGroup":
14647			if err := awsAwsjson11_deserializeDocumentRuleGroup(&sv.RuleGroup, value); err != nil {
14648				return err
14649			}
14650
14651		default:
14652			_, _ = key, value
14653
14654		}
14655	}
14656	*v = sv
14657	return nil
14658}
14659
14660func awsAwsjson11_deserializeOpDocumentCreateRuleOutput(v **CreateRuleOutput, value interface{}) error {
14661	if v == nil {
14662		return fmt.Errorf("unexpected nil of type %T", v)
14663	}
14664	if value == nil {
14665		return nil
14666	}
14667
14668	shape, ok := value.(map[string]interface{})
14669	if !ok {
14670		return fmt.Errorf("unexpected JSON type %v", value)
14671	}
14672
14673	var sv *CreateRuleOutput
14674	if *v == nil {
14675		sv = &CreateRuleOutput{}
14676	} else {
14677		sv = *v
14678	}
14679
14680	for key, value := range shape {
14681		switch key {
14682		case "ChangeToken":
14683			if value != nil {
14684				jtv, ok := value.(string)
14685				if !ok {
14686					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14687				}
14688				sv.ChangeToken = ptr.String(jtv)
14689			}
14690
14691		case "Rule":
14692			if err := awsAwsjson11_deserializeDocumentRule(&sv.Rule, value); err != nil {
14693				return err
14694			}
14695
14696		default:
14697			_, _ = key, value
14698
14699		}
14700	}
14701	*v = sv
14702	return nil
14703}
14704
14705func awsAwsjson11_deserializeOpDocumentCreateSizeConstraintSetOutput(v **CreateSizeConstraintSetOutput, value interface{}) error {
14706	if v == nil {
14707		return fmt.Errorf("unexpected nil of type %T", v)
14708	}
14709	if value == nil {
14710		return nil
14711	}
14712
14713	shape, ok := value.(map[string]interface{})
14714	if !ok {
14715		return fmt.Errorf("unexpected JSON type %v", value)
14716	}
14717
14718	var sv *CreateSizeConstraintSetOutput
14719	if *v == nil {
14720		sv = &CreateSizeConstraintSetOutput{}
14721	} else {
14722		sv = *v
14723	}
14724
14725	for key, value := range shape {
14726		switch key {
14727		case "ChangeToken":
14728			if value != nil {
14729				jtv, ok := value.(string)
14730				if !ok {
14731					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14732				}
14733				sv.ChangeToken = ptr.String(jtv)
14734			}
14735
14736		case "SizeConstraintSet":
14737			if err := awsAwsjson11_deserializeDocumentSizeConstraintSet(&sv.SizeConstraintSet, value); err != nil {
14738				return err
14739			}
14740
14741		default:
14742			_, _ = key, value
14743
14744		}
14745	}
14746	*v = sv
14747	return nil
14748}
14749
14750func awsAwsjson11_deserializeOpDocumentCreateSqlInjectionMatchSetOutput(v **CreateSqlInjectionMatchSetOutput, value interface{}) error {
14751	if v == nil {
14752		return fmt.Errorf("unexpected nil of type %T", v)
14753	}
14754	if value == nil {
14755		return nil
14756	}
14757
14758	shape, ok := value.(map[string]interface{})
14759	if !ok {
14760		return fmt.Errorf("unexpected JSON type %v", value)
14761	}
14762
14763	var sv *CreateSqlInjectionMatchSetOutput
14764	if *v == nil {
14765		sv = &CreateSqlInjectionMatchSetOutput{}
14766	} else {
14767		sv = *v
14768	}
14769
14770	for key, value := range shape {
14771		switch key {
14772		case "ChangeToken":
14773			if value != nil {
14774				jtv, ok := value.(string)
14775				if !ok {
14776					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14777				}
14778				sv.ChangeToken = ptr.String(jtv)
14779			}
14780
14781		case "SqlInjectionMatchSet":
14782			if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchSet(&sv.SqlInjectionMatchSet, value); err != nil {
14783				return err
14784			}
14785
14786		default:
14787			_, _ = key, value
14788
14789		}
14790	}
14791	*v = sv
14792	return nil
14793}
14794
14795func awsAwsjson11_deserializeOpDocumentCreateWebACLMigrationStackOutput(v **CreateWebACLMigrationStackOutput, value interface{}) error {
14796	if v == nil {
14797		return fmt.Errorf("unexpected nil of type %T", v)
14798	}
14799	if value == nil {
14800		return nil
14801	}
14802
14803	shape, ok := value.(map[string]interface{})
14804	if !ok {
14805		return fmt.Errorf("unexpected JSON type %v", value)
14806	}
14807
14808	var sv *CreateWebACLMigrationStackOutput
14809	if *v == nil {
14810		sv = &CreateWebACLMigrationStackOutput{}
14811	} else {
14812		sv = *v
14813	}
14814
14815	for key, value := range shape {
14816		switch key {
14817		case "S3ObjectUrl":
14818			if value != nil {
14819				jtv, ok := value.(string)
14820				if !ok {
14821					return fmt.Errorf("expected S3ObjectUrl to be of type string, got %T instead", value)
14822				}
14823				sv.S3ObjectUrl = ptr.String(jtv)
14824			}
14825
14826		default:
14827			_, _ = key, value
14828
14829		}
14830	}
14831	*v = sv
14832	return nil
14833}
14834
14835func awsAwsjson11_deserializeOpDocumentCreateWebACLOutput(v **CreateWebACLOutput, value interface{}) error {
14836	if v == nil {
14837		return fmt.Errorf("unexpected nil of type %T", v)
14838	}
14839	if value == nil {
14840		return nil
14841	}
14842
14843	shape, ok := value.(map[string]interface{})
14844	if !ok {
14845		return fmt.Errorf("unexpected JSON type %v", value)
14846	}
14847
14848	var sv *CreateWebACLOutput
14849	if *v == nil {
14850		sv = &CreateWebACLOutput{}
14851	} else {
14852		sv = *v
14853	}
14854
14855	for key, value := range shape {
14856		switch key {
14857		case "ChangeToken":
14858			if value != nil {
14859				jtv, ok := value.(string)
14860				if !ok {
14861					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14862				}
14863				sv.ChangeToken = ptr.String(jtv)
14864			}
14865
14866		case "WebACL":
14867			if err := awsAwsjson11_deserializeDocumentWebACL(&sv.WebACL, value); err != nil {
14868				return err
14869			}
14870
14871		default:
14872			_, _ = key, value
14873
14874		}
14875	}
14876	*v = sv
14877	return nil
14878}
14879
14880func awsAwsjson11_deserializeOpDocumentCreateXssMatchSetOutput(v **CreateXssMatchSetOutput, value interface{}) error {
14881	if v == nil {
14882		return fmt.Errorf("unexpected nil of type %T", v)
14883	}
14884	if value == nil {
14885		return nil
14886	}
14887
14888	shape, ok := value.(map[string]interface{})
14889	if !ok {
14890		return fmt.Errorf("unexpected JSON type %v", value)
14891	}
14892
14893	var sv *CreateXssMatchSetOutput
14894	if *v == nil {
14895		sv = &CreateXssMatchSetOutput{}
14896	} else {
14897		sv = *v
14898	}
14899
14900	for key, value := range shape {
14901		switch key {
14902		case "ChangeToken":
14903			if value != nil {
14904				jtv, ok := value.(string)
14905				if !ok {
14906					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14907				}
14908				sv.ChangeToken = ptr.String(jtv)
14909			}
14910
14911		case "XssMatchSet":
14912			if err := awsAwsjson11_deserializeDocumentXssMatchSet(&sv.XssMatchSet, value); err != nil {
14913				return err
14914			}
14915
14916		default:
14917			_, _ = key, value
14918
14919		}
14920	}
14921	*v = sv
14922	return nil
14923}
14924
14925func awsAwsjson11_deserializeOpDocumentDeleteByteMatchSetOutput(v **DeleteByteMatchSetOutput, value interface{}) error {
14926	if v == nil {
14927		return fmt.Errorf("unexpected nil of type %T", v)
14928	}
14929	if value == nil {
14930		return nil
14931	}
14932
14933	shape, ok := value.(map[string]interface{})
14934	if !ok {
14935		return fmt.Errorf("unexpected JSON type %v", value)
14936	}
14937
14938	var sv *DeleteByteMatchSetOutput
14939	if *v == nil {
14940		sv = &DeleteByteMatchSetOutput{}
14941	} else {
14942		sv = *v
14943	}
14944
14945	for key, value := range shape {
14946		switch key {
14947		case "ChangeToken":
14948			if value != nil {
14949				jtv, ok := value.(string)
14950				if !ok {
14951					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14952				}
14953				sv.ChangeToken = ptr.String(jtv)
14954			}
14955
14956		default:
14957			_, _ = key, value
14958
14959		}
14960	}
14961	*v = sv
14962	return nil
14963}
14964
14965func awsAwsjson11_deserializeOpDocumentDeleteGeoMatchSetOutput(v **DeleteGeoMatchSetOutput, value interface{}) error {
14966	if v == nil {
14967		return fmt.Errorf("unexpected nil of type %T", v)
14968	}
14969	if value == nil {
14970		return nil
14971	}
14972
14973	shape, ok := value.(map[string]interface{})
14974	if !ok {
14975		return fmt.Errorf("unexpected JSON type %v", value)
14976	}
14977
14978	var sv *DeleteGeoMatchSetOutput
14979	if *v == nil {
14980		sv = &DeleteGeoMatchSetOutput{}
14981	} else {
14982		sv = *v
14983	}
14984
14985	for key, value := range shape {
14986		switch key {
14987		case "ChangeToken":
14988			if value != nil {
14989				jtv, ok := value.(string)
14990				if !ok {
14991					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
14992				}
14993				sv.ChangeToken = ptr.String(jtv)
14994			}
14995
14996		default:
14997			_, _ = key, value
14998
14999		}
15000	}
15001	*v = sv
15002	return nil
15003}
15004
15005func awsAwsjson11_deserializeOpDocumentDeleteIPSetOutput(v **DeleteIPSetOutput, value interface{}) error {
15006	if v == nil {
15007		return fmt.Errorf("unexpected nil of type %T", v)
15008	}
15009	if value == nil {
15010		return nil
15011	}
15012
15013	shape, ok := value.(map[string]interface{})
15014	if !ok {
15015		return fmt.Errorf("unexpected JSON type %v", value)
15016	}
15017
15018	var sv *DeleteIPSetOutput
15019	if *v == nil {
15020		sv = &DeleteIPSetOutput{}
15021	} else {
15022		sv = *v
15023	}
15024
15025	for key, value := range shape {
15026		switch key {
15027		case "ChangeToken":
15028			if value != nil {
15029				jtv, ok := value.(string)
15030				if !ok {
15031					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15032				}
15033				sv.ChangeToken = ptr.String(jtv)
15034			}
15035
15036		default:
15037			_, _ = key, value
15038
15039		}
15040	}
15041	*v = sv
15042	return nil
15043}
15044
15045func awsAwsjson11_deserializeOpDocumentDeleteLoggingConfigurationOutput(v **DeleteLoggingConfigurationOutput, value interface{}) error {
15046	if v == nil {
15047		return fmt.Errorf("unexpected nil of type %T", v)
15048	}
15049	if value == nil {
15050		return nil
15051	}
15052
15053	shape, ok := value.(map[string]interface{})
15054	if !ok {
15055		return fmt.Errorf("unexpected JSON type %v", value)
15056	}
15057
15058	var sv *DeleteLoggingConfigurationOutput
15059	if *v == nil {
15060		sv = &DeleteLoggingConfigurationOutput{}
15061	} else {
15062		sv = *v
15063	}
15064
15065	for key, value := range shape {
15066		switch key {
15067		default:
15068			_, _ = key, value
15069
15070		}
15071	}
15072	*v = sv
15073	return nil
15074}
15075
15076func awsAwsjson11_deserializeOpDocumentDeletePermissionPolicyOutput(v **DeletePermissionPolicyOutput, value interface{}) error {
15077	if v == nil {
15078		return fmt.Errorf("unexpected nil of type %T", v)
15079	}
15080	if value == nil {
15081		return nil
15082	}
15083
15084	shape, ok := value.(map[string]interface{})
15085	if !ok {
15086		return fmt.Errorf("unexpected JSON type %v", value)
15087	}
15088
15089	var sv *DeletePermissionPolicyOutput
15090	if *v == nil {
15091		sv = &DeletePermissionPolicyOutput{}
15092	} else {
15093		sv = *v
15094	}
15095
15096	for key, value := range shape {
15097		switch key {
15098		default:
15099			_, _ = key, value
15100
15101		}
15102	}
15103	*v = sv
15104	return nil
15105}
15106
15107func awsAwsjson11_deserializeOpDocumentDeleteRateBasedRuleOutput(v **DeleteRateBasedRuleOutput, value interface{}) error {
15108	if v == nil {
15109		return fmt.Errorf("unexpected nil of type %T", v)
15110	}
15111	if value == nil {
15112		return nil
15113	}
15114
15115	shape, ok := value.(map[string]interface{})
15116	if !ok {
15117		return fmt.Errorf("unexpected JSON type %v", value)
15118	}
15119
15120	var sv *DeleteRateBasedRuleOutput
15121	if *v == nil {
15122		sv = &DeleteRateBasedRuleOutput{}
15123	} else {
15124		sv = *v
15125	}
15126
15127	for key, value := range shape {
15128		switch key {
15129		case "ChangeToken":
15130			if value != nil {
15131				jtv, ok := value.(string)
15132				if !ok {
15133					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15134				}
15135				sv.ChangeToken = ptr.String(jtv)
15136			}
15137
15138		default:
15139			_, _ = key, value
15140
15141		}
15142	}
15143	*v = sv
15144	return nil
15145}
15146
15147func awsAwsjson11_deserializeOpDocumentDeleteRegexMatchSetOutput(v **DeleteRegexMatchSetOutput, value interface{}) error {
15148	if v == nil {
15149		return fmt.Errorf("unexpected nil of type %T", v)
15150	}
15151	if value == nil {
15152		return nil
15153	}
15154
15155	shape, ok := value.(map[string]interface{})
15156	if !ok {
15157		return fmt.Errorf("unexpected JSON type %v", value)
15158	}
15159
15160	var sv *DeleteRegexMatchSetOutput
15161	if *v == nil {
15162		sv = &DeleteRegexMatchSetOutput{}
15163	} else {
15164		sv = *v
15165	}
15166
15167	for key, value := range shape {
15168		switch key {
15169		case "ChangeToken":
15170			if value != nil {
15171				jtv, ok := value.(string)
15172				if !ok {
15173					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15174				}
15175				sv.ChangeToken = ptr.String(jtv)
15176			}
15177
15178		default:
15179			_, _ = key, value
15180
15181		}
15182	}
15183	*v = sv
15184	return nil
15185}
15186
15187func awsAwsjson11_deserializeOpDocumentDeleteRegexPatternSetOutput(v **DeleteRegexPatternSetOutput, value interface{}) error {
15188	if v == nil {
15189		return fmt.Errorf("unexpected nil of type %T", v)
15190	}
15191	if value == nil {
15192		return nil
15193	}
15194
15195	shape, ok := value.(map[string]interface{})
15196	if !ok {
15197		return fmt.Errorf("unexpected JSON type %v", value)
15198	}
15199
15200	var sv *DeleteRegexPatternSetOutput
15201	if *v == nil {
15202		sv = &DeleteRegexPatternSetOutput{}
15203	} else {
15204		sv = *v
15205	}
15206
15207	for key, value := range shape {
15208		switch key {
15209		case "ChangeToken":
15210			if value != nil {
15211				jtv, ok := value.(string)
15212				if !ok {
15213					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15214				}
15215				sv.ChangeToken = ptr.String(jtv)
15216			}
15217
15218		default:
15219			_, _ = key, value
15220
15221		}
15222	}
15223	*v = sv
15224	return nil
15225}
15226
15227func awsAwsjson11_deserializeOpDocumentDeleteRuleGroupOutput(v **DeleteRuleGroupOutput, value interface{}) error {
15228	if v == nil {
15229		return fmt.Errorf("unexpected nil of type %T", v)
15230	}
15231	if value == nil {
15232		return nil
15233	}
15234
15235	shape, ok := value.(map[string]interface{})
15236	if !ok {
15237		return fmt.Errorf("unexpected JSON type %v", value)
15238	}
15239
15240	var sv *DeleteRuleGroupOutput
15241	if *v == nil {
15242		sv = &DeleteRuleGroupOutput{}
15243	} else {
15244		sv = *v
15245	}
15246
15247	for key, value := range shape {
15248		switch key {
15249		case "ChangeToken":
15250			if value != nil {
15251				jtv, ok := value.(string)
15252				if !ok {
15253					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15254				}
15255				sv.ChangeToken = ptr.String(jtv)
15256			}
15257
15258		default:
15259			_, _ = key, value
15260
15261		}
15262	}
15263	*v = sv
15264	return nil
15265}
15266
15267func awsAwsjson11_deserializeOpDocumentDeleteRuleOutput(v **DeleteRuleOutput, value interface{}) error {
15268	if v == nil {
15269		return fmt.Errorf("unexpected nil of type %T", v)
15270	}
15271	if value == nil {
15272		return nil
15273	}
15274
15275	shape, ok := value.(map[string]interface{})
15276	if !ok {
15277		return fmt.Errorf("unexpected JSON type %v", value)
15278	}
15279
15280	var sv *DeleteRuleOutput
15281	if *v == nil {
15282		sv = &DeleteRuleOutput{}
15283	} else {
15284		sv = *v
15285	}
15286
15287	for key, value := range shape {
15288		switch key {
15289		case "ChangeToken":
15290			if value != nil {
15291				jtv, ok := value.(string)
15292				if !ok {
15293					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15294				}
15295				sv.ChangeToken = ptr.String(jtv)
15296			}
15297
15298		default:
15299			_, _ = key, value
15300
15301		}
15302	}
15303	*v = sv
15304	return nil
15305}
15306
15307func awsAwsjson11_deserializeOpDocumentDeleteSizeConstraintSetOutput(v **DeleteSizeConstraintSetOutput, value interface{}) error {
15308	if v == nil {
15309		return fmt.Errorf("unexpected nil of type %T", v)
15310	}
15311	if value == nil {
15312		return nil
15313	}
15314
15315	shape, ok := value.(map[string]interface{})
15316	if !ok {
15317		return fmt.Errorf("unexpected JSON type %v", value)
15318	}
15319
15320	var sv *DeleteSizeConstraintSetOutput
15321	if *v == nil {
15322		sv = &DeleteSizeConstraintSetOutput{}
15323	} else {
15324		sv = *v
15325	}
15326
15327	for key, value := range shape {
15328		switch key {
15329		case "ChangeToken":
15330			if value != nil {
15331				jtv, ok := value.(string)
15332				if !ok {
15333					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15334				}
15335				sv.ChangeToken = ptr.String(jtv)
15336			}
15337
15338		default:
15339			_, _ = key, value
15340
15341		}
15342	}
15343	*v = sv
15344	return nil
15345}
15346
15347func awsAwsjson11_deserializeOpDocumentDeleteSqlInjectionMatchSetOutput(v **DeleteSqlInjectionMatchSetOutput, value interface{}) error {
15348	if v == nil {
15349		return fmt.Errorf("unexpected nil of type %T", v)
15350	}
15351	if value == nil {
15352		return nil
15353	}
15354
15355	shape, ok := value.(map[string]interface{})
15356	if !ok {
15357		return fmt.Errorf("unexpected JSON type %v", value)
15358	}
15359
15360	var sv *DeleteSqlInjectionMatchSetOutput
15361	if *v == nil {
15362		sv = &DeleteSqlInjectionMatchSetOutput{}
15363	} else {
15364		sv = *v
15365	}
15366
15367	for key, value := range shape {
15368		switch key {
15369		case "ChangeToken":
15370			if value != nil {
15371				jtv, ok := value.(string)
15372				if !ok {
15373					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15374				}
15375				sv.ChangeToken = ptr.String(jtv)
15376			}
15377
15378		default:
15379			_, _ = key, value
15380
15381		}
15382	}
15383	*v = sv
15384	return nil
15385}
15386
15387func awsAwsjson11_deserializeOpDocumentDeleteWebACLOutput(v **DeleteWebACLOutput, value interface{}) error {
15388	if v == nil {
15389		return fmt.Errorf("unexpected nil of type %T", v)
15390	}
15391	if value == nil {
15392		return nil
15393	}
15394
15395	shape, ok := value.(map[string]interface{})
15396	if !ok {
15397		return fmt.Errorf("unexpected JSON type %v", value)
15398	}
15399
15400	var sv *DeleteWebACLOutput
15401	if *v == nil {
15402		sv = &DeleteWebACLOutput{}
15403	} else {
15404		sv = *v
15405	}
15406
15407	for key, value := range shape {
15408		switch key {
15409		case "ChangeToken":
15410			if value != nil {
15411				jtv, ok := value.(string)
15412				if !ok {
15413					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15414				}
15415				sv.ChangeToken = ptr.String(jtv)
15416			}
15417
15418		default:
15419			_, _ = key, value
15420
15421		}
15422	}
15423	*v = sv
15424	return nil
15425}
15426
15427func awsAwsjson11_deserializeOpDocumentDeleteXssMatchSetOutput(v **DeleteXssMatchSetOutput, value interface{}) error {
15428	if v == nil {
15429		return fmt.Errorf("unexpected nil of type %T", v)
15430	}
15431	if value == nil {
15432		return nil
15433	}
15434
15435	shape, ok := value.(map[string]interface{})
15436	if !ok {
15437		return fmt.Errorf("unexpected JSON type %v", value)
15438	}
15439
15440	var sv *DeleteXssMatchSetOutput
15441	if *v == nil {
15442		sv = &DeleteXssMatchSetOutput{}
15443	} else {
15444		sv = *v
15445	}
15446
15447	for key, value := range shape {
15448		switch key {
15449		case "ChangeToken":
15450			if value != nil {
15451				jtv, ok := value.(string)
15452				if !ok {
15453					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15454				}
15455				sv.ChangeToken = ptr.String(jtv)
15456			}
15457
15458		default:
15459			_, _ = key, value
15460
15461		}
15462	}
15463	*v = sv
15464	return nil
15465}
15466
15467func awsAwsjson11_deserializeOpDocumentGetByteMatchSetOutput(v **GetByteMatchSetOutput, value interface{}) error {
15468	if v == nil {
15469		return fmt.Errorf("unexpected nil of type %T", v)
15470	}
15471	if value == nil {
15472		return nil
15473	}
15474
15475	shape, ok := value.(map[string]interface{})
15476	if !ok {
15477		return fmt.Errorf("unexpected JSON type %v", value)
15478	}
15479
15480	var sv *GetByteMatchSetOutput
15481	if *v == nil {
15482		sv = &GetByteMatchSetOutput{}
15483	} else {
15484		sv = *v
15485	}
15486
15487	for key, value := range shape {
15488		switch key {
15489		case "ByteMatchSet":
15490			if err := awsAwsjson11_deserializeDocumentByteMatchSet(&sv.ByteMatchSet, value); err != nil {
15491				return err
15492			}
15493
15494		default:
15495			_, _ = key, value
15496
15497		}
15498	}
15499	*v = sv
15500	return nil
15501}
15502
15503func awsAwsjson11_deserializeOpDocumentGetChangeTokenOutput(v **GetChangeTokenOutput, value interface{}) error {
15504	if v == nil {
15505		return fmt.Errorf("unexpected nil of type %T", v)
15506	}
15507	if value == nil {
15508		return nil
15509	}
15510
15511	shape, ok := value.(map[string]interface{})
15512	if !ok {
15513		return fmt.Errorf("unexpected JSON type %v", value)
15514	}
15515
15516	var sv *GetChangeTokenOutput
15517	if *v == nil {
15518		sv = &GetChangeTokenOutput{}
15519	} else {
15520		sv = *v
15521	}
15522
15523	for key, value := range shape {
15524		switch key {
15525		case "ChangeToken":
15526			if value != nil {
15527				jtv, ok := value.(string)
15528				if !ok {
15529					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
15530				}
15531				sv.ChangeToken = ptr.String(jtv)
15532			}
15533
15534		default:
15535			_, _ = key, value
15536
15537		}
15538	}
15539	*v = sv
15540	return nil
15541}
15542
15543func awsAwsjson11_deserializeOpDocumentGetChangeTokenStatusOutput(v **GetChangeTokenStatusOutput, value interface{}) error {
15544	if v == nil {
15545		return fmt.Errorf("unexpected nil of type %T", v)
15546	}
15547	if value == nil {
15548		return nil
15549	}
15550
15551	shape, ok := value.(map[string]interface{})
15552	if !ok {
15553		return fmt.Errorf("unexpected JSON type %v", value)
15554	}
15555
15556	var sv *GetChangeTokenStatusOutput
15557	if *v == nil {
15558		sv = &GetChangeTokenStatusOutput{}
15559	} else {
15560		sv = *v
15561	}
15562
15563	for key, value := range shape {
15564		switch key {
15565		case "ChangeTokenStatus":
15566			if value != nil {
15567				jtv, ok := value.(string)
15568				if !ok {
15569					return fmt.Errorf("expected ChangeTokenStatus to be of type string, got %T instead", value)
15570				}
15571				sv.ChangeTokenStatus = types.ChangeTokenStatus(jtv)
15572			}
15573
15574		default:
15575			_, _ = key, value
15576
15577		}
15578	}
15579	*v = sv
15580	return nil
15581}
15582
15583func awsAwsjson11_deserializeOpDocumentGetGeoMatchSetOutput(v **GetGeoMatchSetOutput, value interface{}) error {
15584	if v == nil {
15585		return fmt.Errorf("unexpected nil of type %T", v)
15586	}
15587	if value == nil {
15588		return nil
15589	}
15590
15591	shape, ok := value.(map[string]interface{})
15592	if !ok {
15593		return fmt.Errorf("unexpected JSON type %v", value)
15594	}
15595
15596	var sv *GetGeoMatchSetOutput
15597	if *v == nil {
15598		sv = &GetGeoMatchSetOutput{}
15599	} else {
15600		sv = *v
15601	}
15602
15603	for key, value := range shape {
15604		switch key {
15605		case "GeoMatchSet":
15606			if err := awsAwsjson11_deserializeDocumentGeoMatchSet(&sv.GeoMatchSet, value); err != nil {
15607				return err
15608			}
15609
15610		default:
15611			_, _ = key, value
15612
15613		}
15614	}
15615	*v = sv
15616	return nil
15617}
15618
15619func awsAwsjson11_deserializeOpDocumentGetIPSetOutput(v **GetIPSetOutput, value interface{}) error {
15620	if v == nil {
15621		return fmt.Errorf("unexpected nil of type %T", v)
15622	}
15623	if value == nil {
15624		return nil
15625	}
15626
15627	shape, ok := value.(map[string]interface{})
15628	if !ok {
15629		return fmt.Errorf("unexpected JSON type %v", value)
15630	}
15631
15632	var sv *GetIPSetOutput
15633	if *v == nil {
15634		sv = &GetIPSetOutput{}
15635	} else {
15636		sv = *v
15637	}
15638
15639	for key, value := range shape {
15640		switch key {
15641		case "IPSet":
15642			if err := awsAwsjson11_deserializeDocumentIPSet(&sv.IPSet, value); err != nil {
15643				return err
15644			}
15645
15646		default:
15647			_, _ = key, value
15648
15649		}
15650	}
15651	*v = sv
15652	return nil
15653}
15654
15655func awsAwsjson11_deserializeOpDocumentGetLoggingConfigurationOutput(v **GetLoggingConfigurationOutput, value interface{}) error {
15656	if v == nil {
15657		return fmt.Errorf("unexpected nil of type %T", v)
15658	}
15659	if value == nil {
15660		return nil
15661	}
15662
15663	shape, ok := value.(map[string]interface{})
15664	if !ok {
15665		return fmt.Errorf("unexpected JSON type %v", value)
15666	}
15667
15668	var sv *GetLoggingConfigurationOutput
15669	if *v == nil {
15670		sv = &GetLoggingConfigurationOutput{}
15671	} else {
15672		sv = *v
15673	}
15674
15675	for key, value := range shape {
15676		switch key {
15677		case "LoggingConfiguration":
15678			if err := awsAwsjson11_deserializeDocumentLoggingConfiguration(&sv.LoggingConfiguration, value); err != nil {
15679				return err
15680			}
15681
15682		default:
15683			_, _ = key, value
15684
15685		}
15686	}
15687	*v = sv
15688	return nil
15689}
15690
15691func awsAwsjson11_deserializeOpDocumentGetPermissionPolicyOutput(v **GetPermissionPolicyOutput, value interface{}) error {
15692	if v == nil {
15693		return fmt.Errorf("unexpected nil of type %T", v)
15694	}
15695	if value == nil {
15696		return nil
15697	}
15698
15699	shape, ok := value.(map[string]interface{})
15700	if !ok {
15701		return fmt.Errorf("unexpected JSON type %v", value)
15702	}
15703
15704	var sv *GetPermissionPolicyOutput
15705	if *v == nil {
15706		sv = &GetPermissionPolicyOutput{}
15707	} else {
15708		sv = *v
15709	}
15710
15711	for key, value := range shape {
15712		switch key {
15713		case "Policy":
15714			if value != nil {
15715				jtv, ok := value.(string)
15716				if !ok {
15717					return fmt.Errorf("expected PolicyString to be of type string, got %T instead", value)
15718				}
15719				sv.Policy = ptr.String(jtv)
15720			}
15721
15722		default:
15723			_, _ = key, value
15724
15725		}
15726	}
15727	*v = sv
15728	return nil
15729}
15730
15731func awsAwsjson11_deserializeOpDocumentGetRateBasedRuleManagedKeysOutput(v **GetRateBasedRuleManagedKeysOutput, value interface{}) error {
15732	if v == nil {
15733		return fmt.Errorf("unexpected nil of type %T", v)
15734	}
15735	if value == nil {
15736		return nil
15737	}
15738
15739	shape, ok := value.(map[string]interface{})
15740	if !ok {
15741		return fmt.Errorf("unexpected JSON type %v", value)
15742	}
15743
15744	var sv *GetRateBasedRuleManagedKeysOutput
15745	if *v == nil {
15746		sv = &GetRateBasedRuleManagedKeysOutput{}
15747	} else {
15748		sv = *v
15749	}
15750
15751	for key, value := range shape {
15752		switch key {
15753		case "ManagedKeys":
15754			if err := awsAwsjson11_deserializeDocumentManagedKeys(&sv.ManagedKeys, value); err != nil {
15755				return err
15756			}
15757
15758		case "NextMarker":
15759			if value != nil {
15760				jtv, ok := value.(string)
15761				if !ok {
15762					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
15763				}
15764				sv.NextMarker = ptr.String(jtv)
15765			}
15766
15767		default:
15768			_, _ = key, value
15769
15770		}
15771	}
15772	*v = sv
15773	return nil
15774}
15775
15776func awsAwsjson11_deserializeOpDocumentGetRateBasedRuleOutput(v **GetRateBasedRuleOutput, value interface{}) error {
15777	if v == nil {
15778		return fmt.Errorf("unexpected nil of type %T", v)
15779	}
15780	if value == nil {
15781		return nil
15782	}
15783
15784	shape, ok := value.(map[string]interface{})
15785	if !ok {
15786		return fmt.Errorf("unexpected JSON type %v", value)
15787	}
15788
15789	var sv *GetRateBasedRuleOutput
15790	if *v == nil {
15791		sv = &GetRateBasedRuleOutput{}
15792	} else {
15793		sv = *v
15794	}
15795
15796	for key, value := range shape {
15797		switch key {
15798		case "Rule":
15799			if err := awsAwsjson11_deserializeDocumentRateBasedRule(&sv.Rule, value); err != nil {
15800				return err
15801			}
15802
15803		default:
15804			_, _ = key, value
15805
15806		}
15807	}
15808	*v = sv
15809	return nil
15810}
15811
15812func awsAwsjson11_deserializeOpDocumentGetRegexMatchSetOutput(v **GetRegexMatchSetOutput, value interface{}) error {
15813	if v == nil {
15814		return fmt.Errorf("unexpected nil of type %T", v)
15815	}
15816	if value == nil {
15817		return nil
15818	}
15819
15820	shape, ok := value.(map[string]interface{})
15821	if !ok {
15822		return fmt.Errorf("unexpected JSON type %v", value)
15823	}
15824
15825	var sv *GetRegexMatchSetOutput
15826	if *v == nil {
15827		sv = &GetRegexMatchSetOutput{}
15828	} else {
15829		sv = *v
15830	}
15831
15832	for key, value := range shape {
15833		switch key {
15834		case "RegexMatchSet":
15835			if err := awsAwsjson11_deserializeDocumentRegexMatchSet(&sv.RegexMatchSet, value); err != nil {
15836				return err
15837			}
15838
15839		default:
15840			_, _ = key, value
15841
15842		}
15843	}
15844	*v = sv
15845	return nil
15846}
15847
15848func awsAwsjson11_deserializeOpDocumentGetRegexPatternSetOutput(v **GetRegexPatternSetOutput, value interface{}) error {
15849	if v == nil {
15850		return fmt.Errorf("unexpected nil of type %T", v)
15851	}
15852	if value == nil {
15853		return nil
15854	}
15855
15856	shape, ok := value.(map[string]interface{})
15857	if !ok {
15858		return fmt.Errorf("unexpected JSON type %v", value)
15859	}
15860
15861	var sv *GetRegexPatternSetOutput
15862	if *v == nil {
15863		sv = &GetRegexPatternSetOutput{}
15864	} else {
15865		sv = *v
15866	}
15867
15868	for key, value := range shape {
15869		switch key {
15870		case "RegexPatternSet":
15871			if err := awsAwsjson11_deserializeDocumentRegexPatternSet(&sv.RegexPatternSet, value); err != nil {
15872				return err
15873			}
15874
15875		default:
15876			_, _ = key, value
15877
15878		}
15879	}
15880	*v = sv
15881	return nil
15882}
15883
15884func awsAwsjson11_deserializeOpDocumentGetRuleGroupOutput(v **GetRuleGroupOutput, value interface{}) error {
15885	if v == nil {
15886		return fmt.Errorf("unexpected nil of type %T", v)
15887	}
15888	if value == nil {
15889		return nil
15890	}
15891
15892	shape, ok := value.(map[string]interface{})
15893	if !ok {
15894		return fmt.Errorf("unexpected JSON type %v", value)
15895	}
15896
15897	var sv *GetRuleGroupOutput
15898	if *v == nil {
15899		sv = &GetRuleGroupOutput{}
15900	} else {
15901		sv = *v
15902	}
15903
15904	for key, value := range shape {
15905		switch key {
15906		case "RuleGroup":
15907			if err := awsAwsjson11_deserializeDocumentRuleGroup(&sv.RuleGroup, value); err != nil {
15908				return err
15909			}
15910
15911		default:
15912			_, _ = key, value
15913
15914		}
15915	}
15916	*v = sv
15917	return nil
15918}
15919
15920func awsAwsjson11_deserializeOpDocumentGetRuleOutput(v **GetRuleOutput, value interface{}) error {
15921	if v == nil {
15922		return fmt.Errorf("unexpected nil of type %T", v)
15923	}
15924	if value == nil {
15925		return nil
15926	}
15927
15928	shape, ok := value.(map[string]interface{})
15929	if !ok {
15930		return fmt.Errorf("unexpected JSON type %v", value)
15931	}
15932
15933	var sv *GetRuleOutput
15934	if *v == nil {
15935		sv = &GetRuleOutput{}
15936	} else {
15937		sv = *v
15938	}
15939
15940	for key, value := range shape {
15941		switch key {
15942		case "Rule":
15943			if err := awsAwsjson11_deserializeDocumentRule(&sv.Rule, value); err != nil {
15944				return err
15945			}
15946
15947		default:
15948			_, _ = key, value
15949
15950		}
15951	}
15952	*v = sv
15953	return nil
15954}
15955
15956func awsAwsjson11_deserializeOpDocumentGetSampledRequestsOutput(v **GetSampledRequestsOutput, value interface{}) error {
15957	if v == nil {
15958		return fmt.Errorf("unexpected nil of type %T", v)
15959	}
15960	if value == nil {
15961		return nil
15962	}
15963
15964	shape, ok := value.(map[string]interface{})
15965	if !ok {
15966		return fmt.Errorf("unexpected JSON type %v", value)
15967	}
15968
15969	var sv *GetSampledRequestsOutput
15970	if *v == nil {
15971		sv = &GetSampledRequestsOutput{}
15972	} else {
15973		sv = *v
15974	}
15975
15976	for key, value := range shape {
15977		switch key {
15978		case "PopulationSize":
15979			if value != nil {
15980				jtv, ok := value.(json.Number)
15981				if !ok {
15982					return fmt.Errorf("expected PopulationSize to be json.Number, got %T instead", value)
15983				}
15984				i64, err := jtv.Int64()
15985				if err != nil {
15986					return err
15987				}
15988				sv.PopulationSize = i64
15989			}
15990
15991		case "SampledRequests":
15992			if err := awsAwsjson11_deserializeDocumentSampledHTTPRequests(&sv.SampledRequests, value); err != nil {
15993				return err
15994			}
15995
15996		case "TimeWindow":
15997			if err := awsAwsjson11_deserializeDocumentTimeWindow(&sv.TimeWindow, value); err != nil {
15998				return err
15999			}
16000
16001		default:
16002			_, _ = key, value
16003
16004		}
16005	}
16006	*v = sv
16007	return nil
16008}
16009
16010func awsAwsjson11_deserializeOpDocumentGetSizeConstraintSetOutput(v **GetSizeConstraintSetOutput, value interface{}) error {
16011	if v == nil {
16012		return fmt.Errorf("unexpected nil of type %T", v)
16013	}
16014	if value == nil {
16015		return nil
16016	}
16017
16018	shape, ok := value.(map[string]interface{})
16019	if !ok {
16020		return fmt.Errorf("unexpected JSON type %v", value)
16021	}
16022
16023	var sv *GetSizeConstraintSetOutput
16024	if *v == nil {
16025		sv = &GetSizeConstraintSetOutput{}
16026	} else {
16027		sv = *v
16028	}
16029
16030	for key, value := range shape {
16031		switch key {
16032		case "SizeConstraintSet":
16033			if err := awsAwsjson11_deserializeDocumentSizeConstraintSet(&sv.SizeConstraintSet, value); err != nil {
16034				return err
16035			}
16036
16037		default:
16038			_, _ = key, value
16039
16040		}
16041	}
16042	*v = sv
16043	return nil
16044}
16045
16046func awsAwsjson11_deserializeOpDocumentGetSqlInjectionMatchSetOutput(v **GetSqlInjectionMatchSetOutput, value interface{}) error {
16047	if v == nil {
16048		return fmt.Errorf("unexpected nil of type %T", v)
16049	}
16050	if value == nil {
16051		return nil
16052	}
16053
16054	shape, ok := value.(map[string]interface{})
16055	if !ok {
16056		return fmt.Errorf("unexpected JSON type %v", value)
16057	}
16058
16059	var sv *GetSqlInjectionMatchSetOutput
16060	if *v == nil {
16061		sv = &GetSqlInjectionMatchSetOutput{}
16062	} else {
16063		sv = *v
16064	}
16065
16066	for key, value := range shape {
16067		switch key {
16068		case "SqlInjectionMatchSet":
16069			if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchSet(&sv.SqlInjectionMatchSet, value); err != nil {
16070				return err
16071			}
16072
16073		default:
16074			_, _ = key, value
16075
16076		}
16077	}
16078	*v = sv
16079	return nil
16080}
16081
16082func awsAwsjson11_deserializeOpDocumentGetWebACLOutput(v **GetWebACLOutput, value interface{}) error {
16083	if v == nil {
16084		return fmt.Errorf("unexpected nil of type %T", v)
16085	}
16086	if value == nil {
16087		return nil
16088	}
16089
16090	shape, ok := value.(map[string]interface{})
16091	if !ok {
16092		return fmt.Errorf("unexpected JSON type %v", value)
16093	}
16094
16095	var sv *GetWebACLOutput
16096	if *v == nil {
16097		sv = &GetWebACLOutput{}
16098	} else {
16099		sv = *v
16100	}
16101
16102	for key, value := range shape {
16103		switch key {
16104		case "WebACL":
16105			if err := awsAwsjson11_deserializeDocumentWebACL(&sv.WebACL, value); err != nil {
16106				return err
16107			}
16108
16109		default:
16110			_, _ = key, value
16111
16112		}
16113	}
16114	*v = sv
16115	return nil
16116}
16117
16118func awsAwsjson11_deserializeOpDocumentGetXssMatchSetOutput(v **GetXssMatchSetOutput, value interface{}) error {
16119	if v == nil {
16120		return fmt.Errorf("unexpected nil of type %T", v)
16121	}
16122	if value == nil {
16123		return nil
16124	}
16125
16126	shape, ok := value.(map[string]interface{})
16127	if !ok {
16128		return fmt.Errorf("unexpected JSON type %v", value)
16129	}
16130
16131	var sv *GetXssMatchSetOutput
16132	if *v == nil {
16133		sv = &GetXssMatchSetOutput{}
16134	} else {
16135		sv = *v
16136	}
16137
16138	for key, value := range shape {
16139		switch key {
16140		case "XssMatchSet":
16141			if err := awsAwsjson11_deserializeDocumentXssMatchSet(&sv.XssMatchSet, value); err != nil {
16142				return err
16143			}
16144
16145		default:
16146			_, _ = key, value
16147
16148		}
16149	}
16150	*v = sv
16151	return nil
16152}
16153
16154func awsAwsjson11_deserializeOpDocumentListActivatedRulesInRuleGroupOutput(v **ListActivatedRulesInRuleGroupOutput, value interface{}) error {
16155	if v == nil {
16156		return fmt.Errorf("unexpected nil of type %T", v)
16157	}
16158	if value == nil {
16159		return nil
16160	}
16161
16162	shape, ok := value.(map[string]interface{})
16163	if !ok {
16164		return fmt.Errorf("unexpected JSON type %v", value)
16165	}
16166
16167	var sv *ListActivatedRulesInRuleGroupOutput
16168	if *v == nil {
16169		sv = &ListActivatedRulesInRuleGroupOutput{}
16170	} else {
16171		sv = *v
16172	}
16173
16174	for key, value := range shape {
16175		switch key {
16176		case "ActivatedRules":
16177			if err := awsAwsjson11_deserializeDocumentActivatedRules(&sv.ActivatedRules, value); err != nil {
16178				return err
16179			}
16180
16181		case "NextMarker":
16182			if value != nil {
16183				jtv, ok := value.(string)
16184				if !ok {
16185					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16186				}
16187				sv.NextMarker = ptr.String(jtv)
16188			}
16189
16190		default:
16191			_, _ = key, value
16192
16193		}
16194	}
16195	*v = sv
16196	return nil
16197}
16198
16199func awsAwsjson11_deserializeOpDocumentListByteMatchSetsOutput(v **ListByteMatchSetsOutput, value interface{}) error {
16200	if v == nil {
16201		return fmt.Errorf("unexpected nil of type %T", v)
16202	}
16203	if value == nil {
16204		return nil
16205	}
16206
16207	shape, ok := value.(map[string]interface{})
16208	if !ok {
16209		return fmt.Errorf("unexpected JSON type %v", value)
16210	}
16211
16212	var sv *ListByteMatchSetsOutput
16213	if *v == nil {
16214		sv = &ListByteMatchSetsOutput{}
16215	} else {
16216		sv = *v
16217	}
16218
16219	for key, value := range shape {
16220		switch key {
16221		case "ByteMatchSets":
16222			if err := awsAwsjson11_deserializeDocumentByteMatchSetSummaries(&sv.ByteMatchSets, value); err != nil {
16223				return err
16224			}
16225
16226		case "NextMarker":
16227			if value != nil {
16228				jtv, ok := value.(string)
16229				if !ok {
16230					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16231				}
16232				sv.NextMarker = ptr.String(jtv)
16233			}
16234
16235		default:
16236			_, _ = key, value
16237
16238		}
16239	}
16240	*v = sv
16241	return nil
16242}
16243
16244func awsAwsjson11_deserializeOpDocumentListGeoMatchSetsOutput(v **ListGeoMatchSetsOutput, value interface{}) error {
16245	if v == nil {
16246		return fmt.Errorf("unexpected nil of type %T", v)
16247	}
16248	if value == nil {
16249		return nil
16250	}
16251
16252	shape, ok := value.(map[string]interface{})
16253	if !ok {
16254		return fmt.Errorf("unexpected JSON type %v", value)
16255	}
16256
16257	var sv *ListGeoMatchSetsOutput
16258	if *v == nil {
16259		sv = &ListGeoMatchSetsOutput{}
16260	} else {
16261		sv = *v
16262	}
16263
16264	for key, value := range shape {
16265		switch key {
16266		case "GeoMatchSets":
16267			if err := awsAwsjson11_deserializeDocumentGeoMatchSetSummaries(&sv.GeoMatchSets, value); err != nil {
16268				return err
16269			}
16270
16271		case "NextMarker":
16272			if value != nil {
16273				jtv, ok := value.(string)
16274				if !ok {
16275					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16276				}
16277				sv.NextMarker = ptr.String(jtv)
16278			}
16279
16280		default:
16281			_, _ = key, value
16282
16283		}
16284	}
16285	*v = sv
16286	return nil
16287}
16288
16289func awsAwsjson11_deserializeOpDocumentListIPSetsOutput(v **ListIPSetsOutput, value interface{}) error {
16290	if v == nil {
16291		return fmt.Errorf("unexpected nil of type %T", v)
16292	}
16293	if value == nil {
16294		return nil
16295	}
16296
16297	shape, ok := value.(map[string]interface{})
16298	if !ok {
16299		return fmt.Errorf("unexpected JSON type %v", value)
16300	}
16301
16302	var sv *ListIPSetsOutput
16303	if *v == nil {
16304		sv = &ListIPSetsOutput{}
16305	} else {
16306		sv = *v
16307	}
16308
16309	for key, value := range shape {
16310		switch key {
16311		case "IPSets":
16312			if err := awsAwsjson11_deserializeDocumentIPSetSummaries(&sv.IPSets, value); err != nil {
16313				return err
16314			}
16315
16316		case "NextMarker":
16317			if value != nil {
16318				jtv, ok := value.(string)
16319				if !ok {
16320					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16321				}
16322				sv.NextMarker = ptr.String(jtv)
16323			}
16324
16325		default:
16326			_, _ = key, value
16327
16328		}
16329	}
16330	*v = sv
16331	return nil
16332}
16333
16334func awsAwsjson11_deserializeOpDocumentListLoggingConfigurationsOutput(v **ListLoggingConfigurationsOutput, value interface{}) error {
16335	if v == nil {
16336		return fmt.Errorf("unexpected nil of type %T", v)
16337	}
16338	if value == nil {
16339		return nil
16340	}
16341
16342	shape, ok := value.(map[string]interface{})
16343	if !ok {
16344		return fmt.Errorf("unexpected JSON type %v", value)
16345	}
16346
16347	var sv *ListLoggingConfigurationsOutput
16348	if *v == nil {
16349		sv = &ListLoggingConfigurationsOutput{}
16350	} else {
16351		sv = *v
16352	}
16353
16354	for key, value := range shape {
16355		switch key {
16356		case "LoggingConfigurations":
16357			if err := awsAwsjson11_deserializeDocumentLoggingConfigurations(&sv.LoggingConfigurations, value); err != nil {
16358				return err
16359			}
16360
16361		case "NextMarker":
16362			if value != nil {
16363				jtv, ok := value.(string)
16364				if !ok {
16365					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16366				}
16367				sv.NextMarker = ptr.String(jtv)
16368			}
16369
16370		default:
16371			_, _ = key, value
16372
16373		}
16374	}
16375	*v = sv
16376	return nil
16377}
16378
16379func awsAwsjson11_deserializeOpDocumentListRateBasedRulesOutput(v **ListRateBasedRulesOutput, value interface{}) error {
16380	if v == nil {
16381		return fmt.Errorf("unexpected nil of type %T", v)
16382	}
16383	if value == nil {
16384		return nil
16385	}
16386
16387	shape, ok := value.(map[string]interface{})
16388	if !ok {
16389		return fmt.Errorf("unexpected JSON type %v", value)
16390	}
16391
16392	var sv *ListRateBasedRulesOutput
16393	if *v == nil {
16394		sv = &ListRateBasedRulesOutput{}
16395	} else {
16396		sv = *v
16397	}
16398
16399	for key, value := range shape {
16400		switch key {
16401		case "NextMarker":
16402			if value != nil {
16403				jtv, ok := value.(string)
16404				if !ok {
16405					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16406				}
16407				sv.NextMarker = ptr.String(jtv)
16408			}
16409
16410		case "Rules":
16411			if err := awsAwsjson11_deserializeDocumentRuleSummaries(&sv.Rules, value); err != nil {
16412				return err
16413			}
16414
16415		default:
16416			_, _ = key, value
16417
16418		}
16419	}
16420	*v = sv
16421	return nil
16422}
16423
16424func awsAwsjson11_deserializeOpDocumentListRegexMatchSetsOutput(v **ListRegexMatchSetsOutput, value interface{}) error {
16425	if v == nil {
16426		return fmt.Errorf("unexpected nil of type %T", v)
16427	}
16428	if value == nil {
16429		return nil
16430	}
16431
16432	shape, ok := value.(map[string]interface{})
16433	if !ok {
16434		return fmt.Errorf("unexpected JSON type %v", value)
16435	}
16436
16437	var sv *ListRegexMatchSetsOutput
16438	if *v == nil {
16439		sv = &ListRegexMatchSetsOutput{}
16440	} else {
16441		sv = *v
16442	}
16443
16444	for key, value := range shape {
16445		switch key {
16446		case "NextMarker":
16447			if value != nil {
16448				jtv, ok := value.(string)
16449				if !ok {
16450					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16451				}
16452				sv.NextMarker = ptr.String(jtv)
16453			}
16454
16455		case "RegexMatchSets":
16456			if err := awsAwsjson11_deserializeDocumentRegexMatchSetSummaries(&sv.RegexMatchSets, value); err != nil {
16457				return err
16458			}
16459
16460		default:
16461			_, _ = key, value
16462
16463		}
16464	}
16465	*v = sv
16466	return nil
16467}
16468
16469func awsAwsjson11_deserializeOpDocumentListRegexPatternSetsOutput(v **ListRegexPatternSetsOutput, value interface{}) error {
16470	if v == nil {
16471		return fmt.Errorf("unexpected nil of type %T", v)
16472	}
16473	if value == nil {
16474		return nil
16475	}
16476
16477	shape, ok := value.(map[string]interface{})
16478	if !ok {
16479		return fmt.Errorf("unexpected JSON type %v", value)
16480	}
16481
16482	var sv *ListRegexPatternSetsOutput
16483	if *v == nil {
16484		sv = &ListRegexPatternSetsOutput{}
16485	} else {
16486		sv = *v
16487	}
16488
16489	for key, value := range shape {
16490		switch key {
16491		case "NextMarker":
16492			if value != nil {
16493				jtv, ok := value.(string)
16494				if !ok {
16495					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16496				}
16497				sv.NextMarker = ptr.String(jtv)
16498			}
16499
16500		case "RegexPatternSets":
16501			if err := awsAwsjson11_deserializeDocumentRegexPatternSetSummaries(&sv.RegexPatternSets, value); err != nil {
16502				return err
16503			}
16504
16505		default:
16506			_, _ = key, value
16507
16508		}
16509	}
16510	*v = sv
16511	return nil
16512}
16513
16514func awsAwsjson11_deserializeOpDocumentListRuleGroupsOutput(v **ListRuleGroupsOutput, value interface{}) error {
16515	if v == nil {
16516		return fmt.Errorf("unexpected nil of type %T", v)
16517	}
16518	if value == nil {
16519		return nil
16520	}
16521
16522	shape, ok := value.(map[string]interface{})
16523	if !ok {
16524		return fmt.Errorf("unexpected JSON type %v", value)
16525	}
16526
16527	var sv *ListRuleGroupsOutput
16528	if *v == nil {
16529		sv = &ListRuleGroupsOutput{}
16530	} else {
16531		sv = *v
16532	}
16533
16534	for key, value := range shape {
16535		switch key {
16536		case "NextMarker":
16537			if value != nil {
16538				jtv, ok := value.(string)
16539				if !ok {
16540					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16541				}
16542				sv.NextMarker = ptr.String(jtv)
16543			}
16544
16545		case "RuleGroups":
16546			if err := awsAwsjson11_deserializeDocumentRuleGroupSummaries(&sv.RuleGroups, value); err != nil {
16547				return err
16548			}
16549
16550		default:
16551			_, _ = key, value
16552
16553		}
16554	}
16555	*v = sv
16556	return nil
16557}
16558
16559func awsAwsjson11_deserializeOpDocumentListRulesOutput(v **ListRulesOutput, value interface{}) error {
16560	if v == nil {
16561		return fmt.Errorf("unexpected nil of type %T", v)
16562	}
16563	if value == nil {
16564		return nil
16565	}
16566
16567	shape, ok := value.(map[string]interface{})
16568	if !ok {
16569		return fmt.Errorf("unexpected JSON type %v", value)
16570	}
16571
16572	var sv *ListRulesOutput
16573	if *v == nil {
16574		sv = &ListRulesOutput{}
16575	} else {
16576		sv = *v
16577	}
16578
16579	for key, value := range shape {
16580		switch key {
16581		case "NextMarker":
16582			if value != nil {
16583				jtv, ok := value.(string)
16584				if !ok {
16585					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16586				}
16587				sv.NextMarker = ptr.String(jtv)
16588			}
16589
16590		case "Rules":
16591			if err := awsAwsjson11_deserializeDocumentRuleSummaries(&sv.Rules, value); err != nil {
16592				return err
16593			}
16594
16595		default:
16596			_, _ = key, value
16597
16598		}
16599	}
16600	*v = sv
16601	return nil
16602}
16603
16604func awsAwsjson11_deserializeOpDocumentListSizeConstraintSetsOutput(v **ListSizeConstraintSetsOutput, value interface{}) error {
16605	if v == nil {
16606		return fmt.Errorf("unexpected nil of type %T", v)
16607	}
16608	if value == nil {
16609		return nil
16610	}
16611
16612	shape, ok := value.(map[string]interface{})
16613	if !ok {
16614		return fmt.Errorf("unexpected JSON type %v", value)
16615	}
16616
16617	var sv *ListSizeConstraintSetsOutput
16618	if *v == nil {
16619		sv = &ListSizeConstraintSetsOutput{}
16620	} else {
16621		sv = *v
16622	}
16623
16624	for key, value := range shape {
16625		switch key {
16626		case "NextMarker":
16627			if value != nil {
16628				jtv, ok := value.(string)
16629				if !ok {
16630					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16631				}
16632				sv.NextMarker = ptr.String(jtv)
16633			}
16634
16635		case "SizeConstraintSets":
16636			if err := awsAwsjson11_deserializeDocumentSizeConstraintSetSummaries(&sv.SizeConstraintSets, value); err != nil {
16637				return err
16638			}
16639
16640		default:
16641			_, _ = key, value
16642
16643		}
16644	}
16645	*v = sv
16646	return nil
16647}
16648
16649func awsAwsjson11_deserializeOpDocumentListSqlInjectionMatchSetsOutput(v **ListSqlInjectionMatchSetsOutput, value interface{}) error {
16650	if v == nil {
16651		return fmt.Errorf("unexpected nil of type %T", v)
16652	}
16653	if value == nil {
16654		return nil
16655	}
16656
16657	shape, ok := value.(map[string]interface{})
16658	if !ok {
16659		return fmt.Errorf("unexpected JSON type %v", value)
16660	}
16661
16662	var sv *ListSqlInjectionMatchSetsOutput
16663	if *v == nil {
16664		sv = &ListSqlInjectionMatchSetsOutput{}
16665	} else {
16666		sv = *v
16667	}
16668
16669	for key, value := range shape {
16670		switch key {
16671		case "NextMarker":
16672			if value != nil {
16673				jtv, ok := value.(string)
16674				if !ok {
16675					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16676				}
16677				sv.NextMarker = ptr.String(jtv)
16678			}
16679
16680		case "SqlInjectionMatchSets":
16681			if err := awsAwsjson11_deserializeDocumentSqlInjectionMatchSetSummaries(&sv.SqlInjectionMatchSets, value); err != nil {
16682				return err
16683			}
16684
16685		default:
16686			_, _ = key, value
16687
16688		}
16689	}
16690	*v = sv
16691	return nil
16692}
16693
16694func awsAwsjson11_deserializeOpDocumentListSubscribedRuleGroupsOutput(v **ListSubscribedRuleGroupsOutput, value interface{}) error {
16695	if v == nil {
16696		return fmt.Errorf("unexpected nil of type %T", v)
16697	}
16698	if value == nil {
16699		return nil
16700	}
16701
16702	shape, ok := value.(map[string]interface{})
16703	if !ok {
16704		return fmt.Errorf("unexpected JSON type %v", value)
16705	}
16706
16707	var sv *ListSubscribedRuleGroupsOutput
16708	if *v == nil {
16709		sv = &ListSubscribedRuleGroupsOutput{}
16710	} else {
16711		sv = *v
16712	}
16713
16714	for key, value := range shape {
16715		switch key {
16716		case "NextMarker":
16717			if value != nil {
16718				jtv, ok := value.(string)
16719				if !ok {
16720					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16721				}
16722				sv.NextMarker = ptr.String(jtv)
16723			}
16724
16725		case "RuleGroups":
16726			if err := awsAwsjson11_deserializeDocumentSubscribedRuleGroupSummaries(&sv.RuleGroups, value); err != nil {
16727				return err
16728			}
16729
16730		default:
16731			_, _ = key, value
16732
16733		}
16734	}
16735	*v = sv
16736	return nil
16737}
16738
16739func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
16740	if v == nil {
16741		return fmt.Errorf("unexpected nil of type %T", v)
16742	}
16743	if value == nil {
16744		return nil
16745	}
16746
16747	shape, ok := value.(map[string]interface{})
16748	if !ok {
16749		return fmt.Errorf("unexpected JSON type %v", value)
16750	}
16751
16752	var sv *ListTagsForResourceOutput
16753	if *v == nil {
16754		sv = &ListTagsForResourceOutput{}
16755	} else {
16756		sv = *v
16757	}
16758
16759	for key, value := range shape {
16760		switch key {
16761		case "NextMarker":
16762			if value != nil {
16763				jtv, ok := value.(string)
16764				if !ok {
16765					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16766				}
16767				sv.NextMarker = ptr.String(jtv)
16768			}
16769
16770		case "TagInfoForResource":
16771			if err := awsAwsjson11_deserializeDocumentTagInfoForResource(&sv.TagInfoForResource, value); err != nil {
16772				return err
16773			}
16774
16775		default:
16776			_, _ = key, value
16777
16778		}
16779	}
16780	*v = sv
16781	return nil
16782}
16783
16784func awsAwsjson11_deserializeOpDocumentListWebACLsOutput(v **ListWebACLsOutput, value interface{}) error {
16785	if v == nil {
16786		return fmt.Errorf("unexpected nil of type %T", v)
16787	}
16788	if value == nil {
16789		return nil
16790	}
16791
16792	shape, ok := value.(map[string]interface{})
16793	if !ok {
16794		return fmt.Errorf("unexpected JSON type %v", value)
16795	}
16796
16797	var sv *ListWebACLsOutput
16798	if *v == nil {
16799		sv = &ListWebACLsOutput{}
16800	} else {
16801		sv = *v
16802	}
16803
16804	for key, value := range shape {
16805		switch key {
16806		case "NextMarker":
16807			if value != nil {
16808				jtv, ok := value.(string)
16809				if !ok {
16810					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16811				}
16812				sv.NextMarker = ptr.String(jtv)
16813			}
16814
16815		case "WebACLs":
16816			if err := awsAwsjson11_deserializeDocumentWebACLSummaries(&sv.WebACLs, value); err != nil {
16817				return err
16818			}
16819
16820		default:
16821			_, _ = key, value
16822
16823		}
16824	}
16825	*v = sv
16826	return nil
16827}
16828
16829func awsAwsjson11_deserializeOpDocumentListXssMatchSetsOutput(v **ListXssMatchSetsOutput, value interface{}) error {
16830	if v == nil {
16831		return fmt.Errorf("unexpected nil of type %T", v)
16832	}
16833	if value == nil {
16834		return nil
16835	}
16836
16837	shape, ok := value.(map[string]interface{})
16838	if !ok {
16839		return fmt.Errorf("unexpected JSON type %v", value)
16840	}
16841
16842	var sv *ListXssMatchSetsOutput
16843	if *v == nil {
16844		sv = &ListXssMatchSetsOutput{}
16845	} else {
16846		sv = *v
16847	}
16848
16849	for key, value := range shape {
16850		switch key {
16851		case "NextMarker":
16852			if value != nil {
16853				jtv, ok := value.(string)
16854				if !ok {
16855					return fmt.Errorf("expected NextMarker to be of type string, got %T instead", value)
16856				}
16857				sv.NextMarker = ptr.String(jtv)
16858			}
16859
16860		case "XssMatchSets":
16861			if err := awsAwsjson11_deserializeDocumentXssMatchSetSummaries(&sv.XssMatchSets, value); err != nil {
16862				return err
16863			}
16864
16865		default:
16866			_, _ = key, value
16867
16868		}
16869	}
16870	*v = sv
16871	return nil
16872}
16873
16874func awsAwsjson11_deserializeOpDocumentPutLoggingConfigurationOutput(v **PutLoggingConfigurationOutput, value interface{}) error {
16875	if v == nil {
16876		return fmt.Errorf("unexpected nil of type %T", v)
16877	}
16878	if value == nil {
16879		return nil
16880	}
16881
16882	shape, ok := value.(map[string]interface{})
16883	if !ok {
16884		return fmt.Errorf("unexpected JSON type %v", value)
16885	}
16886
16887	var sv *PutLoggingConfigurationOutput
16888	if *v == nil {
16889		sv = &PutLoggingConfigurationOutput{}
16890	} else {
16891		sv = *v
16892	}
16893
16894	for key, value := range shape {
16895		switch key {
16896		case "LoggingConfiguration":
16897			if err := awsAwsjson11_deserializeDocumentLoggingConfiguration(&sv.LoggingConfiguration, value); err != nil {
16898				return err
16899			}
16900
16901		default:
16902			_, _ = key, value
16903
16904		}
16905	}
16906	*v = sv
16907	return nil
16908}
16909
16910func awsAwsjson11_deserializeOpDocumentPutPermissionPolicyOutput(v **PutPermissionPolicyOutput, value interface{}) error {
16911	if v == nil {
16912		return fmt.Errorf("unexpected nil of type %T", v)
16913	}
16914	if value == nil {
16915		return nil
16916	}
16917
16918	shape, ok := value.(map[string]interface{})
16919	if !ok {
16920		return fmt.Errorf("unexpected JSON type %v", value)
16921	}
16922
16923	var sv *PutPermissionPolicyOutput
16924	if *v == nil {
16925		sv = &PutPermissionPolicyOutput{}
16926	} else {
16927		sv = *v
16928	}
16929
16930	for key, value := range shape {
16931		switch key {
16932		default:
16933			_, _ = key, value
16934
16935		}
16936	}
16937	*v = sv
16938	return nil
16939}
16940
16941func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
16942	if v == nil {
16943		return fmt.Errorf("unexpected nil of type %T", v)
16944	}
16945	if value == nil {
16946		return nil
16947	}
16948
16949	shape, ok := value.(map[string]interface{})
16950	if !ok {
16951		return fmt.Errorf("unexpected JSON type %v", value)
16952	}
16953
16954	var sv *TagResourceOutput
16955	if *v == nil {
16956		sv = &TagResourceOutput{}
16957	} else {
16958		sv = *v
16959	}
16960
16961	for key, value := range shape {
16962		switch key {
16963		default:
16964			_, _ = key, value
16965
16966		}
16967	}
16968	*v = sv
16969	return nil
16970}
16971
16972func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
16973	if v == nil {
16974		return fmt.Errorf("unexpected nil of type %T", v)
16975	}
16976	if value == nil {
16977		return nil
16978	}
16979
16980	shape, ok := value.(map[string]interface{})
16981	if !ok {
16982		return fmt.Errorf("unexpected JSON type %v", value)
16983	}
16984
16985	var sv *UntagResourceOutput
16986	if *v == nil {
16987		sv = &UntagResourceOutput{}
16988	} else {
16989		sv = *v
16990	}
16991
16992	for key, value := range shape {
16993		switch key {
16994		default:
16995			_, _ = key, value
16996
16997		}
16998	}
16999	*v = sv
17000	return nil
17001}
17002
17003func awsAwsjson11_deserializeOpDocumentUpdateByteMatchSetOutput(v **UpdateByteMatchSetOutput, value interface{}) error {
17004	if v == nil {
17005		return fmt.Errorf("unexpected nil of type %T", v)
17006	}
17007	if value == nil {
17008		return nil
17009	}
17010
17011	shape, ok := value.(map[string]interface{})
17012	if !ok {
17013		return fmt.Errorf("unexpected JSON type %v", value)
17014	}
17015
17016	var sv *UpdateByteMatchSetOutput
17017	if *v == nil {
17018		sv = &UpdateByteMatchSetOutput{}
17019	} else {
17020		sv = *v
17021	}
17022
17023	for key, value := range shape {
17024		switch key {
17025		case "ChangeToken":
17026			if value != nil {
17027				jtv, ok := value.(string)
17028				if !ok {
17029					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17030				}
17031				sv.ChangeToken = ptr.String(jtv)
17032			}
17033
17034		default:
17035			_, _ = key, value
17036
17037		}
17038	}
17039	*v = sv
17040	return nil
17041}
17042
17043func awsAwsjson11_deserializeOpDocumentUpdateGeoMatchSetOutput(v **UpdateGeoMatchSetOutput, value interface{}) error {
17044	if v == nil {
17045		return fmt.Errorf("unexpected nil of type %T", v)
17046	}
17047	if value == nil {
17048		return nil
17049	}
17050
17051	shape, ok := value.(map[string]interface{})
17052	if !ok {
17053		return fmt.Errorf("unexpected JSON type %v", value)
17054	}
17055
17056	var sv *UpdateGeoMatchSetOutput
17057	if *v == nil {
17058		sv = &UpdateGeoMatchSetOutput{}
17059	} else {
17060		sv = *v
17061	}
17062
17063	for key, value := range shape {
17064		switch key {
17065		case "ChangeToken":
17066			if value != nil {
17067				jtv, ok := value.(string)
17068				if !ok {
17069					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17070				}
17071				sv.ChangeToken = ptr.String(jtv)
17072			}
17073
17074		default:
17075			_, _ = key, value
17076
17077		}
17078	}
17079	*v = sv
17080	return nil
17081}
17082
17083func awsAwsjson11_deserializeOpDocumentUpdateIPSetOutput(v **UpdateIPSetOutput, value interface{}) error {
17084	if v == nil {
17085		return fmt.Errorf("unexpected nil of type %T", v)
17086	}
17087	if value == nil {
17088		return nil
17089	}
17090
17091	shape, ok := value.(map[string]interface{})
17092	if !ok {
17093		return fmt.Errorf("unexpected JSON type %v", value)
17094	}
17095
17096	var sv *UpdateIPSetOutput
17097	if *v == nil {
17098		sv = &UpdateIPSetOutput{}
17099	} else {
17100		sv = *v
17101	}
17102
17103	for key, value := range shape {
17104		switch key {
17105		case "ChangeToken":
17106			if value != nil {
17107				jtv, ok := value.(string)
17108				if !ok {
17109					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17110				}
17111				sv.ChangeToken = ptr.String(jtv)
17112			}
17113
17114		default:
17115			_, _ = key, value
17116
17117		}
17118	}
17119	*v = sv
17120	return nil
17121}
17122
17123func awsAwsjson11_deserializeOpDocumentUpdateRateBasedRuleOutput(v **UpdateRateBasedRuleOutput, value interface{}) error {
17124	if v == nil {
17125		return fmt.Errorf("unexpected nil of type %T", v)
17126	}
17127	if value == nil {
17128		return nil
17129	}
17130
17131	shape, ok := value.(map[string]interface{})
17132	if !ok {
17133		return fmt.Errorf("unexpected JSON type %v", value)
17134	}
17135
17136	var sv *UpdateRateBasedRuleOutput
17137	if *v == nil {
17138		sv = &UpdateRateBasedRuleOutput{}
17139	} else {
17140		sv = *v
17141	}
17142
17143	for key, value := range shape {
17144		switch key {
17145		case "ChangeToken":
17146			if value != nil {
17147				jtv, ok := value.(string)
17148				if !ok {
17149					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17150				}
17151				sv.ChangeToken = ptr.String(jtv)
17152			}
17153
17154		default:
17155			_, _ = key, value
17156
17157		}
17158	}
17159	*v = sv
17160	return nil
17161}
17162
17163func awsAwsjson11_deserializeOpDocumentUpdateRegexMatchSetOutput(v **UpdateRegexMatchSetOutput, value interface{}) error {
17164	if v == nil {
17165		return fmt.Errorf("unexpected nil of type %T", v)
17166	}
17167	if value == nil {
17168		return nil
17169	}
17170
17171	shape, ok := value.(map[string]interface{})
17172	if !ok {
17173		return fmt.Errorf("unexpected JSON type %v", value)
17174	}
17175
17176	var sv *UpdateRegexMatchSetOutput
17177	if *v == nil {
17178		sv = &UpdateRegexMatchSetOutput{}
17179	} else {
17180		sv = *v
17181	}
17182
17183	for key, value := range shape {
17184		switch key {
17185		case "ChangeToken":
17186			if value != nil {
17187				jtv, ok := value.(string)
17188				if !ok {
17189					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17190				}
17191				sv.ChangeToken = ptr.String(jtv)
17192			}
17193
17194		default:
17195			_, _ = key, value
17196
17197		}
17198	}
17199	*v = sv
17200	return nil
17201}
17202
17203func awsAwsjson11_deserializeOpDocumentUpdateRegexPatternSetOutput(v **UpdateRegexPatternSetOutput, value interface{}) error {
17204	if v == nil {
17205		return fmt.Errorf("unexpected nil of type %T", v)
17206	}
17207	if value == nil {
17208		return nil
17209	}
17210
17211	shape, ok := value.(map[string]interface{})
17212	if !ok {
17213		return fmt.Errorf("unexpected JSON type %v", value)
17214	}
17215
17216	var sv *UpdateRegexPatternSetOutput
17217	if *v == nil {
17218		sv = &UpdateRegexPatternSetOutput{}
17219	} else {
17220		sv = *v
17221	}
17222
17223	for key, value := range shape {
17224		switch key {
17225		case "ChangeToken":
17226			if value != nil {
17227				jtv, ok := value.(string)
17228				if !ok {
17229					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17230				}
17231				sv.ChangeToken = ptr.String(jtv)
17232			}
17233
17234		default:
17235			_, _ = key, value
17236
17237		}
17238	}
17239	*v = sv
17240	return nil
17241}
17242
17243func awsAwsjson11_deserializeOpDocumentUpdateRuleGroupOutput(v **UpdateRuleGroupOutput, value interface{}) error {
17244	if v == nil {
17245		return fmt.Errorf("unexpected nil of type %T", v)
17246	}
17247	if value == nil {
17248		return nil
17249	}
17250
17251	shape, ok := value.(map[string]interface{})
17252	if !ok {
17253		return fmt.Errorf("unexpected JSON type %v", value)
17254	}
17255
17256	var sv *UpdateRuleGroupOutput
17257	if *v == nil {
17258		sv = &UpdateRuleGroupOutput{}
17259	} else {
17260		sv = *v
17261	}
17262
17263	for key, value := range shape {
17264		switch key {
17265		case "ChangeToken":
17266			if value != nil {
17267				jtv, ok := value.(string)
17268				if !ok {
17269					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17270				}
17271				sv.ChangeToken = ptr.String(jtv)
17272			}
17273
17274		default:
17275			_, _ = key, value
17276
17277		}
17278	}
17279	*v = sv
17280	return nil
17281}
17282
17283func awsAwsjson11_deserializeOpDocumentUpdateRuleOutput(v **UpdateRuleOutput, value interface{}) error {
17284	if v == nil {
17285		return fmt.Errorf("unexpected nil of type %T", v)
17286	}
17287	if value == nil {
17288		return nil
17289	}
17290
17291	shape, ok := value.(map[string]interface{})
17292	if !ok {
17293		return fmt.Errorf("unexpected JSON type %v", value)
17294	}
17295
17296	var sv *UpdateRuleOutput
17297	if *v == nil {
17298		sv = &UpdateRuleOutput{}
17299	} else {
17300		sv = *v
17301	}
17302
17303	for key, value := range shape {
17304		switch key {
17305		case "ChangeToken":
17306			if value != nil {
17307				jtv, ok := value.(string)
17308				if !ok {
17309					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17310				}
17311				sv.ChangeToken = ptr.String(jtv)
17312			}
17313
17314		default:
17315			_, _ = key, value
17316
17317		}
17318	}
17319	*v = sv
17320	return nil
17321}
17322
17323func awsAwsjson11_deserializeOpDocumentUpdateSizeConstraintSetOutput(v **UpdateSizeConstraintSetOutput, value interface{}) error {
17324	if v == nil {
17325		return fmt.Errorf("unexpected nil of type %T", v)
17326	}
17327	if value == nil {
17328		return nil
17329	}
17330
17331	shape, ok := value.(map[string]interface{})
17332	if !ok {
17333		return fmt.Errorf("unexpected JSON type %v", value)
17334	}
17335
17336	var sv *UpdateSizeConstraintSetOutput
17337	if *v == nil {
17338		sv = &UpdateSizeConstraintSetOutput{}
17339	} else {
17340		sv = *v
17341	}
17342
17343	for key, value := range shape {
17344		switch key {
17345		case "ChangeToken":
17346			if value != nil {
17347				jtv, ok := value.(string)
17348				if !ok {
17349					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17350				}
17351				sv.ChangeToken = ptr.String(jtv)
17352			}
17353
17354		default:
17355			_, _ = key, value
17356
17357		}
17358	}
17359	*v = sv
17360	return nil
17361}
17362
17363func awsAwsjson11_deserializeOpDocumentUpdateSqlInjectionMatchSetOutput(v **UpdateSqlInjectionMatchSetOutput, value interface{}) error {
17364	if v == nil {
17365		return fmt.Errorf("unexpected nil of type %T", v)
17366	}
17367	if value == nil {
17368		return nil
17369	}
17370
17371	shape, ok := value.(map[string]interface{})
17372	if !ok {
17373		return fmt.Errorf("unexpected JSON type %v", value)
17374	}
17375
17376	var sv *UpdateSqlInjectionMatchSetOutput
17377	if *v == nil {
17378		sv = &UpdateSqlInjectionMatchSetOutput{}
17379	} else {
17380		sv = *v
17381	}
17382
17383	for key, value := range shape {
17384		switch key {
17385		case "ChangeToken":
17386			if value != nil {
17387				jtv, ok := value.(string)
17388				if !ok {
17389					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17390				}
17391				sv.ChangeToken = ptr.String(jtv)
17392			}
17393
17394		default:
17395			_, _ = key, value
17396
17397		}
17398	}
17399	*v = sv
17400	return nil
17401}
17402
17403func awsAwsjson11_deserializeOpDocumentUpdateWebACLOutput(v **UpdateWebACLOutput, value interface{}) error {
17404	if v == nil {
17405		return fmt.Errorf("unexpected nil of type %T", v)
17406	}
17407	if value == nil {
17408		return nil
17409	}
17410
17411	shape, ok := value.(map[string]interface{})
17412	if !ok {
17413		return fmt.Errorf("unexpected JSON type %v", value)
17414	}
17415
17416	var sv *UpdateWebACLOutput
17417	if *v == nil {
17418		sv = &UpdateWebACLOutput{}
17419	} else {
17420		sv = *v
17421	}
17422
17423	for key, value := range shape {
17424		switch key {
17425		case "ChangeToken":
17426			if value != nil {
17427				jtv, ok := value.(string)
17428				if !ok {
17429					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17430				}
17431				sv.ChangeToken = ptr.String(jtv)
17432			}
17433
17434		default:
17435			_, _ = key, value
17436
17437		}
17438	}
17439	*v = sv
17440	return nil
17441}
17442
17443func awsAwsjson11_deserializeOpDocumentUpdateXssMatchSetOutput(v **UpdateXssMatchSetOutput, value interface{}) error {
17444	if v == nil {
17445		return fmt.Errorf("unexpected nil of type %T", v)
17446	}
17447	if value == nil {
17448		return nil
17449	}
17450
17451	shape, ok := value.(map[string]interface{})
17452	if !ok {
17453		return fmt.Errorf("unexpected JSON type %v", value)
17454	}
17455
17456	var sv *UpdateXssMatchSetOutput
17457	if *v == nil {
17458		sv = &UpdateXssMatchSetOutput{}
17459	} else {
17460		sv = *v
17461	}
17462
17463	for key, value := range shape {
17464		switch key {
17465		case "ChangeToken":
17466			if value != nil {
17467				jtv, ok := value.(string)
17468				if !ok {
17469					return fmt.Errorf("expected ChangeToken to be of type string, got %T instead", value)
17470				}
17471				sv.ChangeToken = ptr.String(jtv)
17472			}
17473
17474		default:
17475			_, _ = key, value
17476
17477		}
17478	}
17479	*v = sv
17480	return nil
17481}
17482