1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cloudformation
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/cloudformation/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_serializeOpActivateType struct {
19}
20
21func (*awsAwsquery_serializeOpActivateType) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsquery_serializeOpActivateType) 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.(*ActivateTypeInput)
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("ActivateType")
51	body.Key("Version").String("2010-05-15")
52
53	if err := awsAwsquery_serializeOpDocumentActivateTypeInput(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_serializeOpBatchDescribeTypeConfigurations struct {
75}
76
77func (*awsAwsquery_serializeOpBatchDescribeTypeConfigurations) ID() string {
78	return "OperationSerializer"
79}
80
81func (m *awsAwsquery_serializeOpBatchDescribeTypeConfigurations) 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.(*BatchDescribeTypeConfigurationsInput)
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("BatchDescribeTypeConfigurations")
107	body.Key("Version").String("2010-05-15")
108
109	if err := awsAwsquery_serializeOpDocumentBatchDescribeTypeConfigurationsInput(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_serializeOpCancelUpdateStack struct {
131}
132
133func (*awsAwsquery_serializeOpCancelUpdateStack) ID() string {
134	return "OperationSerializer"
135}
136
137func (m *awsAwsquery_serializeOpCancelUpdateStack) 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.(*CancelUpdateStackInput)
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("CancelUpdateStack")
163	body.Key("Version").String("2010-05-15")
164
165	if err := awsAwsquery_serializeOpDocumentCancelUpdateStackInput(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_serializeOpContinueUpdateRollback struct {
187}
188
189func (*awsAwsquery_serializeOpContinueUpdateRollback) ID() string {
190	return "OperationSerializer"
191}
192
193func (m *awsAwsquery_serializeOpContinueUpdateRollback) 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.(*ContinueUpdateRollbackInput)
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("ContinueUpdateRollback")
219	body.Key("Version").String("2010-05-15")
220
221	if err := awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(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_serializeOpCreateChangeSet struct {
243}
244
245func (*awsAwsquery_serializeOpCreateChangeSet) ID() string {
246	return "OperationSerializer"
247}
248
249func (m *awsAwsquery_serializeOpCreateChangeSet) 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.(*CreateChangeSetInput)
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("CreateChangeSet")
275	body.Key("Version").String("2010-05-15")
276
277	if err := awsAwsquery_serializeOpDocumentCreateChangeSetInput(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_serializeOpCreateStack struct {
299}
300
301func (*awsAwsquery_serializeOpCreateStack) ID() string {
302	return "OperationSerializer"
303}
304
305func (m *awsAwsquery_serializeOpCreateStack) 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.(*CreateStackInput)
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("CreateStack")
331	body.Key("Version").String("2010-05-15")
332
333	if err := awsAwsquery_serializeOpDocumentCreateStackInput(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_serializeOpCreateStackInstances struct {
355}
356
357func (*awsAwsquery_serializeOpCreateStackInstances) ID() string {
358	return "OperationSerializer"
359}
360
361func (m *awsAwsquery_serializeOpCreateStackInstances) 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.(*CreateStackInstancesInput)
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("CreateStackInstances")
387	body.Key("Version").String("2010-05-15")
388
389	if err := awsAwsquery_serializeOpDocumentCreateStackInstancesInput(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_serializeOpCreateStackSet struct {
411}
412
413func (*awsAwsquery_serializeOpCreateStackSet) ID() string {
414	return "OperationSerializer"
415}
416
417func (m *awsAwsquery_serializeOpCreateStackSet) 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.(*CreateStackSetInput)
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("CreateStackSet")
443	body.Key("Version").String("2010-05-15")
444
445	if err := awsAwsquery_serializeOpDocumentCreateStackSetInput(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_serializeOpDeactivateType struct {
467}
468
469func (*awsAwsquery_serializeOpDeactivateType) ID() string {
470	return "OperationSerializer"
471}
472
473func (m *awsAwsquery_serializeOpDeactivateType) 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.(*DeactivateTypeInput)
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("DeactivateType")
499	body.Key("Version").String("2010-05-15")
500
501	if err := awsAwsquery_serializeOpDocumentDeactivateTypeInput(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_serializeOpDeleteChangeSet struct {
523}
524
525func (*awsAwsquery_serializeOpDeleteChangeSet) ID() string {
526	return "OperationSerializer"
527}
528
529func (m *awsAwsquery_serializeOpDeleteChangeSet) 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.(*DeleteChangeSetInput)
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("DeleteChangeSet")
555	body.Key("Version").String("2010-05-15")
556
557	if err := awsAwsquery_serializeOpDocumentDeleteChangeSetInput(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_serializeOpDeleteStack struct {
579}
580
581func (*awsAwsquery_serializeOpDeleteStack) ID() string {
582	return "OperationSerializer"
583}
584
585func (m *awsAwsquery_serializeOpDeleteStack) 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.(*DeleteStackInput)
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("DeleteStack")
611	body.Key("Version").String("2010-05-15")
612
613	if err := awsAwsquery_serializeOpDocumentDeleteStackInput(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_serializeOpDeleteStackInstances struct {
635}
636
637func (*awsAwsquery_serializeOpDeleteStackInstances) ID() string {
638	return "OperationSerializer"
639}
640
641func (m *awsAwsquery_serializeOpDeleteStackInstances) 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.(*DeleteStackInstancesInput)
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("DeleteStackInstances")
667	body.Key("Version").String("2010-05-15")
668
669	if err := awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(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_serializeOpDeleteStackSet struct {
691}
692
693func (*awsAwsquery_serializeOpDeleteStackSet) ID() string {
694	return "OperationSerializer"
695}
696
697func (m *awsAwsquery_serializeOpDeleteStackSet) 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.(*DeleteStackSetInput)
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("DeleteStackSet")
723	body.Key("Version").String("2010-05-15")
724
725	if err := awsAwsquery_serializeOpDocumentDeleteStackSetInput(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_serializeOpDeregisterType struct {
747}
748
749func (*awsAwsquery_serializeOpDeregisterType) ID() string {
750	return "OperationSerializer"
751}
752
753func (m *awsAwsquery_serializeOpDeregisterType) 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.(*DeregisterTypeInput)
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("DeregisterType")
779	body.Key("Version").String("2010-05-15")
780
781	if err := awsAwsquery_serializeOpDocumentDeregisterTypeInput(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_serializeOpDescribeAccountLimits struct {
803}
804
805func (*awsAwsquery_serializeOpDescribeAccountLimits) ID() string {
806	return "OperationSerializer"
807}
808
809func (m *awsAwsquery_serializeOpDescribeAccountLimits) 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.(*DescribeAccountLimitsInput)
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("DescribeAccountLimits")
835	body.Key("Version").String("2010-05-15")
836
837	if err := awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(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_serializeOpDescribeChangeSet struct {
859}
860
861func (*awsAwsquery_serializeOpDescribeChangeSet) ID() string {
862	return "OperationSerializer"
863}
864
865func (m *awsAwsquery_serializeOpDescribeChangeSet) 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.(*DescribeChangeSetInput)
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("DescribeChangeSet")
891	body.Key("Version").String("2010-05-15")
892
893	if err := awsAwsquery_serializeOpDocumentDescribeChangeSetInput(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_serializeOpDescribePublisher struct {
915}
916
917func (*awsAwsquery_serializeOpDescribePublisher) ID() string {
918	return "OperationSerializer"
919}
920
921func (m *awsAwsquery_serializeOpDescribePublisher) 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.(*DescribePublisherInput)
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("DescribePublisher")
947	body.Key("Version").String("2010-05-15")
948
949	if err := awsAwsquery_serializeOpDocumentDescribePublisherInput(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_serializeOpDescribeStackDriftDetectionStatus struct {
971}
972
973func (*awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) ID() string {
974	return "OperationSerializer"
975}
976
977func (m *awsAwsquery_serializeOpDescribeStackDriftDetectionStatus) 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.(*DescribeStackDriftDetectionStatusInput)
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("DescribeStackDriftDetectionStatus")
1003	body.Key("Version").String("2010-05-15")
1004
1005	if err := awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(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_serializeOpDescribeStackEvents struct {
1027}
1028
1029func (*awsAwsquery_serializeOpDescribeStackEvents) ID() string {
1030	return "OperationSerializer"
1031}
1032
1033func (m *awsAwsquery_serializeOpDescribeStackEvents) 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.(*DescribeStackEventsInput)
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("DescribeStackEvents")
1059	body.Key("Version").String("2010-05-15")
1060
1061	if err := awsAwsquery_serializeOpDocumentDescribeStackEventsInput(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_serializeOpDescribeStackInstance struct {
1083}
1084
1085func (*awsAwsquery_serializeOpDescribeStackInstance) ID() string {
1086	return "OperationSerializer"
1087}
1088
1089func (m *awsAwsquery_serializeOpDescribeStackInstance) 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.(*DescribeStackInstanceInput)
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("DescribeStackInstance")
1115	body.Key("Version").String("2010-05-15")
1116
1117	if err := awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(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_serializeOpDescribeStackResource struct {
1139}
1140
1141func (*awsAwsquery_serializeOpDescribeStackResource) ID() string {
1142	return "OperationSerializer"
1143}
1144
1145func (m *awsAwsquery_serializeOpDescribeStackResource) 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.(*DescribeStackResourceInput)
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("DescribeStackResource")
1171	body.Key("Version").String("2010-05-15")
1172
1173	if err := awsAwsquery_serializeOpDocumentDescribeStackResourceInput(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_serializeOpDescribeStackResourceDrifts struct {
1195}
1196
1197func (*awsAwsquery_serializeOpDescribeStackResourceDrifts) ID() string {
1198	return "OperationSerializer"
1199}
1200
1201func (m *awsAwsquery_serializeOpDescribeStackResourceDrifts) 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.(*DescribeStackResourceDriftsInput)
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("DescribeStackResourceDrifts")
1227	body.Key("Version").String("2010-05-15")
1228
1229	if err := awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(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_serializeOpDescribeStackResources struct {
1251}
1252
1253func (*awsAwsquery_serializeOpDescribeStackResources) ID() string {
1254	return "OperationSerializer"
1255}
1256
1257func (m *awsAwsquery_serializeOpDescribeStackResources) 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.(*DescribeStackResourcesInput)
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("DescribeStackResources")
1283	body.Key("Version").String("2010-05-15")
1284
1285	if err := awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(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_serializeOpDescribeStacks struct {
1307}
1308
1309func (*awsAwsquery_serializeOpDescribeStacks) ID() string {
1310	return "OperationSerializer"
1311}
1312
1313func (m *awsAwsquery_serializeOpDescribeStacks) 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.(*DescribeStacksInput)
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("DescribeStacks")
1339	body.Key("Version").String("2010-05-15")
1340
1341	if err := awsAwsquery_serializeOpDocumentDescribeStacksInput(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_serializeOpDescribeStackSet struct {
1363}
1364
1365func (*awsAwsquery_serializeOpDescribeStackSet) ID() string {
1366	return "OperationSerializer"
1367}
1368
1369func (m *awsAwsquery_serializeOpDescribeStackSet) 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.(*DescribeStackSetInput)
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("DescribeStackSet")
1395	body.Key("Version").String("2010-05-15")
1396
1397	if err := awsAwsquery_serializeOpDocumentDescribeStackSetInput(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_serializeOpDescribeStackSetOperation struct {
1419}
1420
1421func (*awsAwsquery_serializeOpDescribeStackSetOperation) ID() string {
1422	return "OperationSerializer"
1423}
1424
1425func (m *awsAwsquery_serializeOpDescribeStackSetOperation) 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.(*DescribeStackSetOperationInput)
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("DescribeStackSetOperation")
1451	body.Key("Version").String("2010-05-15")
1452
1453	if err := awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(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_serializeOpDescribeType struct {
1475}
1476
1477func (*awsAwsquery_serializeOpDescribeType) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsquery_serializeOpDescribeType) 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.(*DescribeTypeInput)
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("DescribeType")
1507	body.Key("Version").String("2010-05-15")
1508
1509	if err := awsAwsquery_serializeOpDocumentDescribeTypeInput(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_serializeOpDescribeTypeRegistration struct {
1531}
1532
1533func (*awsAwsquery_serializeOpDescribeTypeRegistration) ID() string {
1534	return "OperationSerializer"
1535}
1536
1537func (m *awsAwsquery_serializeOpDescribeTypeRegistration) 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.(*DescribeTypeRegistrationInput)
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("DescribeTypeRegistration")
1563	body.Key("Version").String("2010-05-15")
1564
1565	if err := awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(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_serializeOpDetectStackDrift struct {
1587}
1588
1589func (*awsAwsquery_serializeOpDetectStackDrift) ID() string {
1590	return "OperationSerializer"
1591}
1592
1593func (m *awsAwsquery_serializeOpDetectStackDrift) 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.(*DetectStackDriftInput)
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("DetectStackDrift")
1619	body.Key("Version").String("2010-05-15")
1620
1621	if err := awsAwsquery_serializeOpDocumentDetectStackDriftInput(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_serializeOpDetectStackResourceDrift struct {
1643}
1644
1645func (*awsAwsquery_serializeOpDetectStackResourceDrift) ID() string {
1646	return "OperationSerializer"
1647}
1648
1649func (m *awsAwsquery_serializeOpDetectStackResourceDrift) 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.(*DetectStackResourceDriftInput)
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("DetectStackResourceDrift")
1675	body.Key("Version").String("2010-05-15")
1676
1677	if err := awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(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_serializeOpDetectStackSetDrift struct {
1699}
1700
1701func (*awsAwsquery_serializeOpDetectStackSetDrift) ID() string {
1702	return "OperationSerializer"
1703}
1704
1705func (m *awsAwsquery_serializeOpDetectStackSetDrift) 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.(*DetectStackSetDriftInput)
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("DetectStackSetDrift")
1731	body.Key("Version").String("2010-05-15")
1732
1733	if err := awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(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_serializeOpEstimateTemplateCost struct {
1755}
1756
1757func (*awsAwsquery_serializeOpEstimateTemplateCost) ID() string {
1758	return "OperationSerializer"
1759}
1760
1761func (m *awsAwsquery_serializeOpEstimateTemplateCost) 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.(*EstimateTemplateCostInput)
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("EstimateTemplateCost")
1787	body.Key("Version").String("2010-05-15")
1788
1789	if err := awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(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_serializeOpExecuteChangeSet struct {
1811}
1812
1813func (*awsAwsquery_serializeOpExecuteChangeSet) ID() string {
1814	return "OperationSerializer"
1815}
1816
1817func (m *awsAwsquery_serializeOpExecuteChangeSet) 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.(*ExecuteChangeSetInput)
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("ExecuteChangeSet")
1843	body.Key("Version").String("2010-05-15")
1844
1845	if err := awsAwsquery_serializeOpDocumentExecuteChangeSetInput(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_serializeOpGetStackPolicy struct {
1867}
1868
1869func (*awsAwsquery_serializeOpGetStackPolicy) ID() string {
1870	return "OperationSerializer"
1871}
1872
1873func (m *awsAwsquery_serializeOpGetStackPolicy) 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.(*GetStackPolicyInput)
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("GetStackPolicy")
1899	body.Key("Version").String("2010-05-15")
1900
1901	if err := awsAwsquery_serializeOpDocumentGetStackPolicyInput(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}
1921
1922type awsAwsquery_serializeOpGetTemplate struct {
1923}
1924
1925func (*awsAwsquery_serializeOpGetTemplate) ID() string {
1926	return "OperationSerializer"
1927}
1928
1929func (m *awsAwsquery_serializeOpGetTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1930	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1931) {
1932	request, ok := in.Request.(*smithyhttp.Request)
1933	if !ok {
1934		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1935	}
1936
1937	input, ok := in.Parameters.(*GetTemplateInput)
1938	_ = input
1939	if !ok {
1940		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1941	}
1942
1943	request.Request.URL.Path = "/"
1944	request.Request.Method = "POST"
1945	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1946	if err != nil {
1947		return out, metadata, &smithy.SerializationError{Err: err}
1948	}
1949	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
1950
1951	bodyWriter := bytes.NewBuffer(nil)
1952	bodyEncoder := query.NewEncoder(bodyWriter)
1953	body := bodyEncoder.Object()
1954	body.Key("Action").String("GetTemplate")
1955	body.Key("Version").String("2010-05-15")
1956
1957	if err := awsAwsquery_serializeOpDocumentGetTemplateInput(input, bodyEncoder.Value); err != nil {
1958		return out, metadata, &smithy.SerializationError{Err: err}
1959	}
1960
1961	err = bodyEncoder.Encode()
1962	if err != nil {
1963		return out, metadata, &smithy.SerializationError{Err: err}
1964	}
1965
1966	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
1967		return out, metadata, &smithy.SerializationError{Err: err}
1968	}
1969
1970	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1971		return out, metadata, &smithy.SerializationError{Err: err}
1972	}
1973	in.Request = request
1974
1975	return next.HandleSerialize(ctx, in)
1976}
1977
1978type awsAwsquery_serializeOpGetTemplateSummary struct {
1979}
1980
1981func (*awsAwsquery_serializeOpGetTemplateSummary) ID() string {
1982	return "OperationSerializer"
1983}
1984
1985func (m *awsAwsquery_serializeOpGetTemplateSummary) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1986	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1987) {
1988	request, ok := in.Request.(*smithyhttp.Request)
1989	if !ok {
1990		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1991	}
1992
1993	input, ok := in.Parameters.(*GetTemplateSummaryInput)
1994	_ = input
1995	if !ok {
1996		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1997	}
1998
1999	request.Request.URL.Path = "/"
2000	request.Request.Method = "POST"
2001	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2002	if err != nil {
2003		return out, metadata, &smithy.SerializationError{Err: err}
2004	}
2005	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2006
2007	bodyWriter := bytes.NewBuffer(nil)
2008	bodyEncoder := query.NewEncoder(bodyWriter)
2009	body := bodyEncoder.Object()
2010	body.Key("Action").String("GetTemplateSummary")
2011	body.Key("Version").String("2010-05-15")
2012
2013	if err := awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(input, bodyEncoder.Value); err != nil {
2014		return out, metadata, &smithy.SerializationError{Err: err}
2015	}
2016
2017	err = bodyEncoder.Encode()
2018	if err != nil {
2019		return out, metadata, &smithy.SerializationError{Err: err}
2020	}
2021
2022	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2023		return out, metadata, &smithy.SerializationError{Err: err}
2024	}
2025
2026	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2027		return out, metadata, &smithy.SerializationError{Err: err}
2028	}
2029	in.Request = request
2030
2031	return next.HandleSerialize(ctx, in)
2032}
2033
2034type awsAwsquery_serializeOpImportStacksToStackSet struct {
2035}
2036
2037func (*awsAwsquery_serializeOpImportStacksToStackSet) ID() string {
2038	return "OperationSerializer"
2039}
2040
2041func (m *awsAwsquery_serializeOpImportStacksToStackSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2042	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2043) {
2044	request, ok := in.Request.(*smithyhttp.Request)
2045	if !ok {
2046		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2047	}
2048
2049	input, ok := in.Parameters.(*ImportStacksToStackSetInput)
2050	_ = input
2051	if !ok {
2052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2053	}
2054
2055	request.Request.URL.Path = "/"
2056	request.Request.Method = "POST"
2057	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2058	if err != nil {
2059		return out, metadata, &smithy.SerializationError{Err: err}
2060	}
2061	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2062
2063	bodyWriter := bytes.NewBuffer(nil)
2064	bodyEncoder := query.NewEncoder(bodyWriter)
2065	body := bodyEncoder.Object()
2066	body.Key("Action").String("ImportStacksToStackSet")
2067	body.Key("Version").String("2010-05-15")
2068
2069	if err := awsAwsquery_serializeOpDocumentImportStacksToStackSetInput(input, bodyEncoder.Value); err != nil {
2070		return out, metadata, &smithy.SerializationError{Err: err}
2071	}
2072
2073	err = bodyEncoder.Encode()
2074	if err != nil {
2075		return out, metadata, &smithy.SerializationError{Err: err}
2076	}
2077
2078	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2079		return out, metadata, &smithy.SerializationError{Err: err}
2080	}
2081
2082	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2083		return out, metadata, &smithy.SerializationError{Err: err}
2084	}
2085	in.Request = request
2086
2087	return next.HandleSerialize(ctx, in)
2088}
2089
2090type awsAwsquery_serializeOpListChangeSets struct {
2091}
2092
2093func (*awsAwsquery_serializeOpListChangeSets) ID() string {
2094	return "OperationSerializer"
2095}
2096
2097func (m *awsAwsquery_serializeOpListChangeSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2098	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2099) {
2100	request, ok := in.Request.(*smithyhttp.Request)
2101	if !ok {
2102		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2103	}
2104
2105	input, ok := in.Parameters.(*ListChangeSetsInput)
2106	_ = input
2107	if !ok {
2108		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2109	}
2110
2111	request.Request.URL.Path = "/"
2112	request.Request.Method = "POST"
2113	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2114	if err != nil {
2115		return out, metadata, &smithy.SerializationError{Err: err}
2116	}
2117	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2118
2119	bodyWriter := bytes.NewBuffer(nil)
2120	bodyEncoder := query.NewEncoder(bodyWriter)
2121	body := bodyEncoder.Object()
2122	body.Key("Action").String("ListChangeSets")
2123	body.Key("Version").String("2010-05-15")
2124
2125	if err := awsAwsquery_serializeOpDocumentListChangeSetsInput(input, bodyEncoder.Value); err != nil {
2126		return out, metadata, &smithy.SerializationError{Err: err}
2127	}
2128
2129	err = bodyEncoder.Encode()
2130	if err != nil {
2131		return out, metadata, &smithy.SerializationError{Err: err}
2132	}
2133
2134	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2135		return out, metadata, &smithy.SerializationError{Err: err}
2136	}
2137
2138	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2139		return out, metadata, &smithy.SerializationError{Err: err}
2140	}
2141	in.Request = request
2142
2143	return next.HandleSerialize(ctx, in)
2144}
2145
2146type awsAwsquery_serializeOpListExports struct {
2147}
2148
2149func (*awsAwsquery_serializeOpListExports) ID() string {
2150	return "OperationSerializer"
2151}
2152
2153func (m *awsAwsquery_serializeOpListExports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2154	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2155) {
2156	request, ok := in.Request.(*smithyhttp.Request)
2157	if !ok {
2158		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2159	}
2160
2161	input, ok := in.Parameters.(*ListExportsInput)
2162	_ = input
2163	if !ok {
2164		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2165	}
2166
2167	request.Request.URL.Path = "/"
2168	request.Request.Method = "POST"
2169	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2170	if err != nil {
2171		return out, metadata, &smithy.SerializationError{Err: err}
2172	}
2173	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2174
2175	bodyWriter := bytes.NewBuffer(nil)
2176	bodyEncoder := query.NewEncoder(bodyWriter)
2177	body := bodyEncoder.Object()
2178	body.Key("Action").String("ListExports")
2179	body.Key("Version").String("2010-05-15")
2180
2181	if err := awsAwsquery_serializeOpDocumentListExportsInput(input, bodyEncoder.Value); err != nil {
2182		return out, metadata, &smithy.SerializationError{Err: err}
2183	}
2184
2185	err = bodyEncoder.Encode()
2186	if err != nil {
2187		return out, metadata, &smithy.SerializationError{Err: err}
2188	}
2189
2190	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2191		return out, metadata, &smithy.SerializationError{Err: err}
2192	}
2193
2194	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2195		return out, metadata, &smithy.SerializationError{Err: err}
2196	}
2197	in.Request = request
2198
2199	return next.HandleSerialize(ctx, in)
2200}
2201
2202type awsAwsquery_serializeOpListImports struct {
2203}
2204
2205func (*awsAwsquery_serializeOpListImports) ID() string {
2206	return "OperationSerializer"
2207}
2208
2209func (m *awsAwsquery_serializeOpListImports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2210	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2211) {
2212	request, ok := in.Request.(*smithyhttp.Request)
2213	if !ok {
2214		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2215	}
2216
2217	input, ok := in.Parameters.(*ListImportsInput)
2218	_ = input
2219	if !ok {
2220		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2221	}
2222
2223	request.Request.URL.Path = "/"
2224	request.Request.Method = "POST"
2225	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2226	if err != nil {
2227		return out, metadata, &smithy.SerializationError{Err: err}
2228	}
2229	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2230
2231	bodyWriter := bytes.NewBuffer(nil)
2232	bodyEncoder := query.NewEncoder(bodyWriter)
2233	body := bodyEncoder.Object()
2234	body.Key("Action").String("ListImports")
2235	body.Key("Version").String("2010-05-15")
2236
2237	if err := awsAwsquery_serializeOpDocumentListImportsInput(input, bodyEncoder.Value); err != nil {
2238		return out, metadata, &smithy.SerializationError{Err: err}
2239	}
2240
2241	err = bodyEncoder.Encode()
2242	if err != nil {
2243		return out, metadata, &smithy.SerializationError{Err: err}
2244	}
2245
2246	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2247		return out, metadata, &smithy.SerializationError{Err: err}
2248	}
2249
2250	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2251		return out, metadata, &smithy.SerializationError{Err: err}
2252	}
2253	in.Request = request
2254
2255	return next.HandleSerialize(ctx, in)
2256}
2257
2258type awsAwsquery_serializeOpListStackInstances struct {
2259}
2260
2261func (*awsAwsquery_serializeOpListStackInstances) ID() string {
2262	return "OperationSerializer"
2263}
2264
2265func (m *awsAwsquery_serializeOpListStackInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2266	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2267) {
2268	request, ok := in.Request.(*smithyhttp.Request)
2269	if !ok {
2270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2271	}
2272
2273	input, ok := in.Parameters.(*ListStackInstancesInput)
2274	_ = input
2275	if !ok {
2276		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2277	}
2278
2279	request.Request.URL.Path = "/"
2280	request.Request.Method = "POST"
2281	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2282	if err != nil {
2283		return out, metadata, &smithy.SerializationError{Err: err}
2284	}
2285	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2286
2287	bodyWriter := bytes.NewBuffer(nil)
2288	bodyEncoder := query.NewEncoder(bodyWriter)
2289	body := bodyEncoder.Object()
2290	body.Key("Action").String("ListStackInstances")
2291	body.Key("Version").String("2010-05-15")
2292
2293	if err := awsAwsquery_serializeOpDocumentListStackInstancesInput(input, bodyEncoder.Value); err != nil {
2294		return out, metadata, &smithy.SerializationError{Err: err}
2295	}
2296
2297	err = bodyEncoder.Encode()
2298	if err != nil {
2299		return out, metadata, &smithy.SerializationError{Err: err}
2300	}
2301
2302	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2303		return out, metadata, &smithy.SerializationError{Err: err}
2304	}
2305
2306	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2307		return out, metadata, &smithy.SerializationError{Err: err}
2308	}
2309	in.Request = request
2310
2311	return next.HandleSerialize(ctx, in)
2312}
2313
2314type awsAwsquery_serializeOpListStackResources struct {
2315}
2316
2317func (*awsAwsquery_serializeOpListStackResources) ID() string {
2318	return "OperationSerializer"
2319}
2320
2321func (m *awsAwsquery_serializeOpListStackResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2322	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2323) {
2324	request, ok := in.Request.(*smithyhttp.Request)
2325	if !ok {
2326		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2327	}
2328
2329	input, ok := in.Parameters.(*ListStackResourcesInput)
2330	_ = input
2331	if !ok {
2332		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2333	}
2334
2335	request.Request.URL.Path = "/"
2336	request.Request.Method = "POST"
2337	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2338	if err != nil {
2339		return out, metadata, &smithy.SerializationError{Err: err}
2340	}
2341	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2342
2343	bodyWriter := bytes.NewBuffer(nil)
2344	bodyEncoder := query.NewEncoder(bodyWriter)
2345	body := bodyEncoder.Object()
2346	body.Key("Action").String("ListStackResources")
2347	body.Key("Version").String("2010-05-15")
2348
2349	if err := awsAwsquery_serializeOpDocumentListStackResourcesInput(input, bodyEncoder.Value); err != nil {
2350		return out, metadata, &smithy.SerializationError{Err: err}
2351	}
2352
2353	err = bodyEncoder.Encode()
2354	if err != nil {
2355		return out, metadata, &smithy.SerializationError{Err: err}
2356	}
2357
2358	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2359		return out, metadata, &smithy.SerializationError{Err: err}
2360	}
2361
2362	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2363		return out, metadata, &smithy.SerializationError{Err: err}
2364	}
2365	in.Request = request
2366
2367	return next.HandleSerialize(ctx, in)
2368}
2369
2370type awsAwsquery_serializeOpListStacks struct {
2371}
2372
2373func (*awsAwsquery_serializeOpListStacks) ID() string {
2374	return "OperationSerializer"
2375}
2376
2377func (m *awsAwsquery_serializeOpListStacks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2378	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2379) {
2380	request, ok := in.Request.(*smithyhttp.Request)
2381	if !ok {
2382		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2383	}
2384
2385	input, ok := in.Parameters.(*ListStacksInput)
2386	_ = input
2387	if !ok {
2388		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2389	}
2390
2391	request.Request.URL.Path = "/"
2392	request.Request.Method = "POST"
2393	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2394	if err != nil {
2395		return out, metadata, &smithy.SerializationError{Err: err}
2396	}
2397	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2398
2399	bodyWriter := bytes.NewBuffer(nil)
2400	bodyEncoder := query.NewEncoder(bodyWriter)
2401	body := bodyEncoder.Object()
2402	body.Key("Action").String("ListStacks")
2403	body.Key("Version").String("2010-05-15")
2404
2405	if err := awsAwsquery_serializeOpDocumentListStacksInput(input, bodyEncoder.Value); err != nil {
2406		return out, metadata, &smithy.SerializationError{Err: err}
2407	}
2408
2409	err = bodyEncoder.Encode()
2410	if err != nil {
2411		return out, metadata, &smithy.SerializationError{Err: err}
2412	}
2413
2414	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2415		return out, metadata, &smithy.SerializationError{Err: err}
2416	}
2417
2418	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2419		return out, metadata, &smithy.SerializationError{Err: err}
2420	}
2421	in.Request = request
2422
2423	return next.HandleSerialize(ctx, in)
2424}
2425
2426type awsAwsquery_serializeOpListStackSetOperationResults struct {
2427}
2428
2429func (*awsAwsquery_serializeOpListStackSetOperationResults) ID() string {
2430	return "OperationSerializer"
2431}
2432
2433func (m *awsAwsquery_serializeOpListStackSetOperationResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2434	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2435) {
2436	request, ok := in.Request.(*smithyhttp.Request)
2437	if !ok {
2438		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2439	}
2440
2441	input, ok := in.Parameters.(*ListStackSetOperationResultsInput)
2442	_ = input
2443	if !ok {
2444		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2445	}
2446
2447	request.Request.URL.Path = "/"
2448	request.Request.Method = "POST"
2449	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2450	if err != nil {
2451		return out, metadata, &smithy.SerializationError{Err: err}
2452	}
2453	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2454
2455	bodyWriter := bytes.NewBuffer(nil)
2456	bodyEncoder := query.NewEncoder(bodyWriter)
2457	body := bodyEncoder.Object()
2458	body.Key("Action").String("ListStackSetOperationResults")
2459	body.Key("Version").String("2010-05-15")
2460
2461	if err := awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(input, bodyEncoder.Value); err != nil {
2462		return out, metadata, &smithy.SerializationError{Err: err}
2463	}
2464
2465	err = bodyEncoder.Encode()
2466	if err != nil {
2467		return out, metadata, &smithy.SerializationError{Err: err}
2468	}
2469
2470	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2471		return out, metadata, &smithy.SerializationError{Err: err}
2472	}
2473
2474	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2475		return out, metadata, &smithy.SerializationError{Err: err}
2476	}
2477	in.Request = request
2478
2479	return next.HandleSerialize(ctx, in)
2480}
2481
2482type awsAwsquery_serializeOpListStackSetOperations struct {
2483}
2484
2485func (*awsAwsquery_serializeOpListStackSetOperations) ID() string {
2486	return "OperationSerializer"
2487}
2488
2489func (m *awsAwsquery_serializeOpListStackSetOperations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2490	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2491) {
2492	request, ok := in.Request.(*smithyhttp.Request)
2493	if !ok {
2494		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2495	}
2496
2497	input, ok := in.Parameters.(*ListStackSetOperationsInput)
2498	_ = input
2499	if !ok {
2500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2501	}
2502
2503	request.Request.URL.Path = "/"
2504	request.Request.Method = "POST"
2505	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2506	if err != nil {
2507		return out, metadata, &smithy.SerializationError{Err: err}
2508	}
2509	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2510
2511	bodyWriter := bytes.NewBuffer(nil)
2512	bodyEncoder := query.NewEncoder(bodyWriter)
2513	body := bodyEncoder.Object()
2514	body.Key("Action").String("ListStackSetOperations")
2515	body.Key("Version").String("2010-05-15")
2516
2517	if err := awsAwsquery_serializeOpDocumentListStackSetOperationsInput(input, bodyEncoder.Value); err != nil {
2518		return out, metadata, &smithy.SerializationError{Err: err}
2519	}
2520
2521	err = bodyEncoder.Encode()
2522	if err != nil {
2523		return out, metadata, &smithy.SerializationError{Err: err}
2524	}
2525
2526	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2527		return out, metadata, &smithy.SerializationError{Err: err}
2528	}
2529
2530	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2531		return out, metadata, &smithy.SerializationError{Err: err}
2532	}
2533	in.Request = request
2534
2535	return next.HandleSerialize(ctx, in)
2536}
2537
2538type awsAwsquery_serializeOpListStackSets struct {
2539}
2540
2541func (*awsAwsquery_serializeOpListStackSets) ID() string {
2542	return "OperationSerializer"
2543}
2544
2545func (m *awsAwsquery_serializeOpListStackSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2546	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2547) {
2548	request, ok := in.Request.(*smithyhttp.Request)
2549	if !ok {
2550		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2551	}
2552
2553	input, ok := in.Parameters.(*ListStackSetsInput)
2554	_ = input
2555	if !ok {
2556		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2557	}
2558
2559	request.Request.URL.Path = "/"
2560	request.Request.Method = "POST"
2561	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2562	if err != nil {
2563		return out, metadata, &smithy.SerializationError{Err: err}
2564	}
2565	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2566
2567	bodyWriter := bytes.NewBuffer(nil)
2568	bodyEncoder := query.NewEncoder(bodyWriter)
2569	body := bodyEncoder.Object()
2570	body.Key("Action").String("ListStackSets")
2571	body.Key("Version").String("2010-05-15")
2572
2573	if err := awsAwsquery_serializeOpDocumentListStackSetsInput(input, bodyEncoder.Value); err != nil {
2574		return out, metadata, &smithy.SerializationError{Err: err}
2575	}
2576
2577	err = bodyEncoder.Encode()
2578	if err != nil {
2579		return out, metadata, &smithy.SerializationError{Err: err}
2580	}
2581
2582	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2583		return out, metadata, &smithy.SerializationError{Err: err}
2584	}
2585
2586	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2587		return out, metadata, &smithy.SerializationError{Err: err}
2588	}
2589	in.Request = request
2590
2591	return next.HandleSerialize(ctx, in)
2592}
2593
2594type awsAwsquery_serializeOpListTypeRegistrations struct {
2595}
2596
2597func (*awsAwsquery_serializeOpListTypeRegistrations) ID() string {
2598	return "OperationSerializer"
2599}
2600
2601func (m *awsAwsquery_serializeOpListTypeRegistrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2602	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2603) {
2604	request, ok := in.Request.(*smithyhttp.Request)
2605	if !ok {
2606		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2607	}
2608
2609	input, ok := in.Parameters.(*ListTypeRegistrationsInput)
2610	_ = input
2611	if !ok {
2612		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2613	}
2614
2615	request.Request.URL.Path = "/"
2616	request.Request.Method = "POST"
2617	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2618	if err != nil {
2619		return out, metadata, &smithy.SerializationError{Err: err}
2620	}
2621	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2622
2623	bodyWriter := bytes.NewBuffer(nil)
2624	bodyEncoder := query.NewEncoder(bodyWriter)
2625	body := bodyEncoder.Object()
2626	body.Key("Action").String("ListTypeRegistrations")
2627	body.Key("Version").String("2010-05-15")
2628
2629	if err := awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(input, bodyEncoder.Value); err != nil {
2630		return out, metadata, &smithy.SerializationError{Err: err}
2631	}
2632
2633	err = bodyEncoder.Encode()
2634	if err != nil {
2635		return out, metadata, &smithy.SerializationError{Err: err}
2636	}
2637
2638	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2639		return out, metadata, &smithy.SerializationError{Err: err}
2640	}
2641
2642	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2643		return out, metadata, &smithy.SerializationError{Err: err}
2644	}
2645	in.Request = request
2646
2647	return next.HandleSerialize(ctx, in)
2648}
2649
2650type awsAwsquery_serializeOpListTypes struct {
2651}
2652
2653func (*awsAwsquery_serializeOpListTypes) ID() string {
2654	return "OperationSerializer"
2655}
2656
2657func (m *awsAwsquery_serializeOpListTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2658	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2659) {
2660	request, ok := in.Request.(*smithyhttp.Request)
2661	if !ok {
2662		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2663	}
2664
2665	input, ok := in.Parameters.(*ListTypesInput)
2666	_ = input
2667	if !ok {
2668		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2669	}
2670
2671	request.Request.URL.Path = "/"
2672	request.Request.Method = "POST"
2673	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2674	if err != nil {
2675		return out, metadata, &smithy.SerializationError{Err: err}
2676	}
2677	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2678
2679	bodyWriter := bytes.NewBuffer(nil)
2680	bodyEncoder := query.NewEncoder(bodyWriter)
2681	body := bodyEncoder.Object()
2682	body.Key("Action").String("ListTypes")
2683	body.Key("Version").String("2010-05-15")
2684
2685	if err := awsAwsquery_serializeOpDocumentListTypesInput(input, bodyEncoder.Value); err != nil {
2686		return out, metadata, &smithy.SerializationError{Err: err}
2687	}
2688
2689	err = bodyEncoder.Encode()
2690	if err != nil {
2691		return out, metadata, &smithy.SerializationError{Err: err}
2692	}
2693
2694	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2695		return out, metadata, &smithy.SerializationError{Err: err}
2696	}
2697
2698	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2699		return out, metadata, &smithy.SerializationError{Err: err}
2700	}
2701	in.Request = request
2702
2703	return next.HandleSerialize(ctx, in)
2704}
2705
2706type awsAwsquery_serializeOpListTypeVersions struct {
2707}
2708
2709func (*awsAwsquery_serializeOpListTypeVersions) ID() string {
2710	return "OperationSerializer"
2711}
2712
2713func (m *awsAwsquery_serializeOpListTypeVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2714	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2715) {
2716	request, ok := in.Request.(*smithyhttp.Request)
2717	if !ok {
2718		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2719	}
2720
2721	input, ok := in.Parameters.(*ListTypeVersionsInput)
2722	_ = input
2723	if !ok {
2724		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2725	}
2726
2727	request.Request.URL.Path = "/"
2728	request.Request.Method = "POST"
2729	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2730	if err != nil {
2731		return out, metadata, &smithy.SerializationError{Err: err}
2732	}
2733	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2734
2735	bodyWriter := bytes.NewBuffer(nil)
2736	bodyEncoder := query.NewEncoder(bodyWriter)
2737	body := bodyEncoder.Object()
2738	body.Key("Action").String("ListTypeVersions")
2739	body.Key("Version").String("2010-05-15")
2740
2741	if err := awsAwsquery_serializeOpDocumentListTypeVersionsInput(input, bodyEncoder.Value); err != nil {
2742		return out, metadata, &smithy.SerializationError{Err: err}
2743	}
2744
2745	err = bodyEncoder.Encode()
2746	if err != nil {
2747		return out, metadata, &smithy.SerializationError{Err: err}
2748	}
2749
2750	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2751		return out, metadata, &smithy.SerializationError{Err: err}
2752	}
2753
2754	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2755		return out, metadata, &smithy.SerializationError{Err: err}
2756	}
2757	in.Request = request
2758
2759	return next.HandleSerialize(ctx, in)
2760}
2761
2762type awsAwsquery_serializeOpPublishType struct {
2763}
2764
2765func (*awsAwsquery_serializeOpPublishType) ID() string {
2766	return "OperationSerializer"
2767}
2768
2769func (m *awsAwsquery_serializeOpPublishType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2770	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2771) {
2772	request, ok := in.Request.(*smithyhttp.Request)
2773	if !ok {
2774		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2775	}
2776
2777	input, ok := in.Parameters.(*PublishTypeInput)
2778	_ = input
2779	if !ok {
2780		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2781	}
2782
2783	request.Request.URL.Path = "/"
2784	request.Request.Method = "POST"
2785	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2786	if err != nil {
2787		return out, metadata, &smithy.SerializationError{Err: err}
2788	}
2789	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2790
2791	bodyWriter := bytes.NewBuffer(nil)
2792	bodyEncoder := query.NewEncoder(bodyWriter)
2793	body := bodyEncoder.Object()
2794	body.Key("Action").String("PublishType")
2795	body.Key("Version").String("2010-05-15")
2796
2797	if err := awsAwsquery_serializeOpDocumentPublishTypeInput(input, bodyEncoder.Value); err != nil {
2798		return out, metadata, &smithy.SerializationError{Err: err}
2799	}
2800
2801	err = bodyEncoder.Encode()
2802	if err != nil {
2803		return out, metadata, &smithy.SerializationError{Err: err}
2804	}
2805
2806	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2807		return out, metadata, &smithy.SerializationError{Err: err}
2808	}
2809
2810	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2811		return out, metadata, &smithy.SerializationError{Err: err}
2812	}
2813	in.Request = request
2814
2815	return next.HandleSerialize(ctx, in)
2816}
2817
2818type awsAwsquery_serializeOpRecordHandlerProgress struct {
2819}
2820
2821func (*awsAwsquery_serializeOpRecordHandlerProgress) ID() string {
2822	return "OperationSerializer"
2823}
2824
2825func (m *awsAwsquery_serializeOpRecordHandlerProgress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2826	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2827) {
2828	request, ok := in.Request.(*smithyhttp.Request)
2829	if !ok {
2830		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2831	}
2832
2833	input, ok := in.Parameters.(*RecordHandlerProgressInput)
2834	_ = input
2835	if !ok {
2836		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2837	}
2838
2839	request.Request.URL.Path = "/"
2840	request.Request.Method = "POST"
2841	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2842	if err != nil {
2843		return out, metadata, &smithy.SerializationError{Err: err}
2844	}
2845	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2846
2847	bodyWriter := bytes.NewBuffer(nil)
2848	bodyEncoder := query.NewEncoder(bodyWriter)
2849	body := bodyEncoder.Object()
2850	body.Key("Action").String("RecordHandlerProgress")
2851	body.Key("Version").String("2010-05-15")
2852
2853	if err := awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(input, bodyEncoder.Value); err != nil {
2854		return out, metadata, &smithy.SerializationError{Err: err}
2855	}
2856
2857	err = bodyEncoder.Encode()
2858	if err != nil {
2859		return out, metadata, &smithy.SerializationError{Err: err}
2860	}
2861
2862	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2863		return out, metadata, &smithy.SerializationError{Err: err}
2864	}
2865
2866	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2867		return out, metadata, &smithy.SerializationError{Err: err}
2868	}
2869	in.Request = request
2870
2871	return next.HandleSerialize(ctx, in)
2872}
2873
2874type awsAwsquery_serializeOpRegisterPublisher struct {
2875}
2876
2877func (*awsAwsquery_serializeOpRegisterPublisher) ID() string {
2878	return "OperationSerializer"
2879}
2880
2881func (m *awsAwsquery_serializeOpRegisterPublisher) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2882	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2883) {
2884	request, ok := in.Request.(*smithyhttp.Request)
2885	if !ok {
2886		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2887	}
2888
2889	input, ok := in.Parameters.(*RegisterPublisherInput)
2890	_ = input
2891	if !ok {
2892		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2893	}
2894
2895	request.Request.URL.Path = "/"
2896	request.Request.Method = "POST"
2897	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2898	if err != nil {
2899		return out, metadata, &smithy.SerializationError{Err: err}
2900	}
2901	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2902
2903	bodyWriter := bytes.NewBuffer(nil)
2904	bodyEncoder := query.NewEncoder(bodyWriter)
2905	body := bodyEncoder.Object()
2906	body.Key("Action").String("RegisterPublisher")
2907	body.Key("Version").String("2010-05-15")
2908
2909	if err := awsAwsquery_serializeOpDocumentRegisterPublisherInput(input, bodyEncoder.Value); err != nil {
2910		return out, metadata, &smithy.SerializationError{Err: err}
2911	}
2912
2913	err = bodyEncoder.Encode()
2914	if err != nil {
2915		return out, metadata, &smithy.SerializationError{Err: err}
2916	}
2917
2918	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2919		return out, metadata, &smithy.SerializationError{Err: err}
2920	}
2921
2922	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2923		return out, metadata, &smithy.SerializationError{Err: err}
2924	}
2925	in.Request = request
2926
2927	return next.HandleSerialize(ctx, in)
2928}
2929
2930type awsAwsquery_serializeOpRegisterType struct {
2931}
2932
2933func (*awsAwsquery_serializeOpRegisterType) ID() string {
2934	return "OperationSerializer"
2935}
2936
2937func (m *awsAwsquery_serializeOpRegisterType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2938	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2939) {
2940	request, ok := in.Request.(*smithyhttp.Request)
2941	if !ok {
2942		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2943	}
2944
2945	input, ok := in.Parameters.(*RegisterTypeInput)
2946	_ = input
2947	if !ok {
2948		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2949	}
2950
2951	request.Request.URL.Path = "/"
2952	request.Request.Method = "POST"
2953	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2954	if err != nil {
2955		return out, metadata, &smithy.SerializationError{Err: err}
2956	}
2957	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
2958
2959	bodyWriter := bytes.NewBuffer(nil)
2960	bodyEncoder := query.NewEncoder(bodyWriter)
2961	body := bodyEncoder.Object()
2962	body.Key("Action").String("RegisterType")
2963	body.Key("Version").String("2010-05-15")
2964
2965	if err := awsAwsquery_serializeOpDocumentRegisterTypeInput(input, bodyEncoder.Value); err != nil {
2966		return out, metadata, &smithy.SerializationError{Err: err}
2967	}
2968
2969	err = bodyEncoder.Encode()
2970	if err != nil {
2971		return out, metadata, &smithy.SerializationError{Err: err}
2972	}
2973
2974	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
2975		return out, metadata, &smithy.SerializationError{Err: err}
2976	}
2977
2978	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2979		return out, metadata, &smithy.SerializationError{Err: err}
2980	}
2981	in.Request = request
2982
2983	return next.HandleSerialize(ctx, in)
2984}
2985
2986type awsAwsquery_serializeOpRollbackStack struct {
2987}
2988
2989func (*awsAwsquery_serializeOpRollbackStack) ID() string {
2990	return "OperationSerializer"
2991}
2992
2993func (m *awsAwsquery_serializeOpRollbackStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2994	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2995) {
2996	request, ok := in.Request.(*smithyhttp.Request)
2997	if !ok {
2998		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2999	}
3000
3001	input, ok := in.Parameters.(*RollbackStackInput)
3002	_ = input
3003	if !ok {
3004		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3005	}
3006
3007	request.Request.URL.Path = "/"
3008	request.Request.Method = "POST"
3009	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3010	if err != nil {
3011		return out, metadata, &smithy.SerializationError{Err: err}
3012	}
3013	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3014
3015	bodyWriter := bytes.NewBuffer(nil)
3016	bodyEncoder := query.NewEncoder(bodyWriter)
3017	body := bodyEncoder.Object()
3018	body.Key("Action").String("RollbackStack")
3019	body.Key("Version").String("2010-05-15")
3020
3021	if err := awsAwsquery_serializeOpDocumentRollbackStackInput(input, bodyEncoder.Value); err != nil {
3022		return out, metadata, &smithy.SerializationError{Err: err}
3023	}
3024
3025	err = bodyEncoder.Encode()
3026	if err != nil {
3027		return out, metadata, &smithy.SerializationError{Err: err}
3028	}
3029
3030	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3031		return out, metadata, &smithy.SerializationError{Err: err}
3032	}
3033
3034	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3035		return out, metadata, &smithy.SerializationError{Err: err}
3036	}
3037	in.Request = request
3038
3039	return next.HandleSerialize(ctx, in)
3040}
3041
3042type awsAwsquery_serializeOpSetStackPolicy struct {
3043}
3044
3045func (*awsAwsquery_serializeOpSetStackPolicy) ID() string {
3046	return "OperationSerializer"
3047}
3048
3049func (m *awsAwsquery_serializeOpSetStackPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3050	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3051) {
3052	request, ok := in.Request.(*smithyhttp.Request)
3053	if !ok {
3054		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3055	}
3056
3057	input, ok := in.Parameters.(*SetStackPolicyInput)
3058	_ = input
3059	if !ok {
3060		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3061	}
3062
3063	request.Request.URL.Path = "/"
3064	request.Request.Method = "POST"
3065	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3066	if err != nil {
3067		return out, metadata, &smithy.SerializationError{Err: err}
3068	}
3069	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3070
3071	bodyWriter := bytes.NewBuffer(nil)
3072	bodyEncoder := query.NewEncoder(bodyWriter)
3073	body := bodyEncoder.Object()
3074	body.Key("Action").String("SetStackPolicy")
3075	body.Key("Version").String("2010-05-15")
3076
3077	if err := awsAwsquery_serializeOpDocumentSetStackPolicyInput(input, bodyEncoder.Value); err != nil {
3078		return out, metadata, &smithy.SerializationError{Err: err}
3079	}
3080
3081	err = bodyEncoder.Encode()
3082	if err != nil {
3083		return out, metadata, &smithy.SerializationError{Err: err}
3084	}
3085
3086	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3087		return out, metadata, &smithy.SerializationError{Err: err}
3088	}
3089
3090	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3091		return out, metadata, &smithy.SerializationError{Err: err}
3092	}
3093	in.Request = request
3094
3095	return next.HandleSerialize(ctx, in)
3096}
3097
3098type awsAwsquery_serializeOpSetTypeConfiguration struct {
3099}
3100
3101func (*awsAwsquery_serializeOpSetTypeConfiguration) ID() string {
3102	return "OperationSerializer"
3103}
3104
3105func (m *awsAwsquery_serializeOpSetTypeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3106	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3107) {
3108	request, ok := in.Request.(*smithyhttp.Request)
3109	if !ok {
3110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3111	}
3112
3113	input, ok := in.Parameters.(*SetTypeConfigurationInput)
3114	_ = input
3115	if !ok {
3116		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3117	}
3118
3119	request.Request.URL.Path = "/"
3120	request.Request.Method = "POST"
3121	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3122	if err != nil {
3123		return out, metadata, &smithy.SerializationError{Err: err}
3124	}
3125	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3126
3127	bodyWriter := bytes.NewBuffer(nil)
3128	bodyEncoder := query.NewEncoder(bodyWriter)
3129	body := bodyEncoder.Object()
3130	body.Key("Action").String("SetTypeConfiguration")
3131	body.Key("Version").String("2010-05-15")
3132
3133	if err := awsAwsquery_serializeOpDocumentSetTypeConfigurationInput(input, bodyEncoder.Value); err != nil {
3134		return out, metadata, &smithy.SerializationError{Err: err}
3135	}
3136
3137	err = bodyEncoder.Encode()
3138	if err != nil {
3139		return out, metadata, &smithy.SerializationError{Err: err}
3140	}
3141
3142	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3143		return out, metadata, &smithy.SerializationError{Err: err}
3144	}
3145
3146	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3147		return out, metadata, &smithy.SerializationError{Err: err}
3148	}
3149	in.Request = request
3150
3151	return next.HandleSerialize(ctx, in)
3152}
3153
3154type awsAwsquery_serializeOpSetTypeDefaultVersion struct {
3155}
3156
3157func (*awsAwsquery_serializeOpSetTypeDefaultVersion) ID() string {
3158	return "OperationSerializer"
3159}
3160
3161func (m *awsAwsquery_serializeOpSetTypeDefaultVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3162	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3163) {
3164	request, ok := in.Request.(*smithyhttp.Request)
3165	if !ok {
3166		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3167	}
3168
3169	input, ok := in.Parameters.(*SetTypeDefaultVersionInput)
3170	_ = input
3171	if !ok {
3172		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3173	}
3174
3175	request.Request.URL.Path = "/"
3176	request.Request.Method = "POST"
3177	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3178	if err != nil {
3179		return out, metadata, &smithy.SerializationError{Err: err}
3180	}
3181	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3182
3183	bodyWriter := bytes.NewBuffer(nil)
3184	bodyEncoder := query.NewEncoder(bodyWriter)
3185	body := bodyEncoder.Object()
3186	body.Key("Action").String("SetTypeDefaultVersion")
3187	body.Key("Version").String("2010-05-15")
3188
3189	if err := awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(input, bodyEncoder.Value); err != nil {
3190		return out, metadata, &smithy.SerializationError{Err: err}
3191	}
3192
3193	err = bodyEncoder.Encode()
3194	if err != nil {
3195		return out, metadata, &smithy.SerializationError{Err: err}
3196	}
3197
3198	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3199		return out, metadata, &smithy.SerializationError{Err: err}
3200	}
3201
3202	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3203		return out, metadata, &smithy.SerializationError{Err: err}
3204	}
3205	in.Request = request
3206
3207	return next.HandleSerialize(ctx, in)
3208}
3209
3210type awsAwsquery_serializeOpSignalResource struct {
3211}
3212
3213func (*awsAwsquery_serializeOpSignalResource) ID() string {
3214	return "OperationSerializer"
3215}
3216
3217func (m *awsAwsquery_serializeOpSignalResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3218	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3219) {
3220	request, ok := in.Request.(*smithyhttp.Request)
3221	if !ok {
3222		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3223	}
3224
3225	input, ok := in.Parameters.(*SignalResourceInput)
3226	_ = input
3227	if !ok {
3228		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3229	}
3230
3231	request.Request.URL.Path = "/"
3232	request.Request.Method = "POST"
3233	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3234	if err != nil {
3235		return out, metadata, &smithy.SerializationError{Err: err}
3236	}
3237	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3238
3239	bodyWriter := bytes.NewBuffer(nil)
3240	bodyEncoder := query.NewEncoder(bodyWriter)
3241	body := bodyEncoder.Object()
3242	body.Key("Action").String("SignalResource")
3243	body.Key("Version").String("2010-05-15")
3244
3245	if err := awsAwsquery_serializeOpDocumentSignalResourceInput(input, bodyEncoder.Value); err != nil {
3246		return out, metadata, &smithy.SerializationError{Err: err}
3247	}
3248
3249	err = bodyEncoder.Encode()
3250	if err != nil {
3251		return out, metadata, &smithy.SerializationError{Err: err}
3252	}
3253
3254	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3255		return out, metadata, &smithy.SerializationError{Err: err}
3256	}
3257
3258	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3259		return out, metadata, &smithy.SerializationError{Err: err}
3260	}
3261	in.Request = request
3262
3263	return next.HandleSerialize(ctx, in)
3264}
3265
3266type awsAwsquery_serializeOpStopStackSetOperation struct {
3267}
3268
3269func (*awsAwsquery_serializeOpStopStackSetOperation) ID() string {
3270	return "OperationSerializer"
3271}
3272
3273func (m *awsAwsquery_serializeOpStopStackSetOperation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3274	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3275) {
3276	request, ok := in.Request.(*smithyhttp.Request)
3277	if !ok {
3278		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3279	}
3280
3281	input, ok := in.Parameters.(*StopStackSetOperationInput)
3282	_ = input
3283	if !ok {
3284		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3285	}
3286
3287	request.Request.URL.Path = "/"
3288	request.Request.Method = "POST"
3289	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3290	if err != nil {
3291		return out, metadata, &smithy.SerializationError{Err: err}
3292	}
3293	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3294
3295	bodyWriter := bytes.NewBuffer(nil)
3296	bodyEncoder := query.NewEncoder(bodyWriter)
3297	body := bodyEncoder.Object()
3298	body.Key("Action").String("StopStackSetOperation")
3299	body.Key("Version").String("2010-05-15")
3300
3301	if err := awsAwsquery_serializeOpDocumentStopStackSetOperationInput(input, bodyEncoder.Value); err != nil {
3302		return out, metadata, &smithy.SerializationError{Err: err}
3303	}
3304
3305	err = bodyEncoder.Encode()
3306	if err != nil {
3307		return out, metadata, &smithy.SerializationError{Err: err}
3308	}
3309
3310	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3311		return out, metadata, &smithy.SerializationError{Err: err}
3312	}
3313
3314	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3315		return out, metadata, &smithy.SerializationError{Err: err}
3316	}
3317	in.Request = request
3318
3319	return next.HandleSerialize(ctx, in)
3320}
3321
3322type awsAwsquery_serializeOpTestType struct {
3323}
3324
3325func (*awsAwsquery_serializeOpTestType) ID() string {
3326	return "OperationSerializer"
3327}
3328
3329func (m *awsAwsquery_serializeOpTestType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3330	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3331) {
3332	request, ok := in.Request.(*smithyhttp.Request)
3333	if !ok {
3334		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3335	}
3336
3337	input, ok := in.Parameters.(*TestTypeInput)
3338	_ = input
3339	if !ok {
3340		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3341	}
3342
3343	request.Request.URL.Path = "/"
3344	request.Request.Method = "POST"
3345	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3346	if err != nil {
3347		return out, metadata, &smithy.SerializationError{Err: err}
3348	}
3349	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3350
3351	bodyWriter := bytes.NewBuffer(nil)
3352	bodyEncoder := query.NewEncoder(bodyWriter)
3353	body := bodyEncoder.Object()
3354	body.Key("Action").String("TestType")
3355	body.Key("Version").String("2010-05-15")
3356
3357	if err := awsAwsquery_serializeOpDocumentTestTypeInput(input, bodyEncoder.Value); err != nil {
3358		return out, metadata, &smithy.SerializationError{Err: err}
3359	}
3360
3361	err = bodyEncoder.Encode()
3362	if err != nil {
3363		return out, metadata, &smithy.SerializationError{Err: err}
3364	}
3365
3366	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3367		return out, metadata, &smithy.SerializationError{Err: err}
3368	}
3369
3370	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3371		return out, metadata, &smithy.SerializationError{Err: err}
3372	}
3373	in.Request = request
3374
3375	return next.HandleSerialize(ctx, in)
3376}
3377
3378type awsAwsquery_serializeOpUpdateStack struct {
3379}
3380
3381func (*awsAwsquery_serializeOpUpdateStack) ID() string {
3382	return "OperationSerializer"
3383}
3384
3385func (m *awsAwsquery_serializeOpUpdateStack) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3386	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3387) {
3388	request, ok := in.Request.(*smithyhttp.Request)
3389	if !ok {
3390		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3391	}
3392
3393	input, ok := in.Parameters.(*UpdateStackInput)
3394	_ = input
3395	if !ok {
3396		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3397	}
3398
3399	request.Request.URL.Path = "/"
3400	request.Request.Method = "POST"
3401	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3402	if err != nil {
3403		return out, metadata, &smithy.SerializationError{Err: err}
3404	}
3405	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3406
3407	bodyWriter := bytes.NewBuffer(nil)
3408	bodyEncoder := query.NewEncoder(bodyWriter)
3409	body := bodyEncoder.Object()
3410	body.Key("Action").String("UpdateStack")
3411	body.Key("Version").String("2010-05-15")
3412
3413	if err := awsAwsquery_serializeOpDocumentUpdateStackInput(input, bodyEncoder.Value); err != nil {
3414		return out, metadata, &smithy.SerializationError{Err: err}
3415	}
3416
3417	err = bodyEncoder.Encode()
3418	if err != nil {
3419		return out, metadata, &smithy.SerializationError{Err: err}
3420	}
3421
3422	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3423		return out, metadata, &smithy.SerializationError{Err: err}
3424	}
3425
3426	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3427		return out, metadata, &smithy.SerializationError{Err: err}
3428	}
3429	in.Request = request
3430
3431	return next.HandleSerialize(ctx, in)
3432}
3433
3434type awsAwsquery_serializeOpUpdateStackInstances struct {
3435}
3436
3437func (*awsAwsquery_serializeOpUpdateStackInstances) ID() string {
3438	return "OperationSerializer"
3439}
3440
3441func (m *awsAwsquery_serializeOpUpdateStackInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3442	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3443) {
3444	request, ok := in.Request.(*smithyhttp.Request)
3445	if !ok {
3446		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3447	}
3448
3449	input, ok := in.Parameters.(*UpdateStackInstancesInput)
3450	_ = input
3451	if !ok {
3452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3453	}
3454
3455	request.Request.URL.Path = "/"
3456	request.Request.Method = "POST"
3457	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3458	if err != nil {
3459		return out, metadata, &smithy.SerializationError{Err: err}
3460	}
3461	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3462
3463	bodyWriter := bytes.NewBuffer(nil)
3464	bodyEncoder := query.NewEncoder(bodyWriter)
3465	body := bodyEncoder.Object()
3466	body.Key("Action").String("UpdateStackInstances")
3467	body.Key("Version").String("2010-05-15")
3468
3469	if err := awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(input, bodyEncoder.Value); err != nil {
3470		return out, metadata, &smithy.SerializationError{Err: err}
3471	}
3472
3473	err = bodyEncoder.Encode()
3474	if err != nil {
3475		return out, metadata, &smithy.SerializationError{Err: err}
3476	}
3477
3478	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3479		return out, metadata, &smithy.SerializationError{Err: err}
3480	}
3481
3482	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3483		return out, metadata, &smithy.SerializationError{Err: err}
3484	}
3485	in.Request = request
3486
3487	return next.HandleSerialize(ctx, in)
3488}
3489
3490type awsAwsquery_serializeOpUpdateStackSet struct {
3491}
3492
3493func (*awsAwsquery_serializeOpUpdateStackSet) ID() string {
3494	return "OperationSerializer"
3495}
3496
3497func (m *awsAwsquery_serializeOpUpdateStackSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3498	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3499) {
3500	request, ok := in.Request.(*smithyhttp.Request)
3501	if !ok {
3502		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3503	}
3504
3505	input, ok := in.Parameters.(*UpdateStackSetInput)
3506	_ = input
3507	if !ok {
3508		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3509	}
3510
3511	request.Request.URL.Path = "/"
3512	request.Request.Method = "POST"
3513	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3514	if err != nil {
3515		return out, metadata, &smithy.SerializationError{Err: err}
3516	}
3517	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3518
3519	bodyWriter := bytes.NewBuffer(nil)
3520	bodyEncoder := query.NewEncoder(bodyWriter)
3521	body := bodyEncoder.Object()
3522	body.Key("Action").String("UpdateStackSet")
3523	body.Key("Version").String("2010-05-15")
3524
3525	if err := awsAwsquery_serializeOpDocumentUpdateStackSetInput(input, bodyEncoder.Value); err != nil {
3526		return out, metadata, &smithy.SerializationError{Err: err}
3527	}
3528
3529	err = bodyEncoder.Encode()
3530	if err != nil {
3531		return out, metadata, &smithy.SerializationError{Err: err}
3532	}
3533
3534	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3535		return out, metadata, &smithy.SerializationError{Err: err}
3536	}
3537
3538	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3539		return out, metadata, &smithy.SerializationError{Err: err}
3540	}
3541	in.Request = request
3542
3543	return next.HandleSerialize(ctx, in)
3544}
3545
3546type awsAwsquery_serializeOpUpdateTerminationProtection struct {
3547}
3548
3549func (*awsAwsquery_serializeOpUpdateTerminationProtection) ID() string {
3550	return "OperationSerializer"
3551}
3552
3553func (m *awsAwsquery_serializeOpUpdateTerminationProtection) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3554	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3555) {
3556	request, ok := in.Request.(*smithyhttp.Request)
3557	if !ok {
3558		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3559	}
3560
3561	input, ok := in.Parameters.(*UpdateTerminationProtectionInput)
3562	_ = input
3563	if !ok {
3564		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3565	}
3566
3567	request.Request.URL.Path = "/"
3568	request.Request.Method = "POST"
3569	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3570	if err != nil {
3571		return out, metadata, &smithy.SerializationError{Err: err}
3572	}
3573	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3574
3575	bodyWriter := bytes.NewBuffer(nil)
3576	bodyEncoder := query.NewEncoder(bodyWriter)
3577	body := bodyEncoder.Object()
3578	body.Key("Action").String("UpdateTerminationProtection")
3579	body.Key("Version").String("2010-05-15")
3580
3581	if err := awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(input, bodyEncoder.Value); err != nil {
3582		return out, metadata, &smithy.SerializationError{Err: err}
3583	}
3584
3585	err = bodyEncoder.Encode()
3586	if err != nil {
3587		return out, metadata, &smithy.SerializationError{Err: err}
3588	}
3589
3590	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3591		return out, metadata, &smithy.SerializationError{Err: err}
3592	}
3593
3594	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3595		return out, metadata, &smithy.SerializationError{Err: err}
3596	}
3597	in.Request = request
3598
3599	return next.HandleSerialize(ctx, in)
3600}
3601
3602type awsAwsquery_serializeOpValidateTemplate struct {
3603}
3604
3605func (*awsAwsquery_serializeOpValidateTemplate) ID() string {
3606	return "OperationSerializer"
3607}
3608
3609func (m *awsAwsquery_serializeOpValidateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3610	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3611) {
3612	request, ok := in.Request.(*smithyhttp.Request)
3613	if !ok {
3614		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3615	}
3616
3617	input, ok := in.Parameters.(*ValidateTemplateInput)
3618	_ = input
3619	if !ok {
3620		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3621	}
3622
3623	request.Request.URL.Path = "/"
3624	request.Request.Method = "POST"
3625	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3626	if err != nil {
3627		return out, metadata, &smithy.SerializationError{Err: err}
3628	}
3629	httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
3630
3631	bodyWriter := bytes.NewBuffer(nil)
3632	bodyEncoder := query.NewEncoder(bodyWriter)
3633	body := bodyEncoder.Object()
3634	body.Key("Action").String("ValidateTemplate")
3635	body.Key("Version").String("2010-05-15")
3636
3637	if err := awsAwsquery_serializeOpDocumentValidateTemplateInput(input, bodyEncoder.Value); err != nil {
3638		return out, metadata, &smithy.SerializationError{Err: err}
3639	}
3640
3641	err = bodyEncoder.Encode()
3642	if err != nil {
3643		return out, metadata, &smithy.SerializationError{Err: err}
3644	}
3645
3646	if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
3647		return out, metadata, &smithy.SerializationError{Err: err}
3648	}
3649
3650	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3651		return out, metadata, &smithy.SerializationError{Err: err}
3652	}
3653	in.Request = request
3654
3655	return next.HandleSerialize(ctx, in)
3656}
3657func awsAwsquery_serializeDocumentAccountList(v []string, value query.Value) error {
3658	if len(v) == 0 {
3659		return nil
3660	}
3661	array := value.Array("member")
3662
3663	for i := range v {
3664		av := array.Value()
3665		av.String(v[i])
3666	}
3667	return nil
3668}
3669
3670func awsAwsquery_serializeDocumentAutoDeployment(v *types.AutoDeployment, value query.Value) error {
3671	object := value.Object()
3672	_ = object
3673
3674	if v.Enabled != nil {
3675		objectKey := object.Key("Enabled")
3676		objectKey.Boolean(*v.Enabled)
3677	}
3678
3679	if v.RetainStacksOnAccountRemoval != nil {
3680		objectKey := object.Key("RetainStacksOnAccountRemoval")
3681		objectKey.Boolean(*v.RetainStacksOnAccountRemoval)
3682	}
3683
3684	return nil
3685}
3686
3687func awsAwsquery_serializeDocumentCapabilities(v []types.Capability, value query.Value) error {
3688	if len(v) == 0 {
3689		return nil
3690	}
3691	array := value.Array("member")
3692
3693	for i := range v {
3694		av := array.Value()
3695		av.String(string(v[i]))
3696	}
3697	return nil
3698}
3699
3700func awsAwsquery_serializeDocumentDeploymentTargets(v *types.DeploymentTargets, value query.Value) error {
3701	object := value.Object()
3702	_ = object
3703
3704	if v.Accounts != nil {
3705		objectKey := object.Key("Accounts")
3706		if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil {
3707			return err
3708		}
3709	}
3710
3711	if v.AccountsUrl != nil {
3712		objectKey := object.Key("AccountsUrl")
3713		objectKey.String(*v.AccountsUrl)
3714	}
3715
3716	if v.OrganizationalUnitIds != nil {
3717		objectKey := object.Key("OrganizationalUnitIds")
3718		if err := awsAwsquery_serializeDocumentOrganizationalUnitIdList(v.OrganizationalUnitIds, objectKey); err != nil {
3719			return err
3720		}
3721	}
3722
3723	return nil
3724}
3725
3726func awsAwsquery_serializeDocumentLoggingConfig(v *types.LoggingConfig, value query.Value) error {
3727	object := value.Object()
3728	_ = object
3729
3730	if v.LogGroupName != nil {
3731		objectKey := object.Key("LogGroupName")
3732		objectKey.String(*v.LogGroupName)
3733	}
3734
3735	if v.LogRoleArn != nil {
3736		objectKey := object.Key("LogRoleArn")
3737		objectKey.String(*v.LogRoleArn)
3738	}
3739
3740	return nil
3741}
3742
3743func awsAwsquery_serializeDocumentLogicalResourceIds(v []string, value query.Value) error {
3744	if len(v) == 0 {
3745		return nil
3746	}
3747	array := value.Array("member")
3748
3749	for i := range v {
3750		av := array.Value()
3751		av.String(v[i])
3752	}
3753	return nil
3754}
3755
3756func awsAwsquery_serializeDocumentNotificationARNs(v []string, value query.Value) error {
3757	if len(v) == 0 {
3758		return nil
3759	}
3760	array := value.Array("member")
3761
3762	for i := range v {
3763		av := array.Value()
3764		av.String(v[i])
3765	}
3766	return nil
3767}
3768
3769func awsAwsquery_serializeDocumentOrganizationalUnitIdList(v []string, value query.Value) error {
3770	if len(v) == 0 {
3771		return nil
3772	}
3773	array := value.Array("member")
3774
3775	for i := range v {
3776		av := array.Value()
3777		av.String(v[i])
3778	}
3779	return nil
3780}
3781
3782func awsAwsquery_serializeDocumentParameter(v *types.Parameter, value query.Value) error {
3783	object := value.Object()
3784	_ = object
3785
3786	if v.ParameterKey != nil {
3787		objectKey := object.Key("ParameterKey")
3788		objectKey.String(*v.ParameterKey)
3789	}
3790
3791	if v.ParameterValue != nil {
3792		objectKey := object.Key("ParameterValue")
3793		objectKey.String(*v.ParameterValue)
3794	}
3795
3796	if v.ResolvedValue != nil {
3797		objectKey := object.Key("ResolvedValue")
3798		objectKey.String(*v.ResolvedValue)
3799	}
3800
3801	if v.UsePreviousValue != nil {
3802		objectKey := object.Key("UsePreviousValue")
3803		objectKey.Boolean(*v.UsePreviousValue)
3804	}
3805
3806	return nil
3807}
3808
3809func awsAwsquery_serializeDocumentParameters(v []types.Parameter, value query.Value) error {
3810	if len(v) == 0 {
3811		return nil
3812	}
3813	array := value.Array("member")
3814
3815	for i := range v {
3816		av := array.Value()
3817		if err := awsAwsquery_serializeDocumentParameter(&v[i], av); err != nil {
3818			return err
3819		}
3820	}
3821	return nil
3822}
3823
3824func awsAwsquery_serializeDocumentRegionList(v []string, value query.Value) error {
3825	if len(v) == 0 {
3826		return nil
3827	}
3828	array := value.Array("member")
3829
3830	for i := range v {
3831		av := array.Value()
3832		av.String(v[i])
3833	}
3834	return nil
3835}
3836
3837func awsAwsquery_serializeDocumentResourceIdentifierProperties(v map[string]string, value query.Value) error {
3838	if len(v) == 0 {
3839		return nil
3840	}
3841	object := value.Map("key", "value")
3842
3843	keys := make([]string, 0, len(v))
3844	for key := range v {
3845		keys = append(keys, key)
3846	}
3847	sort.Strings(keys)
3848
3849	for _, key := range keys {
3850		om := object.Key(key)
3851		om.String(v[key])
3852	}
3853	return nil
3854}
3855
3856func awsAwsquery_serializeDocumentResourcesToImport(v []types.ResourceToImport, value query.Value) error {
3857	if len(v) == 0 {
3858		return nil
3859	}
3860	array := value.Array("member")
3861
3862	for i := range v {
3863		av := array.Value()
3864		if err := awsAwsquery_serializeDocumentResourceToImport(&v[i], av); err != nil {
3865			return err
3866		}
3867	}
3868	return nil
3869}
3870
3871func awsAwsquery_serializeDocumentResourcesToSkip(v []string, value query.Value) error {
3872	if len(v) == 0 {
3873		return nil
3874	}
3875	array := value.Array("member")
3876
3877	for i := range v {
3878		av := array.Value()
3879		av.String(v[i])
3880	}
3881	return nil
3882}
3883
3884func awsAwsquery_serializeDocumentResourceToImport(v *types.ResourceToImport, value query.Value) error {
3885	object := value.Object()
3886	_ = object
3887
3888	if v.LogicalResourceId != nil {
3889		objectKey := object.Key("LogicalResourceId")
3890		objectKey.String(*v.LogicalResourceId)
3891	}
3892
3893	if v.ResourceIdentifier != nil {
3894		objectKey := object.Key("ResourceIdentifier")
3895		if err := awsAwsquery_serializeDocumentResourceIdentifierProperties(v.ResourceIdentifier, objectKey); err != nil {
3896			return err
3897		}
3898	}
3899
3900	if v.ResourceType != nil {
3901		objectKey := object.Key("ResourceType")
3902		objectKey.String(*v.ResourceType)
3903	}
3904
3905	return nil
3906}
3907
3908func awsAwsquery_serializeDocumentResourceTypes(v []string, value query.Value) error {
3909	if len(v) == 0 {
3910		return nil
3911	}
3912	array := value.Array("member")
3913
3914	for i := range v {
3915		av := array.Value()
3916		av.String(v[i])
3917	}
3918	return nil
3919}
3920
3921func awsAwsquery_serializeDocumentRetainResources(v []string, value query.Value) error {
3922	if len(v) == 0 {
3923		return nil
3924	}
3925	array := value.Array("member")
3926
3927	for i := range v {
3928		av := array.Value()
3929		av.String(v[i])
3930	}
3931	return nil
3932}
3933
3934func awsAwsquery_serializeDocumentRollbackConfiguration(v *types.RollbackConfiguration, value query.Value) error {
3935	object := value.Object()
3936	_ = object
3937
3938	if v.MonitoringTimeInMinutes != nil {
3939		objectKey := object.Key("MonitoringTimeInMinutes")
3940		objectKey.Integer(*v.MonitoringTimeInMinutes)
3941	}
3942
3943	if v.RollbackTriggers != nil {
3944		objectKey := object.Key("RollbackTriggers")
3945		if err := awsAwsquery_serializeDocumentRollbackTriggers(v.RollbackTriggers, objectKey); err != nil {
3946			return err
3947		}
3948	}
3949
3950	return nil
3951}
3952
3953func awsAwsquery_serializeDocumentRollbackTrigger(v *types.RollbackTrigger, value query.Value) error {
3954	object := value.Object()
3955	_ = object
3956
3957	if v.Arn != nil {
3958		objectKey := object.Key("Arn")
3959		objectKey.String(*v.Arn)
3960	}
3961
3962	if v.Type != nil {
3963		objectKey := object.Key("Type")
3964		objectKey.String(*v.Type)
3965	}
3966
3967	return nil
3968}
3969
3970func awsAwsquery_serializeDocumentRollbackTriggers(v []types.RollbackTrigger, value query.Value) error {
3971	if len(v) == 0 {
3972		return nil
3973	}
3974	array := value.Array("member")
3975
3976	for i := range v {
3977		av := array.Value()
3978		if err := awsAwsquery_serializeDocumentRollbackTrigger(&v[i], av); err != nil {
3979			return err
3980		}
3981	}
3982	return nil
3983}
3984
3985func awsAwsquery_serializeDocumentStackIdList(v []string, value query.Value) error {
3986	if len(v) == 0 {
3987		return nil
3988	}
3989	array := value.Array("member")
3990
3991	for i := range v {
3992		av := array.Value()
3993		av.String(v[i])
3994	}
3995	return nil
3996}
3997
3998func awsAwsquery_serializeDocumentStackInstanceFilter(v *types.StackInstanceFilter, value query.Value) error {
3999	object := value.Object()
4000	_ = object
4001
4002	if len(v.Name) > 0 {
4003		objectKey := object.Key("Name")
4004		objectKey.String(string(v.Name))
4005	}
4006
4007	if v.Values != nil {
4008		objectKey := object.Key("Values")
4009		objectKey.String(*v.Values)
4010	}
4011
4012	return nil
4013}
4014
4015func awsAwsquery_serializeDocumentStackInstanceFilters(v []types.StackInstanceFilter, value query.Value) error {
4016	if len(v) == 0 {
4017		return nil
4018	}
4019	array := value.Array("member")
4020
4021	for i := range v {
4022		av := array.Value()
4023		if err := awsAwsquery_serializeDocumentStackInstanceFilter(&v[i], av); err != nil {
4024			return err
4025		}
4026	}
4027	return nil
4028}
4029
4030func awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v []types.StackResourceDriftStatus, value query.Value) error {
4031	if len(v) == 0 {
4032		return nil
4033	}
4034	array := value.Array("member")
4035
4036	for i := range v {
4037		av := array.Value()
4038		av.String(string(v[i]))
4039	}
4040	return nil
4041}
4042
4043func awsAwsquery_serializeDocumentStackSetOperationPreferences(v *types.StackSetOperationPreferences, value query.Value) error {
4044	object := value.Object()
4045	_ = object
4046
4047	if v.FailureToleranceCount != nil {
4048		objectKey := object.Key("FailureToleranceCount")
4049		objectKey.Integer(*v.FailureToleranceCount)
4050	}
4051
4052	if v.FailureTolerancePercentage != nil {
4053		objectKey := object.Key("FailureTolerancePercentage")
4054		objectKey.Integer(*v.FailureTolerancePercentage)
4055	}
4056
4057	if v.MaxConcurrentCount != nil {
4058		objectKey := object.Key("MaxConcurrentCount")
4059		objectKey.Integer(*v.MaxConcurrentCount)
4060	}
4061
4062	if v.MaxConcurrentPercentage != nil {
4063		objectKey := object.Key("MaxConcurrentPercentage")
4064		objectKey.Integer(*v.MaxConcurrentPercentage)
4065	}
4066
4067	if len(v.RegionConcurrencyType) > 0 {
4068		objectKey := object.Key("RegionConcurrencyType")
4069		objectKey.String(string(v.RegionConcurrencyType))
4070	}
4071
4072	if v.RegionOrder != nil {
4073		objectKey := object.Key("RegionOrder")
4074		if err := awsAwsquery_serializeDocumentRegionList(v.RegionOrder, objectKey); err != nil {
4075			return err
4076		}
4077	}
4078
4079	return nil
4080}
4081
4082func awsAwsquery_serializeDocumentStackStatusFilter(v []types.StackStatus, value query.Value) error {
4083	if len(v) == 0 {
4084		return nil
4085	}
4086	array := value.Array("member")
4087
4088	for i := range v {
4089		av := array.Value()
4090		av.String(string(v[i]))
4091	}
4092	return nil
4093}
4094
4095func awsAwsquery_serializeDocumentTag(v *types.Tag, value query.Value) error {
4096	object := value.Object()
4097	_ = object
4098
4099	if v.Key != nil {
4100		objectKey := object.Key("Key")
4101		objectKey.String(*v.Key)
4102	}
4103
4104	if v.Value != nil {
4105		objectKey := object.Key("Value")
4106		objectKey.String(*v.Value)
4107	}
4108
4109	return nil
4110}
4111
4112func awsAwsquery_serializeDocumentTags(v []types.Tag, value query.Value) error {
4113	if len(v) == 0 {
4114		return nil
4115	}
4116	array := value.Array("member")
4117
4118	for i := range v {
4119		av := array.Value()
4120		if err := awsAwsquery_serializeDocumentTag(&v[i], av); err != nil {
4121			return err
4122		}
4123	}
4124	return nil
4125}
4126
4127func awsAwsquery_serializeDocumentTypeConfigurationIdentifier(v *types.TypeConfigurationIdentifier, value query.Value) error {
4128	object := value.Object()
4129	_ = object
4130
4131	if len(v.Type) > 0 {
4132		objectKey := object.Key("Type")
4133		objectKey.String(string(v.Type))
4134	}
4135
4136	if v.TypeArn != nil {
4137		objectKey := object.Key("TypeArn")
4138		objectKey.String(*v.TypeArn)
4139	}
4140
4141	if v.TypeConfigurationAlias != nil {
4142		objectKey := object.Key("TypeConfigurationAlias")
4143		objectKey.String(*v.TypeConfigurationAlias)
4144	}
4145
4146	if v.TypeConfigurationArn != nil {
4147		objectKey := object.Key("TypeConfigurationArn")
4148		objectKey.String(*v.TypeConfigurationArn)
4149	}
4150
4151	if v.TypeName != nil {
4152		objectKey := object.Key("TypeName")
4153		objectKey.String(*v.TypeName)
4154	}
4155
4156	return nil
4157}
4158
4159func awsAwsquery_serializeDocumentTypeConfigurationIdentifiers(v []types.TypeConfigurationIdentifier, value query.Value) error {
4160	if len(v) == 0 {
4161		return nil
4162	}
4163	array := value.Array("member")
4164
4165	for i := range v {
4166		av := array.Value()
4167		if err := awsAwsquery_serializeDocumentTypeConfigurationIdentifier(&v[i], av); err != nil {
4168			return err
4169		}
4170	}
4171	return nil
4172}
4173
4174func awsAwsquery_serializeDocumentTypeFilters(v *types.TypeFilters, value query.Value) error {
4175	object := value.Object()
4176	_ = object
4177
4178	if len(v.Category) > 0 {
4179		objectKey := object.Key("Category")
4180		objectKey.String(string(v.Category))
4181	}
4182
4183	if v.PublisherId != nil {
4184		objectKey := object.Key("PublisherId")
4185		objectKey.String(*v.PublisherId)
4186	}
4187
4188	if v.TypeNamePrefix != nil {
4189		objectKey := object.Key("TypeNamePrefix")
4190		objectKey.String(*v.TypeNamePrefix)
4191	}
4192
4193	return nil
4194}
4195
4196func awsAwsquery_serializeOpDocumentActivateTypeInput(v *ActivateTypeInput, value query.Value) error {
4197	object := value.Object()
4198	_ = object
4199
4200	if v.AutoUpdate != nil {
4201		objectKey := object.Key("AutoUpdate")
4202		objectKey.Boolean(*v.AutoUpdate)
4203	}
4204
4205	if v.ExecutionRoleArn != nil {
4206		objectKey := object.Key("ExecutionRoleArn")
4207		objectKey.String(*v.ExecutionRoleArn)
4208	}
4209
4210	if v.LoggingConfig != nil {
4211		objectKey := object.Key("LoggingConfig")
4212		if err := awsAwsquery_serializeDocumentLoggingConfig(v.LoggingConfig, objectKey); err != nil {
4213			return err
4214		}
4215	}
4216
4217	if v.MajorVersion != nil {
4218		objectKey := object.Key("MajorVersion")
4219		objectKey.Long(*v.MajorVersion)
4220	}
4221
4222	if v.PublicTypeArn != nil {
4223		objectKey := object.Key("PublicTypeArn")
4224		objectKey.String(*v.PublicTypeArn)
4225	}
4226
4227	if v.PublisherId != nil {
4228		objectKey := object.Key("PublisherId")
4229		objectKey.String(*v.PublisherId)
4230	}
4231
4232	if len(v.Type) > 0 {
4233		objectKey := object.Key("Type")
4234		objectKey.String(string(v.Type))
4235	}
4236
4237	if v.TypeName != nil {
4238		objectKey := object.Key("TypeName")
4239		objectKey.String(*v.TypeName)
4240	}
4241
4242	if v.TypeNameAlias != nil {
4243		objectKey := object.Key("TypeNameAlias")
4244		objectKey.String(*v.TypeNameAlias)
4245	}
4246
4247	if len(v.VersionBump) > 0 {
4248		objectKey := object.Key("VersionBump")
4249		objectKey.String(string(v.VersionBump))
4250	}
4251
4252	return nil
4253}
4254
4255func awsAwsquery_serializeOpDocumentBatchDescribeTypeConfigurationsInput(v *BatchDescribeTypeConfigurationsInput, value query.Value) error {
4256	object := value.Object()
4257	_ = object
4258
4259	if v.TypeConfigurationIdentifiers != nil {
4260		objectKey := object.Key("TypeConfigurationIdentifiers")
4261		if err := awsAwsquery_serializeDocumentTypeConfigurationIdentifiers(v.TypeConfigurationIdentifiers, objectKey); err != nil {
4262			return err
4263		}
4264	}
4265
4266	return nil
4267}
4268
4269func awsAwsquery_serializeOpDocumentCancelUpdateStackInput(v *CancelUpdateStackInput, value query.Value) error {
4270	object := value.Object()
4271	_ = object
4272
4273	if v.ClientRequestToken != nil {
4274		objectKey := object.Key("ClientRequestToken")
4275		objectKey.String(*v.ClientRequestToken)
4276	}
4277
4278	if v.StackName != nil {
4279		objectKey := object.Key("StackName")
4280		objectKey.String(*v.StackName)
4281	}
4282
4283	return nil
4284}
4285
4286func awsAwsquery_serializeOpDocumentContinueUpdateRollbackInput(v *ContinueUpdateRollbackInput, value query.Value) error {
4287	object := value.Object()
4288	_ = object
4289
4290	if v.ClientRequestToken != nil {
4291		objectKey := object.Key("ClientRequestToken")
4292		objectKey.String(*v.ClientRequestToken)
4293	}
4294
4295	if v.ResourcesToSkip != nil {
4296		objectKey := object.Key("ResourcesToSkip")
4297		if err := awsAwsquery_serializeDocumentResourcesToSkip(v.ResourcesToSkip, objectKey); err != nil {
4298			return err
4299		}
4300	}
4301
4302	if v.RoleARN != nil {
4303		objectKey := object.Key("RoleARN")
4304		objectKey.String(*v.RoleARN)
4305	}
4306
4307	if v.StackName != nil {
4308		objectKey := object.Key("StackName")
4309		objectKey.String(*v.StackName)
4310	}
4311
4312	return nil
4313}
4314
4315func awsAwsquery_serializeOpDocumentCreateChangeSetInput(v *CreateChangeSetInput, value query.Value) error {
4316	object := value.Object()
4317	_ = object
4318
4319	if v.Capabilities != nil {
4320		objectKey := object.Key("Capabilities")
4321		if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil {
4322			return err
4323		}
4324	}
4325
4326	if v.ChangeSetName != nil {
4327		objectKey := object.Key("ChangeSetName")
4328		objectKey.String(*v.ChangeSetName)
4329	}
4330
4331	if len(v.ChangeSetType) > 0 {
4332		objectKey := object.Key("ChangeSetType")
4333		objectKey.String(string(v.ChangeSetType))
4334	}
4335
4336	if v.ClientToken != nil {
4337		objectKey := object.Key("ClientToken")
4338		objectKey.String(*v.ClientToken)
4339	}
4340
4341	if v.Description != nil {
4342		objectKey := object.Key("Description")
4343		objectKey.String(*v.Description)
4344	}
4345
4346	if v.IncludeNestedStacks != nil {
4347		objectKey := object.Key("IncludeNestedStacks")
4348		objectKey.Boolean(*v.IncludeNestedStacks)
4349	}
4350
4351	if v.NotificationARNs != nil {
4352		objectKey := object.Key("NotificationARNs")
4353		if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil {
4354			return err
4355		}
4356	}
4357
4358	if v.Parameters != nil {
4359		objectKey := object.Key("Parameters")
4360		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
4361			return err
4362		}
4363	}
4364
4365	if v.ResourcesToImport != nil {
4366		objectKey := object.Key("ResourcesToImport")
4367		if err := awsAwsquery_serializeDocumentResourcesToImport(v.ResourcesToImport, objectKey); err != nil {
4368			return err
4369		}
4370	}
4371
4372	if v.ResourceTypes != nil {
4373		objectKey := object.Key("ResourceTypes")
4374		if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil {
4375			return err
4376		}
4377	}
4378
4379	if v.RoleARN != nil {
4380		objectKey := object.Key("RoleARN")
4381		objectKey.String(*v.RoleARN)
4382	}
4383
4384	if v.RollbackConfiguration != nil {
4385		objectKey := object.Key("RollbackConfiguration")
4386		if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil {
4387			return err
4388		}
4389	}
4390
4391	if v.StackName != nil {
4392		objectKey := object.Key("StackName")
4393		objectKey.String(*v.StackName)
4394	}
4395
4396	if v.Tags != nil {
4397		objectKey := object.Key("Tags")
4398		if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil {
4399			return err
4400		}
4401	}
4402
4403	if v.TemplateBody != nil {
4404		objectKey := object.Key("TemplateBody")
4405		objectKey.String(*v.TemplateBody)
4406	}
4407
4408	if v.TemplateURL != nil {
4409		objectKey := object.Key("TemplateURL")
4410		objectKey.String(*v.TemplateURL)
4411	}
4412
4413	if v.UsePreviousTemplate != nil {
4414		objectKey := object.Key("UsePreviousTemplate")
4415		objectKey.Boolean(*v.UsePreviousTemplate)
4416	}
4417
4418	return nil
4419}
4420
4421func awsAwsquery_serializeOpDocumentCreateStackInput(v *CreateStackInput, value query.Value) error {
4422	object := value.Object()
4423	_ = object
4424
4425	if v.Capabilities != nil {
4426		objectKey := object.Key("Capabilities")
4427		if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil {
4428			return err
4429		}
4430	}
4431
4432	if v.ClientRequestToken != nil {
4433		objectKey := object.Key("ClientRequestToken")
4434		objectKey.String(*v.ClientRequestToken)
4435	}
4436
4437	if v.DisableRollback != nil {
4438		objectKey := object.Key("DisableRollback")
4439		objectKey.Boolean(*v.DisableRollback)
4440	}
4441
4442	if v.EnableTerminationProtection != nil {
4443		objectKey := object.Key("EnableTerminationProtection")
4444		objectKey.Boolean(*v.EnableTerminationProtection)
4445	}
4446
4447	if v.NotificationARNs != nil {
4448		objectKey := object.Key("NotificationARNs")
4449		if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil {
4450			return err
4451		}
4452	}
4453
4454	if len(v.OnFailure) > 0 {
4455		objectKey := object.Key("OnFailure")
4456		objectKey.String(string(v.OnFailure))
4457	}
4458
4459	if v.Parameters != nil {
4460		objectKey := object.Key("Parameters")
4461		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
4462			return err
4463		}
4464	}
4465
4466	if v.ResourceTypes != nil {
4467		objectKey := object.Key("ResourceTypes")
4468		if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil {
4469			return err
4470		}
4471	}
4472
4473	if v.RoleARN != nil {
4474		objectKey := object.Key("RoleARN")
4475		objectKey.String(*v.RoleARN)
4476	}
4477
4478	if v.RollbackConfiguration != nil {
4479		objectKey := object.Key("RollbackConfiguration")
4480		if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil {
4481			return err
4482		}
4483	}
4484
4485	if v.StackName != nil {
4486		objectKey := object.Key("StackName")
4487		objectKey.String(*v.StackName)
4488	}
4489
4490	if v.StackPolicyBody != nil {
4491		objectKey := object.Key("StackPolicyBody")
4492		objectKey.String(*v.StackPolicyBody)
4493	}
4494
4495	if v.StackPolicyURL != nil {
4496		objectKey := object.Key("StackPolicyURL")
4497		objectKey.String(*v.StackPolicyURL)
4498	}
4499
4500	if v.Tags != nil {
4501		objectKey := object.Key("Tags")
4502		if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil {
4503			return err
4504		}
4505	}
4506
4507	if v.TemplateBody != nil {
4508		objectKey := object.Key("TemplateBody")
4509		objectKey.String(*v.TemplateBody)
4510	}
4511
4512	if v.TemplateURL != nil {
4513		objectKey := object.Key("TemplateURL")
4514		objectKey.String(*v.TemplateURL)
4515	}
4516
4517	if v.TimeoutInMinutes != nil {
4518		objectKey := object.Key("TimeoutInMinutes")
4519		objectKey.Integer(*v.TimeoutInMinutes)
4520	}
4521
4522	return nil
4523}
4524
4525func awsAwsquery_serializeOpDocumentCreateStackInstancesInput(v *CreateStackInstancesInput, value query.Value) error {
4526	object := value.Object()
4527	_ = object
4528
4529	if v.Accounts != nil {
4530		objectKey := object.Key("Accounts")
4531		if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil {
4532			return err
4533		}
4534	}
4535
4536	if len(v.CallAs) > 0 {
4537		objectKey := object.Key("CallAs")
4538		objectKey.String(string(v.CallAs))
4539	}
4540
4541	if v.DeploymentTargets != nil {
4542		objectKey := object.Key("DeploymentTargets")
4543		if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil {
4544			return err
4545		}
4546	}
4547
4548	if v.OperationId != nil {
4549		objectKey := object.Key("OperationId")
4550		objectKey.String(*v.OperationId)
4551	}
4552
4553	if v.OperationPreferences != nil {
4554		objectKey := object.Key("OperationPreferences")
4555		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
4556			return err
4557		}
4558	}
4559
4560	if v.ParameterOverrides != nil {
4561		objectKey := object.Key("ParameterOverrides")
4562		if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil {
4563			return err
4564		}
4565	}
4566
4567	if v.Regions != nil {
4568		objectKey := object.Key("Regions")
4569		if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil {
4570			return err
4571		}
4572	}
4573
4574	if v.StackSetName != nil {
4575		objectKey := object.Key("StackSetName")
4576		objectKey.String(*v.StackSetName)
4577	}
4578
4579	return nil
4580}
4581
4582func awsAwsquery_serializeOpDocumentCreateStackSetInput(v *CreateStackSetInput, value query.Value) error {
4583	object := value.Object()
4584	_ = object
4585
4586	if v.AdministrationRoleARN != nil {
4587		objectKey := object.Key("AdministrationRoleARN")
4588		objectKey.String(*v.AdministrationRoleARN)
4589	}
4590
4591	if v.AutoDeployment != nil {
4592		objectKey := object.Key("AutoDeployment")
4593		if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil {
4594			return err
4595		}
4596	}
4597
4598	if len(v.CallAs) > 0 {
4599		objectKey := object.Key("CallAs")
4600		objectKey.String(string(v.CallAs))
4601	}
4602
4603	if v.Capabilities != nil {
4604		objectKey := object.Key("Capabilities")
4605		if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil {
4606			return err
4607		}
4608	}
4609
4610	if v.ClientRequestToken != nil {
4611		objectKey := object.Key("ClientRequestToken")
4612		objectKey.String(*v.ClientRequestToken)
4613	}
4614
4615	if v.Description != nil {
4616		objectKey := object.Key("Description")
4617		objectKey.String(*v.Description)
4618	}
4619
4620	if v.ExecutionRoleName != nil {
4621		objectKey := object.Key("ExecutionRoleName")
4622		objectKey.String(*v.ExecutionRoleName)
4623	}
4624
4625	if v.Parameters != nil {
4626		objectKey := object.Key("Parameters")
4627		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
4628			return err
4629		}
4630	}
4631
4632	if len(v.PermissionModel) > 0 {
4633		objectKey := object.Key("PermissionModel")
4634		objectKey.String(string(v.PermissionModel))
4635	}
4636
4637	if v.StackId != nil {
4638		objectKey := object.Key("StackId")
4639		objectKey.String(*v.StackId)
4640	}
4641
4642	if v.StackSetName != nil {
4643		objectKey := object.Key("StackSetName")
4644		objectKey.String(*v.StackSetName)
4645	}
4646
4647	if v.Tags != nil {
4648		objectKey := object.Key("Tags")
4649		if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil {
4650			return err
4651		}
4652	}
4653
4654	if v.TemplateBody != nil {
4655		objectKey := object.Key("TemplateBody")
4656		objectKey.String(*v.TemplateBody)
4657	}
4658
4659	if v.TemplateURL != nil {
4660		objectKey := object.Key("TemplateURL")
4661		objectKey.String(*v.TemplateURL)
4662	}
4663
4664	return nil
4665}
4666
4667func awsAwsquery_serializeOpDocumentDeactivateTypeInput(v *DeactivateTypeInput, value query.Value) error {
4668	object := value.Object()
4669	_ = object
4670
4671	if v.Arn != nil {
4672		objectKey := object.Key("Arn")
4673		objectKey.String(*v.Arn)
4674	}
4675
4676	if len(v.Type) > 0 {
4677		objectKey := object.Key("Type")
4678		objectKey.String(string(v.Type))
4679	}
4680
4681	if v.TypeName != nil {
4682		objectKey := object.Key("TypeName")
4683		objectKey.String(*v.TypeName)
4684	}
4685
4686	return nil
4687}
4688
4689func awsAwsquery_serializeOpDocumentDeleteChangeSetInput(v *DeleteChangeSetInput, value query.Value) error {
4690	object := value.Object()
4691	_ = object
4692
4693	if v.ChangeSetName != nil {
4694		objectKey := object.Key("ChangeSetName")
4695		objectKey.String(*v.ChangeSetName)
4696	}
4697
4698	if v.StackName != nil {
4699		objectKey := object.Key("StackName")
4700		objectKey.String(*v.StackName)
4701	}
4702
4703	return nil
4704}
4705
4706func awsAwsquery_serializeOpDocumentDeleteStackInput(v *DeleteStackInput, value query.Value) error {
4707	object := value.Object()
4708	_ = object
4709
4710	if v.ClientRequestToken != nil {
4711		objectKey := object.Key("ClientRequestToken")
4712		objectKey.String(*v.ClientRequestToken)
4713	}
4714
4715	if v.RetainResources != nil {
4716		objectKey := object.Key("RetainResources")
4717		if err := awsAwsquery_serializeDocumentRetainResources(v.RetainResources, objectKey); err != nil {
4718			return err
4719		}
4720	}
4721
4722	if v.RoleARN != nil {
4723		objectKey := object.Key("RoleARN")
4724		objectKey.String(*v.RoleARN)
4725	}
4726
4727	if v.StackName != nil {
4728		objectKey := object.Key("StackName")
4729		objectKey.String(*v.StackName)
4730	}
4731
4732	return nil
4733}
4734
4735func awsAwsquery_serializeOpDocumentDeleteStackInstancesInput(v *DeleteStackInstancesInput, value query.Value) error {
4736	object := value.Object()
4737	_ = object
4738
4739	if v.Accounts != nil {
4740		objectKey := object.Key("Accounts")
4741		if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil {
4742			return err
4743		}
4744	}
4745
4746	if len(v.CallAs) > 0 {
4747		objectKey := object.Key("CallAs")
4748		objectKey.String(string(v.CallAs))
4749	}
4750
4751	if v.DeploymentTargets != nil {
4752		objectKey := object.Key("DeploymentTargets")
4753		if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil {
4754			return err
4755		}
4756	}
4757
4758	if v.OperationId != nil {
4759		objectKey := object.Key("OperationId")
4760		objectKey.String(*v.OperationId)
4761	}
4762
4763	if v.OperationPreferences != nil {
4764		objectKey := object.Key("OperationPreferences")
4765		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
4766			return err
4767		}
4768	}
4769
4770	if v.Regions != nil {
4771		objectKey := object.Key("Regions")
4772		if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil {
4773			return err
4774		}
4775	}
4776
4777	{
4778		objectKey := object.Key("RetainStacks")
4779		objectKey.Boolean(v.RetainStacks)
4780	}
4781
4782	if v.StackSetName != nil {
4783		objectKey := object.Key("StackSetName")
4784		objectKey.String(*v.StackSetName)
4785	}
4786
4787	return nil
4788}
4789
4790func awsAwsquery_serializeOpDocumentDeleteStackSetInput(v *DeleteStackSetInput, value query.Value) error {
4791	object := value.Object()
4792	_ = object
4793
4794	if len(v.CallAs) > 0 {
4795		objectKey := object.Key("CallAs")
4796		objectKey.String(string(v.CallAs))
4797	}
4798
4799	if v.StackSetName != nil {
4800		objectKey := object.Key("StackSetName")
4801		objectKey.String(*v.StackSetName)
4802	}
4803
4804	return nil
4805}
4806
4807func awsAwsquery_serializeOpDocumentDeregisterTypeInput(v *DeregisterTypeInput, value query.Value) error {
4808	object := value.Object()
4809	_ = object
4810
4811	if v.Arn != nil {
4812		objectKey := object.Key("Arn")
4813		objectKey.String(*v.Arn)
4814	}
4815
4816	if len(v.Type) > 0 {
4817		objectKey := object.Key("Type")
4818		objectKey.String(string(v.Type))
4819	}
4820
4821	if v.TypeName != nil {
4822		objectKey := object.Key("TypeName")
4823		objectKey.String(*v.TypeName)
4824	}
4825
4826	if v.VersionId != nil {
4827		objectKey := object.Key("VersionId")
4828		objectKey.String(*v.VersionId)
4829	}
4830
4831	return nil
4832}
4833
4834func awsAwsquery_serializeOpDocumentDescribeAccountLimitsInput(v *DescribeAccountLimitsInput, value query.Value) error {
4835	object := value.Object()
4836	_ = object
4837
4838	if v.NextToken != nil {
4839		objectKey := object.Key("NextToken")
4840		objectKey.String(*v.NextToken)
4841	}
4842
4843	return nil
4844}
4845
4846func awsAwsquery_serializeOpDocumentDescribeChangeSetInput(v *DescribeChangeSetInput, value query.Value) error {
4847	object := value.Object()
4848	_ = object
4849
4850	if v.ChangeSetName != nil {
4851		objectKey := object.Key("ChangeSetName")
4852		objectKey.String(*v.ChangeSetName)
4853	}
4854
4855	if v.NextToken != nil {
4856		objectKey := object.Key("NextToken")
4857		objectKey.String(*v.NextToken)
4858	}
4859
4860	if v.StackName != nil {
4861		objectKey := object.Key("StackName")
4862		objectKey.String(*v.StackName)
4863	}
4864
4865	return nil
4866}
4867
4868func awsAwsquery_serializeOpDocumentDescribePublisherInput(v *DescribePublisherInput, value query.Value) error {
4869	object := value.Object()
4870	_ = object
4871
4872	if v.PublisherId != nil {
4873		objectKey := object.Key("PublisherId")
4874		objectKey.String(*v.PublisherId)
4875	}
4876
4877	return nil
4878}
4879
4880func awsAwsquery_serializeOpDocumentDescribeStackDriftDetectionStatusInput(v *DescribeStackDriftDetectionStatusInput, value query.Value) error {
4881	object := value.Object()
4882	_ = object
4883
4884	if v.StackDriftDetectionId != nil {
4885		objectKey := object.Key("StackDriftDetectionId")
4886		objectKey.String(*v.StackDriftDetectionId)
4887	}
4888
4889	return nil
4890}
4891
4892func awsAwsquery_serializeOpDocumentDescribeStackEventsInput(v *DescribeStackEventsInput, value query.Value) error {
4893	object := value.Object()
4894	_ = object
4895
4896	if v.NextToken != nil {
4897		objectKey := object.Key("NextToken")
4898		objectKey.String(*v.NextToken)
4899	}
4900
4901	if v.StackName != nil {
4902		objectKey := object.Key("StackName")
4903		objectKey.String(*v.StackName)
4904	}
4905
4906	return nil
4907}
4908
4909func awsAwsquery_serializeOpDocumentDescribeStackInstanceInput(v *DescribeStackInstanceInput, value query.Value) error {
4910	object := value.Object()
4911	_ = object
4912
4913	if len(v.CallAs) > 0 {
4914		objectKey := object.Key("CallAs")
4915		objectKey.String(string(v.CallAs))
4916	}
4917
4918	if v.StackInstanceAccount != nil {
4919		objectKey := object.Key("StackInstanceAccount")
4920		objectKey.String(*v.StackInstanceAccount)
4921	}
4922
4923	if v.StackInstanceRegion != nil {
4924		objectKey := object.Key("StackInstanceRegion")
4925		objectKey.String(*v.StackInstanceRegion)
4926	}
4927
4928	if v.StackSetName != nil {
4929		objectKey := object.Key("StackSetName")
4930		objectKey.String(*v.StackSetName)
4931	}
4932
4933	return nil
4934}
4935
4936func awsAwsquery_serializeOpDocumentDescribeStackResourceDriftsInput(v *DescribeStackResourceDriftsInput, value query.Value) error {
4937	object := value.Object()
4938	_ = object
4939
4940	if v.MaxResults != nil {
4941		objectKey := object.Key("MaxResults")
4942		objectKey.Integer(*v.MaxResults)
4943	}
4944
4945	if v.NextToken != nil {
4946		objectKey := object.Key("NextToken")
4947		objectKey.String(*v.NextToken)
4948	}
4949
4950	if v.StackName != nil {
4951		objectKey := object.Key("StackName")
4952		objectKey.String(*v.StackName)
4953	}
4954
4955	if v.StackResourceDriftStatusFilters != nil {
4956		objectKey := object.Key("StackResourceDriftStatusFilters")
4957		if err := awsAwsquery_serializeDocumentStackResourceDriftStatusFilters(v.StackResourceDriftStatusFilters, objectKey); err != nil {
4958			return err
4959		}
4960	}
4961
4962	return nil
4963}
4964
4965func awsAwsquery_serializeOpDocumentDescribeStackResourceInput(v *DescribeStackResourceInput, value query.Value) error {
4966	object := value.Object()
4967	_ = object
4968
4969	if v.LogicalResourceId != nil {
4970		objectKey := object.Key("LogicalResourceId")
4971		objectKey.String(*v.LogicalResourceId)
4972	}
4973
4974	if v.StackName != nil {
4975		objectKey := object.Key("StackName")
4976		objectKey.String(*v.StackName)
4977	}
4978
4979	return nil
4980}
4981
4982func awsAwsquery_serializeOpDocumentDescribeStackResourcesInput(v *DescribeStackResourcesInput, value query.Value) error {
4983	object := value.Object()
4984	_ = object
4985
4986	if v.LogicalResourceId != nil {
4987		objectKey := object.Key("LogicalResourceId")
4988		objectKey.String(*v.LogicalResourceId)
4989	}
4990
4991	if v.PhysicalResourceId != nil {
4992		objectKey := object.Key("PhysicalResourceId")
4993		objectKey.String(*v.PhysicalResourceId)
4994	}
4995
4996	if v.StackName != nil {
4997		objectKey := object.Key("StackName")
4998		objectKey.String(*v.StackName)
4999	}
5000
5001	return nil
5002}
5003
5004func awsAwsquery_serializeOpDocumentDescribeStackSetInput(v *DescribeStackSetInput, value query.Value) error {
5005	object := value.Object()
5006	_ = object
5007
5008	if len(v.CallAs) > 0 {
5009		objectKey := object.Key("CallAs")
5010		objectKey.String(string(v.CallAs))
5011	}
5012
5013	if v.StackSetName != nil {
5014		objectKey := object.Key("StackSetName")
5015		objectKey.String(*v.StackSetName)
5016	}
5017
5018	return nil
5019}
5020
5021func awsAwsquery_serializeOpDocumentDescribeStackSetOperationInput(v *DescribeStackSetOperationInput, value query.Value) error {
5022	object := value.Object()
5023	_ = object
5024
5025	if len(v.CallAs) > 0 {
5026		objectKey := object.Key("CallAs")
5027		objectKey.String(string(v.CallAs))
5028	}
5029
5030	if v.OperationId != nil {
5031		objectKey := object.Key("OperationId")
5032		objectKey.String(*v.OperationId)
5033	}
5034
5035	if v.StackSetName != nil {
5036		objectKey := object.Key("StackSetName")
5037		objectKey.String(*v.StackSetName)
5038	}
5039
5040	return nil
5041}
5042
5043func awsAwsquery_serializeOpDocumentDescribeStacksInput(v *DescribeStacksInput, value query.Value) error {
5044	object := value.Object()
5045	_ = object
5046
5047	if v.NextToken != nil {
5048		objectKey := object.Key("NextToken")
5049		objectKey.String(*v.NextToken)
5050	}
5051
5052	if v.StackName != nil {
5053		objectKey := object.Key("StackName")
5054		objectKey.String(*v.StackName)
5055	}
5056
5057	return nil
5058}
5059
5060func awsAwsquery_serializeOpDocumentDescribeTypeInput(v *DescribeTypeInput, value query.Value) error {
5061	object := value.Object()
5062	_ = object
5063
5064	if v.Arn != nil {
5065		objectKey := object.Key("Arn")
5066		objectKey.String(*v.Arn)
5067	}
5068
5069	if v.PublicVersionNumber != nil {
5070		objectKey := object.Key("PublicVersionNumber")
5071		objectKey.String(*v.PublicVersionNumber)
5072	}
5073
5074	if v.PublisherId != nil {
5075		objectKey := object.Key("PublisherId")
5076		objectKey.String(*v.PublisherId)
5077	}
5078
5079	if len(v.Type) > 0 {
5080		objectKey := object.Key("Type")
5081		objectKey.String(string(v.Type))
5082	}
5083
5084	if v.TypeName != nil {
5085		objectKey := object.Key("TypeName")
5086		objectKey.String(*v.TypeName)
5087	}
5088
5089	if v.VersionId != nil {
5090		objectKey := object.Key("VersionId")
5091		objectKey.String(*v.VersionId)
5092	}
5093
5094	return nil
5095}
5096
5097func awsAwsquery_serializeOpDocumentDescribeTypeRegistrationInput(v *DescribeTypeRegistrationInput, value query.Value) error {
5098	object := value.Object()
5099	_ = object
5100
5101	if v.RegistrationToken != nil {
5102		objectKey := object.Key("RegistrationToken")
5103		objectKey.String(*v.RegistrationToken)
5104	}
5105
5106	return nil
5107}
5108
5109func awsAwsquery_serializeOpDocumentDetectStackDriftInput(v *DetectStackDriftInput, value query.Value) error {
5110	object := value.Object()
5111	_ = object
5112
5113	if v.LogicalResourceIds != nil {
5114		objectKey := object.Key("LogicalResourceIds")
5115		if err := awsAwsquery_serializeDocumentLogicalResourceIds(v.LogicalResourceIds, objectKey); err != nil {
5116			return err
5117		}
5118	}
5119
5120	if v.StackName != nil {
5121		objectKey := object.Key("StackName")
5122		objectKey.String(*v.StackName)
5123	}
5124
5125	return nil
5126}
5127
5128func awsAwsquery_serializeOpDocumentDetectStackResourceDriftInput(v *DetectStackResourceDriftInput, value query.Value) error {
5129	object := value.Object()
5130	_ = object
5131
5132	if v.LogicalResourceId != nil {
5133		objectKey := object.Key("LogicalResourceId")
5134		objectKey.String(*v.LogicalResourceId)
5135	}
5136
5137	if v.StackName != nil {
5138		objectKey := object.Key("StackName")
5139		objectKey.String(*v.StackName)
5140	}
5141
5142	return nil
5143}
5144
5145func awsAwsquery_serializeOpDocumentDetectStackSetDriftInput(v *DetectStackSetDriftInput, value query.Value) error {
5146	object := value.Object()
5147	_ = object
5148
5149	if len(v.CallAs) > 0 {
5150		objectKey := object.Key("CallAs")
5151		objectKey.String(string(v.CallAs))
5152	}
5153
5154	if v.OperationId != nil {
5155		objectKey := object.Key("OperationId")
5156		objectKey.String(*v.OperationId)
5157	}
5158
5159	if v.OperationPreferences != nil {
5160		objectKey := object.Key("OperationPreferences")
5161		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
5162			return err
5163		}
5164	}
5165
5166	if v.StackSetName != nil {
5167		objectKey := object.Key("StackSetName")
5168		objectKey.String(*v.StackSetName)
5169	}
5170
5171	return nil
5172}
5173
5174func awsAwsquery_serializeOpDocumentEstimateTemplateCostInput(v *EstimateTemplateCostInput, value query.Value) error {
5175	object := value.Object()
5176	_ = object
5177
5178	if v.Parameters != nil {
5179		objectKey := object.Key("Parameters")
5180		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
5181			return err
5182		}
5183	}
5184
5185	if v.TemplateBody != nil {
5186		objectKey := object.Key("TemplateBody")
5187		objectKey.String(*v.TemplateBody)
5188	}
5189
5190	if v.TemplateURL != nil {
5191		objectKey := object.Key("TemplateURL")
5192		objectKey.String(*v.TemplateURL)
5193	}
5194
5195	return nil
5196}
5197
5198func awsAwsquery_serializeOpDocumentExecuteChangeSetInput(v *ExecuteChangeSetInput, value query.Value) error {
5199	object := value.Object()
5200	_ = object
5201
5202	if v.ChangeSetName != nil {
5203		objectKey := object.Key("ChangeSetName")
5204		objectKey.String(*v.ChangeSetName)
5205	}
5206
5207	if v.ClientRequestToken != nil {
5208		objectKey := object.Key("ClientRequestToken")
5209		objectKey.String(*v.ClientRequestToken)
5210	}
5211
5212	if v.DisableRollback != nil {
5213		objectKey := object.Key("DisableRollback")
5214		objectKey.Boolean(*v.DisableRollback)
5215	}
5216
5217	if v.StackName != nil {
5218		objectKey := object.Key("StackName")
5219		objectKey.String(*v.StackName)
5220	}
5221
5222	return nil
5223}
5224
5225func awsAwsquery_serializeOpDocumentGetStackPolicyInput(v *GetStackPolicyInput, value query.Value) error {
5226	object := value.Object()
5227	_ = object
5228
5229	if v.StackName != nil {
5230		objectKey := object.Key("StackName")
5231		objectKey.String(*v.StackName)
5232	}
5233
5234	return nil
5235}
5236
5237func awsAwsquery_serializeOpDocumentGetTemplateInput(v *GetTemplateInput, value query.Value) error {
5238	object := value.Object()
5239	_ = object
5240
5241	if v.ChangeSetName != nil {
5242		objectKey := object.Key("ChangeSetName")
5243		objectKey.String(*v.ChangeSetName)
5244	}
5245
5246	if v.StackName != nil {
5247		objectKey := object.Key("StackName")
5248		objectKey.String(*v.StackName)
5249	}
5250
5251	if len(v.TemplateStage) > 0 {
5252		objectKey := object.Key("TemplateStage")
5253		objectKey.String(string(v.TemplateStage))
5254	}
5255
5256	return nil
5257}
5258
5259func awsAwsquery_serializeOpDocumentGetTemplateSummaryInput(v *GetTemplateSummaryInput, value query.Value) error {
5260	object := value.Object()
5261	_ = object
5262
5263	if len(v.CallAs) > 0 {
5264		objectKey := object.Key("CallAs")
5265		objectKey.String(string(v.CallAs))
5266	}
5267
5268	if v.StackName != nil {
5269		objectKey := object.Key("StackName")
5270		objectKey.String(*v.StackName)
5271	}
5272
5273	if v.StackSetName != nil {
5274		objectKey := object.Key("StackSetName")
5275		objectKey.String(*v.StackSetName)
5276	}
5277
5278	if v.TemplateBody != nil {
5279		objectKey := object.Key("TemplateBody")
5280		objectKey.String(*v.TemplateBody)
5281	}
5282
5283	if v.TemplateURL != nil {
5284		objectKey := object.Key("TemplateURL")
5285		objectKey.String(*v.TemplateURL)
5286	}
5287
5288	return nil
5289}
5290
5291func awsAwsquery_serializeOpDocumentImportStacksToStackSetInput(v *ImportStacksToStackSetInput, value query.Value) error {
5292	object := value.Object()
5293	_ = object
5294
5295	if len(v.CallAs) > 0 {
5296		objectKey := object.Key("CallAs")
5297		objectKey.String(string(v.CallAs))
5298	}
5299
5300	if v.OperationId != nil {
5301		objectKey := object.Key("OperationId")
5302		objectKey.String(*v.OperationId)
5303	}
5304
5305	if v.OperationPreferences != nil {
5306		objectKey := object.Key("OperationPreferences")
5307		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
5308			return err
5309		}
5310	}
5311
5312	if v.StackIds != nil {
5313		objectKey := object.Key("StackIds")
5314		if err := awsAwsquery_serializeDocumentStackIdList(v.StackIds, objectKey); err != nil {
5315			return err
5316		}
5317	}
5318
5319	if v.StackSetName != nil {
5320		objectKey := object.Key("StackSetName")
5321		objectKey.String(*v.StackSetName)
5322	}
5323
5324	return nil
5325}
5326
5327func awsAwsquery_serializeOpDocumentListChangeSetsInput(v *ListChangeSetsInput, value query.Value) error {
5328	object := value.Object()
5329	_ = object
5330
5331	if v.NextToken != nil {
5332		objectKey := object.Key("NextToken")
5333		objectKey.String(*v.NextToken)
5334	}
5335
5336	if v.StackName != nil {
5337		objectKey := object.Key("StackName")
5338		objectKey.String(*v.StackName)
5339	}
5340
5341	return nil
5342}
5343
5344func awsAwsquery_serializeOpDocumentListExportsInput(v *ListExportsInput, value query.Value) error {
5345	object := value.Object()
5346	_ = object
5347
5348	if v.NextToken != nil {
5349		objectKey := object.Key("NextToken")
5350		objectKey.String(*v.NextToken)
5351	}
5352
5353	return nil
5354}
5355
5356func awsAwsquery_serializeOpDocumentListImportsInput(v *ListImportsInput, value query.Value) error {
5357	object := value.Object()
5358	_ = object
5359
5360	if v.ExportName != nil {
5361		objectKey := object.Key("ExportName")
5362		objectKey.String(*v.ExportName)
5363	}
5364
5365	if v.NextToken != nil {
5366		objectKey := object.Key("NextToken")
5367		objectKey.String(*v.NextToken)
5368	}
5369
5370	return nil
5371}
5372
5373func awsAwsquery_serializeOpDocumentListStackInstancesInput(v *ListStackInstancesInput, value query.Value) error {
5374	object := value.Object()
5375	_ = object
5376
5377	if len(v.CallAs) > 0 {
5378		objectKey := object.Key("CallAs")
5379		objectKey.String(string(v.CallAs))
5380	}
5381
5382	if v.Filters != nil {
5383		objectKey := object.Key("Filters")
5384		if err := awsAwsquery_serializeDocumentStackInstanceFilters(v.Filters, objectKey); err != nil {
5385			return err
5386		}
5387	}
5388
5389	if v.MaxResults != nil {
5390		objectKey := object.Key("MaxResults")
5391		objectKey.Integer(*v.MaxResults)
5392	}
5393
5394	if v.NextToken != nil {
5395		objectKey := object.Key("NextToken")
5396		objectKey.String(*v.NextToken)
5397	}
5398
5399	if v.StackInstanceAccount != nil {
5400		objectKey := object.Key("StackInstanceAccount")
5401		objectKey.String(*v.StackInstanceAccount)
5402	}
5403
5404	if v.StackInstanceRegion != nil {
5405		objectKey := object.Key("StackInstanceRegion")
5406		objectKey.String(*v.StackInstanceRegion)
5407	}
5408
5409	if v.StackSetName != nil {
5410		objectKey := object.Key("StackSetName")
5411		objectKey.String(*v.StackSetName)
5412	}
5413
5414	return nil
5415}
5416
5417func awsAwsquery_serializeOpDocumentListStackResourcesInput(v *ListStackResourcesInput, value query.Value) error {
5418	object := value.Object()
5419	_ = object
5420
5421	if v.NextToken != nil {
5422		objectKey := object.Key("NextToken")
5423		objectKey.String(*v.NextToken)
5424	}
5425
5426	if v.StackName != nil {
5427		objectKey := object.Key("StackName")
5428		objectKey.String(*v.StackName)
5429	}
5430
5431	return nil
5432}
5433
5434func awsAwsquery_serializeOpDocumentListStackSetOperationResultsInput(v *ListStackSetOperationResultsInput, value query.Value) error {
5435	object := value.Object()
5436	_ = object
5437
5438	if len(v.CallAs) > 0 {
5439		objectKey := object.Key("CallAs")
5440		objectKey.String(string(v.CallAs))
5441	}
5442
5443	if v.MaxResults != nil {
5444		objectKey := object.Key("MaxResults")
5445		objectKey.Integer(*v.MaxResults)
5446	}
5447
5448	if v.NextToken != nil {
5449		objectKey := object.Key("NextToken")
5450		objectKey.String(*v.NextToken)
5451	}
5452
5453	if v.OperationId != nil {
5454		objectKey := object.Key("OperationId")
5455		objectKey.String(*v.OperationId)
5456	}
5457
5458	if v.StackSetName != nil {
5459		objectKey := object.Key("StackSetName")
5460		objectKey.String(*v.StackSetName)
5461	}
5462
5463	return nil
5464}
5465
5466func awsAwsquery_serializeOpDocumentListStackSetOperationsInput(v *ListStackSetOperationsInput, value query.Value) error {
5467	object := value.Object()
5468	_ = object
5469
5470	if len(v.CallAs) > 0 {
5471		objectKey := object.Key("CallAs")
5472		objectKey.String(string(v.CallAs))
5473	}
5474
5475	if v.MaxResults != nil {
5476		objectKey := object.Key("MaxResults")
5477		objectKey.Integer(*v.MaxResults)
5478	}
5479
5480	if v.NextToken != nil {
5481		objectKey := object.Key("NextToken")
5482		objectKey.String(*v.NextToken)
5483	}
5484
5485	if v.StackSetName != nil {
5486		objectKey := object.Key("StackSetName")
5487		objectKey.String(*v.StackSetName)
5488	}
5489
5490	return nil
5491}
5492
5493func awsAwsquery_serializeOpDocumentListStackSetsInput(v *ListStackSetsInput, value query.Value) error {
5494	object := value.Object()
5495	_ = object
5496
5497	if len(v.CallAs) > 0 {
5498		objectKey := object.Key("CallAs")
5499		objectKey.String(string(v.CallAs))
5500	}
5501
5502	if v.MaxResults != nil {
5503		objectKey := object.Key("MaxResults")
5504		objectKey.Integer(*v.MaxResults)
5505	}
5506
5507	if v.NextToken != nil {
5508		objectKey := object.Key("NextToken")
5509		objectKey.String(*v.NextToken)
5510	}
5511
5512	if len(v.Status) > 0 {
5513		objectKey := object.Key("Status")
5514		objectKey.String(string(v.Status))
5515	}
5516
5517	return nil
5518}
5519
5520func awsAwsquery_serializeOpDocumentListStacksInput(v *ListStacksInput, value query.Value) error {
5521	object := value.Object()
5522	_ = object
5523
5524	if v.NextToken != nil {
5525		objectKey := object.Key("NextToken")
5526		objectKey.String(*v.NextToken)
5527	}
5528
5529	if v.StackStatusFilter != nil {
5530		objectKey := object.Key("StackStatusFilter")
5531		if err := awsAwsquery_serializeDocumentStackStatusFilter(v.StackStatusFilter, objectKey); err != nil {
5532			return err
5533		}
5534	}
5535
5536	return nil
5537}
5538
5539func awsAwsquery_serializeOpDocumentListTypeRegistrationsInput(v *ListTypeRegistrationsInput, value query.Value) error {
5540	object := value.Object()
5541	_ = object
5542
5543	if v.MaxResults != nil {
5544		objectKey := object.Key("MaxResults")
5545		objectKey.Integer(*v.MaxResults)
5546	}
5547
5548	if v.NextToken != nil {
5549		objectKey := object.Key("NextToken")
5550		objectKey.String(*v.NextToken)
5551	}
5552
5553	if len(v.RegistrationStatusFilter) > 0 {
5554		objectKey := object.Key("RegistrationStatusFilter")
5555		objectKey.String(string(v.RegistrationStatusFilter))
5556	}
5557
5558	if len(v.Type) > 0 {
5559		objectKey := object.Key("Type")
5560		objectKey.String(string(v.Type))
5561	}
5562
5563	if v.TypeArn != nil {
5564		objectKey := object.Key("TypeArn")
5565		objectKey.String(*v.TypeArn)
5566	}
5567
5568	if v.TypeName != nil {
5569		objectKey := object.Key("TypeName")
5570		objectKey.String(*v.TypeName)
5571	}
5572
5573	return nil
5574}
5575
5576func awsAwsquery_serializeOpDocumentListTypesInput(v *ListTypesInput, value query.Value) error {
5577	object := value.Object()
5578	_ = object
5579
5580	if len(v.DeprecatedStatus) > 0 {
5581		objectKey := object.Key("DeprecatedStatus")
5582		objectKey.String(string(v.DeprecatedStatus))
5583	}
5584
5585	if v.Filters != nil {
5586		objectKey := object.Key("Filters")
5587		if err := awsAwsquery_serializeDocumentTypeFilters(v.Filters, objectKey); err != nil {
5588			return err
5589		}
5590	}
5591
5592	if v.MaxResults != nil {
5593		objectKey := object.Key("MaxResults")
5594		objectKey.Integer(*v.MaxResults)
5595	}
5596
5597	if v.NextToken != nil {
5598		objectKey := object.Key("NextToken")
5599		objectKey.String(*v.NextToken)
5600	}
5601
5602	if len(v.ProvisioningType) > 0 {
5603		objectKey := object.Key("ProvisioningType")
5604		objectKey.String(string(v.ProvisioningType))
5605	}
5606
5607	if len(v.Type) > 0 {
5608		objectKey := object.Key("Type")
5609		objectKey.String(string(v.Type))
5610	}
5611
5612	if len(v.Visibility) > 0 {
5613		objectKey := object.Key("Visibility")
5614		objectKey.String(string(v.Visibility))
5615	}
5616
5617	return nil
5618}
5619
5620func awsAwsquery_serializeOpDocumentListTypeVersionsInput(v *ListTypeVersionsInput, value query.Value) error {
5621	object := value.Object()
5622	_ = object
5623
5624	if v.Arn != nil {
5625		objectKey := object.Key("Arn")
5626		objectKey.String(*v.Arn)
5627	}
5628
5629	if len(v.DeprecatedStatus) > 0 {
5630		objectKey := object.Key("DeprecatedStatus")
5631		objectKey.String(string(v.DeprecatedStatus))
5632	}
5633
5634	if v.MaxResults != nil {
5635		objectKey := object.Key("MaxResults")
5636		objectKey.Integer(*v.MaxResults)
5637	}
5638
5639	if v.NextToken != nil {
5640		objectKey := object.Key("NextToken")
5641		objectKey.String(*v.NextToken)
5642	}
5643
5644	if v.PublisherId != nil {
5645		objectKey := object.Key("PublisherId")
5646		objectKey.String(*v.PublisherId)
5647	}
5648
5649	if len(v.Type) > 0 {
5650		objectKey := object.Key("Type")
5651		objectKey.String(string(v.Type))
5652	}
5653
5654	if v.TypeName != nil {
5655		objectKey := object.Key("TypeName")
5656		objectKey.String(*v.TypeName)
5657	}
5658
5659	return nil
5660}
5661
5662func awsAwsquery_serializeOpDocumentPublishTypeInput(v *PublishTypeInput, value query.Value) error {
5663	object := value.Object()
5664	_ = object
5665
5666	if v.Arn != nil {
5667		objectKey := object.Key("Arn")
5668		objectKey.String(*v.Arn)
5669	}
5670
5671	if v.PublicVersionNumber != nil {
5672		objectKey := object.Key("PublicVersionNumber")
5673		objectKey.String(*v.PublicVersionNumber)
5674	}
5675
5676	if len(v.Type) > 0 {
5677		objectKey := object.Key("Type")
5678		objectKey.String(string(v.Type))
5679	}
5680
5681	if v.TypeName != nil {
5682		objectKey := object.Key("TypeName")
5683		objectKey.String(*v.TypeName)
5684	}
5685
5686	return nil
5687}
5688
5689func awsAwsquery_serializeOpDocumentRecordHandlerProgressInput(v *RecordHandlerProgressInput, value query.Value) error {
5690	object := value.Object()
5691	_ = object
5692
5693	if v.BearerToken != nil {
5694		objectKey := object.Key("BearerToken")
5695		objectKey.String(*v.BearerToken)
5696	}
5697
5698	if v.ClientRequestToken != nil {
5699		objectKey := object.Key("ClientRequestToken")
5700		objectKey.String(*v.ClientRequestToken)
5701	}
5702
5703	if len(v.CurrentOperationStatus) > 0 {
5704		objectKey := object.Key("CurrentOperationStatus")
5705		objectKey.String(string(v.CurrentOperationStatus))
5706	}
5707
5708	if len(v.ErrorCode) > 0 {
5709		objectKey := object.Key("ErrorCode")
5710		objectKey.String(string(v.ErrorCode))
5711	}
5712
5713	if len(v.OperationStatus) > 0 {
5714		objectKey := object.Key("OperationStatus")
5715		objectKey.String(string(v.OperationStatus))
5716	}
5717
5718	if v.ResourceModel != nil {
5719		objectKey := object.Key("ResourceModel")
5720		objectKey.String(*v.ResourceModel)
5721	}
5722
5723	if v.StatusMessage != nil {
5724		objectKey := object.Key("StatusMessage")
5725		objectKey.String(*v.StatusMessage)
5726	}
5727
5728	return nil
5729}
5730
5731func awsAwsquery_serializeOpDocumentRegisterPublisherInput(v *RegisterPublisherInput, value query.Value) error {
5732	object := value.Object()
5733	_ = object
5734
5735	if v.AcceptTermsAndConditions != nil {
5736		objectKey := object.Key("AcceptTermsAndConditions")
5737		objectKey.Boolean(*v.AcceptTermsAndConditions)
5738	}
5739
5740	if v.ConnectionArn != nil {
5741		objectKey := object.Key("ConnectionArn")
5742		objectKey.String(*v.ConnectionArn)
5743	}
5744
5745	return nil
5746}
5747
5748func awsAwsquery_serializeOpDocumentRegisterTypeInput(v *RegisterTypeInput, value query.Value) error {
5749	object := value.Object()
5750	_ = object
5751
5752	if v.ClientRequestToken != nil {
5753		objectKey := object.Key("ClientRequestToken")
5754		objectKey.String(*v.ClientRequestToken)
5755	}
5756
5757	if v.ExecutionRoleArn != nil {
5758		objectKey := object.Key("ExecutionRoleArn")
5759		objectKey.String(*v.ExecutionRoleArn)
5760	}
5761
5762	if v.LoggingConfig != nil {
5763		objectKey := object.Key("LoggingConfig")
5764		if err := awsAwsquery_serializeDocumentLoggingConfig(v.LoggingConfig, objectKey); err != nil {
5765			return err
5766		}
5767	}
5768
5769	if v.SchemaHandlerPackage != nil {
5770		objectKey := object.Key("SchemaHandlerPackage")
5771		objectKey.String(*v.SchemaHandlerPackage)
5772	}
5773
5774	if len(v.Type) > 0 {
5775		objectKey := object.Key("Type")
5776		objectKey.String(string(v.Type))
5777	}
5778
5779	if v.TypeName != nil {
5780		objectKey := object.Key("TypeName")
5781		objectKey.String(*v.TypeName)
5782	}
5783
5784	return nil
5785}
5786
5787func awsAwsquery_serializeOpDocumentRollbackStackInput(v *RollbackStackInput, value query.Value) error {
5788	object := value.Object()
5789	_ = object
5790
5791	if v.ClientRequestToken != nil {
5792		objectKey := object.Key("ClientRequestToken")
5793		objectKey.String(*v.ClientRequestToken)
5794	}
5795
5796	if v.RoleARN != nil {
5797		objectKey := object.Key("RoleARN")
5798		objectKey.String(*v.RoleARN)
5799	}
5800
5801	if v.StackName != nil {
5802		objectKey := object.Key("StackName")
5803		objectKey.String(*v.StackName)
5804	}
5805
5806	return nil
5807}
5808
5809func awsAwsquery_serializeOpDocumentSetStackPolicyInput(v *SetStackPolicyInput, value query.Value) error {
5810	object := value.Object()
5811	_ = object
5812
5813	if v.StackName != nil {
5814		objectKey := object.Key("StackName")
5815		objectKey.String(*v.StackName)
5816	}
5817
5818	if v.StackPolicyBody != nil {
5819		objectKey := object.Key("StackPolicyBody")
5820		objectKey.String(*v.StackPolicyBody)
5821	}
5822
5823	if v.StackPolicyURL != nil {
5824		objectKey := object.Key("StackPolicyURL")
5825		objectKey.String(*v.StackPolicyURL)
5826	}
5827
5828	return nil
5829}
5830
5831func awsAwsquery_serializeOpDocumentSetTypeConfigurationInput(v *SetTypeConfigurationInput, value query.Value) error {
5832	object := value.Object()
5833	_ = object
5834
5835	if v.Configuration != nil {
5836		objectKey := object.Key("Configuration")
5837		objectKey.String(*v.Configuration)
5838	}
5839
5840	if v.ConfigurationAlias != nil {
5841		objectKey := object.Key("ConfigurationAlias")
5842		objectKey.String(*v.ConfigurationAlias)
5843	}
5844
5845	if len(v.Type) > 0 {
5846		objectKey := object.Key("Type")
5847		objectKey.String(string(v.Type))
5848	}
5849
5850	if v.TypeArn != nil {
5851		objectKey := object.Key("TypeArn")
5852		objectKey.String(*v.TypeArn)
5853	}
5854
5855	if v.TypeName != nil {
5856		objectKey := object.Key("TypeName")
5857		objectKey.String(*v.TypeName)
5858	}
5859
5860	return nil
5861}
5862
5863func awsAwsquery_serializeOpDocumentSetTypeDefaultVersionInput(v *SetTypeDefaultVersionInput, value query.Value) error {
5864	object := value.Object()
5865	_ = object
5866
5867	if v.Arn != nil {
5868		objectKey := object.Key("Arn")
5869		objectKey.String(*v.Arn)
5870	}
5871
5872	if len(v.Type) > 0 {
5873		objectKey := object.Key("Type")
5874		objectKey.String(string(v.Type))
5875	}
5876
5877	if v.TypeName != nil {
5878		objectKey := object.Key("TypeName")
5879		objectKey.String(*v.TypeName)
5880	}
5881
5882	if v.VersionId != nil {
5883		objectKey := object.Key("VersionId")
5884		objectKey.String(*v.VersionId)
5885	}
5886
5887	return nil
5888}
5889
5890func awsAwsquery_serializeOpDocumentSignalResourceInput(v *SignalResourceInput, value query.Value) error {
5891	object := value.Object()
5892	_ = object
5893
5894	if v.LogicalResourceId != nil {
5895		objectKey := object.Key("LogicalResourceId")
5896		objectKey.String(*v.LogicalResourceId)
5897	}
5898
5899	if v.StackName != nil {
5900		objectKey := object.Key("StackName")
5901		objectKey.String(*v.StackName)
5902	}
5903
5904	if len(v.Status) > 0 {
5905		objectKey := object.Key("Status")
5906		objectKey.String(string(v.Status))
5907	}
5908
5909	if v.UniqueId != nil {
5910		objectKey := object.Key("UniqueId")
5911		objectKey.String(*v.UniqueId)
5912	}
5913
5914	return nil
5915}
5916
5917func awsAwsquery_serializeOpDocumentStopStackSetOperationInput(v *StopStackSetOperationInput, value query.Value) error {
5918	object := value.Object()
5919	_ = object
5920
5921	if len(v.CallAs) > 0 {
5922		objectKey := object.Key("CallAs")
5923		objectKey.String(string(v.CallAs))
5924	}
5925
5926	if v.OperationId != nil {
5927		objectKey := object.Key("OperationId")
5928		objectKey.String(*v.OperationId)
5929	}
5930
5931	if v.StackSetName != nil {
5932		objectKey := object.Key("StackSetName")
5933		objectKey.String(*v.StackSetName)
5934	}
5935
5936	return nil
5937}
5938
5939func awsAwsquery_serializeOpDocumentTestTypeInput(v *TestTypeInput, value query.Value) error {
5940	object := value.Object()
5941	_ = object
5942
5943	if v.Arn != nil {
5944		objectKey := object.Key("Arn")
5945		objectKey.String(*v.Arn)
5946	}
5947
5948	if v.LogDeliveryBucket != nil {
5949		objectKey := object.Key("LogDeliveryBucket")
5950		objectKey.String(*v.LogDeliveryBucket)
5951	}
5952
5953	if len(v.Type) > 0 {
5954		objectKey := object.Key("Type")
5955		objectKey.String(string(v.Type))
5956	}
5957
5958	if v.TypeName != nil {
5959		objectKey := object.Key("TypeName")
5960		objectKey.String(*v.TypeName)
5961	}
5962
5963	if v.VersionId != nil {
5964		objectKey := object.Key("VersionId")
5965		objectKey.String(*v.VersionId)
5966	}
5967
5968	return nil
5969}
5970
5971func awsAwsquery_serializeOpDocumentUpdateStackInput(v *UpdateStackInput, value query.Value) error {
5972	object := value.Object()
5973	_ = object
5974
5975	if v.Capabilities != nil {
5976		objectKey := object.Key("Capabilities")
5977		if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil {
5978			return err
5979		}
5980	}
5981
5982	if v.ClientRequestToken != nil {
5983		objectKey := object.Key("ClientRequestToken")
5984		objectKey.String(*v.ClientRequestToken)
5985	}
5986
5987	if v.DisableRollback != nil {
5988		objectKey := object.Key("DisableRollback")
5989		objectKey.Boolean(*v.DisableRollback)
5990	}
5991
5992	if v.NotificationARNs != nil {
5993		objectKey := object.Key("NotificationARNs")
5994		if err := awsAwsquery_serializeDocumentNotificationARNs(v.NotificationARNs, objectKey); err != nil {
5995			return err
5996		}
5997	}
5998
5999	if v.Parameters != nil {
6000		objectKey := object.Key("Parameters")
6001		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
6002			return err
6003		}
6004	}
6005
6006	if v.ResourceTypes != nil {
6007		objectKey := object.Key("ResourceTypes")
6008		if err := awsAwsquery_serializeDocumentResourceTypes(v.ResourceTypes, objectKey); err != nil {
6009			return err
6010		}
6011	}
6012
6013	if v.RoleARN != nil {
6014		objectKey := object.Key("RoleARN")
6015		objectKey.String(*v.RoleARN)
6016	}
6017
6018	if v.RollbackConfiguration != nil {
6019		objectKey := object.Key("RollbackConfiguration")
6020		if err := awsAwsquery_serializeDocumentRollbackConfiguration(v.RollbackConfiguration, objectKey); err != nil {
6021			return err
6022		}
6023	}
6024
6025	if v.StackName != nil {
6026		objectKey := object.Key("StackName")
6027		objectKey.String(*v.StackName)
6028	}
6029
6030	if v.StackPolicyBody != nil {
6031		objectKey := object.Key("StackPolicyBody")
6032		objectKey.String(*v.StackPolicyBody)
6033	}
6034
6035	if v.StackPolicyDuringUpdateBody != nil {
6036		objectKey := object.Key("StackPolicyDuringUpdateBody")
6037		objectKey.String(*v.StackPolicyDuringUpdateBody)
6038	}
6039
6040	if v.StackPolicyDuringUpdateURL != nil {
6041		objectKey := object.Key("StackPolicyDuringUpdateURL")
6042		objectKey.String(*v.StackPolicyDuringUpdateURL)
6043	}
6044
6045	if v.StackPolicyURL != nil {
6046		objectKey := object.Key("StackPolicyURL")
6047		objectKey.String(*v.StackPolicyURL)
6048	}
6049
6050	if v.Tags != nil {
6051		objectKey := object.Key("Tags")
6052		if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil {
6053			return err
6054		}
6055	}
6056
6057	if v.TemplateBody != nil {
6058		objectKey := object.Key("TemplateBody")
6059		objectKey.String(*v.TemplateBody)
6060	}
6061
6062	if v.TemplateURL != nil {
6063		objectKey := object.Key("TemplateURL")
6064		objectKey.String(*v.TemplateURL)
6065	}
6066
6067	if v.UsePreviousTemplate != nil {
6068		objectKey := object.Key("UsePreviousTemplate")
6069		objectKey.Boolean(*v.UsePreviousTemplate)
6070	}
6071
6072	return nil
6073}
6074
6075func awsAwsquery_serializeOpDocumentUpdateStackInstancesInput(v *UpdateStackInstancesInput, value query.Value) error {
6076	object := value.Object()
6077	_ = object
6078
6079	if v.Accounts != nil {
6080		objectKey := object.Key("Accounts")
6081		if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil {
6082			return err
6083		}
6084	}
6085
6086	if len(v.CallAs) > 0 {
6087		objectKey := object.Key("CallAs")
6088		objectKey.String(string(v.CallAs))
6089	}
6090
6091	if v.DeploymentTargets != nil {
6092		objectKey := object.Key("DeploymentTargets")
6093		if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil {
6094			return err
6095		}
6096	}
6097
6098	if v.OperationId != nil {
6099		objectKey := object.Key("OperationId")
6100		objectKey.String(*v.OperationId)
6101	}
6102
6103	if v.OperationPreferences != nil {
6104		objectKey := object.Key("OperationPreferences")
6105		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
6106			return err
6107		}
6108	}
6109
6110	if v.ParameterOverrides != nil {
6111		objectKey := object.Key("ParameterOverrides")
6112		if err := awsAwsquery_serializeDocumentParameters(v.ParameterOverrides, objectKey); err != nil {
6113			return err
6114		}
6115	}
6116
6117	if v.Regions != nil {
6118		objectKey := object.Key("Regions")
6119		if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil {
6120			return err
6121		}
6122	}
6123
6124	if v.StackSetName != nil {
6125		objectKey := object.Key("StackSetName")
6126		objectKey.String(*v.StackSetName)
6127	}
6128
6129	return nil
6130}
6131
6132func awsAwsquery_serializeOpDocumentUpdateStackSetInput(v *UpdateStackSetInput, value query.Value) error {
6133	object := value.Object()
6134	_ = object
6135
6136	if v.Accounts != nil {
6137		objectKey := object.Key("Accounts")
6138		if err := awsAwsquery_serializeDocumentAccountList(v.Accounts, objectKey); err != nil {
6139			return err
6140		}
6141	}
6142
6143	if v.AdministrationRoleARN != nil {
6144		objectKey := object.Key("AdministrationRoleARN")
6145		objectKey.String(*v.AdministrationRoleARN)
6146	}
6147
6148	if v.AutoDeployment != nil {
6149		objectKey := object.Key("AutoDeployment")
6150		if err := awsAwsquery_serializeDocumentAutoDeployment(v.AutoDeployment, objectKey); err != nil {
6151			return err
6152		}
6153	}
6154
6155	if len(v.CallAs) > 0 {
6156		objectKey := object.Key("CallAs")
6157		objectKey.String(string(v.CallAs))
6158	}
6159
6160	if v.Capabilities != nil {
6161		objectKey := object.Key("Capabilities")
6162		if err := awsAwsquery_serializeDocumentCapabilities(v.Capabilities, objectKey); err != nil {
6163			return err
6164		}
6165	}
6166
6167	if v.DeploymentTargets != nil {
6168		objectKey := object.Key("DeploymentTargets")
6169		if err := awsAwsquery_serializeDocumentDeploymentTargets(v.DeploymentTargets, objectKey); err != nil {
6170			return err
6171		}
6172	}
6173
6174	if v.Description != nil {
6175		objectKey := object.Key("Description")
6176		objectKey.String(*v.Description)
6177	}
6178
6179	if v.ExecutionRoleName != nil {
6180		objectKey := object.Key("ExecutionRoleName")
6181		objectKey.String(*v.ExecutionRoleName)
6182	}
6183
6184	if v.OperationId != nil {
6185		objectKey := object.Key("OperationId")
6186		objectKey.String(*v.OperationId)
6187	}
6188
6189	if v.OperationPreferences != nil {
6190		objectKey := object.Key("OperationPreferences")
6191		if err := awsAwsquery_serializeDocumentStackSetOperationPreferences(v.OperationPreferences, objectKey); err != nil {
6192			return err
6193		}
6194	}
6195
6196	if v.Parameters != nil {
6197		objectKey := object.Key("Parameters")
6198		if err := awsAwsquery_serializeDocumentParameters(v.Parameters, objectKey); err != nil {
6199			return err
6200		}
6201	}
6202
6203	if len(v.PermissionModel) > 0 {
6204		objectKey := object.Key("PermissionModel")
6205		objectKey.String(string(v.PermissionModel))
6206	}
6207
6208	if v.Regions != nil {
6209		objectKey := object.Key("Regions")
6210		if err := awsAwsquery_serializeDocumentRegionList(v.Regions, objectKey); err != nil {
6211			return err
6212		}
6213	}
6214
6215	if v.StackSetName != nil {
6216		objectKey := object.Key("StackSetName")
6217		objectKey.String(*v.StackSetName)
6218	}
6219
6220	if v.Tags != nil {
6221		objectKey := object.Key("Tags")
6222		if err := awsAwsquery_serializeDocumentTags(v.Tags, objectKey); err != nil {
6223			return err
6224		}
6225	}
6226
6227	if v.TemplateBody != nil {
6228		objectKey := object.Key("TemplateBody")
6229		objectKey.String(*v.TemplateBody)
6230	}
6231
6232	if v.TemplateURL != nil {
6233		objectKey := object.Key("TemplateURL")
6234		objectKey.String(*v.TemplateURL)
6235	}
6236
6237	if v.UsePreviousTemplate != nil {
6238		objectKey := object.Key("UsePreviousTemplate")
6239		objectKey.Boolean(*v.UsePreviousTemplate)
6240	}
6241
6242	return nil
6243}
6244
6245func awsAwsquery_serializeOpDocumentUpdateTerminationProtectionInput(v *UpdateTerminationProtectionInput, value query.Value) error {
6246	object := value.Object()
6247	_ = object
6248
6249	if v.EnableTerminationProtection != nil {
6250		objectKey := object.Key("EnableTerminationProtection")
6251		objectKey.Boolean(*v.EnableTerminationProtection)
6252	}
6253
6254	if v.StackName != nil {
6255		objectKey := object.Key("StackName")
6256		objectKey.String(*v.StackName)
6257	}
6258
6259	return nil
6260}
6261
6262func awsAwsquery_serializeOpDocumentValidateTemplateInput(v *ValidateTemplateInput, value query.Value) error {
6263	object := value.Object()
6264	_ = object
6265
6266	if v.TemplateBody != nil {
6267		objectKey := object.Key("TemplateBody")
6268		objectKey.String(*v.TemplateBody)
6269	}
6270
6271	if v.TemplateURL != nil {
6272		objectKey := object.Key("TemplateURL")
6273		objectKey.String(*v.TemplateURL)
6274	}
6275
6276	return nil
6277}
6278