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