1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package sms
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/sms/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithytime "github.com/aws/smithy-go/time"
15	smithyhttp "github.com/aws/smithy-go/transport/http"
16)
17
18type awsAwsjson11_serializeOpCreateApp struct {
19}
20
21func (*awsAwsjson11_serializeOpCreateApp) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpCreateApp) 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.(*CreateAppInput)
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-amz-json-1.1")
46	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.CreateApp")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentCreateAppInput(input, jsonEncoder.Value); err != nil {
50		return out, metadata, &smithy.SerializationError{Err: err}
51	}
52
53	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56
57	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
58		return out, metadata, &smithy.SerializationError{Err: err}
59	}
60	in.Request = request
61
62	return next.HandleSerialize(ctx, in)
63}
64
65type awsAwsjson11_serializeOpCreateReplicationJob struct {
66}
67
68func (*awsAwsjson11_serializeOpCreateReplicationJob) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpCreateReplicationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
73	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
74) {
75	request, ok := in.Request.(*smithyhttp.Request)
76	if !ok {
77		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
78	}
79
80	input, ok := in.Parameters.(*CreateReplicationJobInput)
81	_ = input
82	if !ok {
83		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
84	}
85
86	request.Request.URL.Path = "/"
87	request.Request.Method = "POST"
88	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
89	if err != nil {
90		return out, metadata, &smithy.SerializationError{Err: err}
91	}
92	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
93	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.CreateReplicationJob")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentCreateReplicationJobInput(input, jsonEncoder.Value); err != nil {
97		return out, metadata, &smithy.SerializationError{Err: err}
98	}
99
100	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
101		return out, metadata, &smithy.SerializationError{Err: err}
102	}
103
104	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
105		return out, metadata, &smithy.SerializationError{Err: err}
106	}
107	in.Request = request
108
109	return next.HandleSerialize(ctx, in)
110}
111
112type awsAwsjson11_serializeOpDeleteApp struct {
113}
114
115func (*awsAwsjson11_serializeOpDeleteApp) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpDeleteApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
120	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
121) {
122	request, ok := in.Request.(*smithyhttp.Request)
123	if !ok {
124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
125	}
126
127	input, ok := in.Parameters.(*DeleteAppInput)
128	_ = input
129	if !ok {
130		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
131	}
132
133	request.Request.URL.Path = "/"
134	request.Request.Method = "POST"
135	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
136	if err != nil {
137		return out, metadata, &smithy.SerializationError{Err: err}
138	}
139	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
140	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteApp")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentDeleteAppInput(input, jsonEncoder.Value); err != nil {
144		return out, metadata, &smithy.SerializationError{Err: err}
145	}
146
147	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
148		return out, metadata, &smithy.SerializationError{Err: err}
149	}
150
151	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
152		return out, metadata, &smithy.SerializationError{Err: err}
153	}
154	in.Request = request
155
156	return next.HandleSerialize(ctx, in)
157}
158
159type awsAwsjson11_serializeOpDeleteAppLaunchConfiguration struct {
160}
161
162func (*awsAwsjson11_serializeOpDeleteAppLaunchConfiguration) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpDeleteAppLaunchConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
168) {
169	request, ok := in.Request.(*smithyhttp.Request)
170	if !ok {
171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
172	}
173
174	input, ok := in.Parameters.(*DeleteAppLaunchConfigurationInput)
175	_ = input
176	if !ok {
177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
178	}
179
180	request.Request.URL.Path = "/"
181	request.Request.Method = "POST"
182	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
183	if err != nil {
184		return out, metadata, &smithy.SerializationError{Err: err}
185	}
186	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
187	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteAppLaunchConfiguration")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentDeleteAppLaunchConfigurationInput(input, jsonEncoder.Value); err != nil {
191		return out, metadata, &smithy.SerializationError{Err: err}
192	}
193
194	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
195		return out, metadata, &smithy.SerializationError{Err: err}
196	}
197
198	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201	in.Request = request
202
203	return next.HandleSerialize(ctx, in)
204}
205
206type awsAwsjson11_serializeOpDeleteAppReplicationConfiguration struct {
207}
208
209func (*awsAwsjson11_serializeOpDeleteAppReplicationConfiguration) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpDeleteAppReplicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
214	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
215) {
216	request, ok := in.Request.(*smithyhttp.Request)
217	if !ok {
218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
219	}
220
221	input, ok := in.Parameters.(*DeleteAppReplicationConfigurationInput)
222	_ = input
223	if !ok {
224		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
225	}
226
227	request.Request.URL.Path = "/"
228	request.Request.Method = "POST"
229	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
230	if err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
234	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteAppReplicationConfiguration")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentDeleteAppReplicationConfigurationInput(input, jsonEncoder.Value); err != nil {
238		return out, metadata, &smithy.SerializationError{Err: err}
239	}
240
241	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
242		return out, metadata, &smithy.SerializationError{Err: err}
243	}
244
245	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
246		return out, metadata, &smithy.SerializationError{Err: err}
247	}
248	in.Request = request
249
250	return next.HandleSerialize(ctx, in)
251}
252
253type awsAwsjson11_serializeOpDeleteAppValidationConfiguration struct {
254}
255
256func (*awsAwsjson11_serializeOpDeleteAppValidationConfiguration) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpDeleteAppValidationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
262) {
263	request, ok := in.Request.(*smithyhttp.Request)
264	if !ok {
265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
266	}
267
268	input, ok := in.Parameters.(*DeleteAppValidationConfigurationInput)
269	_ = input
270	if !ok {
271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
272	}
273
274	request.Request.URL.Path = "/"
275	request.Request.Method = "POST"
276	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
277	if err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
281	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteAppValidationConfiguration")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentDeleteAppValidationConfigurationInput(input, jsonEncoder.Value); err != nil {
285		return out, metadata, &smithy.SerializationError{Err: err}
286	}
287
288	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295	in.Request = request
296
297	return next.HandleSerialize(ctx, in)
298}
299
300type awsAwsjson11_serializeOpDeleteReplicationJob struct {
301}
302
303func (*awsAwsjson11_serializeOpDeleteReplicationJob) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpDeleteReplicationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
308	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
309) {
310	request, ok := in.Request.(*smithyhttp.Request)
311	if !ok {
312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
313	}
314
315	input, ok := in.Parameters.(*DeleteReplicationJobInput)
316	_ = input
317	if !ok {
318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
319	}
320
321	request.Request.URL.Path = "/"
322	request.Request.Method = "POST"
323	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
324	if err != nil {
325		return out, metadata, &smithy.SerializationError{Err: err}
326	}
327	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
328	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteReplicationJob")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentDeleteReplicationJobInput(input, jsonEncoder.Value); err != nil {
332		return out, metadata, &smithy.SerializationError{Err: err}
333	}
334
335	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
336		return out, metadata, &smithy.SerializationError{Err: err}
337	}
338
339	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
340		return out, metadata, &smithy.SerializationError{Err: err}
341	}
342	in.Request = request
343
344	return next.HandleSerialize(ctx, in)
345}
346
347type awsAwsjson11_serializeOpDeleteServerCatalog struct {
348}
349
350func (*awsAwsjson11_serializeOpDeleteServerCatalog) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpDeleteServerCatalog) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
355	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
356) {
357	request, ok := in.Request.(*smithyhttp.Request)
358	if !ok {
359		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
360	}
361
362	input, ok := in.Parameters.(*DeleteServerCatalogInput)
363	_ = input
364	if !ok {
365		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
366	}
367
368	request.Request.URL.Path = "/"
369	request.Request.Method = "POST"
370	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
371	if err != nil {
372		return out, metadata, &smithy.SerializationError{Err: err}
373	}
374	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
375	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DeleteServerCatalog")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentDeleteServerCatalogInput(input, jsonEncoder.Value); err != nil {
379		return out, metadata, &smithy.SerializationError{Err: err}
380	}
381
382	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
383		return out, metadata, &smithy.SerializationError{Err: err}
384	}
385
386	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
387		return out, metadata, &smithy.SerializationError{Err: err}
388	}
389	in.Request = request
390
391	return next.HandleSerialize(ctx, in)
392}
393
394type awsAwsjson11_serializeOpDisassociateConnector struct {
395}
396
397func (*awsAwsjson11_serializeOpDisassociateConnector) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpDisassociateConnector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
402	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
403) {
404	request, ok := in.Request.(*smithyhttp.Request)
405	if !ok {
406		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
407	}
408
409	input, ok := in.Parameters.(*DisassociateConnectorInput)
410	_ = input
411	if !ok {
412		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
413	}
414
415	request.Request.URL.Path = "/"
416	request.Request.Method = "POST"
417	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
418	if err != nil {
419		return out, metadata, &smithy.SerializationError{Err: err}
420	}
421	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
422	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.DisassociateConnector")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentDisassociateConnectorInput(input, jsonEncoder.Value); err != nil {
426		return out, metadata, &smithy.SerializationError{Err: err}
427	}
428
429	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
430		return out, metadata, &smithy.SerializationError{Err: err}
431	}
432
433	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
434		return out, metadata, &smithy.SerializationError{Err: err}
435	}
436	in.Request = request
437
438	return next.HandleSerialize(ctx, in)
439}
440
441type awsAwsjson11_serializeOpGenerateChangeSet struct {
442}
443
444func (*awsAwsjson11_serializeOpGenerateChangeSet) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpGenerateChangeSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
449	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
450) {
451	request, ok := in.Request.(*smithyhttp.Request)
452	if !ok {
453		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
454	}
455
456	input, ok := in.Parameters.(*GenerateChangeSetInput)
457	_ = input
458	if !ok {
459		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
460	}
461
462	request.Request.URL.Path = "/"
463	request.Request.Method = "POST"
464	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
465	if err != nil {
466		return out, metadata, &smithy.SerializationError{Err: err}
467	}
468	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
469	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GenerateChangeSet")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentGenerateChangeSetInput(input, jsonEncoder.Value); err != nil {
473		return out, metadata, &smithy.SerializationError{Err: err}
474	}
475
476	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
477		return out, metadata, &smithy.SerializationError{Err: err}
478	}
479
480	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
481		return out, metadata, &smithy.SerializationError{Err: err}
482	}
483	in.Request = request
484
485	return next.HandleSerialize(ctx, in)
486}
487
488type awsAwsjson11_serializeOpGenerateTemplate struct {
489}
490
491func (*awsAwsjson11_serializeOpGenerateTemplate) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpGenerateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
497) {
498	request, ok := in.Request.(*smithyhttp.Request)
499	if !ok {
500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
501	}
502
503	input, ok := in.Parameters.(*GenerateTemplateInput)
504	_ = input
505	if !ok {
506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
507	}
508
509	request.Request.URL.Path = "/"
510	request.Request.Method = "POST"
511	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
512	if err != nil {
513		return out, metadata, &smithy.SerializationError{Err: err}
514	}
515	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
516	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GenerateTemplate")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentGenerateTemplateInput(input, jsonEncoder.Value); err != nil {
520		return out, metadata, &smithy.SerializationError{Err: err}
521	}
522
523	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
524		return out, metadata, &smithy.SerializationError{Err: err}
525	}
526
527	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530	in.Request = request
531
532	return next.HandleSerialize(ctx, in)
533}
534
535type awsAwsjson11_serializeOpGetApp struct {
536}
537
538func (*awsAwsjson11_serializeOpGetApp) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpGetApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
543	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
544) {
545	request, ok := in.Request.(*smithyhttp.Request)
546	if !ok {
547		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
548	}
549
550	input, ok := in.Parameters.(*GetAppInput)
551	_ = input
552	if !ok {
553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
554	}
555
556	request.Request.URL.Path = "/"
557	request.Request.Method = "POST"
558	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
559	if err != nil {
560		return out, metadata, &smithy.SerializationError{Err: err}
561	}
562	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
563	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetApp")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentGetAppInput(input, jsonEncoder.Value); err != nil {
567		return out, metadata, &smithy.SerializationError{Err: err}
568	}
569
570	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573
574	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
575		return out, metadata, &smithy.SerializationError{Err: err}
576	}
577	in.Request = request
578
579	return next.HandleSerialize(ctx, in)
580}
581
582type awsAwsjson11_serializeOpGetAppLaunchConfiguration struct {
583}
584
585func (*awsAwsjson11_serializeOpGetAppLaunchConfiguration) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpGetAppLaunchConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
590	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
591) {
592	request, ok := in.Request.(*smithyhttp.Request)
593	if !ok {
594		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
595	}
596
597	input, ok := in.Parameters.(*GetAppLaunchConfigurationInput)
598	_ = input
599	if !ok {
600		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
601	}
602
603	request.Request.URL.Path = "/"
604	request.Request.Method = "POST"
605	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
606	if err != nil {
607		return out, metadata, &smithy.SerializationError{Err: err}
608	}
609	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
610	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetAppLaunchConfiguration")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentGetAppLaunchConfigurationInput(input, jsonEncoder.Value); err != nil {
614		return out, metadata, &smithy.SerializationError{Err: err}
615	}
616
617	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
618		return out, metadata, &smithy.SerializationError{Err: err}
619	}
620
621	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
622		return out, metadata, &smithy.SerializationError{Err: err}
623	}
624	in.Request = request
625
626	return next.HandleSerialize(ctx, in)
627}
628
629type awsAwsjson11_serializeOpGetAppReplicationConfiguration struct {
630}
631
632func (*awsAwsjson11_serializeOpGetAppReplicationConfiguration) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpGetAppReplicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
638) {
639	request, ok := in.Request.(*smithyhttp.Request)
640	if !ok {
641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
642	}
643
644	input, ok := in.Parameters.(*GetAppReplicationConfigurationInput)
645	_ = input
646	if !ok {
647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
648	}
649
650	request.Request.URL.Path = "/"
651	request.Request.Method = "POST"
652	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
653	if err != nil {
654		return out, metadata, &smithy.SerializationError{Err: err}
655	}
656	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
657	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetAppReplicationConfiguration")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentGetAppReplicationConfigurationInput(input, jsonEncoder.Value); err != nil {
661		return out, metadata, &smithy.SerializationError{Err: err}
662	}
663
664	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
665		return out, metadata, &smithy.SerializationError{Err: err}
666	}
667
668	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
669		return out, metadata, &smithy.SerializationError{Err: err}
670	}
671	in.Request = request
672
673	return next.HandleSerialize(ctx, in)
674}
675
676type awsAwsjson11_serializeOpGetAppValidationConfiguration struct {
677}
678
679func (*awsAwsjson11_serializeOpGetAppValidationConfiguration) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpGetAppValidationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
684	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
685) {
686	request, ok := in.Request.(*smithyhttp.Request)
687	if !ok {
688		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
689	}
690
691	input, ok := in.Parameters.(*GetAppValidationConfigurationInput)
692	_ = input
693	if !ok {
694		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
695	}
696
697	request.Request.URL.Path = "/"
698	request.Request.Method = "POST"
699	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
700	if err != nil {
701		return out, metadata, &smithy.SerializationError{Err: err}
702	}
703	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
704	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetAppValidationConfiguration")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentGetAppValidationConfigurationInput(input, jsonEncoder.Value); err != nil {
708		return out, metadata, &smithy.SerializationError{Err: err}
709	}
710
711	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
712		return out, metadata, &smithy.SerializationError{Err: err}
713	}
714
715	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
716		return out, metadata, &smithy.SerializationError{Err: err}
717	}
718	in.Request = request
719
720	return next.HandleSerialize(ctx, in)
721}
722
723type awsAwsjson11_serializeOpGetAppValidationOutput struct {
724}
725
726func (*awsAwsjson11_serializeOpGetAppValidationOutput) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpGetAppValidationOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
732) {
733	request, ok := in.Request.(*smithyhttp.Request)
734	if !ok {
735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
736	}
737
738	input, ok := in.Parameters.(*GetAppValidationOutputInput)
739	_ = input
740	if !ok {
741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
742	}
743
744	request.Request.URL.Path = "/"
745	request.Request.Method = "POST"
746	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
747	if err != nil {
748		return out, metadata, &smithy.SerializationError{Err: err}
749	}
750	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
751	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetAppValidationOutput")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentGetAppValidationOutputInput(input, jsonEncoder.Value); err != nil {
755		return out, metadata, &smithy.SerializationError{Err: err}
756	}
757
758	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
759		return out, metadata, &smithy.SerializationError{Err: err}
760	}
761
762	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
763		return out, metadata, &smithy.SerializationError{Err: err}
764	}
765	in.Request = request
766
767	return next.HandleSerialize(ctx, in)
768}
769
770type awsAwsjson11_serializeOpGetConnectors struct {
771}
772
773func (*awsAwsjson11_serializeOpGetConnectors) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpGetConnectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
778	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
779) {
780	request, ok := in.Request.(*smithyhttp.Request)
781	if !ok {
782		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
783	}
784
785	input, ok := in.Parameters.(*GetConnectorsInput)
786	_ = input
787	if !ok {
788		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
789	}
790
791	request.Request.URL.Path = "/"
792	request.Request.Method = "POST"
793	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
794	if err != nil {
795		return out, metadata, &smithy.SerializationError{Err: err}
796	}
797	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
798	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetConnectors")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentGetConnectorsInput(input, jsonEncoder.Value); err != nil {
802		return out, metadata, &smithy.SerializationError{Err: err}
803	}
804
805	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
806		return out, metadata, &smithy.SerializationError{Err: err}
807	}
808
809	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
810		return out, metadata, &smithy.SerializationError{Err: err}
811	}
812	in.Request = request
813
814	return next.HandleSerialize(ctx, in)
815}
816
817type awsAwsjson11_serializeOpGetReplicationJobs struct {
818}
819
820func (*awsAwsjson11_serializeOpGetReplicationJobs) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpGetReplicationJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
825	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
826) {
827	request, ok := in.Request.(*smithyhttp.Request)
828	if !ok {
829		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
830	}
831
832	input, ok := in.Parameters.(*GetReplicationJobsInput)
833	_ = input
834	if !ok {
835		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
836	}
837
838	request.Request.URL.Path = "/"
839	request.Request.Method = "POST"
840	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
841	if err != nil {
842		return out, metadata, &smithy.SerializationError{Err: err}
843	}
844	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
845	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetReplicationJobs")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentGetReplicationJobsInput(input, jsonEncoder.Value); err != nil {
849		return out, metadata, &smithy.SerializationError{Err: err}
850	}
851
852	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
853		return out, metadata, &smithy.SerializationError{Err: err}
854	}
855
856	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
857		return out, metadata, &smithy.SerializationError{Err: err}
858	}
859	in.Request = request
860
861	return next.HandleSerialize(ctx, in)
862}
863
864type awsAwsjson11_serializeOpGetReplicationRuns struct {
865}
866
867func (*awsAwsjson11_serializeOpGetReplicationRuns) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpGetReplicationRuns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
872	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
873) {
874	request, ok := in.Request.(*smithyhttp.Request)
875	if !ok {
876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
877	}
878
879	input, ok := in.Parameters.(*GetReplicationRunsInput)
880	_ = input
881	if !ok {
882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
883	}
884
885	request.Request.URL.Path = "/"
886	request.Request.Method = "POST"
887	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
888	if err != nil {
889		return out, metadata, &smithy.SerializationError{Err: err}
890	}
891	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
892	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetReplicationRuns")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentGetReplicationRunsInput(input, jsonEncoder.Value); err != nil {
896		return out, metadata, &smithy.SerializationError{Err: err}
897	}
898
899	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
900		return out, metadata, &smithy.SerializationError{Err: err}
901	}
902
903	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
904		return out, metadata, &smithy.SerializationError{Err: err}
905	}
906	in.Request = request
907
908	return next.HandleSerialize(ctx, in)
909}
910
911type awsAwsjson11_serializeOpGetServers struct {
912}
913
914func (*awsAwsjson11_serializeOpGetServers) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpGetServers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
919	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
920) {
921	request, ok := in.Request.(*smithyhttp.Request)
922	if !ok {
923		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
924	}
925
926	input, ok := in.Parameters.(*GetServersInput)
927	_ = input
928	if !ok {
929		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
930	}
931
932	request.Request.URL.Path = "/"
933	request.Request.Method = "POST"
934	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
935	if err != nil {
936		return out, metadata, &smithy.SerializationError{Err: err}
937	}
938	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
939	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.GetServers")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentGetServersInput(input, jsonEncoder.Value); err != nil {
943		return out, metadata, &smithy.SerializationError{Err: err}
944	}
945
946	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
947		return out, metadata, &smithy.SerializationError{Err: err}
948	}
949
950	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
951		return out, metadata, &smithy.SerializationError{Err: err}
952	}
953	in.Request = request
954
955	return next.HandleSerialize(ctx, in)
956}
957
958type awsAwsjson11_serializeOpImportAppCatalog struct {
959}
960
961func (*awsAwsjson11_serializeOpImportAppCatalog) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpImportAppCatalog) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
966	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
967) {
968	request, ok := in.Request.(*smithyhttp.Request)
969	if !ok {
970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
971	}
972
973	input, ok := in.Parameters.(*ImportAppCatalogInput)
974	_ = input
975	if !ok {
976		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
977	}
978
979	request.Request.URL.Path = "/"
980	request.Request.Method = "POST"
981	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
982	if err != nil {
983		return out, metadata, &smithy.SerializationError{Err: err}
984	}
985	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
986	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.ImportAppCatalog")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentImportAppCatalogInput(input, jsonEncoder.Value); err != nil {
990		return out, metadata, &smithy.SerializationError{Err: err}
991	}
992
993	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
994		return out, metadata, &smithy.SerializationError{Err: err}
995	}
996
997	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
998		return out, metadata, &smithy.SerializationError{Err: err}
999	}
1000	in.Request = request
1001
1002	return next.HandleSerialize(ctx, in)
1003}
1004
1005type awsAwsjson11_serializeOpImportServerCatalog struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpImportServerCatalog) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpImportServerCatalog) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1013	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1014) {
1015	request, ok := in.Request.(*smithyhttp.Request)
1016	if !ok {
1017		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1018	}
1019
1020	input, ok := in.Parameters.(*ImportServerCatalogInput)
1021	_ = input
1022	if !ok {
1023		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1024	}
1025
1026	request.Request.URL.Path = "/"
1027	request.Request.Method = "POST"
1028	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1029	if err != nil {
1030		return out, metadata, &smithy.SerializationError{Err: err}
1031	}
1032	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1033	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.ImportServerCatalog")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentImportServerCatalogInput(input, jsonEncoder.Value); err != nil {
1037		return out, metadata, &smithy.SerializationError{Err: err}
1038	}
1039
1040	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1041		return out, metadata, &smithy.SerializationError{Err: err}
1042	}
1043
1044	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047	in.Request = request
1048
1049	return next.HandleSerialize(ctx, in)
1050}
1051
1052type awsAwsjson11_serializeOpLaunchApp struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpLaunchApp) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpLaunchApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1060	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	request, ok := in.Request.(*smithyhttp.Request)
1063	if !ok {
1064		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1065	}
1066
1067	input, ok := in.Parameters.(*LaunchAppInput)
1068	_ = input
1069	if !ok {
1070		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1071	}
1072
1073	request.Request.URL.Path = "/"
1074	request.Request.Method = "POST"
1075	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1076	if err != nil {
1077		return out, metadata, &smithy.SerializationError{Err: err}
1078	}
1079	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1080	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.LaunchApp")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentLaunchAppInput(input, jsonEncoder.Value); err != nil {
1084		return out, metadata, &smithy.SerializationError{Err: err}
1085	}
1086
1087	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1088		return out, metadata, &smithy.SerializationError{Err: err}
1089	}
1090
1091	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1092		return out, metadata, &smithy.SerializationError{Err: err}
1093	}
1094	in.Request = request
1095
1096	return next.HandleSerialize(ctx, in)
1097}
1098
1099type awsAwsjson11_serializeOpListApps struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpListApps) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpListApps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1107	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1108) {
1109	request, ok := in.Request.(*smithyhttp.Request)
1110	if !ok {
1111		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1112	}
1113
1114	input, ok := in.Parameters.(*ListAppsInput)
1115	_ = input
1116	if !ok {
1117		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1118	}
1119
1120	request.Request.URL.Path = "/"
1121	request.Request.Method = "POST"
1122	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1123	if err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1127	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.ListApps")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentListAppsInput(input, jsonEncoder.Value); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133
1134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1135		return out, metadata, &smithy.SerializationError{Err: err}
1136	}
1137
1138	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1139		return out, metadata, &smithy.SerializationError{Err: err}
1140	}
1141	in.Request = request
1142
1143	return next.HandleSerialize(ctx, in)
1144}
1145
1146type awsAwsjson11_serializeOpNotifyAppValidationOutput struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpNotifyAppValidationOutput) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpNotifyAppValidationOutput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1154	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1155) {
1156	request, ok := in.Request.(*smithyhttp.Request)
1157	if !ok {
1158		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1159	}
1160
1161	input, ok := in.Parameters.(*NotifyAppValidationOutputInput)
1162	_ = input
1163	if !ok {
1164		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1165	}
1166
1167	request.Request.URL.Path = "/"
1168	request.Request.Method = "POST"
1169	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1170	if err != nil {
1171		return out, metadata, &smithy.SerializationError{Err: err}
1172	}
1173	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1174	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.NotifyAppValidationOutput")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentNotifyAppValidationOutputInput(input, jsonEncoder.Value); err != nil {
1178		return out, metadata, &smithy.SerializationError{Err: err}
1179	}
1180
1181	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1182		return out, metadata, &smithy.SerializationError{Err: err}
1183	}
1184
1185	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1186		return out, metadata, &smithy.SerializationError{Err: err}
1187	}
1188	in.Request = request
1189
1190	return next.HandleSerialize(ctx, in)
1191}
1192
1193type awsAwsjson11_serializeOpPutAppLaunchConfiguration struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpPutAppLaunchConfiguration) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpPutAppLaunchConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1201	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	request, ok := in.Request.(*smithyhttp.Request)
1204	if !ok {
1205		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1206	}
1207
1208	input, ok := in.Parameters.(*PutAppLaunchConfigurationInput)
1209	_ = input
1210	if !ok {
1211		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1212	}
1213
1214	request.Request.URL.Path = "/"
1215	request.Request.Method = "POST"
1216	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1217	if err != nil {
1218		return out, metadata, &smithy.SerializationError{Err: err}
1219	}
1220	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1221	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.PutAppLaunchConfiguration")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentPutAppLaunchConfigurationInput(input, jsonEncoder.Value); err != nil {
1225		return out, metadata, &smithy.SerializationError{Err: err}
1226	}
1227
1228	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1229		return out, metadata, &smithy.SerializationError{Err: err}
1230	}
1231
1232	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1233		return out, metadata, &smithy.SerializationError{Err: err}
1234	}
1235	in.Request = request
1236
1237	return next.HandleSerialize(ctx, in)
1238}
1239
1240type awsAwsjson11_serializeOpPutAppReplicationConfiguration struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpPutAppReplicationConfiguration) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpPutAppReplicationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1249) {
1250	request, ok := in.Request.(*smithyhttp.Request)
1251	if !ok {
1252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1253	}
1254
1255	input, ok := in.Parameters.(*PutAppReplicationConfigurationInput)
1256	_ = input
1257	if !ok {
1258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1259	}
1260
1261	request.Request.URL.Path = "/"
1262	request.Request.Method = "POST"
1263	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1264	if err != nil {
1265		return out, metadata, &smithy.SerializationError{Err: err}
1266	}
1267	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1268	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.PutAppReplicationConfiguration")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentPutAppReplicationConfigurationInput(input, jsonEncoder.Value); err != nil {
1272		return out, metadata, &smithy.SerializationError{Err: err}
1273	}
1274
1275	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1276		return out, metadata, &smithy.SerializationError{Err: err}
1277	}
1278
1279	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1280		return out, metadata, &smithy.SerializationError{Err: err}
1281	}
1282	in.Request = request
1283
1284	return next.HandleSerialize(ctx, in)
1285}
1286
1287type awsAwsjson11_serializeOpPutAppValidationConfiguration struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpPutAppValidationConfiguration) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpPutAppValidationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1295	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1296) {
1297	request, ok := in.Request.(*smithyhttp.Request)
1298	if !ok {
1299		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1300	}
1301
1302	input, ok := in.Parameters.(*PutAppValidationConfigurationInput)
1303	_ = input
1304	if !ok {
1305		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1306	}
1307
1308	request.Request.URL.Path = "/"
1309	request.Request.Method = "POST"
1310	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1311	if err != nil {
1312		return out, metadata, &smithy.SerializationError{Err: err}
1313	}
1314	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1315	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.PutAppValidationConfiguration")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentPutAppValidationConfigurationInput(input, jsonEncoder.Value); err != nil {
1319		return out, metadata, &smithy.SerializationError{Err: err}
1320	}
1321
1322	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1323		return out, metadata, &smithy.SerializationError{Err: err}
1324	}
1325
1326	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1327		return out, metadata, &smithy.SerializationError{Err: err}
1328	}
1329	in.Request = request
1330
1331	return next.HandleSerialize(ctx, in)
1332}
1333
1334type awsAwsjson11_serializeOpStartAppReplication struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpStartAppReplication) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpStartAppReplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1342	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1343) {
1344	request, ok := in.Request.(*smithyhttp.Request)
1345	if !ok {
1346		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1347	}
1348
1349	input, ok := in.Parameters.(*StartAppReplicationInput)
1350	_ = input
1351	if !ok {
1352		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1353	}
1354
1355	request.Request.URL.Path = "/"
1356	request.Request.Method = "POST"
1357	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1358	if err != nil {
1359		return out, metadata, &smithy.SerializationError{Err: err}
1360	}
1361	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1362	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.StartAppReplication")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentStartAppReplicationInput(input, jsonEncoder.Value); err != nil {
1366		return out, metadata, &smithy.SerializationError{Err: err}
1367	}
1368
1369	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1370		return out, metadata, &smithy.SerializationError{Err: err}
1371	}
1372
1373	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1374		return out, metadata, &smithy.SerializationError{Err: err}
1375	}
1376	in.Request = request
1377
1378	return next.HandleSerialize(ctx, in)
1379}
1380
1381type awsAwsjson11_serializeOpStartOnDemandAppReplication struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpStartOnDemandAppReplication) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpStartOnDemandAppReplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1390) {
1391	request, ok := in.Request.(*smithyhttp.Request)
1392	if !ok {
1393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1394	}
1395
1396	input, ok := in.Parameters.(*StartOnDemandAppReplicationInput)
1397	_ = input
1398	if !ok {
1399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1400	}
1401
1402	request.Request.URL.Path = "/"
1403	request.Request.Method = "POST"
1404	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1405	if err != nil {
1406		return out, metadata, &smithy.SerializationError{Err: err}
1407	}
1408	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1409	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.StartOnDemandAppReplication")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentStartOnDemandAppReplicationInput(input, jsonEncoder.Value); err != nil {
1413		return out, metadata, &smithy.SerializationError{Err: err}
1414	}
1415
1416	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1417		return out, metadata, &smithy.SerializationError{Err: err}
1418	}
1419
1420	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1421		return out, metadata, &smithy.SerializationError{Err: err}
1422	}
1423	in.Request = request
1424
1425	return next.HandleSerialize(ctx, in)
1426}
1427
1428type awsAwsjson11_serializeOpStartOnDemandReplicationRun struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpStartOnDemandReplicationRun) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpStartOnDemandReplicationRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1436	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1437) {
1438	request, ok := in.Request.(*smithyhttp.Request)
1439	if !ok {
1440		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1441	}
1442
1443	input, ok := in.Parameters.(*StartOnDemandReplicationRunInput)
1444	_ = input
1445	if !ok {
1446		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1447	}
1448
1449	request.Request.URL.Path = "/"
1450	request.Request.Method = "POST"
1451	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1452	if err != nil {
1453		return out, metadata, &smithy.SerializationError{Err: err}
1454	}
1455	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1456	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.StartOnDemandReplicationRun")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentStartOnDemandReplicationRunInput(input, jsonEncoder.Value); err != nil {
1460		return out, metadata, &smithy.SerializationError{Err: err}
1461	}
1462
1463	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1464		return out, metadata, &smithy.SerializationError{Err: err}
1465	}
1466
1467	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1468		return out, metadata, &smithy.SerializationError{Err: err}
1469	}
1470	in.Request = request
1471
1472	return next.HandleSerialize(ctx, in)
1473}
1474
1475type awsAwsjson11_serializeOpStopAppReplication struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpStopAppReplication) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpStopAppReplication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1483	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1484) {
1485	request, ok := in.Request.(*smithyhttp.Request)
1486	if !ok {
1487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1488	}
1489
1490	input, ok := in.Parameters.(*StopAppReplicationInput)
1491	_ = input
1492	if !ok {
1493		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1494	}
1495
1496	request.Request.URL.Path = "/"
1497	request.Request.Method = "POST"
1498	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1499	if err != nil {
1500		return out, metadata, &smithy.SerializationError{Err: err}
1501	}
1502	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1503	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.StopAppReplication")
1504
1505	jsonEncoder := smithyjson.NewEncoder()
1506	if err := awsAwsjson11_serializeOpDocumentStopAppReplicationInput(input, jsonEncoder.Value); err != nil {
1507		return out, metadata, &smithy.SerializationError{Err: err}
1508	}
1509
1510	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1511		return out, metadata, &smithy.SerializationError{Err: err}
1512	}
1513
1514	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1515		return out, metadata, &smithy.SerializationError{Err: err}
1516	}
1517	in.Request = request
1518
1519	return next.HandleSerialize(ctx, in)
1520}
1521
1522type awsAwsjson11_serializeOpTerminateApp struct {
1523}
1524
1525func (*awsAwsjson11_serializeOpTerminateApp) ID() string {
1526	return "OperationSerializer"
1527}
1528
1529func (m *awsAwsjson11_serializeOpTerminateApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1530	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1531) {
1532	request, ok := in.Request.(*smithyhttp.Request)
1533	if !ok {
1534		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1535	}
1536
1537	input, ok := in.Parameters.(*TerminateAppInput)
1538	_ = input
1539	if !ok {
1540		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1541	}
1542
1543	request.Request.URL.Path = "/"
1544	request.Request.Method = "POST"
1545	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1546	if err != nil {
1547		return out, metadata, &smithy.SerializationError{Err: err}
1548	}
1549	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1550	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.TerminateApp")
1551
1552	jsonEncoder := smithyjson.NewEncoder()
1553	if err := awsAwsjson11_serializeOpDocumentTerminateAppInput(input, jsonEncoder.Value); err != nil {
1554		return out, metadata, &smithy.SerializationError{Err: err}
1555	}
1556
1557	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1558		return out, metadata, &smithy.SerializationError{Err: err}
1559	}
1560
1561	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1562		return out, metadata, &smithy.SerializationError{Err: err}
1563	}
1564	in.Request = request
1565
1566	return next.HandleSerialize(ctx, in)
1567}
1568
1569type awsAwsjson11_serializeOpUpdateApp struct {
1570}
1571
1572func (*awsAwsjson11_serializeOpUpdateApp) ID() string {
1573	return "OperationSerializer"
1574}
1575
1576func (m *awsAwsjson11_serializeOpUpdateApp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1577	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1578) {
1579	request, ok := in.Request.(*smithyhttp.Request)
1580	if !ok {
1581		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1582	}
1583
1584	input, ok := in.Parameters.(*UpdateAppInput)
1585	_ = input
1586	if !ok {
1587		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1588	}
1589
1590	request.Request.URL.Path = "/"
1591	request.Request.Method = "POST"
1592	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1593	if err != nil {
1594		return out, metadata, &smithy.SerializationError{Err: err}
1595	}
1596	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1597	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.UpdateApp")
1598
1599	jsonEncoder := smithyjson.NewEncoder()
1600	if err := awsAwsjson11_serializeOpDocumentUpdateAppInput(input, jsonEncoder.Value); err != nil {
1601		return out, metadata, &smithy.SerializationError{Err: err}
1602	}
1603
1604	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1605		return out, metadata, &smithy.SerializationError{Err: err}
1606	}
1607
1608	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1609		return out, metadata, &smithy.SerializationError{Err: err}
1610	}
1611	in.Request = request
1612
1613	return next.HandleSerialize(ctx, in)
1614}
1615
1616type awsAwsjson11_serializeOpUpdateReplicationJob struct {
1617}
1618
1619func (*awsAwsjson11_serializeOpUpdateReplicationJob) ID() string {
1620	return "OperationSerializer"
1621}
1622
1623func (m *awsAwsjson11_serializeOpUpdateReplicationJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1624	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1625) {
1626	request, ok := in.Request.(*smithyhttp.Request)
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1629	}
1630
1631	input, ok := in.Parameters.(*UpdateReplicationJobInput)
1632	_ = input
1633	if !ok {
1634		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1635	}
1636
1637	request.Request.URL.Path = "/"
1638	request.Request.Method = "POST"
1639	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1640	if err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1644	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSServerMigrationService_V2016_10_24.UpdateReplicationJob")
1645
1646	jsonEncoder := smithyjson.NewEncoder()
1647	if err := awsAwsjson11_serializeOpDocumentUpdateReplicationJobInput(input, jsonEncoder.Value); err != nil {
1648		return out, metadata, &smithy.SerializationError{Err: err}
1649	}
1650
1651	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1652		return out, metadata, &smithy.SerializationError{Err: err}
1653	}
1654
1655	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1656		return out, metadata, &smithy.SerializationError{Err: err}
1657	}
1658	in.Request = request
1659
1660	return next.HandleSerialize(ctx, in)
1661}
1662func awsAwsjson11_serializeDocumentAppIds(v []string, value smithyjson.Value) error {
1663	array := value.Array()
1664	defer array.Close()
1665
1666	for i := range v {
1667		av := array.Value()
1668		av.String(v[i])
1669	}
1670	return nil
1671}
1672
1673func awsAwsjson11_serializeDocumentAppValidationConfiguration(v *types.AppValidationConfiguration, value smithyjson.Value) error {
1674	object := value.Object()
1675	defer object.Close()
1676
1677	if len(v.AppValidationStrategy) > 0 {
1678		ok := object.Key("appValidationStrategy")
1679		ok.String(string(v.AppValidationStrategy))
1680	}
1681
1682	if v.Name != nil {
1683		ok := object.Key("name")
1684		ok.String(*v.Name)
1685	}
1686
1687	if v.SsmValidationParameters != nil {
1688		ok := object.Key("ssmValidationParameters")
1689		if err := awsAwsjson11_serializeDocumentSSMValidationParameters(v.SsmValidationParameters, ok); err != nil {
1690			return err
1691		}
1692	}
1693
1694	if v.ValidationId != nil {
1695		ok := object.Key("validationId")
1696		ok.String(*v.ValidationId)
1697	}
1698
1699	return nil
1700}
1701
1702func awsAwsjson11_serializeDocumentAppValidationConfigurations(v []types.AppValidationConfiguration, value smithyjson.Value) error {
1703	array := value.Array()
1704	defer array.Close()
1705
1706	for i := range v {
1707		av := array.Value()
1708		if err := awsAwsjson11_serializeDocumentAppValidationConfiguration(&v[i], av); err != nil {
1709			return err
1710		}
1711	}
1712	return nil
1713}
1714
1715func awsAwsjson11_serializeDocumentNotificationContext(v *types.NotificationContext, value smithyjson.Value) error {
1716	object := value.Object()
1717	defer object.Close()
1718
1719	if len(v.Status) > 0 {
1720		ok := object.Key("status")
1721		ok.String(string(v.Status))
1722	}
1723
1724	if v.StatusMessage != nil {
1725		ok := object.Key("statusMessage")
1726		ok.String(*v.StatusMessage)
1727	}
1728
1729	if v.ValidationId != nil {
1730		ok := object.Key("validationId")
1731		ok.String(*v.ValidationId)
1732	}
1733
1734	return nil
1735}
1736
1737func awsAwsjson11_serializeDocumentS3Location(v *types.S3Location, value smithyjson.Value) error {
1738	object := value.Object()
1739	defer object.Close()
1740
1741	if v.Bucket != nil {
1742		ok := object.Key("bucket")
1743		ok.String(*v.Bucket)
1744	}
1745
1746	if v.Key != nil {
1747		ok := object.Key("key")
1748		ok.String(*v.Key)
1749	}
1750
1751	return nil
1752}
1753
1754func awsAwsjson11_serializeDocumentServer(v *types.Server, value smithyjson.Value) error {
1755	object := value.Object()
1756	defer object.Close()
1757
1758	if v.ReplicationJobId != nil {
1759		ok := object.Key("replicationJobId")
1760		ok.String(*v.ReplicationJobId)
1761	}
1762
1763	if v.ReplicationJobTerminated != nil {
1764		ok := object.Key("replicationJobTerminated")
1765		ok.Boolean(*v.ReplicationJobTerminated)
1766	}
1767
1768	if v.ServerId != nil {
1769		ok := object.Key("serverId")
1770		ok.String(*v.ServerId)
1771	}
1772
1773	if len(v.ServerType) > 0 {
1774		ok := object.Key("serverType")
1775		ok.String(string(v.ServerType))
1776	}
1777
1778	if v.VmServer != nil {
1779		ok := object.Key("vmServer")
1780		if err := awsAwsjson11_serializeDocumentVmServer(v.VmServer, ok); err != nil {
1781			return err
1782		}
1783	}
1784
1785	return nil
1786}
1787
1788func awsAwsjson11_serializeDocumentServerGroup(v *types.ServerGroup, value smithyjson.Value) error {
1789	object := value.Object()
1790	defer object.Close()
1791
1792	if v.Name != nil {
1793		ok := object.Key("name")
1794		ok.String(*v.Name)
1795	}
1796
1797	if v.ServerGroupId != nil {
1798		ok := object.Key("serverGroupId")
1799		ok.String(*v.ServerGroupId)
1800	}
1801
1802	if v.ServerList != nil {
1803		ok := object.Key("serverList")
1804		if err := awsAwsjson11_serializeDocumentServerList(v.ServerList, ok); err != nil {
1805			return err
1806		}
1807	}
1808
1809	return nil
1810}
1811
1812func awsAwsjson11_serializeDocumentServerGroupLaunchConfiguration(v *types.ServerGroupLaunchConfiguration, value smithyjson.Value) error {
1813	object := value.Object()
1814	defer object.Close()
1815
1816	if v.LaunchOrder != nil {
1817		ok := object.Key("launchOrder")
1818		ok.Integer(*v.LaunchOrder)
1819	}
1820
1821	if v.ServerGroupId != nil {
1822		ok := object.Key("serverGroupId")
1823		ok.String(*v.ServerGroupId)
1824	}
1825
1826	if v.ServerLaunchConfigurations != nil {
1827		ok := object.Key("serverLaunchConfigurations")
1828		if err := awsAwsjson11_serializeDocumentServerLaunchConfigurations(v.ServerLaunchConfigurations, ok); err != nil {
1829			return err
1830		}
1831	}
1832
1833	return nil
1834}
1835
1836func awsAwsjson11_serializeDocumentServerGroupLaunchConfigurations(v []types.ServerGroupLaunchConfiguration, value smithyjson.Value) error {
1837	array := value.Array()
1838	defer array.Close()
1839
1840	for i := range v {
1841		av := array.Value()
1842		if err := awsAwsjson11_serializeDocumentServerGroupLaunchConfiguration(&v[i], av); err != nil {
1843			return err
1844		}
1845	}
1846	return nil
1847}
1848
1849func awsAwsjson11_serializeDocumentServerGroupReplicationConfiguration(v *types.ServerGroupReplicationConfiguration, value smithyjson.Value) error {
1850	object := value.Object()
1851	defer object.Close()
1852
1853	if v.ServerGroupId != nil {
1854		ok := object.Key("serverGroupId")
1855		ok.String(*v.ServerGroupId)
1856	}
1857
1858	if v.ServerReplicationConfigurations != nil {
1859		ok := object.Key("serverReplicationConfigurations")
1860		if err := awsAwsjson11_serializeDocumentServerReplicationConfigurations(v.ServerReplicationConfigurations, ok); err != nil {
1861			return err
1862		}
1863	}
1864
1865	return nil
1866}
1867
1868func awsAwsjson11_serializeDocumentServerGroupReplicationConfigurations(v []types.ServerGroupReplicationConfiguration, value smithyjson.Value) error {
1869	array := value.Array()
1870	defer array.Close()
1871
1872	for i := range v {
1873		av := array.Value()
1874		if err := awsAwsjson11_serializeDocumentServerGroupReplicationConfiguration(&v[i], av); err != nil {
1875			return err
1876		}
1877	}
1878	return nil
1879}
1880
1881func awsAwsjson11_serializeDocumentServerGroups(v []types.ServerGroup, value smithyjson.Value) error {
1882	array := value.Array()
1883	defer array.Close()
1884
1885	for i := range v {
1886		av := array.Value()
1887		if err := awsAwsjson11_serializeDocumentServerGroup(&v[i], av); err != nil {
1888			return err
1889		}
1890	}
1891	return nil
1892}
1893
1894func awsAwsjson11_serializeDocumentServerGroupValidationConfiguration(v *types.ServerGroupValidationConfiguration, value smithyjson.Value) error {
1895	object := value.Object()
1896	defer object.Close()
1897
1898	if v.ServerGroupId != nil {
1899		ok := object.Key("serverGroupId")
1900		ok.String(*v.ServerGroupId)
1901	}
1902
1903	if v.ServerValidationConfigurations != nil {
1904		ok := object.Key("serverValidationConfigurations")
1905		if err := awsAwsjson11_serializeDocumentServerValidationConfigurations(v.ServerValidationConfigurations, ok); err != nil {
1906			return err
1907		}
1908	}
1909
1910	return nil
1911}
1912
1913func awsAwsjson11_serializeDocumentServerGroupValidationConfigurations(v []types.ServerGroupValidationConfiguration, value smithyjson.Value) error {
1914	array := value.Array()
1915	defer array.Close()
1916
1917	for i := range v {
1918		av := array.Value()
1919		if err := awsAwsjson11_serializeDocumentServerGroupValidationConfiguration(&v[i], av); err != nil {
1920			return err
1921		}
1922	}
1923	return nil
1924}
1925
1926func awsAwsjson11_serializeDocumentServerLaunchConfiguration(v *types.ServerLaunchConfiguration, value smithyjson.Value) error {
1927	object := value.Object()
1928	defer object.Close()
1929
1930	if v.AssociatePublicIpAddress != nil {
1931		ok := object.Key("associatePublicIpAddress")
1932		ok.Boolean(*v.AssociatePublicIpAddress)
1933	}
1934
1935	if v.ConfigureScript != nil {
1936		ok := object.Key("configureScript")
1937		if err := awsAwsjson11_serializeDocumentS3Location(v.ConfigureScript, ok); err != nil {
1938			return err
1939		}
1940	}
1941
1942	if len(v.ConfigureScriptType) > 0 {
1943		ok := object.Key("configureScriptType")
1944		ok.String(string(v.ConfigureScriptType))
1945	}
1946
1947	if v.Ec2KeyName != nil {
1948		ok := object.Key("ec2KeyName")
1949		ok.String(*v.Ec2KeyName)
1950	}
1951
1952	if v.IamInstanceProfileName != nil {
1953		ok := object.Key("iamInstanceProfileName")
1954		ok.String(*v.IamInstanceProfileName)
1955	}
1956
1957	if v.InstanceType != nil {
1958		ok := object.Key("instanceType")
1959		ok.String(*v.InstanceType)
1960	}
1961
1962	if v.LogicalId != nil {
1963		ok := object.Key("logicalId")
1964		ok.String(*v.LogicalId)
1965	}
1966
1967	if v.SecurityGroup != nil {
1968		ok := object.Key("securityGroup")
1969		ok.String(*v.SecurityGroup)
1970	}
1971
1972	if v.Server != nil {
1973		ok := object.Key("server")
1974		if err := awsAwsjson11_serializeDocumentServer(v.Server, ok); err != nil {
1975			return err
1976		}
1977	}
1978
1979	if v.Subnet != nil {
1980		ok := object.Key("subnet")
1981		ok.String(*v.Subnet)
1982	}
1983
1984	if v.UserData != nil {
1985		ok := object.Key("userData")
1986		if err := awsAwsjson11_serializeDocumentUserData(v.UserData, ok); err != nil {
1987			return err
1988		}
1989	}
1990
1991	if v.Vpc != nil {
1992		ok := object.Key("vpc")
1993		ok.String(*v.Vpc)
1994	}
1995
1996	return nil
1997}
1998
1999func awsAwsjson11_serializeDocumentServerLaunchConfigurations(v []types.ServerLaunchConfiguration, value smithyjson.Value) error {
2000	array := value.Array()
2001	defer array.Close()
2002
2003	for i := range v {
2004		av := array.Value()
2005		if err := awsAwsjson11_serializeDocumentServerLaunchConfiguration(&v[i], av); err != nil {
2006			return err
2007		}
2008	}
2009	return nil
2010}
2011
2012func awsAwsjson11_serializeDocumentServerList(v []types.Server, value smithyjson.Value) error {
2013	array := value.Array()
2014	defer array.Close()
2015
2016	for i := range v {
2017		av := array.Value()
2018		if err := awsAwsjson11_serializeDocumentServer(&v[i], av); err != nil {
2019			return err
2020		}
2021	}
2022	return nil
2023}
2024
2025func awsAwsjson11_serializeDocumentServerReplicationConfiguration(v *types.ServerReplicationConfiguration, value smithyjson.Value) error {
2026	object := value.Object()
2027	defer object.Close()
2028
2029	if v.Server != nil {
2030		ok := object.Key("server")
2031		if err := awsAwsjson11_serializeDocumentServer(v.Server, ok); err != nil {
2032			return err
2033		}
2034	}
2035
2036	if v.ServerReplicationParameters != nil {
2037		ok := object.Key("serverReplicationParameters")
2038		if err := awsAwsjson11_serializeDocumentServerReplicationParameters(v.ServerReplicationParameters, ok); err != nil {
2039			return err
2040		}
2041	}
2042
2043	return nil
2044}
2045
2046func awsAwsjson11_serializeDocumentServerReplicationConfigurations(v []types.ServerReplicationConfiguration, value smithyjson.Value) error {
2047	array := value.Array()
2048	defer array.Close()
2049
2050	for i := range v {
2051		av := array.Value()
2052		if err := awsAwsjson11_serializeDocumentServerReplicationConfiguration(&v[i], av); err != nil {
2053			return err
2054		}
2055	}
2056	return nil
2057}
2058
2059func awsAwsjson11_serializeDocumentServerReplicationParameters(v *types.ServerReplicationParameters, value smithyjson.Value) error {
2060	object := value.Object()
2061	defer object.Close()
2062
2063	if v.Encrypted != nil {
2064		ok := object.Key("encrypted")
2065		ok.Boolean(*v.Encrypted)
2066	}
2067
2068	if v.Frequency != nil {
2069		ok := object.Key("frequency")
2070		ok.Integer(*v.Frequency)
2071	}
2072
2073	if v.KmsKeyId != nil {
2074		ok := object.Key("kmsKeyId")
2075		ok.String(*v.KmsKeyId)
2076	}
2077
2078	if len(v.LicenseType) > 0 {
2079		ok := object.Key("licenseType")
2080		ok.String(string(v.LicenseType))
2081	}
2082
2083	if v.NumberOfRecentAmisToKeep != nil {
2084		ok := object.Key("numberOfRecentAmisToKeep")
2085		ok.Integer(*v.NumberOfRecentAmisToKeep)
2086	}
2087
2088	if v.RunOnce != nil {
2089		ok := object.Key("runOnce")
2090		ok.Boolean(*v.RunOnce)
2091	}
2092
2093	if v.SeedTime != nil {
2094		ok := object.Key("seedTime")
2095		ok.Double(smithytime.FormatEpochSeconds(*v.SeedTime))
2096	}
2097
2098	return nil
2099}
2100
2101func awsAwsjson11_serializeDocumentServerValidationConfiguration(v *types.ServerValidationConfiguration, value smithyjson.Value) error {
2102	object := value.Object()
2103	defer object.Close()
2104
2105	if v.Name != nil {
2106		ok := object.Key("name")
2107		ok.String(*v.Name)
2108	}
2109
2110	if v.Server != nil {
2111		ok := object.Key("server")
2112		if err := awsAwsjson11_serializeDocumentServer(v.Server, ok); err != nil {
2113			return err
2114		}
2115	}
2116
2117	if len(v.ServerValidationStrategy) > 0 {
2118		ok := object.Key("serverValidationStrategy")
2119		ok.String(string(v.ServerValidationStrategy))
2120	}
2121
2122	if v.UserDataValidationParameters != nil {
2123		ok := object.Key("userDataValidationParameters")
2124		if err := awsAwsjson11_serializeDocumentUserDataValidationParameters(v.UserDataValidationParameters, ok); err != nil {
2125			return err
2126		}
2127	}
2128
2129	if v.ValidationId != nil {
2130		ok := object.Key("validationId")
2131		ok.String(*v.ValidationId)
2132	}
2133
2134	return nil
2135}
2136
2137func awsAwsjson11_serializeDocumentServerValidationConfigurations(v []types.ServerValidationConfiguration, value smithyjson.Value) error {
2138	array := value.Array()
2139	defer array.Close()
2140
2141	for i := range v {
2142		av := array.Value()
2143		if err := awsAwsjson11_serializeDocumentServerValidationConfiguration(&v[i], av); err != nil {
2144			return err
2145		}
2146	}
2147	return nil
2148}
2149
2150func awsAwsjson11_serializeDocumentSource(v *types.Source, value smithyjson.Value) error {
2151	object := value.Object()
2152	defer object.Close()
2153
2154	if v.S3Location != nil {
2155		ok := object.Key("s3Location")
2156		if err := awsAwsjson11_serializeDocumentS3Location(v.S3Location, ok); err != nil {
2157			return err
2158		}
2159	}
2160
2161	return nil
2162}
2163
2164func awsAwsjson11_serializeDocumentSSMValidationParameters(v *types.SSMValidationParameters, value smithyjson.Value) error {
2165	object := value.Object()
2166	defer object.Close()
2167
2168	if v.Command != nil {
2169		ok := object.Key("command")
2170		ok.String(*v.Command)
2171	}
2172
2173	if v.ExecutionTimeoutSeconds != 0 {
2174		ok := object.Key("executionTimeoutSeconds")
2175		ok.Integer(v.ExecutionTimeoutSeconds)
2176	}
2177
2178	if v.InstanceId != nil {
2179		ok := object.Key("instanceId")
2180		ok.String(*v.InstanceId)
2181	}
2182
2183	if v.OutputS3BucketName != nil {
2184		ok := object.Key("outputS3BucketName")
2185		ok.String(*v.OutputS3BucketName)
2186	}
2187
2188	if len(v.ScriptType) > 0 {
2189		ok := object.Key("scriptType")
2190		ok.String(string(v.ScriptType))
2191	}
2192
2193	if v.Source != nil {
2194		ok := object.Key("source")
2195		if err := awsAwsjson11_serializeDocumentSource(v.Source, ok); err != nil {
2196			return err
2197		}
2198	}
2199
2200	return nil
2201}
2202
2203func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2204	object := value.Object()
2205	defer object.Close()
2206
2207	if v.Key != nil {
2208		ok := object.Key("key")
2209		ok.String(*v.Key)
2210	}
2211
2212	if v.Value != nil {
2213		ok := object.Key("value")
2214		ok.String(*v.Value)
2215	}
2216
2217	return nil
2218}
2219
2220func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
2221	array := value.Array()
2222	defer array.Close()
2223
2224	for i := range v {
2225		av := array.Value()
2226		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
2227			return err
2228		}
2229	}
2230	return nil
2231}
2232
2233func awsAwsjson11_serializeDocumentUserData(v *types.UserData, value smithyjson.Value) error {
2234	object := value.Object()
2235	defer object.Close()
2236
2237	if v.S3Location != nil {
2238		ok := object.Key("s3Location")
2239		if err := awsAwsjson11_serializeDocumentS3Location(v.S3Location, ok); err != nil {
2240			return err
2241		}
2242	}
2243
2244	return nil
2245}
2246
2247func awsAwsjson11_serializeDocumentUserDataValidationParameters(v *types.UserDataValidationParameters, value smithyjson.Value) error {
2248	object := value.Object()
2249	defer object.Close()
2250
2251	if len(v.ScriptType) > 0 {
2252		ok := object.Key("scriptType")
2253		ok.String(string(v.ScriptType))
2254	}
2255
2256	if v.Source != nil {
2257		ok := object.Key("source")
2258		if err := awsAwsjson11_serializeDocumentSource(v.Source, ok); err != nil {
2259			return err
2260		}
2261	}
2262
2263	return nil
2264}
2265
2266func awsAwsjson11_serializeDocumentVmServer(v *types.VmServer, value smithyjson.Value) error {
2267	object := value.Object()
2268	defer object.Close()
2269
2270	if v.VmManagerName != nil {
2271		ok := object.Key("vmManagerName")
2272		ok.String(*v.VmManagerName)
2273	}
2274
2275	if len(v.VmManagerType) > 0 {
2276		ok := object.Key("vmManagerType")
2277		ok.String(string(v.VmManagerType))
2278	}
2279
2280	if v.VmName != nil {
2281		ok := object.Key("vmName")
2282		ok.String(*v.VmName)
2283	}
2284
2285	if v.VmPath != nil {
2286		ok := object.Key("vmPath")
2287		ok.String(*v.VmPath)
2288	}
2289
2290	if v.VmServerAddress != nil {
2291		ok := object.Key("vmServerAddress")
2292		if err := awsAwsjson11_serializeDocumentVmServerAddress(v.VmServerAddress, ok); err != nil {
2293			return err
2294		}
2295	}
2296
2297	return nil
2298}
2299
2300func awsAwsjson11_serializeDocumentVmServerAddress(v *types.VmServerAddress, value smithyjson.Value) error {
2301	object := value.Object()
2302	defer object.Close()
2303
2304	if v.VmId != nil {
2305		ok := object.Key("vmId")
2306		ok.String(*v.VmId)
2307	}
2308
2309	if v.VmManagerId != nil {
2310		ok := object.Key("vmManagerId")
2311		ok.String(*v.VmManagerId)
2312	}
2313
2314	return nil
2315}
2316
2317func awsAwsjson11_serializeDocumentVmServerAddressList(v []types.VmServerAddress, value smithyjson.Value) error {
2318	array := value.Array()
2319	defer array.Close()
2320
2321	for i := range v {
2322		av := array.Value()
2323		if err := awsAwsjson11_serializeDocumentVmServerAddress(&v[i], av); err != nil {
2324			return err
2325		}
2326	}
2327	return nil
2328}
2329
2330func awsAwsjson11_serializeOpDocumentCreateAppInput(v *CreateAppInput, value smithyjson.Value) error {
2331	object := value.Object()
2332	defer object.Close()
2333
2334	if v.ClientToken != nil {
2335		ok := object.Key("clientToken")
2336		ok.String(*v.ClientToken)
2337	}
2338
2339	if v.Description != nil {
2340		ok := object.Key("description")
2341		ok.String(*v.Description)
2342	}
2343
2344	if v.Name != nil {
2345		ok := object.Key("name")
2346		ok.String(*v.Name)
2347	}
2348
2349	if v.RoleName != nil {
2350		ok := object.Key("roleName")
2351		ok.String(*v.RoleName)
2352	}
2353
2354	if v.ServerGroups != nil {
2355		ok := object.Key("serverGroups")
2356		if err := awsAwsjson11_serializeDocumentServerGroups(v.ServerGroups, ok); err != nil {
2357			return err
2358		}
2359	}
2360
2361	if v.Tags != nil {
2362		ok := object.Key("tags")
2363		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2364			return err
2365		}
2366	}
2367
2368	return nil
2369}
2370
2371func awsAwsjson11_serializeOpDocumentCreateReplicationJobInput(v *CreateReplicationJobInput, value smithyjson.Value) error {
2372	object := value.Object()
2373	defer object.Close()
2374
2375	if v.Description != nil {
2376		ok := object.Key("description")
2377		ok.String(*v.Description)
2378	}
2379
2380	if v.Encrypted != nil {
2381		ok := object.Key("encrypted")
2382		ok.Boolean(*v.Encrypted)
2383	}
2384
2385	if v.Frequency != nil {
2386		ok := object.Key("frequency")
2387		ok.Integer(*v.Frequency)
2388	}
2389
2390	if v.KmsKeyId != nil {
2391		ok := object.Key("kmsKeyId")
2392		ok.String(*v.KmsKeyId)
2393	}
2394
2395	if len(v.LicenseType) > 0 {
2396		ok := object.Key("licenseType")
2397		ok.String(string(v.LicenseType))
2398	}
2399
2400	if v.NumberOfRecentAmisToKeep != nil {
2401		ok := object.Key("numberOfRecentAmisToKeep")
2402		ok.Integer(*v.NumberOfRecentAmisToKeep)
2403	}
2404
2405	if v.RoleName != nil {
2406		ok := object.Key("roleName")
2407		ok.String(*v.RoleName)
2408	}
2409
2410	if v.RunOnce != nil {
2411		ok := object.Key("runOnce")
2412		ok.Boolean(*v.RunOnce)
2413	}
2414
2415	if v.SeedReplicationTime != nil {
2416		ok := object.Key("seedReplicationTime")
2417		ok.Double(smithytime.FormatEpochSeconds(*v.SeedReplicationTime))
2418	}
2419
2420	if v.ServerId != nil {
2421		ok := object.Key("serverId")
2422		ok.String(*v.ServerId)
2423	}
2424
2425	return nil
2426}
2427
2428func awsAwsjson11_serializeOpDocumentDeleteAppInput(v *DeleteAppInput, value smithyjson.Value) error {
2429	object := value.Object()
2430	defer object.Close()
2431
2432	if v.AppId != nil {
2433		ok := object.Key("appId")
2434		ok.String(*v.AppId)
2435	}
2436
2437	if v.ForceStopAppReplication != nil {
2438		ok := object.Key("forceStopAppReplication")
2439		ok.Boolean(*v.ForceStopAppReplication)
2440	}
2441
2442	if v.ForceTerminateApp != nil {
2443		ok := object.Key("forceTerminateApp")
2444		ok.Boolean(*v.ForceTerminateApp)
2445	}
2446
2447	return nil
2448}
2449
2450func awsAwsjson11_serializeOpDocumentDeleteAppLaunchConfigurationInput(v *DeleteAppLaunchConfigurationInput, value smithyjson.Value) error {
2451	object := value.Object()
2452	defer object.Close()
2453
2454	if v.AppId != nil {
2455		ok := object.Key("appId")
2456		ok.String(*v.AppId)
2457	}
2458
2459	return nil
2460}
2461
2462func awsAwsjson11_serializeOpDocumentDeleteAppReplicationConfigurationInput(v *DeleteAppReplicationConfigurationInput, value smithyjson.Value) error {
2463	object := value.Object()
2464	defer object.Close()
2465
2466	if v.AppId != nil {
2467		ok := object.Key("appId")
2468		ok.String(*v.AppId)
2469	}
2470
2471	return nil
2472}
2473
2474func awsAwsjson11_serializeOpDocumentDeleteAppValidationConfigurationInput(v *DeleteAppValidationConfigurationInput, value smithyjson.Value) error {
2475	object := value.Object()
2476	defer object.Close()
2477
2478	if v.AppId != nil {
2479		ok := object.Key("appId")
2480		ok.String(*v.AppId)
2481	}
2482
2483	return nil
2484}
2485
2486func awsAwsjson11_serializeOpDocumentDeleteReplicationJobInput(v *DeleteReplicationJobInput, value smithyjson.Value) error {
2487	object := value.Object()
2488	defer object.Close()
2489
2490	if v.ReplicationJobId != nil {
2491		ok := object.Key("replicationJobId")
2492		ok.String(*v.ReplicationJobId)
2493	}
2494
2495	return nil
2496}
2497
2498func awsAwsjson11_serializeOpDocumentDeleteServerCatalogInput(v *DeleteServerCatalogInput, value smithyjson.Value) error {
2499	object := value.Object()
2500	defer object.Close()
2501
2502	return nil
2503}
2504
2505func awsAwsjson11_serializeOpDocumentDisassociateConnectorInput(v *DisassociateConnectorInput, value smithyjson.Value) error {
2506	object := value.Object()
2507	defer object.Close()
2508
2509	if v.ConnectorId != nil {
2510		ok := object.Key("connectorId")
2511		ok.String(*v.ConnectorId)
2512	}
2513
2514	return nil
2515}
2516
2517func awsAwsjson11_serializeOpDocumentGenerateChangeSetInput(v *GenerateChangeSetInput, value smithyjson.Value) error {
2518	object := value.Object()
2519	defer object.Close()
2520
2521	if v.AppId != nil {
2522		ok := object.Key("appId")
2523		ok.String(*v.AppId)
2524	}
2525
2526	if len(v.ChangesetFormat) > 0 {
2527		ok := object.Key("changesetFormat")
2528		ok.String(string(v.ChangesetFormat))
2529	}
2530
2531	return nil
2532}
2533
2534func awsAwsjson11_serializeOpDocumentGenerateTemplateInput(v *GenerateTemplateInput, value smithyjson.Value) error {
2535	object := value.Object()
2536	defer object.Close()
2537
2538	if v.AppId != nil {
2539		ok := object.Key("appId")
2540		ok.String(*v.AppId)
2541	}
2542
2543	if len(v.TemplateFormat) > 0 {
2544		ok := object.Key("templateFormat")
2545		ok.String(string(v.TemplateFormat))
2546	}
2547
2548	return nil
2549}
2550
2551func awsAwsjson11_serializeOpDocumentGetAppInput(v *GetAppInput, value smithyjson.Value) error {
2552	object := value.Object()
2553	defer object.Close()
2554
2555	if v.AppId != nil {
2556		ok := object.Key("appId")
2557		ok.String(*v.AppId)
2558	}
2559
2560	return nil
2561}
2562
2563func awsAwsjson11_serializeOpDocumentGetAppLaunchConfigurationInput(v *GetAppLaunchConfigurationInput, value smithyjson.Value) error {
2564	object := value.Object()
2565	defer object.Close()
2566
2567	if v.AppId != nil {
2568		ok := object.Key("appId")
2569		ok.String(*v.AppId)
2570	}
2571
2572	return nil
2573}
2574
2575func awsAwsjson11_serializeOpDocumentGetAppReplicationConfigurationInput(v *GetAppReplicationConfigurationInput, value smithyjson.Value) error {
2576	object := value.Object()
2577	defer object.Close()
2578
2579	if v.AppId != nil {
2580		ok := object.Key("appId")
2581		ok.String(*v.AppId)
2582	}
2583
2584	return nil
2585}
2586
2587func awsAwsjson11_serializeOpDocumentGetAppValidationConfigurationInput(v *GetAppValidationConfigurationInput, value smithyjson.Value) error {
2588	object := value.Object()
2589	defer object.Close()
2590
2591	if v.AppId != nil {
2592		ok := object.Key("appId")
2593		ok.String(*v.AppId)
2594	}
2595
2596	return nil
2597}
2598
2599func awsAwsjson11_serializeOpDocumentGetAppValidationOutputInput(v *GetAppValidationOutputInput, value smithyjson.Value) error {
2600	object := value.Object()
2601	defer object.Close()
2602
2603	if v.AppId != nil {
2604		ok := object.Key("appId")
2605		ok.String(*v.AppId)
2606	}
2607
2608	return nil
2609}
2610
2611func awsAwsjson11_serializeOpDocumentGetConnectorsInput(v *GetConnectorsInput, value smithyjson.Value) error {
2612	object := value.Object()
2613	defer object.Close()
2614
2615	if v.MaxResults != nil {
2616		ok := object.Key("maxResults")
2617		ok.Integer(*v.MaxResults)
2618	}
2619
2620	if v.NextToken != nil {
2621		ok := object.Key("nextToken")
2622		ok.String(*v.NextToken)
2623	}
2624
2625	return nil
2626}
2627
2628func awsAwsjson11_serializeOpDocumentGetReplicationJobsInput(v *GetReplicationJobsInput, value smithyjson.Value) error {
2629	object := value.Object()
2630	defer object.Close()
2631
2632	if v.MaxResults != nil {
2633		ok := object.Key("maxResults")
2634		ok.Integer(*v.MaxResults)
2635	}
2636
2637	if v.NextToken != nil {
2638		ok := object.Key("nextToken")
2639		ok.String(*v.NextToken)
2640	}
2641
2642	if v.ReplicationJobId != nil {
2643		ok := object.Key("replicationJobId")
2644		ok.String(*v.ReplicationJobId)
2645	}
2646
2647	return nil
2648}
2649
2650func awsAwsjson11_serializeOpDocumentGetReplicationRunsInput(v *GetReplicationRunsInput, value smithyjson.Value) error {
2651	object := value.Object()
2652	defer object.Close()
2653
2654	if v.MaxResults != nil {
2655		ok := object.Key("maxResults")
2656		ok.Integer(*v.MaxResults)
2657	}
2658
2659	if v.NextToken != nil {
2660		ok := object.Key("nextToken")
2661		ok.String(*v.NextToken)
2662	}
2663
2664	if v.ReplicationJobId != nil {
2665		ok := object.Key("replicationJobId")
2666		ok.String(*v.ReplicationJobId)
2667	}
2668
2669	return nil
2670}
2671
2672func awsAwsjson11_serializeOpDocumentGetServersInput(v *GetServersInput, value smithyjson.Value) error {
2673	object := value.Object()
2674	defer object.Close()
2675
2676	if v.MaxResults != nil {
2677		ok := object.Key("maxResults")
2678		ok.Integer(*v.MaxResults)
2679	}
2680
2681	if v.NextToken != nil {
2682		ok := object.Key("nextToken")
2683		ok.String(*v.NextToken)
2684	}
2685
2686	if v.VmServerAddressList != nil {
2687		ok := object.Key("vmServerAddressList")
2688		if err := awsAwsjson11_serializeDocumentVmServerAddressList(v.VmServerAddressList, ok); err != nil {
2689			return err
2690		}
2691	}
2692
2693	return nil
2694}
2695
2696func awsAwsjson11_serializeOpDocumentImportAppCatalogInput(v *ImportAppCatalogInput, value smithyjson.Value) error {
2697	object := value.Object()
2698	defer object.Close()
2699
2700	if v.RoleName != nil {
2701		ok := object.Key("roleName")
2702		ok.String(*v.RoleName)
2703	}
2704
2705	return nil
2706}
2707
2708func awsAwsjson11_serializeOpDocumentImportServerCatalogInput(v *ImportServerCatalogInput, value smithyjson.Value) error {
2709	object := value.Object()
2710	defer object.Close()
2711
2712	return nil
2713}
2714
2715func awsAwsjson11_serializeOpDocumentLaunchAppInput(v *LaunchAppInput, value smithyjson.Value) error {
2716	object := value.Object()
2717	defer object.Close()
2718
2719	if v.AppId != nil {
2720		ok := object.Key("appId")
2721		ok.String(*v.AppId)
2722	}
2723
2724	return nil
2725}
2726
2727func awsAwsjson11_serializeOpDocumentListAppsInput(v *ListAppsInput, value smithyjson.Value) error {
2728	object := value.Object()
2729	defer object.Close()
2730
2731	if v.AppIds != nil {
2732		ok := object.Key("appIds")
2733		if err := awsAwsjson11_serializeDocumentAppIds(v.AppIds, ok); err != nil {
2734			return err
2735		}
2736	}
2737
2738	if v.MaxResults != nil {
2739		ok := object.Key("maxResults")
2740		ok.Integer(*v.MaxResults)
2741	}
2742
2743	if v.NextToken != nil {
2744		ok := object.Key("nextToken")
2745		ok.String(*v.NextToken)
2746	}
2747
2748	return nil
2749}
2750
2751func awsAwsjson11_serializeOpDocumentNotifyAppValidationOutputInput(v *NotifyAppValidationOutputInput, value smithyjson.Value) error {
2752	object := value.Object()
2753	defer object.Close()
2754
2755	if v.AppId != nil {
2756		ok := object.Key("appId")
2757		ok.String(*v.AppId)
2758	}
2759
2760	if v.NotificationContext != nil {
2761		ok := object.Key("notificationContext")
2762		if err := awsAwsjson11_serializeDocumentNotificationContext(v.NotificationContext, ok); err != nil {
2763			return err
2764		}
2765	}
2766
2767	return nil
2768}
2769
2770func awsAwsjson11_serializeOpDocumentPutAppLaunchConfigurationInput(v *PutAppLaunchConfigurationInput, value smithyjson.Value) error {
2771	object := value.Object()
2772	defer object.Close()
2773
2774	if v.AppId != nil {
2775		ok := object.Key("appId")
2776		ok.String(*v.AppId)
2777	}
2778
2779	if v.AutoLaunch != nil {
2780		ok := object.Key("autoLaunch")
2781		ok.Boolean(*v.AutoLaunch)
2782	}
2783
2784	if v.RoleName != nil {
2785		ok := object.Key("roleName")
2786		ok.String(*v.RoleName)
2787	}
2788
2789	if v.ServerGroupLaunchConfigurations != nil {
2790		ok := object.Key("serverGroupLaunchConfigurations")
2791		if err := awsAwsjson11_serializeDocumentServerGroupLaunchConfigurations(v.ServerGroupLaunchConfigurations, ok); err != nil {
2792			return err
2793		}
2794	}
2795
2796	return nil
2797}
2798
2799func awsAwsjson11_serializeOpDocumentPutAppReplicationConfigurationInput(v *PutAppReplicationConfigurationInput, value smithyjson.Value) error {
2800	object := value.Object()
2801	defer object.Close()
2802
2803	if v.AppId != nil {
2804		ok := object.Key("appId")
2805		ok.String(*v.AppId)
2806	}
2807
2808	if v.ServerGroupReplicationConfigurations != nil {
2809		ok := object.Key("serverGroupReplicationConfigurations")
2810		if err := awsAwsjson11_serializeDocumentServerGroupReplicationConfigurations(v.ServerGroupReplicationConfigurations, ok); err != nil {
2811			return err
2812		}
2813	}
2814
2815	return nil
2816}
2817
2818func awsAwsjson11_serializeOpDocumentPutAppValidationConfigurationInput(v *PutAppValidationConfigurationInput, value smithyjson.Value) error {
2819	object := value.Object()
2820	defer object.Close()
2821
2822	if v.AppId != nil {
2823		ok := object.Key("appId")
2824		ok.String(*v.AppId)
2825	}
2826
2827	if v.AppValidationConfigurations != nil {
2828		ok := object.Key("appValidationConfigurations")
2829		if err := awsAwsjson11_serializeDocumentAppValidationConfigurations(v.AppValidationConfigurations, ok); err != nil {
2830			return err
2831		}
2832	}
2833
2834	if v.ServerGroupValidationConfigurations != nil {
2835		ok := object.Key("serverGroupValidationConfigurations")
2836		if err := awsAwsjson11_serializeDocumentServerGroupValidationConfigurations(v.ServerGroupValidationConfigurations, ok); err != nil {
2837			return err
2838		}
2839	}
2840
2841	return nil
2842}
2843
2844func awsAwsjson11_serializeOpDocumentStartAppReplicationInput(v *StartAppReplicationInput, value smithyjson.Value) error {
2845	object := value.Object()
2846	defer object.Close()
2847
2848	if v.AppId != nil {
2849		ok := object.Key("appId")
2850		ok.String(*v.AppId)
2851	}
2852
2853	return nil
2854}
2855
2856func awsAwsjson11_serializeOpDocumentStartOnDemandAppReplicationInput(v *StartOnDemandAppReplicationInput, value smithyjson.Value) error {
2857	object := value.Object()
2858	defer object.Close()
2859
2860	if v.AppId != nil {
2861		ok := object.Key("appId")
2862		ok.String(*v.AppId)
2863	}
2864
2865	if v.Description != nil {
2866		ok := object.Key("description")
2867		ok.String(*v.Description)
2868	}
2869
2870	return nil
2871}
2872
2873func awsAwsjson11_serializeOpDocumentStartOnDemandReplicationRunInput(v *StartOnDemandReplicationRunInput, value smithyjson.Value) error {
2874	object := value.Object()
2875	defer object.Close()
2876
2877	if v.Description != nil {
2878		ok := object.Key("description")
2879		ok.String(*v.Description)
2880	}
2881
2882	if v.ReplicationJobId != nil {
2883		ok := object.Key("replicationJobId")
2884		ok.String(*v.ReplicationJobId)
2885	}
2886
2887	return nil
2888}
2889
2890func awsAwsjson11_serializeOpDocumentStopAppReplicationInput(v *StopAppReplicationInput, value smithyjson.Value) error {
2891	object := value.Object()
2892	defer object.Close()
2893
2894	if v.AppId != nil {
2895		ok := object.Key("appId")
2896		ok.String(*v.AppId)
2897	}
2898
2899	return nil
2900}
2901
2902func awsAwsjson11_serializeOpDocumentTerminateAppInput(v *TerminateAppInput, value smithyjson.Value) error {
2903	object := value.Object()
2904	defer object.Close()
2905
2906	if v.AppId != nil {
2907		ok := object.Key("appId")
2908		ok.String(*v.AppId)
2909	}
2910
2911	return nil
2912}
2913
2914func awsAwsjson11_serializeOpDocumentUpdateAppInput(v *UpdateAppInput, value smithyjson.Value) error {
2915	object := value.Object()
2916	defer object.Close()
2917
2918	if v.AppId != nil {
2919		ok := object.Key("appId")
2920		ok.String(*v.AppId)
2921	}
2922
2923	if v.Description != nil {
2924		ok := object.Key("description")
2925		ok.String(*v.Description)
2926	}
2927
2928	if v.Name != nil {
2929		ok := object.Key("name")
2930		ok.String(*v.Name)
2931	}
2932
2933	if v.RoleName != nil {
2934		ok := object.Key("roleName")
2935		ok.String(*v.RoleName)
2936	}
2937
2938	if v.ServerGroups != nil {
2939		ok := object.Key("serverGroups")
2940		if err := awsAwsjson11_serializeDocumentServerGroups(v.ServerGroups, ok); err != nil {
2941			return err
2942		}
2943	}
2944
2945	if v.Tags != nil {
2946		ok := object.Key("tags")
2947		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2948			return err
2949		}
2950	}
2951
2952	return nil
2953}
2954
2955func awsAwsjson11_serializeOpDocumentUpdateReplicationJobInput(v *UpdateReplicationJobInput, value smithyjson.Value) error {
2956	object := value.Object()
2957	defer object.Close()
2958
2959	if v.Description != nil {
2960		ok := object.Key("description")
2961		ok.String(*v.Description)
2962	}
2963
2964	if v.Encrypted != nil {
2965		ok := object.Key("encrypted")
2966		ok.Boolean(*v.Encrypted)
2967	}
2968
2969	if v.Frequency != nil {
2970		ok := object.Key("frequency")
2971		ok.Integer(*v.Frequency)
2972	}
2973
2974	if v.KmsKeyId != nil {
2975		ok := object.Key("kmsKeyId")
2976		ok.String(*v.KmsKeyId)
2977	}
2978
2979	if len(v.LicenseType) > 0 {
2980		ok := object.Key("licenseType")
2981		ok.String(string(v.LicenseType))
2982	}
2983
2984	if v.NextReplicationRunStartTime != nil {
2985		ok := object.Key("nextReplicationRunStartTime")
2986		ok.Double(smithytime.FormatEpochSeconds(*v.NextReplicationRunStartTime))
2987	}
2988
2989	if v.NumberOfRecentAmisToKeep != nil {
2990		ok := object.Key("numberOfRecentAmisToKeep")
2991		ok.Integer(*v.NumberOfRecentAmisToKeep)
2992	}
2993
2994	if v.ReplicationJobId != nil {
2995		ok := object.Key("replicationJobId")
2996		ok.String(*v.ReplicationJobId)
2997	}
2998
2999	if v.RoleName != nil {
3000		ok := object.Key("roleName")
3001		ok.String(*v.RoleName)
3002	}
3003
3004	return nil
3005}
3006