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