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