1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package forecast
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/forecast/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsAwsjson11_serializeOpCreateDataset struct {
18}
19
20func (*awsAwsjson11_serializeOpCreateDataset) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpCreateDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*CreateDatasetInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	request.Request.URL.Path = "/"
39	request.Request.Method = "POST"
40	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
41	if err != nil {
42		return out, metadata, &smithy.SerializationError{Err: err}
43	}
44	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
45	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreateDataset")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentCreateDatasetInput(input, jsonEncoder.Value); err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
53		return out, metadata, &smithy.SerializationError{Err: err}
54	}
55
56	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
57		return out, metadata, &smithy.SerializationError{Err: err}
58	}
59	in.Request = request
60
61	return next.HandleSerialize(ctx, in)
62}
63
64type awsAwsjson11_serializeOpCreateDatasetGroup struct {
65}
66
67func (*awsAwsjson11_serializeOpCreateDatasetGroup) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpCreateDatasetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
72	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
73) {
74	request, ok := in.Request.(*smithyhttp.Request)
75	if !ok {
76		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
77	}
78
79	input, ok := in.Parameters.(*CreateDatasetGroupInput)
80	_ = input
81	if !ok {
82		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
83	}
84
85	request.Request.URL.Path = "/"
86	request.Request.Method = "POST"
87	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
88	if err != nil {
89		return out, metadata, &smithy.SerializationError{Err: err}
90	}
91	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
92	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreateDatasetGroup")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentCreateDatasetGroupInput(input, jsonEncoder.Value); err != nil {
96		return out, metadata, &smithy.SerializationError{Err: err}
97	}
98
99	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
100		return out, metadata, &smithy.SerializationError{Err: err}
101	}
102
103	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
104		return out, metadata, &smithy.SerializationError{Err: err}
105	}
106	in.Request = request
107
108	return next.HandleSerialize(ctx, in)
109}
110
111type awsAwsjson11_serializeOpCreateDatasetImportJob struct {
112}
113
114func (*awsAwsjson11_serializeOpCreateDatasetImportJob) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpCreateDatasetImportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
119	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
120) {
121	request, ok := in.Request.(*smithyhttp.Request)
122	if !ok {
123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
124	}
125
126	input, ok := in.Parameters.(*CreateDatasetImportJobInput)
127	_ = input
128	if !ok {
129		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
130	}
131
132	request.Request.URL.Path = "/"
133	request.Request.Method = "POST"
134	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
135	if err != nil {
136		return out, metadata, &smithy.SerializationError{Err: err}
137	}
138	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
139	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreateDatasetImportJob")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentCreateDatasetImportJobInput(input, jsonEncoder.Value); err != nil {
143		return out, metadata, &smithy.SerializationError{Err: err}
144	}
145
146	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
147		return out, metadata, &smithy.SerializationError{Err: err}
148	}
149
150	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
151		return out, metadata, &smithy.SerializationError{Err: err}
152	}
153	in.Request = request
154
155	return next.HandleSerialize(ctx, in)
156}
157
158type awsAwsjson11_serializeOpCreateForecast struct {
159}
160
161func (*awsAwsjson11_serializeOpCreateForecast) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCreateForecast) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
166	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
167) {
168	request, ok := in.Request.(*smithyhttp.Request)
169	if !ok {
170		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
171	}
172
173	input, ok := in.Parameters.(*CreateForecastInput)
174	_ = input
175	if !ok {
176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
177	}
178
179	request.Request.URL.Path = "/"
180	request.Request.Method = "POST"
181	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
182	if err != nil {
183		return out, metadata, &smithy.SerializationError{Err: err}
184	}
185	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
186	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreateForecast")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCreateForecastInput(input, jsonEncoder.Value); err != nil {
190		return out, metadata, &smithy.SerializationError{Err: err}
191	}
192
193	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
194		return out, metadata, &smithy.SerializationError{Err: err}
195	}
196
197	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
198		return out, metadata, &smithy.SerializationError{Err: err}
199	}
200	in.Request = request
201
202	return next.HandleSerialize(ctx, in)
203}
204
205type awsAwsjson11_serializeOpCreateForecastExportJob struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateForecastExportJob) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateForecastExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
213	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
214) {
215	request, ok := in.Request.(*smithyhttp.Request)
216	if !ok {
217		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
218	}
219
220	input, ok := in.Parameters.(*CreateForecastExportJobInput)
221	_ = input
222	if !ok {
223		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
224	}
225
226	request.Request.URL.Path = "/"
227	request.Request.Method = "POST"
228	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
229	if err != nil {
230		return out, metadata, &smithy.SerializationError{Err: err}
231	}
232	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
233	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreateForecastExportJob")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateForecastExportJobInput(input, jsonEncoder.Value); err != nil {
237		return out, metadata, &smithy.SerializationError{Err: err}
238	}
239
240	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
241		return out, metadata, &smithy.SerializationError{Err: err}
242	}
243
244	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
245		return out, metadata, &smithy.SerializationError{Err: err}
246	}
247	in.Request = request
248
249	return next.HandleSerialize(ctx, in)
250}
251
252type awsAwsjson11_serializeOpCreatePredictor struct {
253}
254
255func (*awsAwsjson11_serializeOpCreatePredictor) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpCreatePredictor) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
260	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
261) {
262	request, ok := in.Request.(*smithyhttp.Request)
263	if !ok {
264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
265	}
266
267	input, ok := in.Parameters.(*CreatePredictorInput)
268	_ = input
269	if !ok {
270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
271	}
272
273	request.Request.URL.Path = "/"
274	request.Request.Method = "POST"
275	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
276	if err != nil {
277		return out, metadata, &smithy.SerializationError{Err: err}
278	}
279	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
280	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreatePredictor")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentCreatePredictorInput(input, jsonEncoder.Value); err != nil {
284		return out, metadata, &smithy.SerializationError{Err: err}
285	}
286
287	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
288		return out, metadata, &smithy.SerializationError{Err: err}
289	}
290
291	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
292		return out, metadata, &smithy.SerializationError{Err: err}
293	}
294	in.Request = request
295
296	return next.HandleSerialize(ctx, in)
297}
298
299type awsAwsjson11_serializeOpCreatePredictorBacktestExportJob struct {
300}
301
302func (*awsAwsjson11_serializeOpCreatePredictorBacktestExportJob) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpCreatePredictorBacktestExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
308) {
309	request, ok := in.Request.(*smithyhttp.Request)
310	if !ok {
311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
312	}
313
314	input, ok := in.Parameters.(*CreatePredictorBacktestExportJobInput)
315	_ = input
316	if !ok {
317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
318	}
319
320	request.Request.URL.Path = "/"
321	request.Request.Method = "POST"
322	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
323	if err != nil {
324		return out, metadata, &smithy.SerializationError{Err: err}
325	}
326	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
327	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.CreatePredictorBacktestExportJob")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentCreatePredictorBacktestExportJobInput(input, jsonEncoder.Value); err != nil {
331		return out, metadata, &smithy.SerializationError{Err: err}
332	}
333
334	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
335		return out, metadata, &smithy.SerializationError{Err: err}
336	}
337
338	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341	in.Request = request
342
343	return next.HandleSerialize(ctx, in)
344}
345
346type awsAwsjson11_serializeOpDeleteDataset struct {
347}
348
349func (*awsAwsjson11_serializeOpDeleteDataset) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpDeleteDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
354	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
355) {
356	request, ok := in.Request.(*smithyhttp.Request)
357	if !ok {
358		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
359	}
360
361	input, ok := in.Parameters.(*DeleteDatasetInput)
362	_ = input
363	if !ok {
364		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
365	}
366
367	request.Request.URL.Path = "/"
368	request.Request.Method = "POST"
369	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
370	if err != nil {
371		return out, metadata, &smithy.SerializationError{Err: err}
372	}
373	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
374	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeleteDataset")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentDeleteDatasetInput(input, jsonEncoder.Value); err != nil {
378		return out, metadata, &smithy.SerializationError{Err: err}
379	}
380
381	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
382		return out, metadata, &smithy.SerializationError{Err: err}
383	}
384
385	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
386		return out, metadata, &smithy.SerializationError{Err: err}
387	}
388	in.Request = request
389
390	return next.HandleSerialize(ctx, in)
391}
392
393type awsAwsjson11_serializeOpDeleteDatasetGroup struct {
394}
395
396func (*awsAwsjson11_serializeOpDeleteDatasetGroup) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpDeleteDatasetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
401	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
402) {
403	request, ok := in.Request.(*smithyhttp.Request)
404	if !ok {
405		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
406	}
407
408	input, ok := in.Parameters.(*DeleteDatasetGroupInput)
409	_ = input
410	if !ok {
411		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
412	}
413
414	request.Request.URL.Path = "/"
415	request.Request.Method = "POST"
416	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
417	if err != nil {
418		return out, metadata, &smithy.SerializationError{Err: err}
419	}
420	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
421	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeleteDatasetGroup")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentDeleteDatasetGroupInput(input, jsonEncoder.Value); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427
428	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
429		return out, metadata, &smithy.SerializationError{Err: err}
430	}
431
432	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
433		return out, metadata, &smithy.SerializationError{Err: err}
434	}
435	in.Request = request
436
437	return next.HandleSerialize(ctx, in)
438}
439
440type awsAwsjson11_serializeOpDeleteDatasetImportJob struct {
441}
442
443func (*awsAwsjson11_serializeOpDeleteDatasetImportJob) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpDeleteDatasetImportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
448	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
449) {
450	request, ok := in.Request.(*smithyhttp.Request)
451	if !ok {
452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
453	}
454
455	input, ok := in.Parameters.(*DeleteDatasetImportJobInput)
456	_ = input
457	if !ok {
458		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
459	}
460
461	request.Request.URL.Path = "/"
462	request.Request.Method = "POST"
463	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
464	if err != nil {
465		return out, metadata, &smithy.SerializationError{Err: err}
466	}
467	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
468	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeleteDatasetImportJob")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentDeleteDatasetImportJobInput(input, jsonEncoder.Value); err != nil {
472		return out, metadata, &smithy.SerializationError{Err: err}
473	}
474
475	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
476		return out, metadata, &smithy.SerializationError{Err: err}
477	}
478
479	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
480		return out, metadata, &smithy.SerializationError{Err: err}
481	}
482	in.Request = request
483
484	return next.HandleSerialize(ctx, in)
485}
486
487type awsAwsjson11_serializeOpDeleteForecast struct {
488}
489
490func (*awsAwsjson11_serializeOpDeleteForecast) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDeleteForecast) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
495	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
496) {
497	request, ok := in.Request.(*smithyhttp.Request)
498	if !ok {
499		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
500	}
501
502	input, ok := in.Parameters.(*DeleteForecastInput)
503	_ = input
504	if !ok {
505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
506	}
507
508	request.Request.URL.Path = "/"
509	request.Request.Method = "POST"
510	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
511	if err != nil {
512		return out, metadata, &smithy.SerializationError{Err: err}
513	}
514	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
515	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeleteForecast")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDeleteForecastInput(input, jsonEncoder.Value); err != nil {
519		return out, metadata, &smithy.SerializationError{Err: err}
520	}
521
522	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
523		return out, metadata, &smithy.SerializationError{Err: err}
524	}
525
526	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
527		return out, metadata, &smithy.SerializationError{Err: err}
528	}
529	in.Request = request
530
531	return next.HandleSerialize(ctx, in)
532}
533
534type awsAwsjson11_serializeOpDeleteForecastExportJob struct {
535}
536
537func (*awsAwsjson11_serializeOpDeleteForecastExportJob) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDeleteForecastExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
542	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
543) {
544	request, ok := in.Request.(*smithyhttp.Request)
545	if !ok {
546		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
547	}
548
549	input, ok := in.Parameters.(*DeleteForecastExportJobInput)
550	_ = input
551	if !ok {
552		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
553	}
554
555	request.Request.URL.Path = "/"
556	request.Request.Method = "POST"
557	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
558	if err != nil {
559		return out, metadata, &smithy.SerializationError{Err: err}
560	}
561	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
562	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeleteForecastExportJob")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDeleteForecastExportJobInput(input, jsonEncoder.Value); err != nil {
566		return out, metadata, &smithy.SerializationError{Err: err}
567	}
568
569	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
570		return out, metadata, &smithy.SerializationError{Err: err}
571	}
572
573	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
574		return out, metadata, &smithy.SerializationError{Err: err}
575	}
576	in.Request = request
577
578	return next.HandleSerialize(ctx, in)
579}
580
581type awsAwsjson11_serializeOpDeletePredictor struct {
582}
583
584func (*awsAwsjson11_serializeOpDeletePredictor) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDeletePredictor) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
589	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
590) {
591	request, ok := in.Request.(*smithyhttp.Request)
592	if !ok {
593		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
594	}
595
596	input, ok := in.Parameters.(*DeletePredictorInput)
597	_ = input
598	if !ok {
599		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
600	}
601
602	request.Request.URL.Path = "/"
603	request.Request.Method = "POST"
604	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
605	if err != nil {
606		return out, metadata, &smithy.SerializationError{Err: err}
607	}
608	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
609	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeletePredictor")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDeletePredictorInput(input, jsonEncoder.Value); err != nil {
613		return out, metadata, &smithy.SerializationError{Err: err}
614	}
615
616	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
617		return out, metadata, &smithy.SerializationError{Err: err}
618	}
619
620	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
621		return out, metadata, &smithy.SerializationError{Err: err}
622	}
623	in.Request = request
624
625	return next.HandleSerialize(ctx, in)
626}
627
628type awsAwsjson11_serializeOpDeletePredictorBacktestExportJob struct {
629}
630
631func (*awsAwsjson11_serializeOpDeletePredictorBacktestExportJob) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpDeletePredictorBacktestExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
636	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
637) {
638	request, ok := in.Request.(*smithyhttp.Request)
639	if !ok {
640		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
641	}
642
643	input, ok := in.Parameters.(*DeletePredictorBacktestExportJobInput)
644	_ = input
645	if !ok {
646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
647	}
648
649	request.Request.URL.Path = "/"
650	request.Request.Method = "POST"
651	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
652	if err != nil {
653		return out, metadata, &smithy.SerializationError{Err: err}
654	}
655	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
656	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DeletePredictorBacktestExportJob")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentDeletePredictorBacktestExportJobInput(input, jsonEncoder.Value); err != nil {
660		return out, metadata, &smithy.SerializationError{Err: err}
661	}
662
663	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
664		return out, metadata, &smithy.SerializationError{Err: err}
665	}
666
667	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
668		return out, metadata, &smithy.SerializationError{Err: err}
669	}
670	in.Request = request
671
672	return next.HandleSerialize(ctx, in)
673}
674
675type awsAwsjson11_serializeOpDescribeDataset struct {
676}
677
678func (*awsAwsjson11_serializeOpDescribeDataset) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDescribeDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
683	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
684) {
685	request, ok := in.Request.(*smithyhttp.Request)
686	if !ok {
687		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
688	}
689
690	input, ok := in.Parameters.(*DescribeDatasetInput)
691	_ = input
692	if !ok {
693		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
694	}
695
696	request.Request.URL.Path = "/"
697	request.Request.Method = "POST"
698	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
699	if err != nil {
700		return out, metadata, &smithy.SerializationError{Err: err}
701	}
702	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
703	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribeDataset")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDescribeDatasetInput(input, jsonEncoder.Value); err != nil {
707		return out, metadata, &smithy.SerializationError{Err: err}
708	}
709
710	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
711		return out, metadata, &smithy.SerializationError{Err: err}
712	}
713
714	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717	in.Request = request
718
719	return next.HandleSerialize(ctx, in)
720}
721
722type awsAwsjson11_serializeOpDescribeDatasetGroup struct {
723}
724
725func (*awsAwsjson11_serializeOpDescribeDatasetGroup) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDescribeDatasetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
730	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
731) {
732	request, ok := in.Request.(*smithyhttp.Request)
733	if !ok {
734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
735	}
736
737	input, ok := in.Parameters.(*DescribeDatasetGroupInput)
738	_ = input
739	if !ok {
740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
741	}
742
743	request.Request.URL.Path = "/"
744	request.Request.Method = "POST"
745	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
746	if err != nil {
747		return out, metadata, &smithy.SerializationError{Err: err}
748	}
749	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
750	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribeDatasetGroup")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDescribeDatasetGroupInput(input, jsonEncoder.Value); err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760
761	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
762		return out, metadata, &smithy.SerializationError{Err: err}
763	}
764	in.Request = request
765
766	return next.HandleSerialize(ctx, in)
767}
768
769type awsAwsjson11_serializeOpDescribeDatasetImportJob struct {
770}
771
772func (*awsAwsjson11_serializeOpDescribeDatasetImportJob) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDescribeDatasetImportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
777	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
778) {
779	request, ok := in.Request.(*smithyhttp.Request)
780	if !ok {
781		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
782	}
783
784	input, ok := in.Parameters.(*DescribeDatasetImportJobInput)
785	_ = input
786	if !ok {
787		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
788	}
789
790	request.Request.URL.Path = "/"
791	request.Request.Method = "POST"
792	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
793	if err != nil {
794		return out, metadata, &smithy.SerializationError{Err: err}
795	}
796	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
797	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribeDatasetImportJob")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDescribeDatasetImportJobInput(input, jsonEncoder.Value); err != nil {
801		return out, metadata, &smithy.SerializationError{Err: err}
802	}
803
804	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
805		return out, metadata, &smithy.SerializationError{Err: err}
806	}
807
808	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
809		return out, metadata, &smithy.SerializationError{Err: err}
810	}
811	in.Request = request
812
813	return next.HandleSerialize(ctx, in)
814}
815
816type awsAwsjson11_serializeOpDescribeForecast struct {
817}
818
819func (*awsAwsjson11_serializeOpDescribeForecast) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDescribeForecast) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
824	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
825) {
826	request, ok := in.Request.(*smithyhttp.Request)
827	if !ok {
828		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
829	}
830
831	input, ok := in.Parameters.(*DescribeForecastInput)
832	_ = input
833	if !ok {
834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
835	}
836
837	request.Request.URL.Path = "/"
838	request.Request.Method = "POST"
839	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
840	if err != nil {
841		return out, metadata, &smithy.SerializationError{Err: err}
842	}
843	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
844	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribeForecast")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDescribeForecastInput(input, jsonEncoder.Value); err != nil {
848		return out, metadata, &smithy.SerializationError{Err: err}
849	}
850
851	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
852		return out, metadata, &smithy.SerializationError{Err: err}
853	}
854
855	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
856		return out, metadata, &smithy.SerializationError{Err: err}
857	}
858	in.Request = request
859
860	return next.HandleSerialize(ctx, in)
861}
862
863type awsAwsjson11_serializeOpDescribeForecastExportJob struct {
864}
865
866func (*awsAwsjson11_serializeOpDescribeForecastExportJob) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDescribeForecastExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
871	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
872) {
873	request, ok := in.Request.(*smithyhttp.Request)
874	if !ok {
875		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
876	}
877
878	input, ok := in.Parameters.(*DescribeForecastExportJobInput)
879	_ = input
880	if !ok {
881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
882	}
883
884	request.Request.URL.Path = "/"
885	request.Request.Method = "POST"
886	httpBindingEncoder, 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	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
891	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribeForecastExportJob")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDescribeForecastExportJobInput(input, jsonEncoder.Value); err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897
898	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905	in.Request = request
906
907	return next.HandleSerialize(ctx, in)
908}
909
910type awsAwsjson11_serializeOpDescribePredictor struct {
911}
912
913func (*awsAwsjson11_serializeOpDescribePredictor) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDescribePredictor) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
918	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
919) {
920	request, ok := in.Request.(*smithyhttp.Request)
921	if !ok {
922		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
923	}
924
925	input, ok := in.Parameters.(*DescribePredictorInput)
926	_ = input
927	if !ok {
928		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
929	}
930
931	request.Request.URL.Path = "/"
932	request.Request.Method = "POST"
933	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
934	if err != nil {
935		return out, metadata, &smithy.SerializationError{Err: err}
936	}
937	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
938	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribePredictor")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDescribePredictorInput(input, jsonEncoder.Value); err != nil {
942		return out, metadata, &smithy.SerializationError{Err: err}
943	}
944
945	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
946		return out, metadata, &smithy.SerializationError{Err: err}
947	}
948
949	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
950		return out, metadata, &smithy.SerializationError{Err: err}
951	}
952	in.Request = request
953
954	return next.HandleSerialize(ctx, in)
955}
956
957type awsAwsjson11_serializeOpDescribePredictorBacktestExportJob struct {
958}
959
960func (*awsAwsjson11_serializeOpDescribePredictorBacktestExportJob) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDescribePredictorBacktestExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
966) {
967	request, ok := in.Request.(*smithyhttp.Request)
968	if !ok {
969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
970	}
971
972	input, ok := in.Parameters.(*DescribePredictorBacktestExportJobInput)
973	_ = input
974	if !ok {
975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
976	}
977
978	request.Request.URL.Path = "/"
979	request.Request.Method = "POST"
980	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
981	if err != nil {
982		return out, metadata, &smithy.SerializationError{Err: err}
983	}
984	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
985	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.DescribePredictorBacktestExportJob")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDescribePredictorBacktestExportJobInput(input, jsonEncoder.Value); err != nil {
989		return out, metadata, &smithy.SerializationError{Err: err}
990	}
991
992	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
993		return out, metadata, &smithy.SerializationError{Err: err}
994	}
995
996	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
997		return out, metadata, &smithy.SerializationError{Err: err}
998	}
999	in.Request = request
1000
1001	return next.HandleSerialize(ctx, in)
1002}
1003
1004type awsAwsjson11_serializeOpGetAccuracyMetrics struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpGetAccuracyMetrics) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpGetAccuracyMetrics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1012	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1013) {
1014	request, ok := in.Request.(*smithyhttp.Request)
1015	if !ok {
1016		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1017	}
1018
1019	input, ok := in.Parameters.(*GetAccuracyMetricsInput)
1020	_ = input
1021	if !ok {
1022		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1023	}
1024
1025	request.Request.URL.Path = "/"
1026	request.Request.Method = "POST"
1027	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1028	if err != nil {
1029		return out, metadata, &smithy.SerializationError{Err: err}
1030	}
1031	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1032	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.GetAccuracyMetrics")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentGetAccuracyMetricsInput(input, jsonEncoder.Value); err != nil {
1036		return out, metadata, &smithy.SerializationError{Err: err}
1037	}
1038
1039	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1040		return out, metadata, &smithy.SerializationError{Err: err}
1041	}
1042
1043	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1044		return out, metadata, &smithy.SerializationError{Err: err}
1045	}
1046	in.Request = request
1047
1048	return next.HandleSerialize(ctx, in)
1049}
1050
1051type awsAwsjson11_serializeOpListDatasetGroups struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpListDatasetGroups) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpListDatasetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1059	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1060) {
1061	request, ok := in.Request.(*smithyhttp.Request)
1062	if !ok {
1063		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1064	}
1065
1066	input, ok := in.Parameters.(*ListDatasetGroupsInput)
1067	_ = input
1068	if !ok {
1069		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1070	}
1071
1072	request.Request.URL.Path = "/"
1073	request.Request.Method = "POST"
1074	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1075	if err != nil {
1076		return out, metadata, &smithy.SerializationError{Err: err}
1077	}
1078	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1079	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListDatasetGroups")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentListDatasetGroupsInput(input, jsonEncoder.Value); err != nil {
1083		return out, metadata, &smithy.SerializationError{Err: err}
1084	}
1085
1086	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1087		return out, metadata, &smithy.SerializationError{Err: err}
1088	}
1089
1090	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1091		return out, metadata, &smithy.SerializationError{Err: err}
1092	}
1093	in.Request = request
1094
1095	return next.HandleSerialize(ctx, in)
1096}
1097
1098type awsAwsjson11_serializeOpListDatasetImportJobs struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpListDatasetImportJobs) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpListDatasetImportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1106	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1107) {
1108	request, ok := in.Request.(*smithyhttp.Request)
1109	if !ok {
1110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1111	}
1112
1113	input, ok := in.Parameters.(*ListDatasetImportJobsInput)
1114	_ = input
1115	if !ok {
1116		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1117	}
1118
1119	request.Request.URL.Path = "/"
1120	request.Request.Method = "POST"
1121	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1122	if err != nil {
1123		return out, metadata, &smithy.SerializationError{Err: err}
1124	}
1125	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1126	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListDatasetImportJobs")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentListDatasetImportJobsInput(input, jsonEncoder.Value); err != nil {
1130		return out, metadata, &smithy.SerializationError{Err: err}
1131	}
1132
1133	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1134		return out, metadata, &smithy.SerializationError{Err: err}
1135	}
1136
1137	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1138		return out, metadata, &smithy.SerializationError{Err: err}
1139	}
1140	in.Request = request
1141
1142	return next.HandleSerialize(ctx, in)
1143}
1144
1145type awsAwsjson11_serializeOpListDatasets struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpListDatasets) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpListDatasets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1153	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1154) {
1155	request, ok := in.Request.(*smithyhttp.Request)
1156	if !ok {
1157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1158	}
1159
1160	input, ok := in.Parameters.(*ListDatasetsInput)
1161	_ = input
1162	if !ok {
1163		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1164	}
1165
1166	request.Request.URL.Path = "/"
1167	request.Request.Method = "POST"
1168	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1169	if err != nil {
1170		return out, metadata, &smithy.SerializationError{Err: err}
1171	}
1172	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1173	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListDatasets")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentListDatasetsInput(input, jsonEncoder.Value); err != nil {
1177		return out, metadata, &smithy.SerializationError{Err: err}
1178	}
1179
1180	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1181		return out, metadata, &smithy.SerializationError{Err: err}
1182	}
1183
1184	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1185		return out, metadata, &smithy.SerializationError{Err: err}
1186	}
1187	in.Request = request
1188
1189	return next.HandleSerialize(ctx, in)
1190}
1191
1192type awsAwsjson11_serializeOpListForecastExportJobs struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpListForecastExportJobs) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpListForecastExportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1200	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	request, ok := in.Request.(*smithyhttp.Request)
1203	if !ok {
1204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1205	}
1206
1207	input, ok := in.Parameters.(*ListForecastExportJobsInput)
1208	_ = input
1209	if !ok {
1210		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1211	}
1212
1213	request.Request.URL.Path = "/"
1214	request.Request.Method = "POST"
1215	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1216	if err != nil {
1217		return out, metadata, &smithy.SerializationError{Err: err}
1218	}
1219	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1220	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListForecastExportJobs")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentListForecastExportJobsInput(input, jsonEncoder.Value); err != nil {
1224		return out, metadata, &smithy.SerializationError{Err: err}
1225	}
1226
1227	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1228		return out, metadata, &smithy.SerializationError{Err: err}
1229	}
1230
1231	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1232		return out, metadata, &smithy.SerializationError{Err: err}
1233	}
1234	in.Request = request
1235
1236	return next.HandleSerialize(ctx, in)
1237}
1238
1239type awsAwsjson11_serializeOpListForecasts struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpListForecasts) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpListForecasts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1247	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1248) {
1249	request, ok := in.Request.(*smithyhttp.Request)
1250	if !ok {
1251		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1252	}
1253
1254	input, ok := in.Parameters.(*ListForecastsInput)
1255	_ = input
1256	if !ok {
1257		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1258	}
1259
1260	request.Request.URL.Path = "/"
1261	request.Request.Method = "POST"
1262	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1263	if err != nil {
1264		return out, metadata, &smithy.SerializationError{Err: err}
1265	}
1266	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1267	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListForecasts")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentListForecastsInput(input, jsonEncoder.Value); err != nil {
1271		return out, metadata, &smithy.SerializationError{Err: err}
1272	}
1273
1274	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277
1278	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1279		return out, metadata, &smithy.SerializationError{Err: err}
1280	}
1281	in.Request = request
1282
1283	return next.HandleSerialize(ctx, in)
1284}
1285
1286type awsAwsjson11_serializeOpListPredictorBacktestExportJobs struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpListPredictorBacktestExportJobs) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpListPredictorBacktestExportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	request, ok := in.Request.(*smithyhttp.Request)
1297	if !ok {
1298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1299	}
1300
1301	input, ok := in.Parameters.(*ListPredictorBacktestExportJobsInput)
1302	_ = input
1303	if !ok {
1304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1305	}
1306
1307	request.Request.URL.Path = "/"
1308	request.Request.Method = "POST"
1309	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1310	if err != nil {
1311		return out, metadata, &smithy.SerializationError{Err: err}
1312	}
1313	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1314	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListPredictorBacktestExportJobs")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentListPredictorBacktestExportJobsInput(input, jsonEncoder.Value); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320
1321	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1322		return out, metadata, &smithy.SerializationError{Err: err}
1323	}
1324
1325	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328	in.Request = request
1329
1330	return next.HandleSerialize(ctx, in)
1331}
1332
1333type awsAwsjson11_serializeOpListPredictors struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpListPredictors) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpListPredictors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1341	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	request, ok := in.Request.(*smithyhttp.Request)
1344	if !ok {
1345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1346	}
1347
1348	input, ok := in.Parameters.(*ListPredictorsInput)
1349	_ = input
1350	if !ok {
1351		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1352	}
1353
1354	request.Request.URL.Path = "/"
1355	request.Request.Method = "POST"
1356	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1357	if err != nil {
1358		return out, metadata, &smithy.SerializationError{Err: err}
1359	}
1360	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1361	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListPredictors")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentListPredictorsInput(input, jsonEncoder.Value); err != nil {
1365		return out, metadata, &smithy.SerializationError{Err: err}
1366	}
1367
1368	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1369		return out, metadata, &smithy.SerializationError{Err: err}
1370	}
1371
1372	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1373		return out, metadata, &smithy.SerializationError{Err: err}
1374	}
1375	in.Request = request
1376
1377	return next.HandleSerialize(ctx, in)
1378}
1379
1380type awsAwsjson11_serializeOpListTagsForResource struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1388	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1389) {
1390	request, ok := in.Request.(*smithyhttp.Request)
1391	if !ok {
1392		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1393	}
1394
1395	input, ok := in.Parameters.(*ListTagsForResourceInput)
1396	_ = input
1397	if !ok {
1398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1399	}
1400
1401	request.Request.URL.Path = "/"
1402	request.Request.Method = "POST"
1403	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1404	if err != nil {
1405		return out, metadata, &smithy.SerializationError{Err: err}
1406	}
1407	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1408	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.ListTagsForResource")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
1412		return out, metadata, &smithy.SerializationError{Err: err}
1413	}
1414
1415	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1416		return out, metadata, &smithy.SerializationError{Err: err}
1417	}
1418
1419	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1420		return out, metadata, &smithy.SerializationError{Err: err}
1421	}
1422	in.Request = request
1423
1424	return next.HandleSerialize(ctx, in)
1425}
1426
1427type awsAwsjson11_serializeOpTagResource struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpTagResource) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1435	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1436) {
1437	request, ok := in.Request.(*smithyhttp.Request)
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1440	}
1441
1442	input, ok := in.Parameters.(*TagResourceInput)
1443	_ = input
1444	if !ok {
1445		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1446	}
1447
1448	request.Request.URL.Path = "/"
1449	request.Request.Method = "POST"
1450	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1451	if err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1455	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.TagResource")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsjson11_serializeOpUntagResource struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*UntagResourceInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1502	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.UntagResource")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1514		return out, metadata, &smithy.SerializationError{Err: err}
1515	}
1516	in.Request = request
1517
1518	return next.HandleSerialize(ctx, in)
1519}
1520
1521type awsAwsjson11_serializeOpUpdateDatasetGroup struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpUpdateDatasetGroup) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpUpdateDatasetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1530) {
1531	request, ok := in.Request.(*smithyhttp.Request)
1532	if !ok {
1533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1534	}
1535
1536	input, ok := in.Parameters.(*UpdateDatasetGroupInput)
1537	_ = input
1538	if !ok {
1539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1540	}
1541
1542	request.Request.URL.Path = "/"
1543	request.Request.Method = "POST"
1544	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1549	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonForecast.UpdateDatasetGroup")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentUpdateDatasetGroupInput(input, jsonEncoder.Value); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563	in.Request = request
1564
1565	return next.HandleSerialize(ctx, in)
1566}
1567func awsAwsjson11_serializeDocumentArnList(v []string, value smithyjson.Value) error {
1568	array := value.Array()
1569	defer array.Close()
1570
1571	for i := range v {
1572		av := array.Value()
1573		av.String(v[i])
1574	}
1575	return nil
1576}
1577
1578func awsAwsjson11_serializeDocumentCategoricalParameterRange(v *types.CategoricalParameterRange, value smithyjson.Value) error {
1579	object := value.Object()
1580	defer object.Close()
1581
1582	if v.Name != nil {
1583		ok := object.Key("Name")
1584		ok.String(*v.Name)
1585	}
1586
1587	if v.Values != nil {
1588		ok := object.Key("Values")
1589		if err := awsAwsjson11_serializeDocumentValues(v.Values, ok); err != nil {
1590			return err
1591		}
1592	}
1593
1594	return nil
1595}
1596
1597func awsAwsjson11_serializeDocumentCategoricalParameterRanges(v []types.CategoricalParameterRange, value smithyjson.Value) error {
1598	array := value.Array()
1599	defer array.Close()
1600
1601	for i := range v {
1602		av := array.Value()
1603		if err := awsAwsjson11_serializeDocumentCategoricalParameterRange(&v[i], av); err != nil {
1604			return err
1605		}
1606	}
1607	return nil
1608}
1609
1610func awsAwsjson11_serializeDocumentContinuousParameterRange(v *types.ContinuousParameterRange, value smithyjson.Value) error {
1611	object := value.Object()
1612	defer object.Close()
1613
1614	if v.MaxValue != nil {
1615		ok := object.Key("MaxValue")
1616		ok.Double(*v.MaxValue)
1617	}
1618
1619	if v.MinValue != nil {
1620		ok := object.Key("MinValue")
1621		ok.Double(*v.MinValue)
1622	}
1623
1624	if v.Name != nil {
1625		ok := object.Key("Name")
1626		ok.String(*v.Name)
1627	}
1628
1629	if len(v.ScalingType) > 0 {
1630		ok := object.Key("ScalingType")
1631		ok.String(string(v.ScalingType))
1632	}
1633
1634	return nil
1635}
1636
1637func awsAwsjson11_serializeDocumentContinuousParameterRanges(v []types.ContinuousParameterRange, value smithyjson.Value) error {
1638	array := value.Array()
1639	defer array.Close()
1640
1641	for i := range v {
1642		av := array.Value()
1643		if err := awsAwsjson11_serializeDocumentContinuousParameterRange(&v[i], av); err != nil {
1644			return err
1645		}
1646	}
1647	return nil
1648}
1649
1650func awsAwsjson11_serializeDocumentDataDestination(v *types.DataDestination, value smithyjson.Value) error {
1651	object := value.Object()
1652	defer object.Close()
1653
1654	if v.S3Config != nil {
1655		ok := object.Key("S3Config")
1656		if err := awsAwsjson11_serializeDocumentS3Config(v.S3Config, ok); err != nil {
1657			return err
1658		}
1659	}
1660
1661	return nil
1662}
1663
1664func awsAwsjson11_serializeDocumentDataSource(v *types.DataSource, value smithyjson.Value) error {
1665	object := value.Object()
1666	defer object.Close()
1667
1668	if v.S3Config != nil {
1669		ok := object.Key("S3Config")
1670		if err := awsAwsjson11_serializeDocumentS3Config(v.S3Config, ok); err != nil {
1671			return err
1672		}
1673	}
1674
1675	return nil
1676}
1677
1678func awsAwsjson11_serializeDocumentEncryptionConfig(v *types.EncryptionConfig, value smithyjson.Value) error {
1679	object := value.Object()
1680	defer object.Close()
1681
1682	if v.KMSKeyArn != nil {
1683		ok := object.Key("KMSKeyArn")
1684		ok.String(*v.KMSKeyArn)
1685	}
1686
1687	if v.RoleArn != nil {
1688		ok := object.Key("RoleArn")
1689		ok.String(*v.RoleArn)
1690	}
1691
1692	return nil
1693}
1694
1695func awsAwsjson11_serializeDocumentEvaluationParameters(v *types.EvaluationParameters, value smithyjson.Value) error {
1696	object := value.Object()
1697	defer object.Close()
1698
1699	if v.BackTestWindowOffset != nil {
1700		ok := object.Key("BackTestWindowOffset")
1701		ok.Integer(*v.BackTestWindowOffset)
1702	}
1703
1704	if v.NumberOfBacktestWindows != nil {
1705		ok := object.Key("NumberOfBacktestWindows")
1706		ok.Integer(*v.NumberOfBacktestWindows)
1707	}
1708
1709	return nil
1710}
1711
1712func awsAwsjson11_serializeDocumentFeaturization(v *types.Featurization, value smithyjson.Value) error {
1713	object := value.Object()
1714	defer object.Close()
1715
1716	if v.AttributeName != nil {
1717		ok := object.Key("AttributeName")
1718		ok.String(*v.AttributeName)
1719	}
1720
1721	if v.FeaturizationPipeline != nil {
1722		ok := object.Key("FeaturizationPipeline")
1723		if err := awsAwsjson11_serializeDocumentFeaturizationPipeline(v.FeaturizationPipeline, ok); err != nil {
1724			return err
1725		}
1726	}
1727
1728	return nil
1729}
1730
1731func awsAwsjson11_serializeDocumentFeaturizationConfig(v *types.FeaturizationConfig, value smithyjson.Value) error {
1732	object := value.Object()
1733	defer object.Close()
1734
1735	if v.Featurizations != nil {
1736		ok := object.Key("Featurizations")
1737		if err := awsAwsjson11_serializeDocumentFeaturizations(v.Featurizations, ok); err != nil {
1738			return err
1739		}
1740	}
1741
1742	if v.ForecastDimensions != nil {
1743		ok := object.Key("ForecastDimensions")
1744		if err := awsAwsjson11_serializeDocumentForecastDimensions(v.ForecastDimensions, ok); err != nil {
1745			return err
1746		}
1747	}
1748
1749	if v.ForecastFrequency != nil {
1750		ok := object.Key("ForecastFrequency")
1751		ok.String(*v.ForecastFrequency)
1752	}
1753
1754	return nil
1755}
1756
1757func awsAwsjson11_serializeDocumentFeaturizationMethod(v *types.FeaturizationMethod, value smithyjson.Value) error {
1758	object := value.Object()
1759	defer object.Close()
1760
1761	if len(v.FeaturizationMethodName) > 0 {
1762		ok := object.Key("FeaturizationMethodName")
1763		ok.String(string(v.FeaturizationMethodName))
1764	}
1765
1766	if v.FeaturizationMethodParameters != nil {
1767		ok := object.Key("FeaturizationMethodParameters")
1768		if err := awsAwsjson11_serializeDocumentFeaturizationMethodParameters(v.FeaturizationMethodParameters, ok); err != nil {
1769			return err
1770		}
1771	}
1772
1773	return nil
1774}
1775
1776func awsAwsjson11_serializeDocumentFeaturizationMethodParameters(v map[string]string, value smithyjson.Value) error {
1777	object := value.Object()
1778	defer object.Close()
1779
1780	for key := range v {
1781		om := object.Key(key)
1782		om.String(v[key])
1783	}
1784	return nil
1785}
1786
1787func awsAwsjson11_serializeDocumentFeaturizationPipeline(v []types.FeaturizationMethod, value smithyjson.Value) error {
1788	array := value.Array()
1789	defer array.Close()
1790
1791	for i := range v {
1792		av := array.Value()
1793		if err := awsAwsjson11_serializeDocumentFeaturizationMethod(&v[i], av); err != nil {
1794			return err
1795		}
1796	}
1797	return nil
1798}
1799
1800func awsAwsjson11_serializeDocumentFeaturizations(v []types.Featurization, value smithyjson.Value) error {
1801	array := value.Array()
1802	defer array.Close()
1803
1804	for i := range v {
1805		av := array.Value()
1806		if err := awsAwsjson11_serializeDocumentFeaturization(&v[i], av); err != nil {
1807			return err
1808		}
1809	}
1810	return nil
1811}
1812
1813func awsAwsjson11_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
1814	object := value.Object()
1815	defer object.Close()
1816
1817	if len(v.Condition) > 0 {
1818		ok := object.Key("Condition")
1819		ok.String(string(v.Condition))
1820	}
1821
1822	if v.Key != nil {
1823		ok := object.Key("Key")
1824		ok.String(*v.Key)
1825	}
1826
1827	if v.Value != nil {
1828		ok := object.Key("Value")
1829		ok.String(*v.Value)
1830	}
1831
1832	return nil
1833}
1834
1835func awsAwsjson11_serializeDocumentFilters(v []types.Filter, value smithyjson.Value) error {
1836	array := value.Array()
1837	defer array.Close()
1838
1839	for i := range v {
1840		av := array.Value()
1841		if err := awsAwsjson11_serializeDocumentFilter(&v[i], av); err != nil {
1842			return err
1843		}
1844	}
1845	return nil
1846}
1847
1848func awsAwsjson11_serializeDocumentForecastDimensions(v []string, value smithyjson.Value) error {
1849	array := value.Array()
1850	defer array.Close()
1851
1852	for i := range v {
1853		av := array.Value()
1854		av.String(v[i])
1855	}
1856	return nil
1857}
1858
1859func awsAwsjson11_serializeDocumentForecastTypes(v []string, value smithyjson.Value) error {
1860	array := value.Array()
1861	defer array.Close()
1862
1863	for i := range v {
1864		av := array.Value()
1865		av.String(v[i])
1866	}
1867	return nil
1868}
1869
1870func awsAwsjson11_serializeDocumentHyperParameterTuningJobConfig(v *types.HyperParameterTuningJobConfig, value smithyjson.Value) error {
1871	object := value.Object()
1872	defer object.Close()
1873
1874	if v.ParameterRanges != nil {
1875		ok := object.Key("ParameterRanges")
1876		if err := awsAwsjson11_serializeDocumentParameterRanges(v.ParameterRanges, ok); err != nil {
1877			return err
1878		}
1879	}
1880
1881	return nil
1882}
1883
1884func awsAwsjson11_serializeDocumentInputDataConfig(v *types.InputDataConfig, value smithyjson.Value) error {
1885	object := value.Object()
1886	defer object.Close()
1887
1888	if v.DatasetGroupArn != nil {
1889		ok := object.Key("DatasetGroupArn")
1890		ok.String(*v.DatasetGroupArn)
1891	}
1892
1893	if v.SupplementaryFeatures != nil {
1894		ok := object.Key("SupplementaryFeatures")
1895		if err := awsAwsjson11_serializeDocumentSupplementaryFeatures(v.SupplementaryFeatures, ok); err != nil {
1896			return err
1897		}
1898	}
1899
1900	return nil
1901}
1902
1903func awsAwsjson11_serializeDocumentIntegerParameterRange(v *types.IntegerParameterRange, value smithyjson.Value) error {
1904	object := value.Object()
1905	defer object.Close()
1906
1907	if v.MaxValue != nil {
1908		ok := object.Key("MaxValue")
1909		ok.Integer(*v.MaxValue)
1910	}
1911
1912	if v.MinValue != nil {
1913		ok := object.Key("MinValue")
1914		ok.Integer(*v.MinValue)
1915	}
1916
1917	if v.Name != nil {
1918		ok := object.Key("Name")
1919		ok.String(*v.Name)
1920	}
1921
1922	if len(v.ScalingType) > 0 {
1923		ok := object.Key("ScalingType")
1924		ok.String(string(v.ScalingType))
1925	}
1926
1927	return nil
1928}
1929
1930func awsAwsjson11_serializeDocumentIntegerParameterRanges(v []types.IntegerParameterRange, value smithyjson.Value) error {
1931	array := value.Array()
1932	defer array.Close()
1933
1934	for i := range v {
1935		av := array.Value()
1936		if err := awsAwsjson11_serializeDocumentIntegerParameterRange(&v[i], av); err != nil {
1937			return err
1938		}
1939	}
1940	return nil
1941}
1942
1943func awsAwsjson11_serializeDocumentParameterRanges(v *types.ParameterRanges, value smithyjson.Value) error {
1944	object := value.Object()
1945	defer object.Close()
1946
1947	if v.CategoricalParameterRanges != nil {
1948		ok := object.Key("CategoricalParameterRanges")
1949		if err := awsAwsjson11_serializeDocumentCategoricalParameterRanges(v.CategoricalParameterRanges, ok); err != nil {
1950			return err
1951		}
1952	}
1953
1954	if v.ContinuousParameterRanges != nil {
1955		ok := object.Key("ContinuousParameterRanges")
1956		if err := awsAwsjson11_serializeDocumentContinuousParameterRanges(v.ContinuousParameterRanges, ok); err != nil {
1957			return err
1958		}
1959	}
1960
1961	if v.IntegerParameterRanges != nil {
1962		ok := object.Key("IntegerParameterRanges")
1963		if err := awsAwsjson11_serializeDocumentIntegerParameterRanges(v.IntegerParameterRanges, ok); err != nil {
1964			return err
1965		}
1966	}
1967
1968	return nil
1969}
1970
1971func awsAwsjson11_serializeDocumentS3Config(v *types.S3Config, value smithyjson.Value) error {
1972	object := value.Object()
1973	defer object.Close()
1974
1975	if v.KMSKeyArn != nil {
1976		ok := object.Key("KMSKeyArn")
1977		ok.String(*v.KMSKeyArn)
1978	}
1979
1980	if v.Path != nil {
1981		ok := object.Key("Path")
1982		ok.String(*v.Path)
1983	}
1984
1985	if v.RoleArn != nil {
1986		ok := object.Key("RoleArn")
1987		ok.String(*v.RoleArn)
1988	}
1989
1990	return nil
1991}
1992
1993func awsAwsjson11_serializeDocumentSchema(v *types.Schema, value smithyjson.Value) error {
1994	object := value.Object()
1995	defer object.Close()
1996
1997	if v.Attributes != nil {
1998		ok := object.Key("Attributes")
1999		if err := awsAwsjson11_serializeDocumentSchemaAttributes(v.Attributes, ok); err != nil {
2000			return err
2001		}
2002	}
2003
2004	return nil
2005}
2006
2007func awsAwsjson11_serializeDocumentSchemaAttribute(v *types.SchemaAttribute, value smithyjson.Value) error {
2008	object := value.Object()
2009	defer object.Close()
2010
2011	if v.AttributeName != nil {
2012		ok := object.Key("AttributeName")
2013		ok.String(*v.AttributeName)
2014	}
2015
2016	if len(v.AttributeType) > 0 {
2017		ok := object.Key("AttributeType")
2018		ok.String(string(v.AttributeType))
2019	}
2020
2021	return nil
2022}
2023
2024func awsAwsjson11_serializeDocumentSchemaAttributes(v []types.SchemaAttribute, value smithyjson.Value) error {
2025	array := value.Array()
2026	defer array.Close()
2027
2028	for i := range v {
2029		av := array.Value()
2030		if err := awsAwsjson11_serializeDocumentSchemaAttribute(&v[i], av); err != nil {
2031			return err
2032		}
2033	}
2034	return nil
2035}
2036
2037func awsAwsjson11_serializeDocumentSupplementaryFeature(v *types.SupplementaryFeature, value smithyjson.Value) error {
2038	object := value.Object()
2039	defer object.Close()
2040
2041	if v.Name != nil {
2042		ok := object.Key("Name")
2043		ok.String(*v.Name)
2044	}
2045
2046	if v.Value != nil {
2047		ok := object.Key("Value")
2048		ok.String(*v.Value)
2049	}
2050
2051	return nil
2052}
2053
2054func awsAwsjson11_serializeDocumentSupplementaryFeatures(v []types.SupplementaryFeature, value smithyjson.Value) error {
2055	array := value.Array()
2056	defer array.Close()
2057
2058	for i := range v {
2059		av := array.Value()
2060		if err := awsAwsjson11_serializeDocumentSupplementaryFeature(&v[i], av); err != nil {
2061			return err
2062		}
2063	}
2064	return nil
2065}
2066
2067func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2068	object := value.Object()
2069	defer object.Close()
2070
2071	if v.Key != nil {
2072		ok := object.Key("Key")
2073		ok.String(*v.Key)
2074	}
2075
2076	if v.Value != nil {
2077		ok := object.Key("Value")
2078		ok.String(*v.Value)
2079	}
2080
2081	return nil
2082}
2083
2084func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
2085	array := value.Array()
2086	defer array.Close()
2087
2088	for i := range v {
2089		av := array.Value()
2090		av.String(v[i])
2091	}
2092	return nil
2093}
2094
2095func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
2096	array := value.Array()
2097	defer array.Close()
2098
2099	for i := range v {
2100		av := array.Value()
2101		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
2102			return err
2103		}
2104	}
2105	return nil
2106}
2107
2108func awsAwsjson11_serializeDocumentTrainingParameters(v map[string]string, value smithyjson.Value) error {
2109	object := value.Object()
2110	defer object.Close()
2111
2112	for key := range v {
2113		om := object.Key(key)
2114		om.String(v[key])
2115	}
2116	return nil
2117}
2118
2119func awsAwsjson11_serializeDocumentValues(v []string, value smithyjson.Value) error {
2120	array := value.Array()
2121	defer array.Close()
2122
2123	for i := range v {
2124		av := array.Value()
2125		av.String(v[i])
2126	}
2127	return nil
2128}
2129
2130func awsAwsjson11_serializeOpDocumentCreateDatasetGroupInput(v *CreateDatasetGroupInput, value smithyjson.Value) error {
2131	object := value.Object()
2132	defer object.Close()
2133
2134	if v.DatasetArns != nil {
2135		ok := object.Key("DatasetArns")
2136		if err := awsAwsjson11_serializeDocumentArnList(v.DatasetArns, ok); err != nil {
2137			return err
2138		}
2139	}
2140
2141	if v.DatasetGroupName != nil {
2142		ok := object.Key("DatasetGroupName")
2143		ok.String(*v.DatasetGroupName)
2144	}
2145
2146	if len(v.Domain) > 0 {
2147		ok := object.Key("Domain")
2148		ok.String(string(v.Domain))
2149	}
2150
2151	if v.Tags != nil {
2152		ok := object.Key("Tags")
2153		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2154			return err
2155		}
2156	}
2157
2158	return nil
2159}
2160
2161func awsAwsjson11_serializeOpDocumentCreateDatasetImportJobInput(v *CreateDatasetImportJobInput, value smithyjson.Value) error {
2162	object := value.Object()
2163	defer object.Close()
2164
2165	if v.DatasetArn != nil {
2166		ok := object.Key("DatasetArn")
2167		ok.String(*v.DatasetArn)
2168	}
2169
2170	if v.DatasetImportJobName != nil {
2171		ok := object.Key("DatasetImportJobName")
2172		ok.String(*v.DatasetImportJobName)
2173	}
2174
2175	if v.DataSource != nil {
2176		ok := object.Key("DataSource")
2177		if err := awsAwsjson11_serializeDocumentDataSource(v.DataSource, ok); err != nil {
2178			return err
2179		}
2180	}
2181
2182	if v.GeolocationFormat != nil {
2183		ok := object.Key("GeolocationFormat")
2184		ok.String(*v.GeolocationFormat)
2185	}
2186
2187	if v.Tags != nil {
2188		ok := object.Key("Tags")
2189		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2190			return err
2191		}
2192	}
2193
2194	if v.TimestampFormat != nil {
2195		ok := object.Key("TimestampFormat")
2196		ok.String(*v.TimestampFormat)
2197	}
2198
2199	if v.TimeZone != nil {
2200		ok := object.Key("TimeZone")
2201		ok.String(*v.TimeZone)
2202	}
2203
2204	if v.UseGeolocationForTimeZone {
2205		ok := object.Key("UseGeolocationForTimeZone")
2206		ok.Boolean(v.UseGeolocationForTimeZone)
2207	}
2208
2209	return nil
2210}
2211
2212func awsAwsjson11_serializeOpDocumentCreateDatasetInput(v *CreateDatasetInput, value smithyjson.Value) error {
2213	object := value.Object()
2214	defer object.Close()
2215
2216	if v.DataFrequency != nil {
2217		ok := object.Key("DataFrequency")
2218		ok.String(*v.DataFrequency)
2219	}
2220
2221	if v.DatasetName != nil {
2222		ok := object.Key("DatasetName")
2223		ok.String(*v.DatasetName)
2224	}
2225
2226	if len(v.DatasetType) > 0 {
2227		ok := object.Key("DatasetType")
2228		ok.String(string(v.DatasetType))
2229	}
2230
2231	if len(v.Domain) > 0 {
2232		ok := object.Key("Domain")
2233		ok.String(string(v.Domain))
2234	}
2235
2236	if v.EncryptionConfig != nil {
2237		ok := object.Key("EncryptionConfig")
2238		if err := awsAwsjson11_serializeDocumentEncryptionConfig(v.EncryptionConfig, ok); err != nil {
2239			return err
2240		}
2241	}
2242
2243	if v.Schema != nil {
2244		ok := object.Key("Schema")
2245		if err := awsAwsjson11_serializeDocumentSchema(v.Schema, ok); err != nil {
2246			return err
2247		}
2248	}
2249
2250	if v.Tags != nil {
2251		ok := object.Key("Tags")
2252		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2253			return err
2254		}
2255	}
2256
2257	return nil
2258}
2259
2260func awsAwsjson11_serializeOpDocumentCreateForecastExportJobInput(v *CreateForecastExportJobInput, value smithyjson.Value) error {
2261	object := value.Object()
2262	defer object.Close()
2263
2264	if v.Destination != nil {
2265		ok := object.Key("Destination")
2266		if err := awsAwsjson11_serializeDocumentDataDestination(v.Destination, ok); err != nil {
2267			return err
2268		}
2269	}
2270
2271	if v.ForecastArn != nil {
2272		ok := object.Key("ForecastArn")
2273		ok.String(*v.ForecastArn)
2274	}
2275
2276	if v.ForecastExportJobName != nil {
2277		ok := object.Key("ForecastExportJobName")
2278		ok.String(*v.ForecastExportJobName)
2279	}
2280
2281	if v.Tags != nil {
2282		ok := object.Key("Tags")
2283		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2284			return err
2285		}
2286	}
2287
2288	return nil
2289}
2290
2291func awsAwsjson11_serializeOpDocumentCreateForecastInput(v *CreateForecastInput, value smithyjson.Value) error {
2292	object := value.Object()
2293	defer object.Close()
2294
2295	if v.ForecastName != nil {
2296		ok := object.Key("ForecastName")
2297		ok.String(*v.ForecastName)
2298	}
2299
2300	if v.ForecastTypes != nil {
2301		ok := object.Key("ForecastTypes")
2302		if err := awsAwsjson11_serializeDocumentForecastTypes(v.ForecastTypes, ok); err != nil {
2303			return err
2304		}
2305	}
2306
2307	if v.PredictorArn != nil {
2308		ok := object.Key("PredictorArn")
2309		ok.String(*v.PredictorArn)
2310	}
2311
2312	if v.Tags != nil {
2313		ok := object.Key("Tags")
2314		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2315			return err
2316		}
2317	}
2318
2319	return nil
2320}
2321
2322func awsAwsjson11_serializeOpDocumentCreatePredictorBacktestExportJobInput(v *CreatePredictorBacktestExportJobInput, value smithyjson.Value) error {
2323	object := value.Object()
2324	defer object.Close()
2325
2326	if v.Destination != nil {
2327		ok := object.Key("Destination")
2328		if err := awsAwsjson11_serializeDocumentDataDestination(v.Destination, ok); err != nil {
2329			return err
2330		}
2331	}
2332
2333	if v.PredictorArn != nil {
2334		ok := object.Key("PredictorArn")
2335		ok.String(*v.PredictorArn)
2336	}
2337
2338	if v.PredictorBacktestExportJobName != nil {
2339		ok := object.Key("PredictorBacktestExportJobName")
2340		ok.String(*v.PredictorBacktestExportJobName)
2341	}
2342
2343	if v.Tags != nil {
2344		ok := object.Key("Tags")
2345		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2346			return err
2347		}
2348	}
2349
2350	return nil
2351}
2352
2353func awsAwsjson11_serializeOpDocumentCreatePredictorInput(v *CreatePredictorInput, value smithyjson.Value) error {
2354	object := value.Object()
2355	defer object.Close()
2356
2357	if v.AlgorithmArn != nil {
2358		ok := object.Key("AlgorithmArn")
2359		ok.String(*v.AlgorithmArn)
2360	}
2361
2362	if v.EncryptionConfig != nil {
2363		ok := object.Key("EncryptionConfig")
2364		if err := awsAwsjson11_serializeDocumentEncryptionConfig(v.EncryptionConfig, ok); err != nil {
2365			return err
2366		}
2367	}
2368
2369	if v.EvaluationParameters != nil {
2370		ok := object.Key("EvaluationParameters")
2371		if err := awsAwsjson11_serializeDocumentEvaluationParameters(v.EvaluationParameters, ok); err != nil {
2372			return err
2373		}
2374	}
2375
2376	if v.FeaturizationConfig != nil {
2377		ok := object.Key("FeaturizationConfig")
2378		if err := awsAwsjson11_serializeDocumentFeaturizationConfig(v.FeaturizationConfig, ok); err != nil {
2379			return err
2380		}
2381	}
2382
2383	if v.ForecastHorizon != nil {
2384		ok := object.Key("ForecastHorizon")
2385		ok.Integer(*v.ForecastHorizon)
2386	}
2387
2388	if v.ForecastTypes != nil {
2389		ok := object.Key("ForecastTypes")
2390		if err := awsAwsjson11_serializeDocumentForecastTypes(v.ForecastTypes, ok); err != nil {
2391			return err
2392		}
2393	}
2394
2395	if v.HPOConfig != nil {
2396		ok := object.Key("HPOConfig")
2397		if err := awsAwsjson11_serializeDocumentHyperParameterTuningJobConfig(v.HPOConfig, ok); err != nil {
2398			return err
2399		}
2400	}
2401
2402	if v.InputDataConfig != nil {
2403		ok := object.Key("InputDataConfig")
2404		if err := awsAwsjson11_serializeDocumentInputDataConfig(v.InputDataConfig, ok); err != nil {
2405			return err
2406		}
2407	}
2408
2409	if v.PerformAutoML != nil {
2410		ok := object.Key("PerformAutoML")
2411		ok.Boolean(*v.PerformAutoML)
2412	}
2413
2414	if v.PerformHPO != nil {
2415		ok := object.Key("PerformHPO")
2416		ok.Boolean(*v.PerformHPO)
2417	}
2418
2419	if v.PredictorName != nil {
2420		ok := object.Key("PredictorName")
2421		ok.String(*v.PredictorName)
2422	}
2423
2424	if v.Tags != nil {
2425		ok := object.Key("Tags")
2426		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2427			return err
2428		}
2429	}
2430
2431	if v.TrainingParameters != nil {
2432		ok := object.Key("TrainingParameters")
2433		if err := awsAwsjson11_serializeDocumentTrainingParameters(v.TrainingParameters, ok); err != nil {
2434			return err
2435		}
2436	}
2437
2438	return nil
2439}
2440
2441func awsAwsjson11_serializeOpDocumentDeleteDatasetGroupInput(v *DeleteDatasetGroupInput, value smithyjson.Value) error {
2442	object := value.Object()
2443	defer object.Close()
2444
2445	if v.DatasetGroupArn != nil {
2446		ok := object.Key("DatasetGroupArn")
2447		ok.String(*v.DatasetGroupArn)
2448	}
2449
2450	return nil
2451}
2452
2453func awsAwsjson11_serializeOpDocumentDeleteDatasetImportJobInput(v *DeleteDatasetImportJobInput, value smithyjson.Value) error {
2454	object := value.Object()
2455	defer object.Close()
2456
2457	if v.DatasetImportJobArn != nil {
2458		ok := object.Key("DatasetImportJobArn")
2459		ok.String(*v.DatasetImportJobArn)
2460	}
2461
2462	return nil
2463}
2464
2465func awsAwsjson11_serializeOpDocumentDeleteDatasetInput(v *DeleteDatasetInput, value smithyjson.Value) error {
2466	object := value.Object()
2467	defer object.Close()
2468
2469	if v.DatasetArn != nil {
2470		ok := object.Key("DatasetArn")
2471		ok.String(*v.DatasetArn)
2472	}
2473
2474	return nil
2475}
2476
2477func awsAwsjson11_serializeOpDocumentDeleteForecastExportJobInput(v *DeleteForecastExportJobInput, value smithyjson.Value) error {
2478	object := value.Object()
2479	defer object.Close()
2480
2481	if v.ForecastExportJobArn != nil {
2482		ok := object.Key("ForecastExportJobArn")
2483		ok.String(*v.ForecastExportJobArn)
2484	}
2485
2486	return nil
2487}
2488
2489func awsAwsjson11_serializeOpDocumentDeleteForecastInput(v *DeleteForecastInput, value smithyjson.Value) error {
2490	object := value.Object()
2491	defer object.Close()
2492
2493	if v.ForecastArn != nil {
2494		ok := object.Key("ForecastArn")
2495		ok.String(*v.ForecastArn)
2496	}
2497
2498	return nil
2499}
2500
2501func awsAwsjson11_serializeOpDocumentDeletePredictorBacktestExportJobInput(v *DeletePredictorBacktestExportJobInput, value smithyjson.Value) error {
2502	object := value.Object()
2503	defer object.Close()
2504
2505	if v.PredictorBacktestExportJobArn != nil {
2506		ok := object.Key("PredictorBacktestExportJobArn")
2507		ok.String(*v.PredictorBacktestExportJobArn)
2508	}
2509
2510	return nil
2511}
2512
2513func awsAwsjson11_serializeOpDocumentDeletePredictorInput(v *DeletePredictorInput, value smithyjson.Value) error {
2514	object := value.Object()
2515	defer object.Close()
2516
2517	if v.PredictorArn != nil {
2518		ok := object.Key("PredictorArn")
2519		ok.String(*v.PredictorArn)
2520	}
2521
2522	return nil
2523}
2524
2525func awsAwsjson11_serializeOpDocumentDescribeDatasetGroupInput(v *DescribeDatasetGroupInput, value smithyjson.Value) error {
2526	object := value.Object()
2527	defer object.Close()
2528
2529	if v.DatasetGroupArn != nil {
2530		ok := object.Key("DatasetGroupArn")
2531		ok.String(*v.DatasetGroupArn)
2532	}
2533
2534	return nil
2535}
2536
2537func awsAwsjson11_serializeOpDocumentDescribeDatasetImportJobInput(v *DescribeDatasetImportJobInput, value smithyjson.Value) error {
2538	object := value.Object()
2539	defer object.Close()
2540
2541	if v.DatasetImportJobArn != nil {
2542		ok := object.Key("DatasetImportJobArn")
2543		ok.String(*v.DatasetImportJobArn)
2544	}
2545
2546	return nil
2547}
2548
2549func awsAwsjson11_serializeOpDocumentDescribeDatasetInput(v *DescribeDatasetInput, value smithyjson.Value) error {
2550	object := value.Object()
2551	defer object.Close()
2552
2553	if v.DatasetArn != nil {
2554		ok := object.Key("DatasetArn")
2555		ok.String(*v.DatasetArn)
2556	}
2557
2558	return nil
2559}
2560
2561func awsAwsjson11_serializeOpDocumentDescribeForecastExportJobInput(v *DescribeForecastExportJobInput, value smithyjson.Value) error {
2562	object := value.Object()
2563	defer object.Close()
2564
2565	if v.ForecastExportJobArn != nil {
2566		ok := object.Key("ForecastExportJobArn")
2567		ok.String(*v.ForecastExportJobArn)
2568	}
2569
2570	return nil
2571}
2572
2573func awsAwsjson11_serializeOpDocumentDescribeForecastInput(v *DescribeForecastInput, value smithyjson.Value) error {
2574	object := value.Object()
2575	defer object.Close()
2576
2577	if v.ForecastArn != nil {
2578		ok := object.Key("ForecastArn")
2579		ok.String(*v.ForecastArn)
2580	}
2581
2582	return nil
2583}
2584
2585func awsAwsjson11_serializeOpDocumentDescribePredictorBacktestExportJobInput(v *DescribePredictorBacktestExportJobInput, value smithyjson.Value) error {
2586	object := value.Object()
2587	defer object.Close()
2588
2589	if v.PredictorBacktestExportJobArn != nil {
2590		ok := object.Key("PredictorBacktestExportJobArn")
2591		ok.String(*v.PredictorBacktestExportJobArn)
2592	}
2593
2594	return nil
2595}
2596
2597func awsAwsjson11_serializeOpDocumentDescribePredictorInput(v *DescribePredictorInput, value smithyjson.Value) error {
2598	object := value.Object()
2599	defer object.Close()
2600
2601	if v.PredictorArn != nil {
2602		ok := object.Key("PredictorArn")
2603		ok.String(*v.PredictorArn)
2604	}
2605
2606	return nil
2607}
2608
2609func awsAwsjson11_serializeOpDocumentGetAccuracyMetricsInput(v *GetAccuracyMetricsInput, value smithyjson.Value) error {
2610	object := value.Object()
2611	defer object.Close()
2612
2613	if v.PredictorArn != nil {
2614		ok := object.Key("PredictorArn")
2615		ok.String(*v.PredictorArn)
2616	}
2617
2618	return nil
2619}
2620
2621func awsAwsjson11_serializeOpDocumentListDatasetGroupsInput(v *ListDatasetGroupsInput, value smithyjson.Value) error {
2622	object := value.Object()
2623	defer object.Close()
2624
2625	if v.MaxResults != nil {
2626		ok := object.Key("MaxResults")
2627		ok.Integer(*v.MaxResults)
2628	}
2629
2630	if v.NextToken != nil {
2631		ok := object.Key("NextToken")
2632		ok.String(*v.NextToken)
2633	}
2634
2635	return nil
2636}
2637
2638func awsAwsjson11_serializeOpDocumentListDatasetImportJobsInput(v *ListDatasetImportJobsInput, value smithyjson.Value) error {
2639	object := value.Object()
2640	defer object.Close()
2641
2642	if v.Filters != nil {
2643		ok := object.Key("Filters")
2644		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2645			return err
2646		}
2647	}
2648
2649	if v.MaxResults != nil {
2650		ok := object.Key("MaxResults")
2651		ok.Integer(*v.MaxResults)
2652	}
2653
2654	if v.NextToken != nil {
2655		ok := object.Key("NextToken")
2656		ok.String(*v.NextToken)
2657	}
2658
2659	return nil
2660}
2661
2662func awsAwsjson11_serializeOpDocumentListDatasetsInput(v *ListDatasetsInput, value smithyjson.Value) error {
2663	object := value.Object()
2664	defer object.Close()
2665
2666	if v.MaxResults != nil {
2667		ok := object.Key("MaxResults")
2668		ok.Integer(*v.MaxResults)
2669	}
2670
2671	if v.NextToken != nil {
2672		ok := object.Key("NextToken")
2673		ok.String(*v.NextToken)
2674	}
2675
2676	return nil
2677}
2678
2679func awsAwsjson11_serializeOpDocumentListForecastExportJobsInput(v *ListForecastExportJobsInput, value smithyjson.Value) error {
2680	object := value.Object()
2681	defer object.Close()
2682
2683	if v.Filters != nil {
2684		ok := object.Key("Filters")
2685		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2686			return err
2687		}
2688	}
2689
2690	if v.MaxResults != nil {
2691		ok := object.Key("MaxResults")
2692		ok.Integer(*v.MaxResults)
2693	}
2694
2695	if v.NextToken != nil {
2696		ok := object.Key("NextToken")
2697		ok.String(*v.NextToken)
2698	}
2699
2700	return nil
2701}
2702
2703func awsAwsjson11_serializeOpDocumentListForecastsInput(v *ListForecastsInput, value smithyjson.Value) error {
2704	object := value.Object()
2705	defer object.Close()
2706
2707	if v.Filters != nil {
2708		ok := object.Key("Filters")
2709		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2710			return err
2711		}
2712	}
2713
2714	if v.MaxResults != nil {
2715		ok := object.Key("MaxResults")
2716		ok.Integer(*v.MaxResults)
2717	}
2718
2719	if v.NextToken != nil {
2720		ok := object.Key("NextToken")
2721		ok.String(*v.NextToken)
2722	}
2723
2724	return nil
2725}
2726
2727func awsAwsjson11_serializeOpDocumentListPredictorBacktestExportJobsInput(v *ListPredictorBacktestExportJobsInput, value smithyjson.Value) error {
2728	object := value.Object()
2729	defer object.Close()
2730
2731	if v.Filters != nil {
2732		ok := object.Key("Filters")
2733		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2734			return err
2735		}
2736	}
2737
2738	if v.MaxResults != nil {
2739		ok := object.Key("MaxResults")
2740		ok.Integer(*v.MaxResults)
2741	}
2742
2743	if v.NextToken != nil {
2744		ok := object.Key("NextToken")
2745		ok.String(*v.NextToken)
2746	}
2747
2748	return nil
2749}
2750
2751func awsAwsjson11_serializeOpDocumentListPredictorsInput(v *ListPredictorsInput, value smithyjson.Value) error {
2752	object := value.Object()
2753	defer object.Close()
2754
2755	if v.Filters != nil {
2756		ok := object.Key("Filters")
2757		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2758			return err
2759		}
2760	}
2761
2762	if v.MaxResults != nil {
2763		ok := object.Key("MaxResults")
2764		ok.Integer(*v.MaxResults)
2765	}
2766
2767	if v.NextToken != nil {
2768		ok := object.Key("NextToken")
2769		ok.String(*v.NextToken)
2770	}
2771
2772	return nil
2773}
2774
2775func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
2776	object := value.Object()
2777	defer object.Close()
2778
2779	if v.ResourceArn != nil {
2780		ok := object.Key("ResourceArn")
2781		ok.String(*v.ResourceArn)
2782	}
2783
2784	return nil
2785}
2786
2787func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
2788	object := value.Object()
2789	defer object.Close()
2790
2791	if v.ResourceArn != nil {
2792		ok := object.Key("ResourceArn")
2793		ok.String(*v.ResourceArn)
2794	}
2795
2796	if v.Tags != nil {
2797		ok := object.Key("Tags")
2798		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2799			return err
2800		}
2801	}
2802
2803	return nil
2804}
2805
2806func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
2807	object := value.Object()
2808	defer object.Close()
2809
2810	if v.ResourceArn != nil {
2811		ok := object.Key("ResourceArn")
2812		ok.String(*v.ResourceArn)
2813	}
2814
2815	if v.TagKeys != nil {
2816		ok := object.Key("TagKeys")
2817		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
2818			return err
2819		}
2820	}
2821
2822	return nil
2823}
2824
2825func awsAwsjson11_serializeOpDocumentUpdateDatasetGroupInput(v *UpdateDatasetGroupInput, value smithyjson.Value) error {
2826	object := value.Object()
2827	defer object.Close()
2828
2829	if v.DatasetArns != nil {
2830		ok := object.Key("DatasetArns")
2831		if err := awsAwsjson11_serializeDocumentArnList(v.DatasetArns, ok); err != nil {
2832			return err
2833		}
2834	}
2835
2836	if v.DatasetGroupArn != nil {
2837		ok := object.Key("DatasetGroupArn")
2838		ok.String(*v.DatasetGroupArn)
2839	}
2840
2841	return nil
2842}
2843