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