1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package elasticloadbalancingv2
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/aws/protocol/query"
10	"github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
11	smithy "github.com/aws/smithy-go"
12	"github.com/aws/smithy-go/encoding/httpbinding"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15	"sort"
16)
17
18type awsAwsquery_serializeOpAddListenerCertificates struct {
19}
20
21func (*awsAwsquery_serializeOpAddListenerCertificates) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsquery_serializeOpAddListenerCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27) {
28	request, ok := in.Request.(*smithyhttp.Request)
29	if !ok {
30		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31	}
32
33	input, ok := in.Parameters.(*AddListenerCertificatesInput)
34	_ = input
35	if !ok {
36		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37	}
38
39	request.Request.URL.Path = "/"
40	request.Request.Method = "POST"
41	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
42	if err != nil {
43		return out, metadata, &smithy.SerializationError{Err: err}
44	}
45	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
46
47	bodyWriter := bytes.NewBuffer(nil)
48	bodyEncoder := query.NewEncoder(bodyWriter)
49	body := bodyEncoder.Object()
50	body.Key("Action").String("AddListenerCertificates")
51	body.Key("Version").String("2015-12-01")
52
53	if err := awsAwsquery_serializeOpDocumentAddListenerCertificatesInput(input, bodyEncoder.Value); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56
57	err = bodyEncoder.Encode()
58	if err != nil {
59		return out, metadata, &smithy.SerializationError{Err: err}
60	}
61
62	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
63		return out, metadata, &smithy.SerializationError{Err: err}
64	}
65
66	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
67		return out, metadata, &smithy.SerializationError{Err: err}
68	}
69	in.Request = request
70
71	return next.HandleSerialize(ctx, in)
72}
73
74type awsAwsquery_serializeOpAddTags struct {
75}
76
77func (*awsAwsquery_serializeOpAddTags) ID() string {
78	return "OperationSerializer"
79}
80
81func (m *awsAwsquery_serializeOpAddTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
82	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
83) {
84	request, ok := in.Request.(*smithyhttp.Request)
85	if !ok {
86		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
87	}
88
89	input, ok := in.Parameters.(*AddTagsInput)
90	_ = input
91	if !ok {
92		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
93	}
94
95	request.Request.URL.Path = "/"
96	request.Request.Method = "POST"
97	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
98	if err != nil {
99		return out, metadata, &smithy.SerializationError{Err: err}
100	}
101	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
102
103	bodyWriter := bytes.NewBuffer(nil)
104	bodyEncoder := query.NewEncoder(bodyWriter)
105	body := bodyEncoder.Object()
106	body.Key("Action").String("AddTags")
107	body.Key("Version").String("2015-12-01")
108
109	if err := awsAwsquery_serializeOpDocumentAddTagsInput(input, bodyEncoder.Value); err != nil {
110		return out, metadata, &smithy.SerializationError{Err: err}
111	}
112
113	err = bodyEncoder.Encode()
114	if err != nil {
115		return out, metadata, &smithy.SerializationError{Err: err}
116	}
117
118	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
119		return out, metadata, &smithy.SerializationError{Err: err}
120	}
121
122	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
123		return out, metadata, &smithy.SerializationError{Err: err}
124	}
125	in.Request = request
126
127	return next.HandleSerialize(ctx, in)
128}
129
130type awsAwsquery_serializeOpCreateListener struct {
131}
132
133func (*awsAwsquery_serializeOpCreateListener) ID() string {
134	return "OperationSerializer"
135}
136
137func (m *awsAwsquery_serializeOpCreateListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
138	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
139) {
140	request, ok := in.Request.(*smithyhttp.Request)
141	if !ok {
142		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
143	}
144
145	input, ok := in.Parameters.(*CreateListenerInput)
146	_ = input
147	if !ok {
148		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
149	}
150
151	request.Request.URL.Path = "/"
152	request.Request.Method = "POST"
153	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
154	if err != nil {
155		return out, metadata, &smithy.SerializationError{Err: err}
156	}
157	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
158
159	bodyWriter := bytes.NewBuffer(nil)
160	bodyEncoder := query.NewEncoder(bodyWriter)
161	body := bodyEncoder.Object()
162	body.Key("Action").String("CreateListener")
163	body.Key("Version").String("2015-12-01")
164
165	if err := awsAwsquery_serializeOpDocumentCreateListenerInput(input, bodyEncoder.Value); err != nil {
166		return out, metadata, &smithy.SerializationError{Err: err}
167	}
168
169	err = bodyEncoder.Encode()
170	if err != nil {
171		return out, metadata, &smithy.SerializationError{Err: err}
172	}
173
174	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
175		return out, metadata, &smithy.SerializationError{Err: err}
176	}
177
178	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
179		return out, metadata, &smithy.SerializationError{Err: err}
180	}
181	in.Request = request
182
183	return next.HandleSerialize(ctx, in)
184}
185
186type awsAwsquery_serializeOpCreateLoadBalancer struct {
187}
188
189func (*awsAwsquery_serializeOpCreateLoadBalancer) ID() string {
190	return "OperationSerializer"
191}
192
193func (m *awsAwsquery_serializeOpCreateLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
194	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
195) {
196	request, ok := in.Request.(*smithyhttp.Request)
197	if !ok {
198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
199	}
200
201	input, ok := in.Parameters.(*CreateLoadBalancerInput)
202	_ = input
203	if !ok {
204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
205	}
206
207	request.Request.URL.Path = "/"
208	request.Request.Method = "POST"
209	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
210	if err != nil {
211		return out, metadata, &smithy.SerializationError{Err: err}
212	}
213	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
214
215	bodyWriter := bytes.NewBuffer(nil)
216	bodyEncoder := query.NewEncoder(bodyWriter)
217	body := bodyEncoder.Object()
218	body.Key("Action").String("CreateLoadBalancer")
219	body.Key("Version").String("2015-12-01")
220
221	if err := awsAwsquery_serializeOpDocumentCreateLoadBalancerInput(input, bodyEncoder.Value); err != nil {
222		return out, metadata, &smithy.SerializationError{Err: err}
223	}
224
225	err = bodyEncoder.Encode()
226	if err != nil {
227		return out, metadata, &smithy.SerializationError{Err: err}
228	}
229
230	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233
234	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
235		return out, metadata, &smithy.SerializationError{Err: err}
236	}
237	in.Request = request
238
239	return next.HandleSerialize(ctx, in)
240}
241
242type awsAwsquery_serializeOpCreateRule struct {
243}
244
245func (*awsAwsquery_serializeOpCreateRule) ID() string {
246	return "OperationSerializer"
247}
248
249func (m *awsAwsquery_serializeOpCreateRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
250	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
251) {
252	request, ok := in.Request.(*smithyhttp.Request)
253	if !ok {
254		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
255	}
256
257	input, ok := in.Parameters.(*CreateRuleInput)
258	_ = input
259	if !ok {
260		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
261	}
262
263	request.Request.URL.Path = "/"
264	request.Request.Method = "POST"
265	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
266	if err != nil {
267		return out, metadata, &smithy.SerializationError{Err: err}
268	}
269	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
270
271	bodyWriter := bytes.NewBuffer(nil)
272	bodyEncoder := query.NewEncoder(bodyWriter)
273	body := bodyEncoder.Object()
274	body.Key("Action").String("CreateRule")
275	body.Key("Version").String("2015-12-01")
276
277	if err := awsAwsquery_serializeOpDocumentCreateRuleInput(input, bodyEncoder.Value); err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280
281	err = bodyEncoder.Encode()
282	if err != nil {
283		return out, metadata, &smithy.SerializationError{Err: err}
284	}
285
286	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
287		return out, metadata, &smithy.SerializationError{Err: err}
288	}
289
290	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
291		return out, metadata, &smithy.SerializationError{Err: err}
292	}
293	in.Request = request
294
295	return next.HandleSerialize(ctx, in)
296}
297
298type awsAwsquery_serializeOpCreateTargetGroup struct {
299}
300
301func (*awsAwsquery_serializeOpCreateTargetGroup) ID() string {
302	return "OperationSerializer"
303}
304
305func (m *awsAwsquery_serializeOpCreateTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
306	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
307) {
308	request, ok := in.Request.(*smithyhttp.Request)
309	if !ok {
310		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
311	}
312
313	input, ok := in.Parameters.(*CreateTargetGroupInput)
314	_ = input
315	if !ok {
316		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
317	}
318
319	request.Request.URL.Path = "/"
320	request.Request.Method = "POST"
321	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
322	if err != nil {
323		return out, metadata, &smithy.SerializationError{Err: err}
324	}
325	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
326
327	bodyWriter := bytes.NewBuffer(nil)
328	bodyEncoder := query.NewEncoder(bodyWriter)
329	body := bodyEncoder.Object()
330	body.Key("Action").String("CreateTargetGroup")
331	body.Key("Version").String("2015-12-01")
332
333	if err := awsAwsquery_serializeOpDocumentCreateTargetGroupInput(input, bodyEncoder.Value); err != nil {
334		return out, metadata, &smithy.SerializationError{Err: err}
335	}
336
337	err = bodyEncoder.Encode()
338	if err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341
342	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
343		return out, metadata, &smithy.SerializationError{Err: err}
344	}
345
346	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
347		return out, metadata, &smithy.SerializationError{Err: err}
348	}
349	in.Request = request
350
351	return next.HandleSerialize(ctx, in)
352}
353
354type awsAwsquery_serializeOpDeleteListener struct {
355}
356
357func (*awsAwsquery_serializeOpDeleteListener) ID() string {
358	return "OperationSerializer"
359}
360
361func (m *awsAwsquery_serializeOpDeleteListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
362	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
363) {
364	request, ok := in.Request.(*smithyhttp.Request)
365	if !ok {
366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
367	}
368
369	input, ok := in.Parameters.(*DeleteListenerInput)
370	_ = input
371	if !ok {
372		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
373	}
374
375	request.Request.URL.Path = "/"
376	request.Request.Method = "POST"
377	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
378	if err != nil {
379		return out, metadata, &smithy.SerializationError{Err: err}
380	}
381	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
382
383	bodyWriter := bytes.NewBuffer(nil)
384	bodyEncoder := query.NewEncoder(bodyWriter)
385	body := bodyEncoder.Object()
386	body.Key("Action").String("DeleteListener")
387	body.Key("Version").String("2015-12-01")
388
389	if err := awsAwsquery_serializeOpDocumentDeleteListenerInput(input, bodyEncoder.Value); err != nil {
390		return out, metadata, &smithy.SerializationError{Err: err}
391	}
392
393	err = bodyEncoder.Encode()
394	if err != nil {
395		return out, metadata, &smithy.SerializationError{Err: err}
396	}
397
398	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
399		return out, metadata, &smithy.SerializationError{Err: err}
400	}
401
402	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
403		return out, metadata, &smithy.SerializationError{Err: err}
404	}
405	in.Request = request
406
407	return next.HandleSerialize(ctx, in)
408}
409
410type awsAwsquery_serializeOpDeleteLoadBalancer struct {
411}
412
413func (*awsAwsquery_serializeOpDeleteLoadBalancer) ID() string {
414	return "OperationSerializer"
415}
416
417func (m *awsAwsquery_serializeOpDeleteLoadBalancer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
418	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
419) {
420	request, ok := in.Request.(*smithyhttp.Request)
421	if !ok {
422		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
423	}
424
425	input, ok := in.Parameters.(*DeleteLoadBalancerInput)
426	_ = input
427	if !ok {
428		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
429	}
430
431	request.Request.URL.Path = "/"
432	request.Request.Method = "POST"
433	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
434	if err != nil {
435		return out, metadata, &smithy.SerializationError{Err: err}
436	}
437	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
438
439	bodyWriter := bytes.NewBuffer(nil)
440	bodyEncoder := query.NewEncoder(bodyWriter)
441	body := bodyEncoder.Object()
442	body.Key("Action").String("DeleteLoadBalancer")
443	body.Key("Version").String("2015-12-01")
444
445	if err := awsAwsquery_serializeOpDocumentDeleteLoadBalancerInput(input, bodyEncoder.Value); err != nil {
446		return out, metadata, &smithy.SerializationError{Err: err}
447	}
448
449	err = bodyEncoder.Encode()
450	if err != nil {
451		return out, metadata, &smithy.SerializationError{Err: err}
452	}
453
454	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
455		return out, metadata, &smithy.SerializationError{Err: err}
456	}
457
458	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
459		return out, metadata, &smithy.SerializationError{Err: err}
460	}
461	in.Request = request
462
463	return next.HandleSerialize(ctx, in)
464}
465
466type awsAwsquery_serializeOpDeleteRule struct {
467}
468
469func (*awsAwsquery_serializeOpDeleteRule) ID() string {
470	return "OperationSerializer"
471}
472
473func (m *awsAwsquery_serializeOpDeleteRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
474	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
475) {
476	request, ok := in.Request.(*smithyhttp.Request)
477	if !ok {
478		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
479	}
480
481	input, ok := in.Parameters.(*DeleteRuleInput)
482	_ = input
483	if !ok {
484		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
485	}
486
487	request.Request.URL.Path = "/"
488	request.Request.Method = "POST"
489	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
490	if err != nil {
491		return out, metadata, &smithy.SerializationError{Err: err}
492	}
493	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
494
495	bodyWriter := bytes.NewBuffer(nil)
496	bodyEncoder := query.NewEncoder(bodyWriter)
497	body := bodyEncoder.Object()
498	body.Key("Action").String("DeleteRule")
499	body.Key("Version").String("2015-12-01")
500
501	if err := awsAwsquery_serializeOpDocumentDeleteRuleInput(input, bodyEncoder.Value); err != nil {
502		return out, metadata, &smithy.SerializationError{Err: err}
503	}
504
505	err = bodyEncoder.Encode()
506	if err != nil {
507		return out, metadata, &smithy.SerializationError{Err: err}
508	}
509
510	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
511		return out, metadata, &smithy.SerializationError{Err: err}
512	}
513
514	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
515		return out, metadata, &smithy.SerializationError{Err: err}
516	}
517	in.Request = request
518
519	return next.HandleSerialize(ctx, in)
520}
521
522type awsAwsquery_serializeOpDeleteTargetGroup struct {
523}
524
525func (*awsAwsquery_serializeOpDeleteTargetGroup) ID() string {
526	return "OperationSerializer"
527}
528
529func (m *awsAwsquery_serializeOpDeleteTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
530	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
531) {
532	request, ok := in.Request.(*smithyhttp.Request)
533	if !ok {
534		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
535	}
536
537	input, ok := in.Parameters.(*DeleteTargetGroupInput)
538	_ = input
539	if !ok {
540		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
541	}
542
543	request.Request.URL.Path = "/"
544	request.Request.Method = "POST"
545	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
546	if err != nil {
547		return out, metadata, &smithy.SerializationError{Err: err}
548	}
549	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
550
551	bodyWriter := bytes.NewBuffer(nil)
552	bodyEncoder := query.NewEncoder(bodyWriter)
553	body := bodyEncoder.Object()
554	body.Key("Action").String("DeleteTargetGroup")
555	body.Key("Version").String("2015-12-01")
556
557	if err := awsAwsquery_serializeOpDocumentDeleteTargetGroupInput(input, bodyEncoder.Value); err != nil {
558		return out, metadata, &smithy.SerializationError{Err: err}
559	}
560
561	err = bodyEncoder.Encode()
562	if err != nil {
563		return out, metadata, &smithy.SerializationError{Err: err}
564	}
565
566	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
567		return out, metadata, &smithy.SerializationError{Err: err}
568	}
569
570	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573	in.Request = request
574
575	return next.HandleSerialize(ctx, in)
576}
577
578type awsAwsquery_serializeOpDeregisterTargets struct {
579}
580
581func (*awsAwsquery_serializeOpDeregisterTargets) ID() string {
582	return "OperationSerializer"
583}
584
585func (m *awsAwsquery_serializeOpDeregisterTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
586	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
587) {
588	request, ok := in.Request.(*smithyhttp.Request)
589	if !ok {
590		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
591	}
592
593	input, ok := in.Parameters.(*DeregisterTargetsInput)
594	_ = input
595	if !ok {
596		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
597	}
598
599	request.Request.URL.Path = "/"
600	request.Request.Method = "POST"
601	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
602	if err != nil {
603		return out, metadata, &smithy.SerializationError{Err: err}
604	}
605	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
606
607	bodyWriter := bytes.NewBuffer(nil)
608	bodyEncoder := query.NewEncoder(bodyWriter)
609	body := bodyEncoder.Object()
610	body.Key("Action").String("DeregisterTargets")
611	body.Key("Version").String("2015-12-01")
612
613	if err := awsAwsquery_serializeOpDocumentDeregisterTargetsInput(input, bodyEncoder.Value); err != nil {
614		return out, metadata, &smithy.SerializationError{Err: err}
615	}
616
617	err = bodyEncoder.Encode()
618	if err != nil {
619		return out, metadata, &smithy.SerializationError{Err: err}
620	}
621
622	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
623		return out, metadata, &smithy.SerializationError{Err: err}
624	}
625
626	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
627		return out, metadata, &smithy.SerializationError{Err: err}
628	}
629	in.Request = request
630
631	return next.HandleSerialize(ctx, in)
632}
633
634type awsAwsquery_serializeOpDescribeAccountLimits struct {
635}
636
637func (*awsAwsquery_serializeOpDescribeAccountLimits) ID() string {
638	return "OperationSerializer"
639}
640
641func (m *awsAwsquery_serializeOpDescribeAccountLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
642	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
643) {
644	request, ok := in.Request.(*smithyhttp.Request)
645	if !ok {
646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
647	}
648
649	input, ok := in.Parameters.(*DescribeAccountLimitsInput)
650	_ = input
651	if !ok {
652		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
653	}
654
655	request.Request.URL.Path = "/"
656	request.Request.Method = "POST"
657	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
658	if err != nil {
659		return out, metadata, &smithy.SerializationError{Err: err}
660	}
661	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
662
663	bodyWriter := bytes.NewBuffer(nil)
664	bodyEncoder := query.NewEncoder(bodyWriter)
665	body := bodyEncoder.Object()
666	body.Key("Action").String("DescribeAccountLimits")
667	body.Key("Version").String("2015-12-01")
668
669	if err := awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(input, bodyEncoder.Value); err != nil {
670		return out, metadata, &smithy.SerializationError{Err: err}
671	}
672
673	err = bodyEncoder.Encode()
674	if err != nil {
675		return out, metadata, &smithy.SerializationError{Err: err}
676	}
677
678	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
679		return out, metadata, &smithy.SerializationError{Err: err}
680	}
681
682	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
683		return out, metadata, &smithy.SerializationError{Err: err}
684	}
685	in.Request = request
686
687	return next.HandleSerialize(ctx, in)
688}
689
690type awsAwsquery_serializeOpDescribeListenerCertificates struct {
691}
692
693func (*awsAwsquery_serializeOpDescribeListenerCertificates) ID() string {
694	return "OperationSerializer"
695}
696
697func (m *awsAwsquery_serializeOpDescribeListenerCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
698	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
699) {
700	request, ok := in.Request.(*smithyhttp.Request)
701	if !ok {
702		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
703	}
704
705	input, ok := in.Parameters.(*DescribeListenerCertificatesInput)
706	_ = input
707	if !ok {
708		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
709	}
710
711	request.Request.URL.Path = "/"
712	request.Request.Method = "POST"
713	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
714	if err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
718
719	bodyWriter := bytes.NewBuffer(nil)
720	bodyEncoder := query.NewEncoder(bodyWriter)
721	body := bodyEncoder.Object()
722	body.Key("Action").String("DescribeListenerCertificates")
723	body.Key("Version").String("2015-12-01")
724
725	if err := awsAwsquery_serializeOpDocumentDescribeListenerCertificatesInput(input, bodyEncoder.Value); err != nil {
726		return out, metadata, &smithy.SerializationError{Err: err}
727	}
728
729	err = bodyEncoder.Encode()
730	if err != nil {
731		return out, metadata, &smithy.SerializationError{Err: err}
732	}
733
734	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
735		return out, metadata, &smithy.SerializationError{Err: err}
736	}
737
738	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
739		return out, metadata, &smithy.SerializationError{Err: err}
740	}
741	in.Request = request
742
743	return next.HandleSerialize(ctx, in)
744}
745
746type awsAwsquery_serializeOpDescribeListeners struct {
747}
748
749func (*awsAwsquery_serializeOpDescribeListeners) ID() string {
750	return "OperationSerializer"
751}
752
753func (m *awsAwsquery_serializeOpDescribeListeners) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
754	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
755) {
756	request, ok := in.Request.(*smithyhttp.Request)
757	if !ok {
758		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
759	}
760
761	input, ok := in.Parameters.(*DescribeListenersInput)
762	_ = input
763	if !ok {
764		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
765	}
766
767	request.Request.URL.Path = "/"
768	request.Request.Method = "POST"
769	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
770	if err != nil {
771		return out, metadata, &smithy.SerializationError{Err: err}
772	}
773	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
774
775	bodyWriter := bytes.NewBuffer(nil)
776	bodyEncoder := query.NewEncoder(bodyWriter)
777	body := bodyEncoder.Object()
778	body.Key("Action").String("DescribeListeners")
779	body.Key("Version").String("2015-12-01")
780
781	if err := awsAwsquery_serializeOpDocumentDescribeListenersInput(input, bodyEncoder.Value); err != nil {
782		return out, metadata, &smithy.SerializationError{Err: err}
783	}
784
785	err = bodyEncoder.Encode()
786	if err != nil {
787		return out, metadata, &smithy.SerializationError{Err: err}
788	}
789
790	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
791		return out, metadata, &smithy.SerializationError{Err: err}
792	}
793
794	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
795		return out, metadata, &smithy.SerializationError{Err: err}
796	}
797	in.Request = request
798
799	return next.HandleSerialize(ctx, in)
800}
801
802type awsAwsquery_serializeOpDescribeLoadBalancerAttributes struct {
803}
804
805func (*awsAwsquery_serializeOpDescribeLoadBalancerAttributes) ID() string {
806	return "OperationSerializer"
807}
808
809func (m *awsAwsquery_serializeOpDescribeLoadBalancerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
810	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
811) {
812	request, ok := in.Request.(*smithyhttp.Request)
813	if !ok {
814		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
815	}
816
817	input, ok := in.Parameters.(*DescribeLoadBalancerAttributesInput)
818	_ = input
819	if !ok {
820		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
821	}
822
823	request.Request.URL.Path = "/"
824	request.Request.Method = "POST"
825	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
826	if err != nil {
827		return out, metadata, &smithy.SerializationError{Err: err}
828	}
829	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
830
831	bodyWriter := bytes.NewBuffer(nil)
832	bodyEncoder := query.NewEncoder(bodyWriter)
833	body := bodyEncoder.Object()
834	body.Key("Action").String("DescribeLoadBalancerAttributes")
835	body.Key("Version").String("2015-12-01")
836
837	if err := awsAwsquery_serializeOpDocumentDescribeLoadBalancerAttributesInput(input, bodyEncoder.Value); err != nil {
838		return out, metadata, &smithy.SerializationError{Err: err}
839	}
840
841	err = bodyEncoder.Encode()
842	if err != nil {
843		return out, metadata, &smithy.SerializationError{Err: err}
844	}
845
846	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
847		return out, metadata, &smithy.SerializationError{Err: err}
848	}
849
850	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
851		return out, metadata, &smithy.SerializationError{Err: err}
852	}
853	in.Request = request
854
855	return next.HandleSerialize(ctx, in)
856}
857
858type awsAwsquery_serializeOpDescribeLoadBalancers struct {
859}
860
861func (*awsAwsquery_serializeOpDescribeLoadBalancers) ID() string {
862	return "OperationSerializer"
863}
864
865func (m *awsAwsquery_serializeOpDescribeLoadBalancers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
866	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
867) {
868	request, ok := in.Request.(*smithyhttp.Request)
869	if !ok {
870		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
871	}
872
873	input, ok := in.Parameters.(*DescribeLoadBalancersInput)
874	_ = input
875	if !ok {
876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
877	}
878
879	request.Request.URL.Path = "/"
880	request.Request.Method = "POST"
881	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
882	if err != nil {
883		return out, metadata, &smithy.SerializationError{Err: err}
884	}
885	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
886
887	bodyWriter := bytes.NewBuffer(nil)
888	bodyEncoder := query.NewEncoder(bodyWriter)
889	body := bodyEncoder.Object()
890	body.Key("Action").String("DescribeLoadBalancers")
891	body.Key("Version").String("2015-12-01")
892
893	if err := awsAwsquery_serializeOpDocumentDescribeLoadBalancersInput(input, bodyEncoder.Value); err != nil {
894		return out, metadata, &smithy.SerializationError{Err: err}
895	}
896
897	err = bodyEncoder.Encode()
898	if err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905
906	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
907		return out, metadata, &smithy.SerializationError{Err: err}
908	}
909	in.Request = request
910
911	return next.HandleSerialize(ctx, in)
912}
913
914type awsAwsquery_serializeOpDescribeRules struct {
915}
916
917func (*awsAwsquery_serializeOpDescribeRules) ID() string {
918	return "OperationSerializer"
919}
920
921func (m *awsAwsquery_serializeOpDescribeRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
922	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
923) {
924	request, ok := in.Request.(*smithyhttp.Request)
925	if !ok {
926		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
927	}
928
929	input, ok := in.Parameters.(*DescribeRulesInput)
930	_ = input
931	if !ok {
932		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
933	}
934
935	request.Request.URL.Path = "/"
936	request.Request.Method = "POST"
937	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
938	if err != nil {
939		return out, metadata, &smithy.SerializationError{Err: err}
940	}
941	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
942
943	bodyWriter := bytes.NewBuffer(nil)
944	bodyEncoder := query.NewEncoder(bodyWriter)
945	body := bodyEncoder.Object()
946	body.Key("Action").String("DescribeRules")
947	body.Key("Version").String("2015-12-01")
948
949	if err := awsAwsquery_serializeOpDocumentDescribeRulesInput(input, bodyEncoder.Value); err != nil {
950		return out, metadata, &smithy.SerializationError{Err: err}
951	}
952
953	err = bodyEncoder.Encode()
954	if err != nil {
955		return out, metadata, &smithy.SerializationError{Err: err}
956	}
957
958	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
959		return out, metadata, &smithy.SerializationError{Err: err}
960	}
961
962	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
963		return out, metadata, &smithy.SerializationError{Err: err}
964	}
965	in.Request = request
966
967	return next.HandleSerialize(ctx, in)
968}
969
970type awsAwsquery_serializeOpDescribeSSLPolicies struct {
971}
972
973func (*awsAwsquery_serializeOpDescribeSSLPolicies) ID() string {
974	return "OperationSerializer"
975}
976
977func (m *awsAwsquery_serializeOpDescribeSSLPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
978	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
979) {
980	request, ok := in.Request.(*smithyhttp.Request)
981	if !ok {
982		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
983	}
984
985	input, ok := in.Parameters.(*DescribeSSLPoliciesInput)
986	_ = input
987	if !ok {
988		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
989	}
990
991	request.Request.URL.Path = "/"
992	request.Request.Method = "POST"
993	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
994	if err != nil {
995		return out, metadata, &smithy.SerializationError{Err: err}
996	}
997	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
998
999	bodyWriter := bytes.NewBuffer(nil)
1000	bodyEncoder := query.NewEncoder(bodyWriter)
1001	body := bodyEncoder.Object()
1002	body.Key("Action").String("DescribeSSLPolicies")
1003	body.Key("Version").String("2015-12-01")
1004
1005	if err := awsAwsquery_serializeOpDocumentDescribeSSLPoliciesInput(input, bodyEncoder.Value); err != nil {
1006		return out, metadata, &smithy.SerializationError{Err: err}
1007	}
1008
1009	err = bodyEncoder.Encode()
1010	if err != nil {
1011		return out, metadata, &smithy.SerializationError{Err: err}
1012	}
1013
1014	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1015		return out, metadata, &smithy.SerializationError{Err: err}
1016	}
1017
1018	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1019		return out, metadata, &smithy.SerializationError{Err: err}
1020	}
1021	in.Request = request
1022
1023	return next.HandleSerialize(ctx, in)
1024}
1025
1026type awsAwsquery_serializeOpDescribeTags struct {
1027}
1028
1029func (*awsAwsquery_serializeOpDescribeTags) ID() string {
1030	return "OperationSerializer"
1031}
1032
1033func (m *awsAwsquery_serializeOpDescribeTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1034	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1035) {
1036	request, ok := in.Request.(*smithyhttp.Request)
1037	if !ok {
1038		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1039	}
1040
1041	input, ok := in.Parameters.(*DescribeTagsInput)
1042	_ = input
1043	if !ok {
1044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1045	}
1046
1047	request.Request.URL.Path = "/"
1048	request.Request.Method = "POST"
1049	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1050	if err != nil {
1051		return out, metadata, &smithy.SerializationError{Err: err}
1052	}
1053	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1054
1055	bodyWriter := bytes.NewBuffer(nil)
1056	bodyEncoder := query.NewEncoder(bodyWriter)
1057	body := bodyEncoder.Object()
1058	body.Key("Action").String("DescribeTags")
1059	body.Key("Version").String("2015-12-01")
1060
1061	if err := awsAwsquery_serializeOpDocumentDescribeTagsInput(input, bodyEncoder.Value); err != nil {
1062		return out, metadata, &smithy.SerializationError{Err: err}
1063	}
1064
1065	err = bodyEncoder.Encode()
1066	if err != nil {
1067		return out, metadata, &smithy.SerializationError{Err: err}
1068	}
1069
1070	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1071		return out, metadata, &smithy.SerializationError{Err: err}
1072	}
1073
1074	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1075		return out, metadata, &smithy.SerializationError{Err: err}
1076	}
1077	in.Request = request
1078
1079	return next.HandleSerialize(ctx, in)
1080}
1081
1082type awsAwsquery_serializeOpDescribeTargetGroupAttributes struct {
1083}
1084
1085func (*awsAwsquery_serializeOpDescribeTargetGroupAttributes) ID() string {
1086	return "OperationSerializer"
1087}
1088
1089func (m *awsAwsquery_serializeOpDescribeTargetGroupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1090	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1091) {
1092	request, ok := in.Request.(*smithyhttp.Request)
1093	if !ok {
1094		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1095	}
1096
1097	input, ok := in.Parameters.(*DescribeTargetGroupAttributesInput)
1098	_ = input
1099	if !ok {
1100		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1101	}
1102
1103	request.Request.URL.Path = "/"
1104	request.Request.Method = "POST"
1105	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1106	if err != nil {
1107		return out, metadata, &smithy.SerializationError{Err: err}
1108	}
1109	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1110
1111	bodyWriter := bytes.NewBuffer(nil)
1112	bodyEncoder := query.NewEncoder(bodyWriter)
1113	body := bodyEncoder.Object()
1114	body.Key("Action").String("DescribeTargetGroupAttributes")
1115	body.Key("Version").String("2015-12-01")
1116
1117	if err := awsAwsquery_serializeOpDocumentDescribeTargetGroupAttributesInput(input, bodyEncoder.Value); err != nil {
1118		return out, metadata, &smithy.SerializationError{Err: err}
1119	}
1120
1121	err = bodyEncoder.Encode()
1122	if err != nil {
1123		return out, metadata, &smithy.SerializationError{Err: err}
1124	}
1125
1126	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1127		return out, metadata, &smithy.SerializationError{Err: err}
1128	}
1129
1130	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133	in.Request = request
1134
1135	return next.HandleSerialize(ctx, in)
1136}
1137
1138type awsAwsquery_serializeOpDescribeTargetGroups struct {
1139}
1140
1141func (*awsAwsquery_serializeOpDescribeTargetGroups) ID() string {
1142	return "OperationSerializer"
1143}
1144
1145func (m *awsAwsquery_serializeOpDescribeTargetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1146	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1147) {
1148	request, ok := in.Request.(*smithyhttp.Request)
1149	if !ok {
1150		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1151	}
1152
1153	input, ok := in.Parameters.(*DescribeTargetGroupsInput)
1154	_ = input
1155	if !ok {
1156		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1157	}
1158
1159	request.Request.URL.Path = "/"
1160	request.Request.Method = "POST"
1161	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1162	if err != nil {
1163		return out, metadata, &smithy.SerializationError{Err: err}
1164	}
1165	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1166
1167	bodyWriter := bytes.NewBuffer(nil)
1168	bodyEncoder := query.NewEncoder(bodyWriter)
1169	body := bodyEncoder.Object()
1170	body.Key("Action").String("DescribeTargetGroups")
1171	body.Key("Version").String("2015-12-01")
1172
1173	if err := awsAwsquery_serializeOpDocumentDescribeTargetGroupsInput(input, bodyEncoder.Value); err != nil {
1174		return out, metadata, &smithy.SerializationError{Err: err}
1175	}
1176
1177	err = bodyEncoder.Encode()
1178	if err != nil {
1179		return out, metadata, &smithy.SerializationError{Err: err}
1180	}
1181
1182	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1183		return out, metadata, &smithy.SerializationError{Err: err}
1184	}
1185
1186	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1187		return out, metadata, &smithy.SerializationError{Err: err}
1188	}
1189	in.Request = request
1190
1191	return next.HandleSerialize(ctx, in)
1192}
1193
1194type awsAwsquery_serializeOpDescribeTargetHealth struct {
1195}
1196
1197func (*awsAwsquery_serializeOpDescribeTargetHealth) ID() string {
1198	return "OperationSerializer"
1199}
1200
1201func (m *awsAwsquery_serializeOpDescribeTargetHealth) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1202	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1203) {
1204	request, ok := in.Request.(*smithyhttp.Request)
1205	if !ok {
1206		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1207	}
1208
1209	input, ok := in.Parameters.(*DescribeTargetHealthInput)
1210	_ = input
1211	if !ok {
1212		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1213	}
1214
1215	request.Request.URL.Path = "/"
1216	request.Request.Method = "POST"
1217	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1218	if err != nil {
1219		return out, metadata, &smithy.SerializationError{Err: err}
1220	}
1221	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1222
1223	bodyWriter := bytes.NewBuffer(nil)
1224	bodyEncoder := query.NewEncoder(bodyWriter)
1225	body := bodyEncoder.Object()
1226	body.Key("Action").String("DescribeTargetHealth")
1227	body.Key("Version").String("2015-12-01")
1228
1229	if err := awsAwsquery_serializeOpDocumentDescribeTargetHealthInput(input, bodyEncoder.Value); err != nil {
1230		return out, metadata, &smithy.SerializationError{Err: err}
1231	}
1232
1233	err = bodyEncoder.Encode()
1234	if err != nil {
1235		return out, metadata, &smithy.SerializationError{Err: err}
1236	}
1237
1238	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1239		return out, metadata, &smithy.SerializationError{Err: err}
1240	}
1241
1242	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1243		return out, metadata, &smithy.SerializationError{Err: err}
1244	}
1245	in.Request = request
1246
1247	return next.HandleSerialize(ctx, in)
1248}
1249
1250type awsAwsquery_serializeOpModifyListener struct {
1251}
1252
1253func (*awsAwsquery_serializeOpModifyListener) ID() string {
1254	return "OperationSerializer"
1255}
1256
1257func (m *awsAwsquery_serializeOpModifyListener) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1258	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1259) {
1260	request, ok := in.Request.(*smithyhttp.Request)
1261	if !ok {
1262		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1263	}
1264
1265	input, ok := in.Parameters.(*ModifyListenerInput)
1266	_ = input
1267	if !ok {
1268		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1269	}
1270
1271	request.Request.URL.Path = "/"
1272	request.Request.Method = "POST"
1273	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1274	if err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1278
1279	bodyWriter := bytes.NewBuffer(nil)
1280	bodyEncoder := query.NewEncoder(bodyWriter)
1281	body := bodyEncoder.Object()
1282	body.Key("Action").String("ModifyListener")
1283	body.Key("Version").String("2015-12-01")
1284
1285	if err := awsAwsquery_serializeOpDocumentModifyListenerInput(input, bodyEncoder.Value); err != nil {
1286		return out, metadata, &smithy.SerializationError{Err: err}
1287	}
1288
1289	err = bodyEncoder.Encode()
1290	if err != nil {
1291		return out, metadata, &smithy.SerializationError{Err: err}
1292	}
1293
1294	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1295		return out, metadata, &smithy.SerializationError{Err: err}
1296	}
1297
1298	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1299		return out, metadata, &smithy.SerializationError{Err: err}
1300	}
1301	in.Request = request
1302
1303	return next.HandleSerialize(ctx, in)
1304}
1305
1306type awsAwsquery_serializeOpModifyLoadBalancerAttributes struct {
1307}
1308
1309func (*awsAwsquery_serializeOpModifyLoadBalancerAttributes) ID() string {
1310	return "OperationSerializer"
1311}
1312
1313func (m *awsAwsquery_serializeOpModifyLoadBalancerAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1314	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1315) {
1316	request, ok := in.Request.(*smithyhttp.Request)
1317	if !ok {
1318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1319	}
1320
1321	input, ok := in.Parameters.(*ModifyLoadBalancerAttributesInput)
1322	_ = input
1323	if !ok {
1324		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1325	}
1326
1327	request.Request.URL.Path = "/"
1328	request.Request.Method = "POST"
1329	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1330	if err != nil {
1331		return out, metadata, &smithy.SerializationError{Err: err}
1332	}
1333	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1334
1335	bodyWriter := bytes.NewBuffer(nil)
1336	bodyEncoder := query.NewEncoder(bodyWriter)
1337	body := bodyEncoder.Object()
1338	body.Key("Action").String("ModifyLoadBalancerAttributes")
1339	body.Key("Version").String("2015-12-01")
1340
1341	if err := awsAwsquery_serializeOpDocumentModifyLoadBalancerAttributesInput(input, bodyEncoder.Value); err != nil {
1342		return out, metadata, &smithy.SerializationError{Err: err}
1343	}
1344
1345	err = bodyEncoder.Encode()
1346	if err != nil {
1347		return out, metadata, &smithy.SerializationError{Err: err}
1348	}
1349
1350	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1351		return out, metadata, &smithy.SerializationError{Err: err}
1352	}
1353
1354	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1355		return out, metadata, &smithy.SerializationError{Err: err}
1356	}
1357	in.Request = request
1358
1359	return next.HandleSerialize(ctx, in)
1360}
1361
1362type awsAwsquery_serializeOpModifyRule struct {
1363}
1364
1365func (*awsAwsquery_serializeOpModifyRule) ID() string {
1366	return "OperationSerializer"
1367}
1368
1369func (m *awsAwsquery_serializeOpModifyRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1370	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1371) {
1372	request, ok := in.Request.(*smithyhttp.Request)
1373	if !ok {
1374		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1375	}
1376
1377	input, ok := in.Parameters.(*ModifyRuleInput)
1378	_ = input
1379	if !ok {
1380		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1381	}
1382
1383	request.Request.URL.Path = "/"
1384	request.Request.Method = "POST"
1385	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1386	if err != nil {
1387		return out, metadata, &smithy.SerializationError{Err: err}
1388	}
1389	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1390
1391	bodyWriter := bytes.NewBuffer(nil)
1392	bodyEncoder := query.NewEncoder(bodyWriter)
1393	body := bodyEncoder.Object()
1394	body.Key("Action").String("ModifyRule")
1395	body.Key("Version").String("2015-12-01")
1396
1397	if err := awsAwsquery_serializeOpDocumentModifyRuleInput(input, bodyEncoder.Value); err != nil {
1398		return out, metadata, &smithy.SerializationError{Err: err}
1399	}
1400
1401	err = bodyEncoder.Encode()
1402	if err != nil {
1403		return out, metadata, &smithy.SerializationError{Err: err}
1404	}
1405
1406	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1407		return out, metadata, &smithy.SerializationError{Err: err}
1408	}
1409
1410	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1411		return out, metadata, &smithy.SerializationError{Err: err}
1412	}
1413	in.Request = request
1414
1415	return next.HandleSerialize(ctx, in)
1416}
1417
1418type awsAwsquery_serializeOpModifyTargetGroup struct {
1419}
1420
1421func (*awsAwsquery_serializeOpModifyTargetGroup) ID() string {
1422	return "OperationSerializer"
1423}
1424
1425func (m *awsAwsquery_serializeOpModifyTargetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1426	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1427) {
1428	request, ok := in.Request.(*smithyhttp.Request)
1429	if !ok {
1430		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1431	}
1432
1433	input, ok := in.Parameters.(*ModifyTargetGroupInput)
1434	_ = input
1435	if !ok {
1436		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1437	}
1438
1439	request.Request.URL.Path = "/"
1440	request.Request.Method = "POST"
1441	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1442	if err != nil {
1443		return out, metadata, &smithy.SerializationError{Err: err}
1444	}
1445	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1446
1447	bodyWriter := bytes.NewBuffer(nil)
1448	bodyEncoder := query.NewEncoder(bodyWriter)
1449	body := bodyEncoder.Object()
1450	body.Key("Action").String("ModifyTargetGroup")
1451	body.Key("Version").String("2015-12-01")
1452
1453	if err := awsAwsquery_serializeOpDocumentModifyTargetGroupInput(input, bodyEncoder.Value); err != nil {
1454		return out, metadata, &smithy.SerializationError{Err: err}
1455	}
1456
1457	err = bodyEncoder.Encode()
1458	if err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsquery_serializeOpModifyTargetGroupAttributes struct {
1475}
1476
1477func (*awsAwsquery_serializeOpModifyTargetGroupAttributes) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsquery_serializeOpModifyTargetGroupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*ModifyTargetGroupAttributesInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1502
1503	bodyWriter := bytes.NewBuffer(nil)
1504	bodyEncoder := query.NewEncoder(bodyWriter)
1505	body := bodyEncoder.Object()
1506	body.Key("Action").String("ModifyTargetGroupAttributes")
1507	body.Key("Version").String("2015-12-01")
1508
1509	if err := awsAwsquery_serializeOpDocumentModifyTargetGroupAttributesInput(input, bodyEncoder.Value); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	err = bodyEncoder.Encode()
1514	if err != nil {
1515		return out, metadata, &smithy.SerializationError{Err: err}
1516	}
1517
1518	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1519		return out, metadata, &smithy.SerializationError{Err: err}
1520	}
1521
1522	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1523		return out, metadata, &smithy.SerializationError{Err: err}
1524	}
1525	in.Request = request
1526
1527	return next.HandleSerialize(ctx, in)
1528}
1529
1530type awsAwsquery_serializeOpRegisterTargets struct {
1531}
1532
1533func (*awsAwsquery_serializeOpRegisterTargets) ID() string {
1534	return "OperationSerializer"
1535}
1536
1537func (m *awsAwsquery_serializeOpRegisterTargets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1538	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1539) {
1540	request, ok := in.Request.(*smithyhttp.Request)
1541	if !ok {
1542		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1543	}
1544
1545	input, ok := in.Parameters.(*RegisterTargetsInput)
1546	_ = input
1547	if !ok {
1548		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1549	}
1550
1551	request.Request.URL.Path = "/"
1552	request.Request.Method = "POST"
1553	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1554	if err != nil {
1555		return out, metadata, &smithy.SerializationError{Err: err}
1556	}
1557	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1558
1559	bodyWriter := bytes.NewBuffer(nil)
1560	bodyEncoder := query.NewEncoder(bodyWriter)
1561	body := bodyEncoder.Object()
1562	body.Key("Action").String("RegisterTargets")
1563	body.Key("Version").String("2015-12-01")
1564
1565	if err := awsAwsquery_serializeOpDocumentRegisterTargetsInput(input, bodyEncoder.Value); err != nil {
1566		return out, metadata, &smithy.SerializationError{Err: err}
1567	}
1568
1569	err = bodyEncoder.Encode()
1570	if err != nil {
1571		return out, metadata, &smithy.SerializationError{Err: err}
1572	}
1573
1574	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1575		return out, metadata, &smithy.SerializationError{Err: err}
1576	}
1577
1578	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1579		return out, metadata, &smithy.SerializationError{Err: err}
1580	}
1581	in.Request = request
1582
1583	return next.HandleSerialize(ctx, in)
1584}
1585
1586type awsAwsquery_serializeOpRemoveListenerCertificates struct {
1587}
1588
1589func (*awsAwsquery_serializeOpRemoveListenerCertificates) ID() string {
1590	return "OperationSerializer"
1591}
1592
1593func (m *awsAwsquery_serializeOpRemoveListenerCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1594	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1595) {
1596	request, ok := in.Request.(*smithyhttp.Request)
1597	if !ok {
1598		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1599	}
1600
1601	input, ok := in.Parameters.(*RemoveListenerCertificatesInput)
1602	_ = input
1603	if !ok {
1604		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1605	}
1606
1607	request.Request.URL.Path = "/"
1608	request.Request.Method = "POST"
1609	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1610	if err != nil {
1611		return out, metadata, &smithy.SerializationError{Err: err}
1612	}
1613	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1614
1615	bodyWriter := bytes.NewBuffer(nil)
1616	bodyEncoder := query.NewEncoder(bodyWriter)
1617	body := bodyEncoder.Object()
1618	body.Key("Action").String("RemoveListenerCertificates")
1619	body.Key("Version").String("2015-12-01")
1620
1621	if err := awsAwsquery_serializeOpDocumentRemoveListenerCertificatesInput(input, bodyEncoder.Value); err != nil {
1622		return out, metadata, &smithy.SerializationError{Err: err}
1623	}
1624
1625	err = bodyEncoder.Encode()
1626	if err != nil {
1627		return out, metadata, &smithy.SerializationError{Err: err}
1628	}
1629
1630	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1631		return out, metadata, &smithy.SerializationError{Err: err}
1632	}
1633
1634	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1635		return out, metadata, &smithy.SerializationError{Err: err}
1636	}
1637	in.Request = request
1638
1639	return next.HandleSerialize(ctx, in)
1640}
1641
1642type awsAwsquery_serializeOpRemoveTags struct {
1643}
1644
1645func (*awsAwsquery_serializeOpRemoveTags) ID() string {
1646	return "OperationSerializer"
1647}
1648
1649func (m *awsAwsquery_serializeOpRemoveTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1650	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1651) {
1652	request, ok := in.Request.(*smithyhttp.Request)
1653	if !ok {
1654		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1655	}
1656
1657	input, ok := in.Parameters.(*RemoveTagsInput)
1658	_ = input
1659	if !ok {
1660		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1661	}
1662
1663	request.Request.URL.Path = "/"
1664	request.Request.Method = "POST"
1665	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1666	if err != nil {
1667		return out, metadata, &smithy.SerializationError{Err: err}
1668	}
1669	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1670
1671	bodyWriter := bytes.NewBuffer(nil)
1672	bodyEncoder := query.NewEncoder(bodyWriter)
1673	body := bodyEncoder.Object()
1674	body.Key("Action").String("RemoveTags")
1675	body.Key("Version").String("2015-12-01")
1676
1677	if err := awsAwsquery_serializeOpDocumentRemoveTagsInput(input, bodyEncoder.Value); err != nil {
1678		return out, metadata, &smithy.SerializationError{Err: err}
1679	}
1680
1681	err = bodyEncoder.Encode()
1682	if err != nil {
1683		return out, metadata, &smithy.SerializationError{Err: err}
1684	}
1685
1686	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1687		return out, metadata, &smithy.SerializationError{Err: err}
1688	}
1689
1690	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1691		return out, metadata, &smithy.SerializationError{Err: err}
1692	}
1693	in.Request = request
1694
1695	return next.HandleSerialize(ctx, in)
1696}
1697
1698type awsAwsquery_serializeOpSetIpAddressType struct {
1699}
1700
1701func (*awsAwsquery_serializeOpSetIpAddressType) ID() string {
1702	return "OperationSerializer"
1703}
1704
1705func (m *awsAwsquery_serializeOpSetIpAddressType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1706	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1707) {
1708	request, ok := in.Request.(*smithyhttp.Request)
1709	if !ok {
1710		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1711	}
1712
1713	input, ok := in.Parameters.(*SetIpAddressTypeInput)
1714	_ = input
1715	if !ok {
1716		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1717	}
1718
1719	request.Request.URL.Path = "/"
1720	request.Request.Method = "POST"
1721	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1722	if err != nil {
1723		return out, metadata, &smithy.SerializationError{Err: err}
1724	}
1725	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1726
1727	bodyWriter := bytes.NewBuffer(nil)
1728	bodyEncoder := query.NewEncoder(bodyWriter)
1729	body := bodyEncoder.Object()
1730	body.Key("Action").String("SetIpAddressType")
1731	body.Key("Version").String("2015-12-01")
1732
1733	if err := awsAwsquery_serializeOpDocumentSetIpAddressTypeInput(input, bodyEncoder.Value); err != nil {
1734		return out, metadata, &smithy.SerializationError{Err: err}
1735	}
1736
1737	err = bodyEncoder.Encode()
1738	if err != nil {
1739		return out, metadata, &smithy.SerializationError{Err: err}
1740	}
1741
1742	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1743		return out, metadata, &smithy.SerializationError{Err: err}
1744	}
1745
1746	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1747		return out, metadata, &smithy.SerializationError{Err: err}
1748	}
1749	in.Request = request
1750
1751	return next.HandleSerialize(ctx, in)
1752}
1753
1754type awsAwsquery_serializeOpSetRulePriorities struct {
1755}
1756
1757func (*awsAwsquery_serializeOpSetRulePriorities) ID() string {
1758	return "OperationSerializer"
1759}
1760
1761func (m *awsAwsquery_serializeOpSetRulePriorities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1762	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1763) {
1764	request, ok := in.Request.(*smithyhttp.Request)
1765	if !ok {
1766		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1767	}
1768
1769	input, ok := in.Parameters.(*SetRulePrioritiesInput)
1770	_ = input
1771	if !ok {
1772		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1773	}
1774
1775	request.Request.URL.Path = "/"
1776	request.Request.Method = "POST"
1777	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1778	if err != nil {
1779		return out, metadata, &smithy.SerializationError{Err: err}
1780	}
1781	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1782
1783	bodyWriter := bytes.NewBuffer(nil)
1784	bodyEncoder := query.NewEncoder(bodyWriter)
1785	body := bodyEncoder.Object()
1786	body.Key("Action").String("SetRulePriorities")
1787	body.Key("Version").String("2015-12-01")
1788
1789	if err := awsAwsquery_serializeOpDocumentSetRulePrioritiesInput(input, bodyEncoder.Value); err != nil {
1790		return out, metadata, &smithy.SerializationError{Err: err}
1791	}
1792
1793	err = bodyEncoder.Encode()
1794	if err != nil {
1795		return out, metadata, &smithy.SerializationError{Err: err}
1796	}
1797
1798	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1799		return out, metadata, &smithy.SerializationError{Err: err}
1800	}
1801
1802	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1803		return out, metadata, &smithy.SerializationError{Err: err}
1804	}
1805	in.Request = request
1806
1807	return next.HandleSerialize(ctx, in)
1808}
1809
1810type awsAwsquery_serializeOpSetSecurityGroups struct {
1811}
1812
1813func (*awsAwsquery_serializeOpSetSecurityGroups) ID() string {
1814	return "OperationSerializer"
1815}
1816
1817func (m *awsAwsquery_serializeOpSetSecurityGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1818	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1819) {
1820	request, ok := in.Request.(*smithyhttp.Request)
1821	if !ok {
1822		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1823	}
1824
1825	input, ok := in.Parameters.(*SetSecurityGroupsInput)
1826	_ = input
1827	if !ok {
1828		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1829	}
1830
1831	request.Request.URL.Path = "/"
1832	request.Request.Method = "POST"
1833	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1834	if err != nil {
1835		return out, metadata, &smithy.SerializationError{Err: err}
1836	}
1837	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1838
1839	bodyWriter := bytes.NewBuffer(nil)
1840	bodyEncoder := query.NewEncoder(bodyWriter)
1841	body := bodyEncoder.Object()
1842	body.Key("Action").String("SetSecurityGroups")
1843	body.Key("Version").String("2015-12-01")
1844
1845	if err := awsAwsquery_serializeOpDocumentSetSecurityGroupsInput(input, bodyEncoder.Value); err != nil {
1846		return out, metadata, &smithy.SerializationError{Err: err}
1847	}
1848
1849	err = bodyEncoder.Encode()
1850	if err != nil {
1851		return out, metadata, &smithy.SerializationError{Err: err}
1852	}
1853
1854	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1855		return out, metadata, &smithy.SerializationError{Err: err}
1856	}
1857
1858	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1859		return out, metadata, &smithy.SerializationError{Err: err}
1860	}
1861	in.Request = request
1862
1863	return next.HandleSerialize(ctx, in)
1864}
1865
1866type awsAwsquery_serializeOpSetSubnets struct {
1867}
1868
1869func (*awsAwsquery_serializeOpSetSubnets) ID() string {
1870	return "OperationSerializer"
1871}
1872
1873func (m *awsAwsquery_serializeOpSetSubnets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1874	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1875) {
1876	request, ok := in.Request.(*smithyhttp.Request)
1877	if !ok {
1878		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1879	}
1880
1881	input, ok := in.Parameters.(*SetSubnetsInput)
1882	_ = input
1883	if !ok {
1884		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1885	}
1886
1887	request.Request.URL.Path = "/"
1888	request.Request.Method = "POST"
1889	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1890	if err != nil {
1891		return out, metadata, &smithy.SerializationError{Err: err}
1892	}
1893	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1894
1895	bodyWriter := bytes.NewBuffer(nil)
1896	bodyEncoder := query.NewEncoder(bodyWriter)
1897	body := bodyEncoder.Object()
1898	body.Key("Action").String("SetSubnets")
1899	body.Key("Version").String("2015-12-01")
1900
1901	if err := awsAwsquery_serializeOpDocumentSetSubnetsInput(input, bodyEncoder.Value); err != nil {
1902		return out, metadata, &smithy.SerializationError{Err: err}
1903	}
1904
1905	err = bodyEncoder.Encode()
1906	if err != nil {
1907		return out, metadata, &smithy.SerializationError{Err: err}
1908	}
1909
1910	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1911		return out, metadata, &smithy.SerializationError{Err: err}
1912	}
1913
1914	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1915		return out, metadata, &smithy.SerializationError{Err: err}
1916	}
1917	in.Request = request
1918
1919	return next.HandleSerialize(ctx, in)
1920}
1921func awsAwsquery_serializeDocumentAction(v *types.Action, value query.Value) error {
1922	object := value.Object()
1923	_ = object
1924
1925	if v.AuthenticateCognitoConfig != nil {
1926		objectKey := object.Key("AuthenticateCognitoConfig")
1927		if err := awsAwsquery_serializeDocumentAuthenticateCognitoActionConfig(v.AuthenticateCognitoConfig, objectKey); err != nil {
1928			return err
1929		}
1930	}
1931
1932	if v.AuthenticateOidcConfig != nil {
1933		objectKey := object.Key("AuthenticateOidcConfig")
1934		if err := awsAwsquery_serializeDocumentAuthenticateOidcActionConfig(v.AuthenticateOidcConfig, objectKey); err != nil {
1935			return err
1936		}
1937	}
1938
1939	if v.FixedResponseConfig != nil {
1940		objectKey := object.Key("FixedResponseConfig")
1941		if err := awsAwsquery_serializeDocumentFixedResponseActionConfig(v.FixedResponseConfig, objectKey); err != nil {
1942			return err
1943		}
1944	}
1945
1946	if v.ForwardConfig != nil {
1947		objectKey := object.Key("ForwardConfig")
1948		if err := awsAwsquery_serializeDocumentForwardActionConfig(v.ForwardConfig, objectKey); err != nil {
1949			return err
1950		}
1951	}
1952
1953	if v.Order != nil {
1954		objectKey := object.Key("Order")
1955		objectKey.Integer(*v.Order)
1956	}
1957
1958	if v.RedirectConfig != nil {
1959		objectKey := object.Key("RedirectConfig")
1960		if err := awsAwsquery_serializeDocumentRedirectActionConfig(v.RedirectConfig, objectKey); err != nil {
1961			return err
1962		}
1963	}
1964
1965	if v.TargetGroupArn != nil {
1966		objectKey := object.Key("TargetGroupArn")
1967		objectKey.String(*v.TargetGroupArn)
1968	}
1969
1970	if len(v.Type) > 0 {
1971		objectKey := object.Key("Type")
1972		objectKey.String(string(v.Type))
1973	}
1974
1975	return nil
1976}
1977
1978func awsAwsquery_serializeDocumentActions(v []types.Action, value query.Value) error {
1979	if len(v) == 0 {
1980		return nil
1981	}
1982	array := value.Array("member")
1983
1984	for i := range v {
1985		av := array.Value()
1986		if err := awsAwsquery_serializeDocumentAction(&v[i], av); err != nil {
1987			return err
1988		}
1989	}
1990	return nil
1991}
1992
1993func awsAwsquery_serializeDocumentAlpnPolicyName(v []string, value query.Value) error {
1994	if len(v) == 0 {
1995		return nil
1996	}
1997	array := value.Array("member")
1998
1999	for i := range v {
2000		av := array.Value()
2001		av.String(v[i])
2002	}
2003	return nil
2004}
2005
2006func awsAwsquery_serializeDocumentAuthenticateCognitoActionAuthenticationRequestExtraParams(v map[string]string, value query.Value) error {
2007	if len(v) == 0 {
2008		return nil
2009	}
2010	object := value.Map("key", "value")
2011
2012	keys := make([]string, 0, len(v))
2013	for key := range v {
2014		keys = append(keys, key)
2015	}
2016	sort.Strings(keys)
2017
2018	for _, key := range keys {
2019		om := object.Key(key)
2020		om.String(v[key])
2021	}
2022	return nil
2023}
2024
2025func awsAwsquery_serializeDocumentAuthenticateCognitoActionConfig(v *types.AuthenticateCognitoActionConfig, value query.Value) error {
2026	object := value.Object()
2027	_ = object
2028
2029	if v.AuthenticationRequestExtraParams != nil {
2030		objectKey := object.Key("AuthenticationRequestExtraParams")
2031		if err := awsAwsquery_serializeDocumentAuthenticateCognitoActionAuthenticationRequestExtraParams(v.AuthenticationRequestExtraParams, objectKey); err != nil {
2032			return err
2033		}
2034	}
2035
2036	if len(v.OnUnauthenticatedRequest) > 0 {
2037		objectKey := object.Key("OnUnauthenticatedRequest")
2038		objectKey.String(string(v.OnUnauthenticatedRequest))
2039	}
2040
2041	if v.Scope != nil {
2042		objectKey := object.Key("Scope")
2043		objectKey.String(*v.Scope)
2044	}
2045
2046	if v.SessionCookieName != nil {
2047		objectKey := object.Key("SessionCookieName")
2048		objectKey.String(*v.SessionCookieName)
2049	}
2050
2051	if v.SessionTimeout != nil {
2052		objectKey := object.Key("SessionTimeout")
2053		objectKey.Long(*v.SessionTimeout)
2054	}
2055
2056	if v.UserPoolArn != nil {
2057		objectKey := object.Key("UserPoolArn")
2058		objectKey.String(*v.UserPoolArn)
2059	}
2060
2061	if v.UserPoolClientId != nil {
2062		objectKey := object.Key("UserPoolClientId")
2063		objectKey.String(*v.UserPoolClientId)
2064	}
2065
2066	if v.UserPoolDomain != nil {
2067		objectKey := object.Key("UserPoolDomain")
2068		objectKey.String(*v.UserPoolDomain)
2069	}
2070
2071	return nil
2072}
2073
2074func awsAwsquery_serializeDocumentAuthenticateOidcActionAuthenticationRequestExtraParams(v map[string]string, value query.Value) error {
2075	if len(v) == 0 {
2076		return nil
2077	}
2078	object := value.Map("key", "value")
2079
2080	keys := make([]string, 0, len(v))
2081	for key := range v {
2082		keys = append(keys, key)
2083	}
2084	sort.Strings(keys)
2085
2086	for _, key := range keys {
2087		om := object.Key(key)
2088		om.String(v[key])
2089	}
2090	return nil
2091}
2092
2093func awsAwsquery_serializeDocumentAuthenticateOidcActionConfig(v *types.AuthenticateOidcActionConfig, value query.Value) error {
2094	object := value.Object()
2095	_ = object
2096
2097	if v.AuthenticationRequestExtraParams != nil {
2098		objectKey := object.Key("AuthenticationRequestExtraParams")
2099		if err := awsAwsquery_serializeDocumentAuthenticateOidcActionAuthenticationRequestExtraParams(v.AuthenticationRequestExtraParams, objectKey); err != nil {
2100			return err
2101		}
2102	}
2103
2104	if v.AuthorizationEndpoint != nil {
2105		objectKey := object.Key("AuthorizationEndpoint")
2106		objectKey.String(*v.AuthorizationEndpoint)
2107	}
2108
2109	if v.ClientId != nil {
2110		objectKey := object.Key("ClientId")
2111		objectKey.String(*v.ClientId)
2112	}
2113
2114	if v.ClientSecret != nil {
2115		objectKey := object.Key("ClientSecret")
2116		objectKey.String(*v.ClientSecret)
2117	}
2118
2119	if v.Issuer != nil {
2120		objectKey := object.Key("Issuer")
2121		objectKey.String(*v.Issuer)
2122	}
2123
2124	if len(v.OnUnauthenticatedRequest) > 0 {
2125		objectKey := object.Key("OnUnauthenticatedRequest")
2126		objectKey.String(string(v.OnUnauthenticatedRequest))
2127	}
2128
2129	if v.Scope != nil {
2130		objectKey := object.Key("Scope")
2131		objectKey.String(*v.Scope)
2132	}
2133
2134	if v.SessionCookieName != nil {
2135		objectKey := object.Key("SessionCookieName")
2136		objectKey.String(*v.SessionCookieName)
2137	}
2138
2139	if v.SessionTimeout != nil {
2140		objectKey := object.Key("SessionTimeout")
2141		objectKey.Long(*v.SessionTimeout)
2142	}
2143
2144	if v.TokenEndpoint != nil {
2145		objectKey := object.Key("TokenEndpoint")
2146		objectKey.String(*v.TokenEndpoint)
2147	}
2148
2149	if v.UseExistingClientSecret != nil {
2150		objectKey := object.Key("UseExistingClientSecret")
2151		objectKey.Boolean(*v.UseExistingClientSecret)
2152	}
2153
2154	if v.UserInfoEndpoint != nil {
2155		objectKey := object.Key("UserInfoEndpoint")
2156		objectKey.String(*v.UserInfoEndpoint)
2157	}
2158
2159	return nil
2160}
2161
2162func awsAwsquery_serializeDocumentCertificate(v *types.Certificate, value query.Value) error {
2163	object := value.Object()
2164	_ = object
2165
2166	if v.CertificateArn != nil {
2167		objectKey := object.Key("CertificateArn")
2168		objectKey.String(*v.CertificateArn)
2169	}
2170
2171	if v.IsDefault != nil {
2172		objectKey := object.Key("IsDefault")
2173		objectKey.Boolean(*v.IsDefault)
2174	}
2175
2176	return nil
2177}
2178
2179func awsAwsquery_serializeDocumentCertificateList(v []types.Certificate, value query.Value) error {
2180	if len(v) == 0 {
2181		return nil
2182	}
2183	array := value.Array("member")
2184
2185	for i := range v {
2186		av := array.Value()
2187		if err := awsAwsquery_serializeDocumentCertificate(&v[i], av); err != nil {
2188			return err
2189		}
2190	}
2191	return nil
2192}
2193
2194func awsAwsquery_serializeDocumentFixedResponseActionConfig(v *types.FixedResponseActionConfig, value query.Value) error {
2195	object := value.Object()
2196	_ = object
2197
2198	if v.ContentType != nil {
2199		objectKey := object.Key("ContentType")
2200		objectKey.String(*v.ContentType)
2201	}
2202
2203	if v.MessageBody != nil {
2204		objectKey := object.Key("MessageBody")
2205		objectKey.String(*v.MessageBody)
2206	}
2207
2208	if v.StatusCode != nil {
2209		objectKey := object.Key("StatusCode")
2210		objectKey.String(*v.StatusCode)
2211	}
2212
2213	return nil
2214}
2215
2216func awsAwsquery_serializeDocumentForwardActionConfig(v *types.ForwardActionConfig, value query.Value) error {
2217	object := value.Object()
2218	_ = object
2219
2220	if v.TargetGroups != nil {
2221		objectKey := object.Key("TargetGroups")
2222		if err := awsAwsquery_serializeDocumentTargetGroupList(v.TargetGroups, objectKey); err != nil {
2223			return err
2224		}
2225	}
2226
2227	if v.TargetGroupStickinessConfig != nil {
2228		objectKey := object.Key("TargetGroupStickinessConfig")
2229		if err := awsAwsquery_serializeDocumentTargetGroupStickinessConfig(v.TargetGroupStickinessConfig, objectKey); err != nil {
2230			return err
2231		}
2232	}
2233
2234	return nil
2235}
2236
2237func awsAwsquery_serializeDocumentHostHeaderConditionConfig(v *types.HostHeaderConditionConfig, value query.Value) error {
2238	object := value.Object()
2239	_ = object
2240
2241	if v.Values != nil {
2242		objectKey := object.Key("Values")
2243		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2244			return err
2245		}
2246	}
2247
2248	return nil
2249}
2250
2251func awsAwsquery_serializeDocumentHttpHeaderConditionConfig(v *types.HttpHeaderConditionConfig, value query.Value) error {
2252	object := value.Object()
2253	_ = object
2254
2255	if v.HttpHeaderName != nil {
2256		objectKey := object.Key("HttpHeaderName")
2257		objectKey.String(*v.HttpHeaderName)
2258	}
2259
2260	if v.Values != nil {
2261		objectKey := object.Key("Values")
2262		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2263			return err
2264		}
2265	}
2266
2267	return nil
2268}
2269
2270func awsAwsquery_serializeDocumentHttpRequestMethodConditionConfig(v *types.HttpRequestMethodConditionConfig, value query.Value) error {
2271	object := value.Object()
2272	_ = object
2273
2274	if v.Values != nil {
2275		objectKey := object.Key("Values")
2276		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2277			return err
2278		}
2279	}
2280
2281	return nil
2282}
2283
2284func awsAwsquery_serializeDocumentListenerArns(v []string, value query.Value) error {
2285	if len(v) == 0 {
2286		return nil
2287	}
2288	array := value.Array("member")
2289
2290	for i := range v {
2291		av := array.Value()
2292		av.String(v[i])
2293	}
2294	return nil
2295}
2296
2297func awsAwsquery_serializeDocumentListOfString(v []string, value query.Value) error {
2298	if len(v) == 0 {
2299		return nil
2300	}
2301	array := value.Array("member")
2302
2303	for i := range v {
2304		av := array.Value()
2305		av.String(v[i])
2306	}
2307	return nil
2308}
2309
2310func awsAwsquery_serializeDocumentLoadBalancerArns(v []string, value query.Value) error {
2311	if len(v) == 0 {
2312		return nil
2313	}
2314	array := value.Array("member")
2315
2316	for i := range v {
2317		av := array.Value()
2318		av.String(v[i])
2319	}
2320	return nil
2321}
2322
2323func awsAwsquery_serializeDocumentLoadBalancerAttribute(v *types.LoadBalancerAttribute, value query.Value) error {
2324	object := value.Object()
2325	_ = object
2326
2327	if v.Key != nil {
2328		objectKey := object.Key("Key")
2329		objectKey.String(*v.Key)
2330	}
2331
2332	if v.Value != nil {
2333		objectKey := object.Key("Value")
2334		objectKey.String(*v.Value)
2335	}
2336
2337	return nil
2338}
2339
2340func awsAwsquery_serializeDocumentLoadBalancerAttributes(v []types.LoadBalancerAttribute, value query.Value) error {
2341	if len(v) == 0 {
2342		return nil
2343	}
2344	array := value.Array("member")
2345
2346	for i := range v {
2347		av := array.Value()
2348		if err := awsAwsquery_serializeDocumentLoadBalancerAttribute(&v[i], av); err != nil {
2349			return err
2350		}
2351	}
2352	return nil
2353}
2354
2355func awsAwsquery_serializeDocumentLoadBalancerNames(v []string, value query.Value) error {
2356	if len(v) == 0 {
2357		return nil
2358	}
2359	array := value.Array("member")
2360
2361	for i := range v {
2362		av := array.Value()
2363		av.String(v[i])
2364	}
2365	return nil
2366}
2367
2368func awsAwsquery_serializeDocumentMatcher(v *types.Matcher, value query.Value) error {
2369	object := value.Object()
2370	_ = object
2371
2372	if v.GrpcCode != nil {
2373		objectKey := object.Key("GrpcCode")
2374		objectKey.String(*v.GrpcCode)
2375	}
2376
2377	if v.HttpCode != nil {
2378		objectKey := object.Key("HttpCode")
2379		objectKey.String(*v.HttpCode)
2380	}
2381
2382	return nil
2383}
2384
2385func awsAwsquery_serializeDocumentPathPatternConditionConfig(v *types.PathPatternConditionConfig, value query.Value) error {
2386	object := value.Object()
2387	_ = object
2388
2389	if v.Values != nil {
2390		objectKey := object.Key("Values")
2391		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2392			return err
2393		}
2394	}
2395
2396	return nil
2397}
2398
2399func awsAwsquery_serializeDocumentQueryStringConditionConfig(v *types.QueryStringConditionConfig, value query.Value) error {
2400	object := value.Object()
2401	_ = object
2402
2403	if v.Values != nil {
2404		objectKey := object.Key("Values")
2405		if err := awsAwsquery_serializeDocumentQueryStringKeyValuePairList(v.Values, objectKey); err != nil {
2406			return err
2407		}
2408	}
2409
2410	return nil
2411}
2412
2413func awsAwsquery_serializeDocumentQueryStringKeyValuePair(v *types.QueryStringKeyValuePair, value query.Value) error {
2414	object := value.Object()
2415	_ = object
2416
2417	if v.Key != nil {
2418		objectKey := object.Key("Key")
2419		objectKey.String(*v.Key)
2420	}
2421
2422	if v.Value != nil {
2423		objectKey := object.Key("Value")
2424		objectKey.String(*v.Value)
2425	}
2426
2427	return nil
2428}
2429
2430func awsAwsquery_serializeDocumentQueryStringKeyValuePairList(v []types.QueryStringKeyValuePair, value query.Value) error {
2431	if len(v) == 0 {
2432		return nil
2433	}
2434	array := value.Array("member")
2435
2436	for i := range v {
2437		av := array.Value()
2438		if err := awsAwsquery_serializeDocumentQueryStringKeyValuePair(&v[i], av); err != nil {
2439			return err
2440		}
2441	}
2442	return nil
2443}
2444
2445func awsAwsquery_serializeDocumentRedirectActionConfig(v *types.RedirectActionConfig, value query.Value) error {
2446	object := value.Object()
2447	_ = object
2448
2449	if v.Host != nil {
2450		objectKey := object.Key("Host")
2451		objectKey.String(*v.Host)
2452	}
2453
2454	if v.Path != nil {
2455		objectKey := object.Key("Path")
2456		objectKey.String(*v.Path)
2457	}
2458
2459	if v.Port != nil {
2460		objectKey := object.Key("Port")
2461		objectKey.String(*v.Port)
2462	}
2463
2464	if v.Protocol != nil {
2465		objectKey := object.Key("Protocol")
2466		objectKey.String(*v.Protocol)
2467	}
2468
2469	if v.Query != nil {
2470		objectKey := object.Key("Query")
2471		objectKey.String(*v.Query)
2472	}
2473
2474	if len(v.StatusCode) > 0 {
2475		objectKey := object.Key("StatusCode")
2476		objectKey.String(string(v.StatusCode))
2477	}
2478
2479	return nil
2480}
2481
2482func awsAwsquery_serializeDocumentResourceArns(v []string, value query.Value) error {
2483	if len(v) == 0 {
2484		return nil
2485	}
2486	array := value.Array("member")
2487
2488	for i := range v {
2489		av := array.Value()
2490		av.String(v[i])
2491	}
2492	return nil
2493}
2494
2495func awsAwsquery_serializeDocumentRuleArns(v []string, value query.Value) error {
2496	if len(v) == 0 {
2497		return nil
2498	}
2499	array := value.Array("member")
2500
2501	for i := range v {
2502		av := array.Value()
2503		av.String(v[i])
2504	}
2505	return nil
2506}
2507
2508func awsAwsquery_serializeDocumentRuleCondition(v *types.RuleCondition, value query.Value) error {
2509	object := value.Object()
2510	_ = object
2511
2512	if v.Field != nil {
2513		objectKey := object.Key("Field")
2514		objectKey.String(*v.Field)
2515	}
2516
2517	if v.HostHeaderConfig != nil {
2518		objectKey := object.Key("HostHeaderConfig")
2519		if err := awsAwsquery_serializeDocumentHostHeaderConditionConfig(v.HostHeaderConfig, objectKey); err != nil {
2520			return err
2521		}
2522	}
2523
2524	if v.HttpHeaderConfig != nil {
2525		objectKey := object.Key("HttpHeaderConfig")
2526		if err := awsAwsquery_serializeDocumentHttpHeaderConditionConfig(v.HttpHeaderConfig, objectKey); err != nil {
2527			return err
2528		}
2529	}
2530
2531	if v.HttpRequestMethodConfig != nil {
2532		objectKey := object.Key("HttpRequestMethodConfig")
2533		if err := awsAwsquery_serializeDocumentHttpRequestMethodConditionConfig(v.HttpRequestMethodConfig, objectKey); err != nil {
2534			return err
2535		}
2536	}
2537
2538	if v.PathPatternConfig != nil {
2539		objectKey := object.Key("PathPatternConfig")
2540		if err := awsAwsquery_serializeDocumentPathPatternConditionConfig(v.PathPatternConfig, objectKey); err != nil {
2541			return err
2542		}
2543	}
2544
2545	if v.QueryStringConfig != nil {
2546		objectKey := object.Key("QueryStringConfig")
2547		if err := awsAwsquery_serializeDocumentQueryStringConditionConfig(v.QueryStringConfig, objectKey); err != nil {
2548			return err
2549		}
2550	}
2551
2552	if v.SourceIpConfig != nil {
2553		objectKey := object.Key("SourceIpConfig")
2554		if err := awsAwsquery_serializeDocumentSourceIpConditionConfig(v.SourceIpConfig, objectKey); err != nil {
2555			return err
2556		}
2557	}
2558
2559	if v.Values != nil {
2560		objectKey := object.Key("Values")
2561		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2562			return err
2563		}
2564	}
2565
2566	return nil
2567}
2568
2569func awsAwsquery_serializeDocumentRuleConditionList(v []types.RuleCondition, value query.Value) error {
2570	if len(v) == 0 {
2571		return nil
2572	}
2573	array := value.Array("member")
2574
2575	for i := range v {
2576		av := array.Value()
2577		if err := awsAwsquery_serializeDocumentRuleCondition(&v[i], av); err != nil {
2578			return err
2579		}
2580	}
2581	return nil
2582}
2583
2584func awsAwsquery_serializeDocumentRulePriorityList(v []types.RulePriorityPair, value query.Value) error {
2585	if len(v) == 0 {
2586		return nil
2587	}
2588	array := value.Array("member")
2589
2590	for i := range v {
2591		av := array.Value()
2592		if err := awsAwsquery_serializeDocumentRulePriorityPair(&v[i], av); err != nil {
2593			return err
2594		}
2595	}
2596	return nil
2597}
2598
2599func awsAwsquery_serializeDocumentRulePriorityPair(v *types.RulePriorityPair, value query.Value) error {
2600	object := value.Object()
2601	_ = object
2602
2603	if v.Priority != nil {
2604		objectKey := object.Key("Priority")
2605		objectKey.Integer(*v.Priority)
2606	}
2607
2608	if v.RuleArn != nil {
2609		objectKey := object.Key("RuleArn")
2610		objectKey.String(*v.RuleArn)
2611	}
2612
2613	return nil
2614}
2615
2616func awsAwsquery_serializeDocumentSecurityGroups(v []string, value query.Value) error {
2617	if len(v) == 0 {
2618		return nil
2619	}
2620	array := value.Array("member")
2621
2622	for i := range v {
2623		av := array.Value()
2624		av.String(v[i])
2625	}
2626	return nil
2627}
2628
2629func awsAwsquery_serializeDocumentSourceIpConditionConfig(v *types.SourceIpConditionConfig, value query.Value) error {
2630	object := value.Object()
2631	_ = object
2632
2633	if v.Values != nil {
2634		objectKey := object.Key("Values")
2635		if err := awsAwsquery_serializeDocumentListOfString(v.Values, objectKey); err != nil {
2636			return err
2637		}
2638	}
2639
2640	return nil
2641}
2642
2643func awsAwsquery_serializeDocumentSslPolicyNames(v []string, value query.Value) error {
2644	if len(v) == 0 {
2645		return nil
2646	}
2647	array := value.Array("member")
2648
2649	for i := range v {
2650		av := array.Value()
2651		av.String(v[i])
2652	}
2653	return nil
2654}
2655
2656func awsAwsquery_serializeDocumentSubnetMapping(v *types.SubnetMapping, value query.Value) error {
2657	object := value.Object()
2658	_ = object
2659
2660	if v.AllocationId != nil {
2661		objectKey := object.Key("AllocationId")
2662		objectKey.String(*v.AllocationId)
2663	}
2664
2665	if v.IPv6Address != nil {
2666		objectKey := object.Key("IPv6Address")
2667		objectKey.String(*v.IPv6Address)
2668	}
2669
2670	if v.PrivateIPv4Address != nil {
2671		objectKey := object.Key("PrivateIPv4Address")
2672		objectKey.String(*v.PrivateIPv4Address)
2673	}
2674
2675	if v.SubnetId != nil {
2676		objectKey := object.Key("SubnetId")
2677		objectKey.String(*v.SubnetId)
2678	}
2679
2680	return nil
2681}
2682
2683func awsAwsquery_serializeDocumentSubnetMappings(v []types.SubnetMapping, value query.Value) error {
2684	if len(v) == 0 {
2685		return nil
2686	}
2687	array := value.Array("member")
2688
2689	for i := range v {
2690		av := array.Value()
2691		if err := awsAwsquery_serializeDocumentSubnetMapping(&v[i], av); err != nil {
2692			return err
2693		}
2694	}
2695	return nil
2696}
2697
2698func awsAwsquery_serializeDocumentSubnets(v []string, value query.Value) error {
2699	if len(v) == 0 {
2700		return nil
2701	}
2702	array := value.Array("member")
2703
2704	for i := range v {
2705		av := array.Value()
2706		av.String(v[i])
2707	}
2708	return nil
2709}
2710
2711func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
2712	object := value.Object()
2713	_ = object
2714
2715	if v.Key != nil {
2716		objectKey := object.Key("Key")
2717		objectKey.String(*v.Key)
2718	}
2719
2720	if v.Value != nil {
2721		objectKey := object.Key("Value")
2722		objectKey.String(*v.Value)
2723	}
2724
2725	return nil
2726}
2727
2728func awsAwsquery_serializeDocumentTagKeys(v []string, value query.Value) error {
2729	if len(v) == 0 {
2730		return nil
2731	}
2732	array := value.Array("member")
2733
2734	for i := range v {
2735		av := array.Value()
2736		av.String(v[i])
2737	}
2738	return nil
2739}
2740
2741func awsAwsquery_serializeDocumentTagList(v []types.Tag, value query.Value) error {
2742	if len(v) == 0 {
2743		return nil
2744	}
2745	array := value.Array("member")
2746
2747	for i := range v {
2748		av := array.Value()
2749		if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
2750			return err
2751		}
2752	}
2753	return nil
2754}
2755
2756func awsAwsquery_serializeDocumentTargetDescription(v *types.TargetDescription, value query.Value) error {
2757	object := value.Object()
2758	_ = object
2759
2760	if v.AvailabilityZone != nil {
2761		objectKey := object.Key("AvailabilityZone")
2762		objectKey.String(*v.AvailabilityZone)
2763	}
2764
2765	if v.Id != nil {
2766		objectKey := object.Key("Id")
2767		objectKey.String(*v.Id)
2768	}
2769
2770	if v.Port != nil {
2771		objectKey := object.Key("Port")
2772		objectKey.Integer(*v.Port)
2773	}
2774
2775	return nil
2776}
2777
2778func awsAwsquery_serializeDocumentTargetDescriptions(v []types.TargetDescription, value query.Value) error {
2779	if len(v) == 0 {
2780		return nil
2781	}
2782	array := value.Array("member")
2783
2784	for i := range v {
2785		av := array.Value()
2786		if err := awsAwsquery_serializeDocumentTargetDescription(&v[i], av); err != nil {
2787			return err
2788		}
2789	}
2790	return nil
2791}
2792
2793func awsAwsquery_serializeDocumentTargetGroupArns(v []string, value query.Value) error {
2794	if len(v) == 0 {
2795		return nil
2796	}
2797	array := value.Array("member")
2798
2799	for i := range v {
2800		av := array.Value()
2801		av.String(v[i])
2802	}
2803	return nil
2804}
2805
2806func awsAwsquery_serializeDocumentTargetGroupAttribute(v *types.TargetGroupAttribute, value query.Value) error {
2807	object := value.Object()
2808	_ = object
2809
2810	if v.Key != nil {
2811		objectKey := object.Key("Key")
2812		objectKey.String(*v.Key)
2813	}
2814
2815	if v.Value != nil {
2816		objectKey := object.Key("Value")
2817		objectKey.String(*v.Value)
2818	}
2819
2820	return nil
2821}
2822
2823func awsAwsquery_serializeDocumentTargetGroupAttributes(v []types.TargetGroupAttribute, value query.Value) error {
2824	if len(v) == 0 {
2825		return nil
2826	}
2827	array := value.Array("member")
2828
2829	for i := range v {
2830		av := array.Value()
2831		if err := awsAwsquery_serializeDocumentTargetGroupAttribute(&v[i], av); err != nil {
2832			return err
2833		}
2834	}
2835	return nil
2836}
2837
2838func awsAwsquery_serializeDocumentTargetGroupList(v []types.TargetGroupTuple, value query.Value) error {
2839	if len(v) == 0 {
2840		return nil
2841	}
2842	array := value.Array("member")
2843
2844	for i := range v {
2845		av := array.Value()
2846		if err := awsAwsquery_serializeDocumentTargetGroupTuple(&v[i], av); err != nil {
2847			return err
2848		}
2849	}
2850	return nil
2851}
2852
2853func awsAwsquery_serializeDocumentTargetGroupNames(v []string, value query.Value) error {
2854	if len(v) == 0 {
2855		return nil
2856	}
2857	array := value.Array("member")
2858
2859	for i := range v {
2860		av := array.Value()
2861		av.String(v[i])
2862	}
2863	return nil
2864}
2865
2866func awsAwsquery_serializeDocumentTargetGroupStickinessConfig(v *types.TargetGroupStickinessConfig, value query.Value) error {
2867	object := value.Object()
2868	_ = object
2869
2870	if v.DurationSeconds != nil {
2871		objectKey := object.Key("DurationSeconds")
2872		objectKey.Integer(*v.DurationSeconds)
2873	}
2874
2875	if v.Enabled != nil {
2876		objectKey := object.Key("Enabled")
2877		objectKey.Boolean(*v.Enabled)
2878	}
2879
2880	return nil
2881}
2882
2883func awsAwsquery_serializeDocumentTargetGroupTuple(v *types.TargetGroupTuple, value query.Value) error {
2884	object := value.Object()
2885	_ = object
2886
2887	if v.TargetGroupArn != nil {
2888		objectKey := object.Key("TargetGroupArn")
2889		objectKey.String(*v.TargetGroupArn)
2890	}
2891
2892	if v.Weight != nil {
2893		objectKey := object.Key("Weight")
2894		objectKey.Integer(*v.Weight)
2895	}
2896
2897	return nil
2898}
2899
2900func awsAwsquery_serializeOpDocumentAddListenerCertificatesInput(v *AddListenerCertificatesInput, value query.Value) error {
2901	object := value.Object()
2902	_ = object
2903
2904	if v.Certificates != nil {
2905		objectKey := object.Key("Certificates")
2906		if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil {
2907			return err
2908		}
2909	}
2910
2911	if v.ListenerArn != nil {
2912		objectKey := object.Key("ListenerArn")
2913		objectKey.String(*v.ListenerArn)
2914	}
2915
2916	return nil
2917}
2918
2919func awsAwsquery_serializeOpDocumentAddTagsInput(v *AddTagsInput, value query.Value) error {
2920	object := value.Object()
2921	_ = object
2922
2923	if v.ResourceArns != nil {
2924		objectKey := object.Key("ResourceArns")
2925		if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil {
2926			return err
2927		}
2928	}
2929
2930	if v.Tags != nil {
2931		objectKey := object.Key("Tags")
2932		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
2933			return err
2934		}
2935	}
2936
2937	return nil
2938}
2939
2940func awsAwsquery_serializeOpDocumentCreateListenerInput(v *CreateListenerInput, value query.Value) error {
2941	object := value.Object()
2942	_ = object
2943
2944	if v.AlpnPolicy != nil {
2945		objectKey := object.Key("AlpnPolicy")
2946		if err := awsAwsquery_serializeDocumentAlpnPolicyName(v.AlpnPolicy, objectKey); err != nil {
2947			return err
2948		}
2949	}
2950
2951	if v.Certificates != nil {
2952		objectKey := object.Key("Certificates")
2953		if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil {
2954			return err
2955		}
2956	}
2957
2958	if v.DefaultActions != nil {
2959		objectKey := object.Key("DefaultActions")
2960		if err := awsAwsquery_serializeDocumentActions(v.DefaultActions, objectKey); err != nil {
2961			return err
2962		}
2963	}
2964
2965	if v.LoadBalancerArn != nil {
2966		objectKey := object.Key("LoadBalancerArn")
2967		objectKey.String(*v.LoadBalancerArn)
2968	}
2969
2970	if v.Port != nil {
2971		objectKey := object.Key("Port")
2972		objectKey.Integer(*v.Port)
2973	}
2974
2975	if len(v.Protocol) > 0 {
2976		objectKey := object.Key("Protocol")
2977		objectKey.String(string(v.Protocol))
2978	}
2979
2980	if v.SslPolicy != nil {
2981		objectKey := object.Key("SslPolicy")
2982		objectKey.String(*v.SslPolicy)
2983	}
2984
2985	if v.Tags != nil {
2986		objectKey := object.Key("Tags")
2987		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
2988			return err
2989		}
2990	}
2991
2992	return nil
2993}
2994
2995func awsAwsquery_serializeOpDocumentCreateLoadBalancerInput(v *CreateLoadBalancerInput, value query.Value) error {
2996	object := value.Object()
2997	_ = object
2998
2999	if v.CustomerOwnedIpv4Pool != nil {
3000		objectKey := object.Key("CustomerOwnedIpv4Pool")
3001		objectKey.String(*v.CustomerOwnedIpv4Pool)
3002	}
3003
3004	if len(v.IpAddressType) > 0 {
3005		objectKey := object.Key("IpAddressType")
3006		objectKey.String(string(v.IpAddressType))
3007	}
3008
3009	if v.Name != nil {
3010		objectKey := object.Key("Name")
3011		objectKey.String(*v.Name)
3012	}
3013
3014	if len(v.Scheme) > 0 {
3015		objectKey := object.Key("Scheme")
3016		objectKey.String(string(v.Scheme))
3017	}
3018
3019	if v.SecurityGroups != nil {
3020		objectKey := object.Key("SecurityGroups")
3021		if err := awsAwsquery_serializeDocumentSecurityGroups(v.SecurityGroups, objectKey); err != nil {
3022			return err
3023		}
3024	}
3025
3026	if v.SubnetMappings != nil {
3027		objectKey := object.Key("SubnetMappings")
3028		if err := awsAwsquery_serializeDocumentSubnetMappings(v.SubnetMappings, objectKey); err != nil {
3029			return err
3030		}
3031	}
3032
3033	if v.Subnets != nil {
3034		objectKey := object.Key("Subnets")
3035		if err := awsAwsquery_serializeDocumentSubnets(v.Subnets, objectKey); err != nil {
3036			return err
3037		}
3038	}
3039
3040	if v.Tags != nil {
3041		objectKey := object.Key("Tags")
3042		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
3043			return err
3044		}
3045	}
3046
3047	if len(v.Type) > 0 {
3048		objectKey := object.Key("Type")
3049		objectKey.String(string(v.Type))
3050	}
3051
3052	return nil
3053}
3054
3055func awsAwsquery_serializeOpDocumentCreateRuleInput(v *CreateRuleInput, value query.Value) error {
3056	object := value.Object()
3057	_ = object
3058
3059	if v.Actions != nil {
3060		objectKey := object.Key("Actions")
3061		if err := awsAwsquery_serializeDocumentActions(v.Actions, objectKey); err != nil {
3062			return err
3063		}
3064	}
3065
3066	if v.Conditions != nil {
3067		objectKey := object.Key("Conditions")
3068		if err := awsAwsquery_serializeDocumentRuleConditionList(v.Conditions, objectKey); err != nil {
3069			return err
3070		}
3071	}
3072
3073	if v.ListenerArn != nil {
3074		objectKey := object.Key("ListenerArn")
3075		objectKey.String(*v.ListenerArn)
3076	}
3077
3078	if v.Priority != nil {
3079		objectKey := object.Key("Priority")
3080		objectKey.Integer(*v.Priority)
3081	}
3082
3083	if v.Tags != nil {
3084		objectKey := object.Key("Tags")
3085		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
3086			return err
3087		}
3088	}
3089
3090	return nil
3091}
3092
3093func awsAwsquery_serializeOpDocumentCreateTargetGroupInput(v *CreateTargetGroupInput, value query.Value) error {
3094	object := value.Object()
3095	_ = object
3096
3097	if v.HealthCheckEnabled != nil {
3098		objectKey := object.Key("HealthCheckEnabled")
3099		objectKey.Boolean(*v.HealthCheckEnabled)
3100	}
3101
3102	if v.HealthCheckIntervalSeconds != nil {
3103		objectKey := object.Key("HealthCheckIntervalSeconds")
3104		objectKey.Integer(*v.HealthCheckIntervalSeconds)
3105	}
3106
3107	if v.HealthCheckPath != nil {
3108		objectKey := object.Key("HealthCheckPath")
3109		objectKey.String(*v.HealthCheckPath)
3110	}
3111
3112	if v.HealthCheckPort != nil {
3113		objectKey := object.Key("HealthCheckPort")
3114		objectKey.String(*v.HealthCheckPort)
3115	}
3116
3117	if len(v.HealthCheckProtocol) > 0 {
3118		objectKey := object.Key("HealthCheckProtocol")
3119		objectKey.String(string(v.HealthCheckProtocol))
3120	}
3121
3122	if v.HealthCheckTimeoutSeconds != nil {
3123		objectKey := object.Key("HealthCheckTimeoutSeconds")
3124		objectKey.Integer(*v.HealthCheckTimeoutSeconds)
3125	}
3126
3127	if v.HealthyThresholdCount != nil {
3128		objectKey := object.Key("HealthyThresholdCount")
3129		objectKey.Integer(*v.HealthyThresholdCount)
3130	}
3131
3132	if v.Matcher != nil {
3133		objectKey := object.Key("Matcher")
3134		if err := awsAwsquery_serializeDocumentMatcher(v.Matcher, objectKey); err != nil {
3135			return err
3136		}
3137	}
3138
3139	if v.Name != nil {
3140		objectKey := object.Key("Name")
3141		objectKey.String(*v.Name)
3142	}
3143
3144	if v.Port != nil {
3145		objectKey := object.Key("Port")
3146		objectKey.Integer(*v.Port)
3147	}
3148
3149	if len(v.Protocol) > 0 {
3150		objectKey := object.Key("Protocol")
3151		objectKey.String(string(v.Protocol))
3152	}
3153
3154	if v.ProtocolVersion != nil {
3155		objectKey := object.Key("ProtocolVersion")
3156		objectKey.String(*v.ProtocolVersion)
3157	}
3158
3159	if v.Tags != nil {
3160		objectKey := object.Key("Tags")
3161		if err := awsAwsquery_serializeDocumentTagList(v.Tags, objectKey); err != nil {
3162			return err
3163		}
3164	}
3165
3166	if len(v.TargetType) > 0 {
3167		objectKey := object.Key("TargetType")
3168		objectKey.String(string(v.TargetType))
3169	}
3170
3171	if v.UnhealthyThresholdCount != nil {
3172		objectKey := object.Key("UnhealthyThresholdCount")
3173		objectKey.Integer(*v.UnhealthyThresholdCount)
3174	}
3175
3176	if v.VpcId != nil {
3177		objectKey := object.Key("VpcId")
3178		objectKey.String(*v.VpcId)
3179	}
3180
3181	return nil
3182}
3183
3184func awsAwsquery_serializeOpDocumentDeleteListenerInput(v *DeleteListenerInput, value query.Value) error {
3185	object := value.Object()
3186	_ = object
3187
3188	if v.ListenerArn != nil {
3189		objectKey := object.Key("ListenerArn")
3190		objectKey.String(*v.ListenerArn)
3191	}
3192
3193	return nil
3194}
3195
3196func awsAwsquery_serializeOpDocumentDeleteLoadBalancerInput(v *DeleteLoadBalancerInput, value query.Value) error {
3197	object := value.Object()
3198	_ = object
3199
3200	if v.LoadBalancerArn != nil {
3201		objectKey := object.Key("LoadBalancerArn")
3202		objectKey.String(*v.LoadBalancerArn)
3203	}
3204
3205	return nil
3206}
3207
3208func awsAwsquery_serializeOpDocumentDeleteRuleInput(v *DeleteRuleInput, value query.Value) error {
3209	object := value.Object()
3210	_ = object
3211
3212	if v.RuleArn != nil {
3213		objectKey := object.Key("RuleArn")
3214		objectKey.String(*v.RuleArn)
3215	}
3216
3217	return nil
3218}
3219
3220func awsAwsquery_serializeOpDocumentDeleteTargetGroupInput(v *DeleteTargetGroupInput, value query.Value) error {
3221	object := value.Object()
3222	_ = object
3223
3224	if v.TargetGroupArn != nil {
3225		objectKey := object.Key("TargetGroupArn")
3226		objectKey.String(*v.TargetGroupArn)
3227	}
3228
3229	return nil
3230}
3231
3232func awsAwsquery_serializeOpDocumentDeregisterTargetsInput(v *DeregisterTargetsInput, value query.Value) error {
3233	object := value.Object()
3234	_ = object
3235
3236	if v.TargetGroupArn != nil {
3237		objectKey := object.Key("TargetGroupArn")
3238		objectKey.String(*v.TargetGroupArn)
3239	}
3240
3241	if v.Targets != nil {
3242		objectKey := object.Key("Targets")
3243		if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil {
3244			return err
3245		}
3246	}
3247
3248	return nil
3249}
3250
3251func awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(v *DescribeAccountLimitsInput, value query.Value) error {
3252	object := value.Object()
3253	_ = object
3254
3255	if v.Marker != nil {
3256		objectKey := object.Key("Marker")
3257		objectKey.String(*v.Marker)
3258	}
3259
3260	if v.PageSize != nil {
3261		objectKey := object.Key("PageSize")
3262		objectKey.Integer(*v.PageSize)
3263	}
3264
3265	return nil
3266}
3267
3268func awsAwsquery_serializeOpDocumentDescribeListenerCertificatesInput(v *DescribeListenerCertificatesInput, value query.Value) error {
3269	object := value.Object()
3270	_ = object
3271
3272	if v.ListenerArn != nil {
3273		objectKey := object.Key("ListenerArn")
3274		objectKey.String(*v.ListenerArn)
3275	}
3276
3277	if v.Marker != nil {
3278		objectKey := object.Key("Marker")
3279		objectKey.String(*v.Marker)
3280	}
3281
3282	if v.PageSize != nil {
3283		objectKey := object.Key("PageSize")
3284		objectKey.Integer(*v.PageSize)
3285	}
3286
3287	return nil
3288}
3289
3290func awsAwsquery_serializeOpDocumentDescribeListenersInput(v *DescribeListenersInput, value query.Value) error {
3291	object := value.Object()
3292	_ = object
3293
3294	if v.ListenerArns != nil {
3295		objectKey := object.Key("ListenerArns")
3296		if err := awsAwsquery_serializeDocumentListenerArns(v.ListenerArns, objectKey); err != nil {
3297			return err
3298		}
3299	}
3300
3301	if v.LoadBalancerArn != nil {
3302		objectKey := object.Key("LoadBalancerArn")
3303		objectKey.String(*v.LoadBalancerArn)
3304	}
3305
3306	if v.Marker != nil {
3307		objectKey := object.Key("Marker")
3308		objectKey.String(*v.Marker)
3309	}
3310
3311	if v.PageSize != nil {
3312		objectKey := object.Key("PageSize")
3313		objectKey.Integer(*v.PageSize)
3314	}
3315
3316	return nil
3317}
3318
3319func awsAwsquery_serializeOpDocumentDescribeLoadBalancerAttributesInput(v *DescribeLoadBalancerAttributesInput, value query.Value) error {
3320	object := value.Object()
3321	_ = object
3322
3323	if v.LoadBalancerArn != nil {
3324		objectKey := object.Key("LoadBalancerArn")
3325		objectKey.String(*v.LoadBalancerArn)
3326	}
3327
3328	return nil
3329}
3330
3331func awsAwsquery_serializeOpDocumentDescribeLoadBalancersInput(v *DescribeLoadBalancersInput, value query.Value) error {
3332	object := value.Object()
3333	_ = object
3334
3335	if v.LoadBalancerArns != nil {
3336		objectKey := object.Key("LoadBalancerArns")
3337		if err := awsAwsquery_serializeDocumentLoadBalancerArns(v.LoadBalancerArns, objectKey); err != nil {
3338			return err
3339		}
3340	}
3341
3342	if v.Marker != nil {
3343		objectKey := object.Key("Marker")
3344		objectKey.String(*v.Marker)
3345	}
3346
3347	if v.Names != nil {
3348		objectKey := object.Key("Names")
3349		if err := awsAwsquery_serializeDocumentLoadBalancerNames(v.Names, objectKey); err != nil {
3350			return err
3351		}
3352	}
3353
3354	if v.PageSize != nil {
3355		objectKey := object.Key("PageSize")
3356		objectKey.Integer(*v.PageSize)
3357	}
3358
3359	return nil
3360}
3361
3362func awsAwsquery_serializeOpDocumentDescribeRulesInput(v *DescribeRulesInput, value query.Value) error {
3363	object := value.Object()
3364	_ = object
3365
3366	if v.ListenerArn != nil {
3367		objectKey := object.Key("ListenerArn")
3368		objectKey.String(*v.ListenerArn)
3369	}
3370
3371	if v.Marker != nil {
3372		objectKey := object.Key("Marker")
3373		objectKey.String(*v.Marker)
3374	}
3375
3376	if v.PageSize != nil {
3377		objectKey := object.Key("PageSize")
3378		objectKey.Integer(*v.PageSize)
3379	}
3380
3381	if v.RuleArns != nil {
3382		objectKey := object.Key("RuleArns")
3383		if err := awsAwsquery_serializeDocumentRuleArns(v.RuleArns, objectKey); err != nil {
3384			return err
3385		}
3386	}
3387
3388	return nil
3389}
3390
3391func awsAwsquery_serializeOpDocumentDescribeSSLPoliciesInput(v *DescribeSSLPoliciesInput, value query.Value) error {
3392	object := value.Object()
3393	_ = object
3394
3395	if v.Marker != nil {
3396		objectKey := object.Key("Marker")
3397		objectKey.String(*v.Marker)
3398	}
3399
3400	if v.Names != nil {
3401		objectKey := object.Key("Names")
3402		if err := awsAwsquery_serializeDocumentSslPolicyNames(v.Names, objectKey); err != nil {
3403			return err
3404		}
3405	}
3406
3407	if v.PageSize != nil {
3408		objectKey := object.Key("PageSize")
3409		objectKey.Integer(*v.PageSize)
3410	}
3411
3412	return nil
3413}
3414
3415func awsAwsquery_serializeOpDocumentDescribeTagsInput(v *DescribeTagsInput, value query.Value) error {
3416	object := value.Object()
3417	_ = object
3418
3419	if v.ResourceArns != nil {
3420		objectKey := object.Key("ResourceArns")
3421		if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil {
3422			return err
3423		}
3424	}
3425
3426	return nil
3427}
3428
3429func awsAwsquery_serializeOpDocumentDescribeTargetGroupAttributesInput(v *DescribeTargetGroupAttributesInput, value query.Value) error {
3430	object := value.Object()
3431	_ = object
3432
3433	if v.TargetGroupArn != nil {
3434		objectKey := object.Key("TargetGroupArn")
3435		objectKey.String(*v.TargetGroupArn)
3436	}
3437
3438	return nil
3439}
3440
3441func awsAwsquery_serializeOpDocumentDescribeTargetGroupsInput(v *DescribeTargetGroupsInput, value query.Value) error {
3442	object := value.Object()
3443	_ = object
3444
3445	if v.LoadBalancerArn != nil {
3446		objectKey := object.Key("LoadBalancerArn")
3447		objectKey.String(*v.LoadBalancerArn)
3448	}
3449
3450	if v.Marker != nil {
3451		objectKey := object.Key("Marker")
3452		objectKey.String(*v.Marker)
3453	}
3454
3455	if v.Names != nil {
3456		objectKey := object.Key("Names")
3457		if err := awsAwsquery_serializeDocumentTargetGroupNames(v.Names, objectKey); err != nil {
3458			return err
3459		}
3460	}
3461
3462	if v.PageSize != nil {
3463		objectKey := object.Key("PageSize")
3464		objectKey.Integer(*v.PageSize)
3465	}
3466
3467	if v.TargetGroupArns != nil {
3468		objectKey := object.Key("TargetGroupArns")
3469		if err := awsAwsquery_serializeDocumentTargetGroupArns(v.TargetGroupArns, objectKey); err != nil {
3470			return err
3471		}
3472	}
3473
3474	return nil
3475}
3476
3477func awsAwsquery_serializeOpDocumentDescribeTargetHealthInput(v *DescribeTargetHealthInput, value query.Value) error {
3478	object := value.Object()
3479	_ = object
3480
3481	if v.TargetGroupArn != nil {
3482		objectKey := object.Key("TargetGroupArn")
3483		objectKey.String(*v.TargetGroupArn)
3484	}
3485
3486	if v.Targets != nil {
3487		objectKey := object.Key("Targets")
3488		if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil {
3489			return err
3490		}
3491	}
3492
3493	return nil
3494}
3495
3496func awsAwsquery_serializeOpDocumentModifyListenerInput(v *ModifyListenerInput, value query.Value) error {
3497	object := value.Object()
3498	_ = object
3499
3500	if v.AlpnPolicy != nil {
3501		objectKey := object.Key("AlpnPolicy")
3502		if err := awsAwsquery_serializeDocumentAlpnPolicyName(v.AlpnPolicy, objectKey); err != nil {
3503			return err
3504		}
3505	}
3506
3507	if v.Certificates != nil {
3508		objectKey := object.Key("Certificates")
3509		if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil {
3510			return err
3511		}
3512	}
3513
3514	if v.DefaultActions != nil {
3515		objectKey := object.Key("DefaultActions")
3516		if err := awsAwsquery_serializeDocumentActions(v.DefaultActions, objectKey); err != nil {
3517			return err
3518		}
3519	}
3520
3521	if v.ListenerArn != nil {
3522		objectKey := object.Key("ListenerArn")
3523		objectKey.String(*v.ListenerArn)
3524	}
3525
3526	if v.Port != nil {
3527		objectKey := object.Key("Port")
3528		objectKey.Integer(*v.Port)
3529	}
3530
3531	if len(v.Protocol) > 0 {
3532		objectKey := object.Key("Protocol")
3533		objectKey.String(string(v.Protocol))
3534	}
3535
3536	if v.SslPolicy != nil {
3537		objectKey := object.Key("SslPolicy")
3538		objectKey.String(*v.SslPolicy)
3539	}
3540
3541	return nil
3542}
3543
3544func awsAwsquery_serializeOpDocumentModifyLoadBalancerAttributesInput(v *ModifyLoadBalancerAttributesInput, value query.Value) error {
3545	object := value.Object()
3546	_ = object
3547
3548	if v.Attributes != nil {
3549		objectKey := object.Key("Attributes")
3550		if err := awsAwsquery_serializeDocumentLoadBalancerAttributes(v.Attributes, objectKey); err != nil {
3551			return err
3552		}
3553	}
3554
3555	if v.LoadBalancerArn != nil {
3556		objectKey := object.Key("LoadBalancerArn")
3557		objectKey.String(*v.LoadBalancerArn)
3558	}
3559
3560	return nil
3561}
3562
3563func awsAwsquery_serializeOpDocumentModifyRuleInput(v *ModifyRuleInput, value query.Value) error {
3564	object := value.Object()
3565	_ = object
3566
3567	if v.Actions != nil {
3568		objectKey := object.Key("Actions")
3569		if err := awsAwsquery_serializeDocumentActions(v.Actions, objectKey); err != nil {
3570			return err
3571		}
3572	}
3573
3574	if v.Conditions != nil {
3575		objectKey := object.Key("Conditions")
3576		if err := awsAwsquery_serializeDocumentRuleConditionList(v.Conditions, objectKey); err != nil {
3577			return err
3578		}
3579	}
3580
3581	if v.RuleArn != nil {
3582		objectKey := object.Key("RuleArn")
3583		objectKey.String(*v.RuleArn)
3584	}
3585
3586	return nil
3587}
3588
3589func awsAwsquery_serializeOpDocumentModifyTargetGroupAttributesInput(v *ModifyTargetGroupAttributesInput, value query.Value) error {
3590	object := value.Object()
3591	_ = object
3592
3593	if v.Attributes != nil {
3594		objectKey := object.Key("Attributes")
3595		if err := awsAwsquery_serializeDocumentTargetGroupAttributes(v.Attributes, objectKey); err != nil {
3596			return err
3597		}
3598	}
3599
3600	if v.TargetGroupArn != nil {
3601		objectKey := object.Key("TargetGroupArn")
3602		objectKey.String(*v.TargetGroupArn)
3603	}
3604
3605	return nil
3606}
3607
3608func awsAwsquery_serializeOpDocumentModifyTargetGroupInput(v *ModifyTargetGroupInput, value query.Value) error {
3609	object := value.Object()
3610	_ = object
3611
3612	if v.HealthCheckEnabled != nil {
3613		objectKey := object.Key("HealthCheckEnabled")
3614		objectKey.Boolean(*v.HealthCheckEnabled)
3615	}
3616
3617	if v.HealthCheckIntervalSeconds != nil {
3618		objectKey := object.Key("HealthCheckIntervalSeconds")
3619		objectKey.Integer(*v.HealthCheckIntervalSeconds)
3620	}
3621
3622	if v.HealthCheckPath != nil {
3623		objectKey := object.Key("HealthCheckPath")
3624		objectKey.String(*v.HealthCheckPath)
3625	}
3626
3627	if v.HealthCheckPort != nil {
3628		objectKey := object.Key("HealthCheckPort")
3629		objectKey.String(*v.HealthCheckPort)
3630	}
3631
3632	if len(v.HealthCheckProtocol) > 0 {
3633		objectKey := object.Key("HealthCheckProtocol")
3634		objectKey.String(string(v.HealthCheckProtocol))
3635	}
3636
3637	if v.HealthCheckTimeoutSeconds != nil {
3638		objectKey := object.Key("HealthCheckTimeoutSeconds")
3639		objectKey.Integer(*v.HealthCheckTimeoutSeconds)
3640	}
3641
3642	if v.HealthyThresholdCount != nil {
3643		objectKey := object.Key("HealthyThresholdCount")
3644		objectKey.Integer(*v.HealthyThresholdCount)
3645	}
3646
3647	if v.Matcher != nil {
3648		objectKey := object.Key("Matcher")
3649		if err := awsAwsquery_serializeDocumentMatcher(v.Matcher, objectKey); err != nil {
3650			return err
3651		}
3652	}
3653
3654	if v.TargetGroupArn != nil {
3655		objectKey := object.Key("TargetGroupArn")
3656		objectKey.String(*v.TargetGroupArn)
3657	}
3658
3659	if v.UnhealthyThresholdCount != nil {
3660		objectKey := object.Key("UnhealthyThresholdCount")
3661		objectKey.Integer(*v.UnhealthyThresholdCount)
3662	}
3663
3664	return nil
3665}
3666
3667func awsAwsquery_serializeOpDocumentRegisterTargetsInput(v *RegisterTargetsInput, value query.Value) error {
3668	object := value.Object()
3669	_ = object
3670
3671	if v.TargetGroupArn != nil {
3672		objectKey := object.Key("TargetGroupArn")
3673		objectKey.String(*v.TargetGroupArn)
3674	}
3675
3676	if v.Targets != nil {
3677		objectKey := object.Key("Targets")
3678		if err := awsAwsquery_serializeDocumentTargetDescriptions(v.Targets, objectKey); err != nil {
3679			return err
3680		}
3681	}
3682
3683	return nil
3684}
3685
3686func awsAwsquery_serializeOpDocumentRemoveListenerCertificatesInput(v *RemoveListenerCertificatesInput, value query.Value) error {
3687	object := value.Object()
3688	_ = object
3689
3690	if v.Certificates != nil {
3691		objectKey := object.Key("Certificates")
3692		if err := awsAwsquery_serializeDocumentCertificateList(v.Certificates, objectKey); err != nil {
3693			return err
3694		}
3695	}
3696
3697	if v.ListenerArn != nil {
3698		objectKey := object.Key("ListenerArn")
3699		objectKey.String(*v.ListenerArn)
3700	}
3701
3702	return nil
3703}
3704
3705func awsAwsquery_serializeOpDocumentRemoveTagsInput(v *RemoveTagsInput, value query.Value) error {
3706	object := value.Object()
3707	_ = object
3708
3709	if v.ResourceArns != nil {
3710		objectKey := object.Key("ResourceArns")
3711		if err := awsAwsquery_serializeDocumentResourceArns(v.ResourceArns, objectKey); err != nil {
3712			return err
3713		}
3714	}
3715
3716	if v.TagKeys != nil {
3717		objectKey := object.Key("TagKeys")
3718		if err := awsAwsquery_serializeDocumentTagKeys(v.TagKeys, objectKey); err != nil {
3719			return err
3720		}
3721	}
3722
3723	return nil
3724}
3725
3726func awsAwsquery_serializeOpDocumentSetIpAddressTypeInput(v *SetIpAddressTypeInput, value query.Value) error {
3727	object := value.Object()
3728	_ = object
3729
3730	if len(v.IpAddressType) > 0 {
3731		objectKey := object.Key("IpAddressType")
3732		objectKey.String(string(v.IpAddressType))
3733	}
3734
3735	if v.LoadBalancerArn != nil {
3736		objectKey := object.Key("LoadBalancerArn")
3737		objectKey.String(*v.LoadBalancerArn)
3738	}
3739
3740	return nil
3741}
3742
3743func awsAwsquery_serializeOpDocumentSetRulePrioritiesInput(v *SetRulePrioritiesInput, value query.Value) error {
3744	object := value.Object()
3745	_ = object
3746
3747	if v.RulePriorities != nil {
3748		objectKey := object.Key("RulePriorities")
3749		if err := awsAwsquery_serializeDocumentRulePriorityList(v.RulePriorities, objectKey); err != nil {
3750			return err
3751		}
3752	}
3753
3754	return nil
3755}
3756
3757func awsAwsquery_serializeOpDocumentSetSecurityGroupsInput(v *SetSecurityGroupsInput, value query.Value) error {
3758	object := value.Object()
3759	_ = object
3760
3761	if v.LoadBalancerArn != nil {
3762		objectKey := object.Key("LoadBalancerArn")
3763		objectKey.String(*v.LoadBalancerArn)
3764	}
3765
3766	if v.SecurityGroups != nil {
3767		objectKey := object.Key("SecurityGroups")
3768		if err := awsAwsquery_serializeDocumentSecurityGroups(v.SecurityGroups, objectKey); err != nil {
3769			return err
3770		}
3771	}
3772
3773	return nil
3774}
3775
3776func awsAwsquery_serializeOpDocumentSetSubnetsInput(v *SetSubnetsInput, value query.Value) error {
3777	object := value.Object()
3778	_ = object
3779
3780	if len(v.IpAddressType) > 0 {
3781		objectKey := object.Key("IpAddressType")
3782		objectKey.String(string(v.IpAddressType))
3783	}
3784
3785	if v.LoadBalancerArn != nil {
3786		objectKey := object.Key("LoadBalancerArn")
3787		objectKey.String(*v.LoadBalancerArn)
3788	}
3789
3790	if v.SubnetMappings != nil {
3791		objectKey := object.Key("SubnetMappings")
3792		if err := awsAwsquery_serializeDocumentSubnetMappings(v.SubnetMappings, objectKey); err != nil {
3793			return err
3794		}
3795	}
3796
3797	if v.Subnets != nil {
3798		objectKey := object.Key("Subnets")
3799		if err := awsAwsquery_serializeDocumentSubnets(v.Subnets, objectKey); err != nil {
3800			return err
3801		}
3802	}
3803
3804	return nil
3805}
3806