1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package frauddetector
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/frauddetector/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	"strings"
16)
17
18type awsAwsjson11_serializeOpBatchCreateVariable struct {
19}
20
21func (*awsAwsjson11_serializeOpBatchCreateVariable) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpBatchCreateVariable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27) {
28	request, ok := in.Request.(*smithyhttp.Request)
29	if !ok {
30		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31	}
32
33	input, ok := in.Parameters.(*BatchCreateVariableInput)
34	_ = input
35	if !ok {
36		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37	}
38
39	request.Request.URL.Path = "/"
40	request.Request.Method = "POST"
41	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
42	if err != nil {
43		return out, metadata, &smithy.SerializationError{Err: err}
44	}
45	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
46	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.BatchCreateVariable")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentBatchCreateVariableInput(input, jsonEncoder.Value); err != nil {
50		return out, metadata, &smithy.SerializationError{Err: err}
51	}
52
53	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56
57	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
58		return out, metadata, &smithy.SerializationError{Err: err}
59	}
60	in.Request = request
61
62	return next.HandleSerialize(ctx, in)
63}
64
65type awsAwsjson11_serializeOpBatchGetVariable struct {
66}
67
68func (*awsAwsjson11_serializeOpBatchGetVariable) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpBatchGetVariable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
73	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
74) {
75	request, ok := in.Request.(*smithyhttp.Request)
76	if !ok {
77		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
78	}
79
80	input, ok := in.Parameters.(*BatchGetVariableInput)
81	_ = input
82	if !ok {
83		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
84	}
85
86	request.Request.URL.Path = "/"
87	request.Request.Method = "POST"
88	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
89	if err != nil {
90		return out, metadata, &smithy.SerializationError{Err: err}
91	}
92	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
93	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.BatchGetVariable")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentBatchGetVariableInput(input, jsonEncoder.Value); err != nil {
97		return out, metadata, &smithy.SerializationError{Err: err}
98	}
99
100	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
101		return out, metadata, &smithy.SerializationError{Err: err}
102	}
103
104	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
105		return out, metadata, &smithy.SerializationError{Err: err}
106	}
107	in.Request = request
108
109	return next.HandleSerialize(ctx, in)
110}
111
112type awsAwsjson11_serializeOpCancelBatchPredictionJob struct {
113}
114
115func (*awsAwsjson11_serializeOpCancelBatchPredictionJob) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpCancelBatchPredictionJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
120	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
121) {
122	request, ok := in.Request.(*smithyhttp.Request)
123	if !ok {
124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
125	}
126
127	input, ok := in.Parameters.(*CancelBatchPredictionJobInput)
128	_ = input
129	if !ok {
130		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
131	}
132
133	request.Request.URL.Path = "/"
134	request.Request.Method = "POST"
135	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
136	if err != nil {
137		return out, metadata, &smithy.SerializationError{Err: err}
138	}
139	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
140	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CancelBatchPredictionJob")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentCancelBatchPredictionJobInput(input, jsonEncoder.Value); err != nil {
144		return out, metadata, &smithy.SerializationError{Err: err}
145	}
146
147	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
148		return out, metadata, &smithy.SerializationError{Err: err}
149	}
150
151	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
152		return out, metadata, &smithy.SerializationError{Err: err}
153	}
154	in.Request = request
155
156	return next.HandleSerialize(ctx, in)
157}
158
159type awsAwsjson11_serializeOpCreateBatchPredictionJob struct {
160}
161
162func (*awsAwsjson11_serializeOpCreateBatchPredictionJob) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpCreateBatchPredictionJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
168) {
169	request, ok := in.Request.(*smithyhttp.Request)
170	if !ok {
171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
172	}
173
174	input, ok := in.Parameters.(*CreateBatchPredictionJobInput)
175	_ = input
176	if !ok {
177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
178	}
179
180	request.Request.URL.Path = "/"
181	request.Request.Method = "POST"
182	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
183	if err != nil {
184		return out, metadata, &smithy.SerializationError{Err: err}
185	}
186	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
187	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateBatchPredictionJob")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentCreateBatchPredictionJobInput(input, jsonEncoder.Value); err != nil {
191		return out, metadata, &smithy.SerializationError{Err: err}
192	}
193
194	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
195		return out, metadata, &smithy.SerializationError{Err: err}
196	}
197
198	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201	in.Request = request
202
203	return next.HandleSerialize(ctx, in)
204}
205
206type awsAwsjson11_serializeOpCreateDetectorVersion struct {
207}
208
209func (*awsAwsjson11_serializeOpCreateDetectorVersion) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpCreateDetectorVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
214	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
215) {
216	request, ok := in.Request.(*smithyhttp.Request)
217	if !ok {
218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
219	}
220
221	input, ok := in.Parameters.(*CreateDetectorVersionInput)
222	_ = input
223	if !ok {
224		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
225	}
226
227	request.Request.URL.Path = "/"
228	request.Request.Method = "POST"
229	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
230	if err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
234	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateDetectorVersion")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentCreateDetectorVersionInput(input, jsonEncoder.Value); err != nil {
238		return out, metadata, &smithy.SerializationError{Err: err}
239	}
240
241	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
242		return out, metadata, &smithy.SerializationError{Err: err}
243	}
244
245	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
246		return out, metadata, &smithy.SerializationError{Err: err}
247	}
248	in.Request = request
249
250	return next.HandleSerialize(ctx, in)
251}
252
253type awsAwsjson11_serializeOpCreateModel struct {
254}
255
256func (*awsAwsjson11_serializeOpCreateModel) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpCreateModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
262) {
263	request, ok := in.Request.(*smithyhttp.Request)
264	if !ok {
265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
266	}
267
268	input, ok := in.Parameters.(*CreateModelInput)
269	_ = input
270	if !ok {
271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
272	}
273
274	request.Request.URL.Path = "/"
275	request.Request.Method = "POST"
276	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
277	if err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
281	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateModel")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentCreateModelInput(input, jsonEncoder.Value); err != nil {
285		return out, metadata, &smithy.SerializationError{Err: err}
286	}
287
288	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295	in.Request = request
296
297	return next.HandleSerialize(ctx, in)
298}
299
300type awsAwsjson11_serializeOpCreateModelVersion struct {
301}
302
303func (*awsAwsjson11_serializeOpCreateModelVersion) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpCreateModelVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
308	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
309) {
310	request, ok := in.Request.(*smithyhttp.Request)
311	if !ok {
312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
313	}
314
315	input, ok := in.Parameters.(*CreateModelVersionInput)
316	_ = input
317	if !ok {
318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
319	}
320
321	request.Request.URL.Path = "/"
322	request.Request.Method = "POST"
323	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
324	if err != nil {
325		return out, metadata, &smithy.SerializationError{Err: err}
326	}
327	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
328	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateModelVersion")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentCreateModelVersionInput(input, jsonEncoder.Value); err != nil {
332		return out, metadata, &smithy.SerializationError{Err: err}
333	}
334
335	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
336		return out, metadata, &smithy.SerializationError{Err: err}
337	}
338
339	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
340		return out, metadata, &smithy.SerializationError{Err: err}
341	}
342	in.Request = request
343
344	return next.HandleSerialize(ctx, in)
345}
346
347type awsAwsjson11_serializeOpCreateRule struct {
348}
349
350func (*awsAwsjson11_serializeOpCreateRule) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpCreateRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
355	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
356) {
357	request, ok := in.Request.(*smithyhttp.Request)
358	if !ok {
359		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
360	}
361
362	input, ok := in.Parameters.(*CreateRuleInput)
363	_ = input
364	if !ok {
365		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
366	}
367
368	request.Request.URL.Path = "/"
369	request.Request.Method = "POST"
370	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
371	if err != nil {
372		return out, metadata, &smithy.SerializationError{Err: err}
373	}
374	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
375	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateRule")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentCreateRuleInput(input, jsonEncoder.Value); err != nil {
379		return out, metadata, &smithy.SerializationError{Err: err}
380	}
381
382	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
383		return out, metadata, &smithy.SerializationError{Err: err}
384	}
385
386	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
387		return out, metadata, &smithy.SerializationError{Err: err}
388	}
389	in.Request = request
390
391	return next.HandleSerialize(ctx, in)
392}
393
394type awsAwsjson11_serializeOpCreateVariable struct {
395}
396
397func (*awsAwsjson11_serializeOpCreateVariable) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpCreateVariable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
402	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
403) {
404	request, ok := in.Request.(*smithyhttp.Request)
405	if !ok {
406		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
407	}
408
409	input, ok := in.Parameters.(*CreateVariableInput)
410	_ = input
411	if !ok {
412		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
413	}
414
415	request.Request.URL.Path = "/"
416	request.Request.Method = "POST"
417	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
418	if err != nil {
419		return out, metadata, &smithy.SerializationError{Err: err}
420	}
421	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
422	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.CreateVariable")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentCreateVariableInput(input, jsonEncoder.Value); err != nil {
426		return out, metadata, &smithy.SerializationError{Err: err}
427	}
428
429	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
430		return out, metadata, &smithy.SerializationError{Err: err}
431	}
432
433	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
434		return out, metadata, &smithy.SerializationError{Err: err}
435	}
436	in.Request = request
437
438	return next.HandleSerialize(ctx, in)
439}
440
441type awsAwsjson11_serializeOpDeleteBatchPredictionJob struct {
442}
443
444func (*awsAwsjson11_serializeOpDeleteBatchPredictionJob) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpDeleteBatchPredictionJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
449	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
450) {
451	request, ok := in.Request.(*smithyhttp.Request)
452	if !ok {
453		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
454	}
455
456	input, ok := in.Parameters.(*DeleteBatchPredictionJobInput)
457	_ = input
458	if !ok {
459		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
460	}
461
462	request.Request.URL.Path = "/"
463	request.Request.Method = "POST"
464	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
465	if err != nil {
466		return out, metadata, &smithy.SerializationError{Err: err}
467	}
468	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
469	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteBatchPredictionJob")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentDeleteBatchPredictionJobInput(input, jsonEncoder.Value); err != nil {
473		return out, metadata, &smithy.SerializationError{Err: err}
474	}
475
476	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
477		return out, metadata, &smithy.SerializationError{Err: err}
478	}
479
480	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
481		return out, metadata, &smithy.SerializationError{Err: err}
482	}
483	in.Request = request
484
485	return next.HandleSerialize(ctx, in)
486}
487
488type awsAwsjson11_serializeOpDeleteDetector struct {
489}
490
491func (*awsAwsjson11_serializeOpDeleteDetector) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpDeleteDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
497) {
498	request, ok := in.Request.(*smithyhttp.Request)
499	if !ok {
500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
501	}
502
503	input, ok := in.Parameters.(*DeleteDetectorInput)
504	_ = input
505	if !ok {
506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
507	}
508
509	request.Request.URL.Path = "/"
510	request.Request.Method = "POST"
511	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
512	if err != nil {
513		return out, metadata, &smithy.SerializationError{Err: err}
514	}
515	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
516	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteDetector")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentDeleteDetectorInput(input, jsonEncoder.Value); err != nil {
520		return out, metadata, &smithy.SerializationError{Err: err}
521	}
522
523	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
524		return out, metadata, &smithy.SerializationError{Err: err}
525	}
526
527	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530	in.Request = request
531
532	return next.HandleSerialize(ctx, in)
533}
534
535type awsAwsjson11_serializeOpDeleteDetectorVersion struct {
536}
537
538func (*awsAwsjson11_serializeOpDeleteDetectorVersion) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpDeleteDetectorVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
543	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
544) {
545	request, ok := in.Request.(*smithyhttp.Request)
546	if !ok {
547		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
548	}
549
550	input, ok := in.Parameters.(*DeleteDetectorVersionInput)
551	_ = input
552	if !ok {
553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
554	}
555
556	request.Request.URL.Path = "/"
557	request.Request.Method = "POST"
558	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
559	if err != nil {
560		return out, metadata, &smithy.SerializationError{Err: err}
561	}
562	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
563	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteDetectorVersion")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentDeleteDetectorVersionInput(input, jsonEncoder.Value); err != nil {
567		return out, metadata, &smithy.SerializationError{Err: err}
568	}
569
570	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573
574	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
575		return out, metadata, &smithy.SerializationError{Err: err}
576	}
577	in.Request = request
578
579	return next.HandleSerialize(ctx, in)
580}
581
582type awsAwsjson11_serializeOpDeleteEntityType struct {
583}
584
585func (*awsAwsjson11_serializeOpDeleteEntityType) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpDeleteEntityType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
590	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
591) {
592	request, ok := in.Request.(*smithyhttp.Request)
593	if !ok {
594		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
595	}
596
597	input, ok := in.Parameters.(*DeleteEntityTypeInput)
598	_ = input
599	if !ok {
600		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
601	}
602
603	request.Request.URL.Path = "/"
604	request.Request.Method = "POST"
605	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
606	if err != nil {
607		return out, metadata, &smithy.SerializationError{Err: err}
608	}
609	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
610	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteEntityType")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentDeleteEntityTypeInput(input, jsonEncoder.Value); err != nil {
614		return out, metadata, &smithy.SerializationError{Err: err}
615	}
616
617	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
618		return out, metadata, &smithy.SerializationError{Err: err}
619	}
620
621	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
622		return out, metadata, &smithy.SerializationError{Err: err}
623	}
624	in.Request = request
625
626	return next.HandleSerialize(ctx, in)
627}
628
629type awsAwsjson11_serializeOpDeleteEvent struct {
630}
631
632func (*awsAwsjson11_serializeOpDeleteEvent) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpDeleteEvent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
638) {
639	request, ok := in.Request.(*smithyhttp.Request)
640	if !ok {
641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
642	}
643
644	input, ok := in.Parameters.(*DeleteEventInput)
645	_ = input
646	if !ok {
647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
648	}
649
650	request.Request.URL.Path = "/"
651	request.Request.Method = "POST"
652	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
653	if err != nil {
654		return out, metadata, &smithy.SerializationError{Err: err}
655	}
656	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
657	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteEvent")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentDeleteEventInput(input, jsonEncoder.Value); err != nil {
661		return out, metadata, &smithy.SerializationError{Err: err}
662	}
663
664	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
665		return out, metadata, &smithy.SerializationError{Err: err}
666	}
667
668	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
669		return out, metadata, &smithy.SerializationError{Err: err}
670	}
671	in.Request = request
672
673	return next.HandleSerialize(ctx, in)
674}
675
676type awsAwsjson11_serializeOpDeleteEventType struct {
677}
678
679func (*awsAwsjson11_serializeOpDeleteEventType) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpDeleteEventType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
684	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
685) {
686	request, ok := in.Request.(*smithyhttp.Request)
687	if !ok {
688		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
689	}
690
691	input, ok := in.Parameters.(*DeleteEventTypeInput)
692	_ = input
693	if !ok {
694		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
695	}
696
697	request.Request.URL.Path = "/"
698	request.Request.Method = "POST"
699	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
700	if err != nil {
701		return out, metadata, &smithy.SerializationError{Err: err}
702	}
703	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
704	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteEventType")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentDeleteEventTypeInput(input, jsonEncoder.Value); err != nil {
708		return out, metadata, &smithy.SerializationError{Err: err}
709	}
710
711	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
712		return out, metadata, &smithy.SerializationError{Err: err}
713	}
714
715	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
716		return out, metadata, &smithy.SerializationError{Err: err}
717	}
718	in.Request = request
719
720	return next.HandleSerialize(ctx, in)
721}
722
723type awsAwsjson11_serializeOpDeleteExternalModel struct {
724}
725
726func (*awsAwsjson11_serializeOpDeleteExternalModel) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpDeleteExternalModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
732) {
733	request, ok := in.Request.(*smithyhttp.Request)
734	if !ok {
735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
736	}
737
738	input, ok := in.Parameters.(*DeleteExternalModelInput)
739	_ = input
740	if !ok {
741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
742	}
743
744	request.Request.URL.Path = "/"
745	request.Request.Method = "POST"
746	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
747	if err != nil {
748		return out, metadata, &smithy.SerializationError{Err: err}
749	}
750	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
751	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteExternalModel")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentDeleteExternalModelInput(input, jsonEncoder.Value); err != nil {
755		return out, metadata, &smithy.SerializationError{Err: err}
756	}
757
758	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
759		return out, metadata, &smithy.SerializationError{Err: err}
760	}
761
762	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
763		return out, metadata, &smithy.SerializationError{Err: err}
764	}
765	in.Request = request
766
767	return next.HandleSerialize(ctx, in)
768}
769
770type awsAwsjson11_serializeOpDeleteLabel struct {
771}
772
773func (*awsAwsjson11_serializeOpDeleteLabel) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpDeleteLabel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
778	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
779) {
780	request, ok := in.Request.(*smithyhttp.Request)
781	if !ok {
782		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
783	}
784
785	input, ok := in.Parameters.(*DeleteLabelInput)
786	_ = input
787	if !ok {
788		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
789	}
790
791	request.Request.URL.Path = "/"
792	request.Request.Method = "POST"
793	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
794	if err != nil {
795		return out, metadata, &smithy.SerializationError{Err: err}
796	}
797	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
798	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteLabel")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentDeleteLabelInput(input, jsonEncoder.Value); err != nil {
802		return out, metadata, &smithy.SerializationError{Err: err}
803	}
804
805	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
806		return out, metadata, &smithy.SerializationError{Err: err}
807	}
808
809	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
810		return out, metadata, &smithy.SerializationError{Err: err}
811	}
812	in.Request = request
813
814	return next.HandleSerialize(ctx, in)
815}
816
817type awsAwsjson11_serializeOpDeleteModel struct {
818}
819
820func (*awsAwsjson11_serializeOpDeleteModel) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpDeleteModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
825	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
826) {
827	request, ok := in.Request.(*smithyhttp.Request)
828	if !ok {
829		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
830	}
831
832	input, ok := in.Parameters.(*DeleteModelInput)
833	_ = input
834	if !ok {
835		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
836	}
837
838	request.Request.URL.Path = "/"
839	request.Request.Method = "POST"
840	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
841	if err != nil {
842		return out, metadata, &smithy.SerializationError{Err: err}
843	}
844	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
845	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteModel")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentDeleteModelInput(input, jsonEncoder.Value); err != nil {
849		return out, metadata, &smithy.SerializationError{Err: err}
850	}
851
852	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
853		return out, metadata, &smithy.SerializationError{Err: err}
854	}
855
856	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
857		return out, metadata, &smithy.SerializationError{Err: err}
858	}
859	in.Request = request
860
861	return next.HandleSerialize(ctx, in)
862}
863
864type awsAwsjson11_serializeOpDeleteModelVersion struct {
865}
866
867func (*awsAwsjson11_serializeOpDeleteModelVersion) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpDeleteModelVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
872	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
873) {
874	request, ok := in.Request.(*smithyhttp.Request)
875	if !ok {
876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
877	}
878
879	input, ok := in.Parameters.(*DeleteModelVersionInput)
880	_ = input
881	if !ok {
882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
883	}
884
885	request.Request.URL.Path = "/"
886	request.Request.Method = "POST"
887	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
888	if err != nil {
889		return out, metadata, &smithy.SerializationError{Err: err}
890	}
891	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
892	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteModelVersion")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentDeleteModelVersionInput(input, jsonEncoder.Value); err != nil {
896		return out, metadata, &smithy.SerializationError{Err: err}
897	}
898
899	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
900		return out, metadata, &smithy.SerializationError{Err: err}
901	}
902
903	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
904		return out, metadata, &smithy.SerializationError{Err: err}
905	}
906	in.Request = request
907
908	return next.HandleSerialize(ctx, in)
909}
910
911type awsAwsjson11_serializeOpDeleteOutcome struct {
912}
913
914func (*awsAwsjson11_serializeOpDeleteOutcome) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpDeleteOutcome) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
919	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
920) {
921	request, ok := in.Request.(*smithyhttp.Request)
922	if !ok {
923		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
924	}
925
926	input, ok := in.Parameters.(*DeleteOutcomeInput)
927	_ = input
928	if !ok {
929		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
930	}
931
932	request.Request.URL.Path = "/"
933	request.Request.Method = "POST"
934	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
935	if err != nil {
936		return out, metadata, &smithy.SerializationError{Err: err}
937	}
938	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
939	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteOutcome")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentDeleteOutcomeInput(input, jsonEncoder.Value); err != nil {
943		return out, metadata, &smithy.SerializationError{Err: err}
944	}
945
946	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
947		return out, metadata, &smithy.SerializationError{Err: err}
948	}
949
950	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
951		return out, metadata, &smithy.SerializationError{Err: err}
952	}
953	in.Request = request
954
955	return next.HandleSerialize(ctx, in)
956}
957
958type awsAwsjson11_serializeOpDeleteRule struct {
959}
960
961func (*awsAwsjson11_serializeOpDeleteRule) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpDeleteRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
966	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
967) {
968	request, ok := in.Request.(*smithyhttp.Request)
969	if !ok {
970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
971	}
972
973	input, ok := in.Parameters.(*DeleteRuleInput)
974	_ = input
975	if !ok {
976		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
977	}
978
979	request.Request.URL.Path = "/"
980	request.Request.Method = "POST"
981	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
982	if err != nil {
983		return out, metadata, &smithy.SerializationError{Err: err}
984	}
985	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
986	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteRule")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentDeleteRuleInput(input, jsonEncoder.Value); err != nil {
990		return out, metadata, &smithy.SerializationError{Err: err}
991	}
992
993	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
994		return out, metadata, &smithy.SerializationError{Err: err}
995	}
996
997	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
998		return out, metadata, &smithy.SerializationError{Err: err}
999	}
1000	in.Request = request
1001
1002	return next.HandleSerialize(ctx, in)
1003}
1004
1005type awsAwsjson11_serializeOpDeleteVariable struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpDeleteVariable) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpDeleteVariable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1013	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1014) {
1015	request, ok := in.Request.(*smithyhttp.Request)
1016	if !ok {
1017		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1018	}
1019
1020	input, ok := in.Parameters.(*DeleteVariableInput)
1021	_ = input
1022	if !ok {
1023		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1024	}
1025
1026	request.Request.URL.Path = "/"
1027	request.Request.Method = "POST"
1028	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1029	if err != nil {
1030		return out, metadata, &smithy.SerializationError{Err: err}
1031	}
1032	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1033	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DeleteVariable")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentDeleteVariableInput(input, jsonEncoder.Value); err != nil {
1037		return out, metadata, &smithy.SerializationError{Err: err}
1038	}
1039
1040	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1041		return out, metadata, &smithy.SerializationError{Err: err}
1042	}
1043
1044	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047	in.Request = request
1048
1049	return next.HandleSerialize(ctx, in)
1050}
1051
1052type awsAwsjson11_serializeOpDescribeDetector struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpDescribeDetector) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpDescribeDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1060	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	request, ok := in.Request.(*smithyhttp.Request)
1063	if !ok {
1064		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1065	}
1066
1067	input, ok := in.Parameters.(*DescribeDetectorInput)
1068	_ = input
1069	if !ok {
1070		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1071	}
1072
1073	request.Request.URL.Path = "/"
1074	request.Request.Method = "POST"
1075	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1076	if err != nil {
1077		return out, metadata, &smithy.SerializationError{Err: err}
1078	}
1079	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1080	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DescribeDetector")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentDescribeDetectorInput(input, jsonEncoder.Value); err != nil {
1084		return out, metadata, &smithy.SerializationError{Err: err}
1085	}
1086
1087	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1088		return out, metadata, &smithy.SerializationError{Err: err}
1089	}
1090
1091	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1092		return out, metadata, &smithy.SerializationError{Err: err}
1093	}
1094	in.Request = request
1095
1096	return next.HandleSerialize(ctx, in)
1097}
1098
1099type awsAwsjson11_serializeOpDescribeModelVersions struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpDescribeModelVersions) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpDescribeModelVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1107	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1108) {
1109	request, ok := in.Request.(*smithyhttp.Request)
1110	if !ok {
1111		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1112	}
1113
1114	input, ok := in.Parameters.(*DescribeModelVersionsInput)
1115	_ = input
1116	if !ok {
1117		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1118	}
1119
1120	request.Request.URL.Path = "/"
1121	request.Request.Method = "POST"
1122	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1123	if err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1127	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.DescribeModelVersions")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentDescribeModelVersionsInput(input, jsonEncoder.Value); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133
1134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1135		return out, metadata, &smithy.SerializationError{Err: err}
1136	}
1137
1138	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1139		return out, metadata, &smithy.SerializationError{Err: err}
1140	}
1141	in.Request = request
1142
1143	return next.HandleSerialize(ctx, in)
1144}
1145
1146type awsAwsjson11_serializeOpGetBatchPredictionJobs struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpGetBatchPredictionJobs) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpGetBatchPredictionJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1154	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1155) {
1156	request, ok := in.Request.(*smithyhttp.Request)
1157	if !ok {
1158		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1159	}
1160
1161	input, ok := in.Parameters.(*GetBatchPredictionJobsInput)
1162	_ = input
1163	if !ok {
1164		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1165	}
1166
1167	request.Request.URL.Path = "/"
1168	request.Request.Method = "POST"
1169	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1170	if err != nil {
1171		return out, metadata, &smithy.SerializationError{Err: err}
1172	}
1173	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1174	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetBatchPredictionJobs")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentGetBatchPredictionJobsInput(input, jsonEncoder.Value); err != nil {
1178		return out, metadata, &smithy.SerializationError{Err: err}
1179	}
1180
1181	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1182		return out, metadata, &smithy.SerializationError{Err: err}
1183	}
1184
1185	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1186		return out, metadata, &smithy.SerializationError{Err: err}
1187	}
1188	in.Request = request
1189
1190	return next.HandleSerialize(ctx, in)
1191}
1192
1193type awsAwsjson11_serializeOpGetDetectors struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpGetDetectors) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpGetDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1201	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	request, ok := in.Request.(*smithyhttp.Request)
1204	if !ok {
1205		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1206	}
1207
1208	input, ok := in.Parameters.(*GetDetectorsInput)
1209	_ = input
1210	if !ok {
1211		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1212	}
1213
1214	request.Request.URL.Path = "/"
1215	request.Request.Method = "POST"
1216	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1217	if err != nil {
1218		return out, metadata, &smithy.SerializationError{Err: err}
1219	}
1220	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1221	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetDetectors")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentGetDetectorsInput(input, jsonEncoder.Value); err != nil {
1225		return out, metadata, &smithy.SerializationError{Err: err}
1226	}
1227
1228	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1229		return out, metadata, &smithy.SerializationError{Err: err}
1230	}
1231
1232	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1233		return out, metadata, &smithy.SerializationError{Err: err}
1234	}
1235	in.Request = request
1236
1237	return next.HandleSerialize(ctx, in)
1238}
1239
1240type awsAwsjson11_serializeOpGetDetectorVersion struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpGetDetectorVersion) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpGetDetectorVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1249) {
1250	request, ok := in.Request.(*smithyhttp.Request)
1251	if !ok {
1252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1253	}
1254
1255	input, ok := in.Parameters.(*GetDetectorVersionInput)
1256	_ = input
1257	if !ok {
1258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1259	}
1260
1261	request.Request.URL.Path = "/"
1262	request.Request.Method = "POST"
1263	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1264	if err != nil {
1265		return out, metadata, &smithy.SerializationError{Err: err}
1266	}
1267	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1268	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetDetectorVersion")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentGetDetectorVersionInput(input, jsonEncoder.Value); err != nil {
1272		return out, metadata, &smithy.SerializationError{Err: err}
1273	}
1274
1275	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1276		return out, metadata, &smithy.SerializationError{Err: err}
1277	}
1278
1279	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1280		return out, metadata, &smithy.SerializationError{Err: err}
1281	}
1282	in.Request = request
1283
1284	return next.HandleSerialize(ctx, in)
1285}
1286
1287type awsAwsjson11_serializeOpGetEntityTypes struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpGetEntityTypes) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpGetEntityTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1295	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1296) {
1297	request, ok := in.Request.(*smithyhttp.Request)
1298	if !ok {
1299		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1300	}
1301
1302	input, ok := in.Parameters.(*GetEntityTypesInput)
1303	_ = input
1304	if !ok {
1305		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1306	}
1307
1308	request.Request.URL.Path = "/"
1309	request.Request.Method = "POST"
1310	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1311	if err != nil {
1312		return out, metadata, &smithy.SerializationError{Err: err}
1313	}
1314	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1315	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetEntityTypes")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentGetEntityTypesInput(input, jsonEncoder.Value); err != nil {
1319		return out, metadata, &smithy.SerializationError{Err: err}
1320	}
1321
1322	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1323		return out, metadata, &smithy.SerializationError{Err: err}
1324	}
1325
1326	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1327		return out, metadata, &smithy.SerializationError{Err: err}
1328	}
1329	in.Request = request
1330
1331	return next.HandleSerialize(ctx, in)
1332}
1333
1334type awsAwsjson11_serializeOpGetEventPrediction struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpGetEventPrediction) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpGetEventPrediction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1342	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1343) {
1344	request, ok := in.Request.(*smithyhttp.Request)
1345	if !ok {
1346		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1347	}
1348
1349	input, ok := in.Parameters.(*GetEventPredictionInput)
1350	_ = input
1351	if !ok {
1352		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1353	}
1354
1355	request.Request.URL.Path = "/"
1356	request.Request.Method = "POST"
1357	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1358	if err != nil {
1359		return out, metadata, &smithy.SerializationError{Err: err}
1360	}
1361	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1362	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetEventPrediction")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentGetEventPredictionInput(input, jsonEncoder.Value); err != nil {
1366		return out, metadata, &smithy.SerializationError{Err: err}
1367	}
1368
1369	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1370		return out, metadata, &smithy.SerializationError{Err: err}
1371	}
1372
1373	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1374		return out, metadata, &smithy.SerializationError{Err: err}
1375	}
1376	in.Request = request
1377
1378	return next.HandleSerialize(ctx, in)
1379}
1380
1381type awsAwsjson11_serializeOpGetEventTypes struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpGetEventTypes) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpGetEventTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1390) {
1391	request, ok := in.Request.(*smithyhttp.Request)
1392	if !ok {
1393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1394	}
1395
1396	input, ok := in.Parameters.(*GetEventTypesInput)
1397	_ = input
1398	if !ok {
1399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1400	}
1401
1402	request.Request.URL.Path = "/"
1403	request.Request.Method = "POST"
1404	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1405	if err != nil {
1406		return out, metadata, &smithy.SerializationError{Err: err}
1407	}
1408	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1409	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetEventTypes")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentGetEventTypesInput(input, jsonEncoder.Value); err != nil {
1413		return out, metadata, &smithy.SerializationError{Err: err}
1414	}
1415
1416	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1417		return out, metadata, &smithy.SerializationError{Err: err}
1418	}
1419
1420	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1421		return out, metadata, &smithy.SerializationError{Err: err}
1422	}
1423	in.Request = request
1424
1425	return next.HandleSerialize(ctx, in)
1426}
1427
1428type awsAwsjson11_serializeOpGetExternalModels struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpGetExternalModels) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpGetExternalModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1436	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1437) {
1438	request, ok := in.Request.(*smithyhttp.Request)
1439	if !ok {
1440		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1441	}
1442
1443	input, ok := in.Parameters.(*GetExternalModelsInput)
1444	_ = input
1445	if !ok {
1446		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1447	}
1448
1449	request.Request.URL.Path = "/"
1450	request.Request.Method = "POST"
1451	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1452	if err != nil {
1453		return out, metadata, &smithy.SerializationError{Err: err}
1454	}
1455	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1456	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetExternalModels")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentGetExternalModelsInput(input, jsonEncoder.Value); err != nil {
1460		return out, metadata, &smithy.SerializationError{Err: err}
1461	}
1462
1463	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1464		return out, metadata, &smithy.SerializationError{Err: err}
1465	}
1466
1467	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1468		return out, metadata, &smithy.SerializationError{Err: err}
1469	}
1470	in.Request = request
1471
1472	return next.HandleSerialize(ctx, in)
1473}
1474
1475type awsAwsjson11_serializeOpGetKMSEncryptionKey struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpGetKMSEncryptionKey) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpGetKMSEncryptionKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1483	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1484) {
1485	request, ok := in.Request.(*smithyhttp.Request)
1486	if !ok {
1487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1488	}
1489
1490	input, ok := in.Parameters.(*GetKMSEncryptionKeyInput)
1491	_ = input
1492	if !ok {
1493		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1494	}
1495
1496	request.Request.URL.Path = "/"
1497	request.Request.Method = "POST"
1498	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1499	if err != nil {
1500		return out, metadata, &smithy.SerializationError{Err: err}
1501	}
1502	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1503	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetKMSEncryptionKey")
1504
1505	if request, err = request.SetStream(strings.NewReader(`{}`)); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512	in.Request = request
1513
1514	return next.HandleSerialize(ctx, in)
1515}
1516
1517type awsAwsjson11_serializeOpGetLabels struct {
1518}
1519
1520func (*awsAwsjson11_serializeOpGetLabels) ID() string {
1521	return "OperationSerializer"
1522}
1523
1524func (m *awsAwsjson11_serializeOpGetLabels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1525	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1526) {
1527	request, ok := in.Request.(*smithyhttp.Request)
1528	if !ok {
1529		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1530	}
1531
1532	input, ok := in.Parameters.(*GetLabelsInput)
1533	_ = input
1534	if !ok {
1535		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1536	}
1537
1538	request.Request.URL.Path = "/"
1539	request.Request.Method = "POST"
1540	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1541	if err != nil {
1542		return out, metadata, &smithy.SerializationError{Err: err}
1543	}
1544	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1545	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetLabels")
1546
1547	jsonEncoder := smithyjson.NewEncoder()
1548	if err := awsAwsjson11_serializeOpDocumentGetLabelsInput(input, jsonEncoder.Value); err != nil {
1549		return out, metadata, &smithy.SerializationError{Err: err}
1550	}
1551
1552	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559	in.Request = request
1560
1561	return next.HandleSerialize(ctx, in)
1562}
1563
1564type awsAwsjson11_serializeOpGetModels struct {
1565}
1566
1567func (*awsAwsjson11_serializeOpGetModels) ID() string {
1568	return "OperationSerializer"
1569}
1570
1571func (m *awsAwsjson11_serializeOpGetModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1572	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1573) {
1574	request, ok := in.Request.(*smithyhttp.Request)
1575	if !ok {
1576		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1577	}
1578
1579	input, ok := in.Parameters.(*GetModelsInput)
1580	_ = input
1581	if !ok {
1582		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1583	}
1584
1585	request.Request.URL.Path = "/"
1586	request.Request.Method = "POST"
1587	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1588	if err != nil {
1589		return out, metadata, &smithy.SerializationError{Err: err}
1590	}
1591	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1592	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetModels")
1593
1594	jsonEncoder := smithyjson.NewEncoder()
1595	if err := awsAwsjson11_serializeOpDocumentGetModelsInput(input, jsonEncoder.Value); err != nil {
1596		return out, metadata, &smithy.SerializationError{Err: err}
1597	}
1598
1599	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606	in.Request = request
1607
1608	return next.HandleSerialize(ctx, in)
1609}
1610
1611type awsAwsjson11_serializeOpGetModelVersion struct {
1612}
1613
1614func (*awsAwsjson11_serializeOpGetModelVersion) ID() string {
1615	return "OperationSerializer"
1616}
1617
1618func (m *awsAwsjson11_serializeOpGetModelVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1619	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1620) {
1621	request, ok := in.Request.(*smithyhttp.Request)
1622	if !ok {
1623		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1624	}
1625
1626	input, ok := in.Parameters.(*GetModelVersionInput)
1627	_ = input
1628	if !ok {
1629		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1630	}
1631
1632	request.Request.URL.Path = "/"
1633	request.Request.Method = "POST"
1634	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1635	if err != nil {
1636		return out, metadata, &smithy.SerializationError{Err: err}
1637	}
1638	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1639	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetModelVersion")
1640
1641	jsonEncoder := smithyjson.NewEncoder()
1642	if err := awsAwsjson11_serializeOpDocumentGetModelVersionInput(input, jsonEncoder.Value); err != nil {
1643		return out, metadata, &smithy.SerializationError{Err: err}
1644	}
1645
1646	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1647		return out, metadata, &smithy.SerializationError{Err: err}
1648	}
1649
1650	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1651		return out, metadata, &smithy.SerializationError{Err: err}
1652	}
1653	in.Request = request
1654
1655	return next.HandleSerialize(ctx, in)
1656}
1657
1658type awsAwsjson11_serializeOpGetOutcomes struct {
1659}
1660
1661func (*awsAwsjson11_serializeOpGetOutcomes) ID() string {
1662	return "OperationSerializer"
1663}
1664
1665func (m *awsAwsjson11_serializeOpGetOutcomes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1666	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1667) {
1668	request, ok := in.Request.(*smithyhttp.Request)
1669	if !ok {
1670		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1671	}
1672
1673	input, ok := in.Parameters.(*GetOutcomesInput)
1674	_ = input
1675	if !ok {
1676		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1677	}
1678
1679	request.Request.URL.Path = "/"
1680	request.Request.Method = "POST"
1681	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1682	if err != nil {
1683		return out, metadata, &smithy.SerializationError{Err: err}
1684	}
1685	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1686	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetOutcomes")
1687
1688	jsonEncoder := smithyjson.NewEncoder()
1689	if err := awsAwsjson11_serializeOpDocumentGetOutcomesInput(input, jsonEncoder.Value); err != nil {
1690		return out, metadata, &smithy.SerializationError{Err: err}
1691	}
1692
1693	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1694		return out, metadata, &smithy.SerializationError{Err: err}
1695	}
1696
1697	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1698		return out, metadata, &smithy.SerializationError{Err: err}
1699	}
1700	in.Request = request
1701
1702	return next.HandleSerialize(ctx, in)
1703}
1704
1705type awsAwsjson11_serializeOpGetRules struct {
1706}
1707
1708func (*awsAwsjson11_serializeOpGetRules) ID() string {
1709	return "OperationSerializer"
1710}
1711
1712func (m *awsAwsjson11_serializeOpGetRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1713	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1714) {
1715	request, ok := in.Request.(*smithyhttp.Request)
1716	if !ok {
1717		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1718	}
1719
1720	input, ok := in.Parameters.(*GetRulesInput)
1721	_ = input
1722	if !ok {
1723		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1724	}
1725
1726	request.Request.URL.Path = "/"
1727	request.Request.Method = "POST"
1728	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1729	if err != nil {
1730		return out, metadata, &smithy.SerializationError{Err: err}
1731	}
1732	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1733	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetRules")
1734
1735	jsonEncoder := smithyjson.NewEncoder()
1736	if err := awsAwsjson11_serializeOpDocumentGetRulesInput(input, jsonEncoder.Value); err != nil {
1737		return out, metadata, &smithy.SerializationError{Err: err}
1738	}
1739
1740	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1741		return out, metadata, &smithy.SerializationError{Err: err}
1742	}
1743
1744	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1745		return out, metadata, &smithy.SerializationError{Err: err}
1746	}
1747	in.Request = request
1748
1749	return next.HandleSerialize(ctx, in)
1750}
1751
1752type awsAwsjson11_serializeOpGetVariables struct {
1753}
1754
1755func (*awsAwsjson11_serializeOpGetVariables) ID() string {
1756	return "OperationSerializer"
1757}
1758
1759func (m *awsAwsjson11_serializeOpGetVariables) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1760	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1761) {
1762	request, ok := in.Request.(*smithyhttp.Request)
1763	if !ok {
1764		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1765	}
1766
1767	input, ok := in.Parameters.(*GetVariablesInput)
1768	_ = input
1769	if !ok {
1770		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1771	}
1772
1773	request.Request.URL.Path = "/"
1774	request.Request.Method = "POST"
1775	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1776	if err != nil {
1777		return out, metadata, &smithy.SerializationError{Err: err}
1778	}
1779	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1780	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.GetVariables")
1781
1782	jsonEncoder := smithyjson.NewEncoder()
1783	if err := awsAwsjson11_serializeOpDocumentGetVariablesInput(input, jsonEncoder.Value); err != nil {
1784		return out, metadata, &smithy.SerializationError{Err: err}
1785	}
1786
1787	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1788		return out, metadata, &smithy.SerializationError{Err: err}
1789	}
1790
1791	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1792		return out, metadata, &smithy.SerializationError{Err: err}
1793	}
1794	in.Request = request
1795
1796	return next.HandleSerialize(ctx, in)
1797}
1798
1799type awsAwsjson11_serializeOpListTagsForResource struct {
1800}
1801
1802func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1803	return "OperationSerializer"
1804}
1805
1806func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1807	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1808) {
1809	request, ok := in.Request.(*smithyhttp.Request)
1810	if !ok {
1811		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1812	}
1813
1814	input, ok := in.Parameters.(*ListTagsForResourceInput)
1815	_ = input
1816	if !ok {
1817		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1818	}
1819
1820	request.Request.URL.Path = "/"
1821	request.Request.Method = "POST"
1822	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1823	if err != nil {
1824		return out, metadata, &smithy.SerializationError{Err: err}
1825	}
1826	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1827	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.ListTagsForResource")
1828
1829	jsonEncoder := smithyjson.NewEncoder()
1830	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
1831		return out, metadata, &smithy.SerializationError{Err: err}
1832	}
1833
1834	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1835		return out, metadata, &smithy.SerializationError{Err: err}
1836	}
1837
1838	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1839		return out, metadata, &smithy.SerializationError{Err: err}
1840	}
1841	in.Request = request
1842
1843	return next.HandleSerialize(ctx, in)
1844}
1845
1846type awsAwsjson11_serializeOpPutDetector struct {
1847}
1848
1849func (*awsAwsjson11_serializeOpPutDetector) ID() string {
1850	return "OperationSerializer"
1851}
1852
1853func (m *awsAwsjson11_serializeOpPutDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1854	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1855) {
1856	request, ok := in.Request.(*smithyhttp.Request)
1857	if !ok {
1858		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1859	}
1860
1861	input, ok := in.Parameters.(*PutDetectorInput)
1862	_ = input
1863	if !ok {
1864		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1865	}
1866
1867	request.Request.URL.Path = "/"
1868	request.Request.Method = "POST"
1869	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1870	if err != nil {
1871		return out, metadata, &smithy.SerializationError{Err: err}
1872	}
1873	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1874	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutDetector")
1875
1876	jsonEncoder := smithyjson.NewEncoder()
1877	if err := awsAwsjson11_serializeOpDocumentPutDetectorInput(input, jsonEncoder.Value); err != nil {
1878		return out, metadata, &smithy.SerializationError{Err: err}
1879	}
1880
1881	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1882		return out, metadata, &smithy.SerializationError{Err: err}
1883	}
1884
1885	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1886		return out, metadata, &smithy.SerializationError{Err: err}
1887	}
1888	in.Request = request
1889
1890	return next.HandleSerialize(ctx, in)
1891}
1892
1893type awsAwsjson11_serializeOpPutEntityType struct {
1894}
1895
1896func (*awsAwsjson11_serializeOpPutEntityType) ID() string {
1897	return "OperationSerializer"
1898}
1899
1900func (m *awsAwsjson11_serializeOpPutEntityType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1901	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	request, ok := in.Request.(*smithyhttp.Request)
1904	if !ok {
1905		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1906	}
1907
1908	input, ok := in.Parameters.(*PutEntityTypeInput)
1909	_ = input
1910	if !ok {
1911		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1912	}
1913
1914	request.Request.URL.Path = "/"
1915	request.Request.Method = "POST"
1916	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1917	if err != nil {
1918		return out, metadata, &smithy.SerializationError{Err: err}
1919	}
1920	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1921	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutEntityType")
1922
1923	jsonEncoder := smithyjson.NewEncoder()
1924	if err := awsAwsjson11_serializeOpDocumentPutEntityTypeInput(input, jsonEncoder.Value); err != nil {
1925		return out, metadata, &smithy.SerializationError{Err: err}
1926	}
1927
1928	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1929		return out, metadata, &smithy.SerializationError{Err: err}
1930	}
1931
1932	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1933		return out, metadata, &smithy.SerializationError{Err: err}
1934	}
1935	in.Request = request
1936
1937	return next.HandleSerialize(ctx, in)
1938}
1939
1940type awsAwsjson11_serializeOpPutEventType struct {
1941}
1942
1943func (*awsAwsjson11_serializeOpPutEventType) ID() string {
1944	return "OperationSerializer"
1945}
1946
1947func (m *awsAwsjson11_serializeOpPutEventType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1948	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1949) {
1950	request, ok := in.Request.(*smithyhttp.Request)
1951	if !ok {
1952		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1953	}
1954
1955	input, ok := in.Parameters.(*PutEventTypeInput)
1956	_ = input
1957	if !ok {
1958		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1959	}
1960
1961	request.Request.URL.Path = "/"
1962	request.Request.Method = "POST"
1963	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1964	if err != nil {
1965		return out, metadata, &smithy.SerializationError{Err: err}
1966	}
1967	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1968	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutEventType")
1969
1970	jsonEncoder := smithyjson.NewEncoder()
1971	if err := awsAwsjson11_serializeOpDocumentPutEventTypeInput(input, jsonEncoder.Value); err != nil {
1972		return out, metadata, &smithy.SerializationError{Err: err}
1973	}
1974
1975	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1976		return out, metadata, &smithy.SerializationError{Err: err}
1977	}
1978
1979	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1980		return out, metadata, &smithy.SerializationError{Err: err}
1981	}
1982	in.Request = request
1983
1984	return next.HandleSerialize(ctx, in)
1985}
1986
1987type awsAwsjson11_serializeOpPutExternalModel struct {
1988}
1989
1990func (*awsAwsjson11_serializeOpPutExternalModel) ID() string {
1991	return "OperationSerializer"
1992}
1993
1994func (m *awsAwsjson11_serializeOpPutExternalModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1995	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1996) {
1997	request, ok := in.Request.(*smithyhttp.Request)
1998	if !ok {
1999		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2000	}
2001
2002	input, ok := in.Parameters.(*PutExternalModelInput)
2003	_ = input
2004	if !ok {
2005		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2006	}
2007
2008	request.Request.URL.Path = "/"
2009	request.Request.Method = "POST"
2010	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2011	if err != nil {
2012		return out, metadata, &smithy.SerializationError{Err: err}
2013	}
2014	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2015	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutExternalModel")
2016
2017	jsonEncoder := smithyjson.NewEncoder()
2018	if err := awsAwsjson11_serializeOpDocumentPutExternalModelInput(input, jsonEncoder.Value); err != nil {
2019		return out, metadata, &smithy.SerializationError{Err: err}
2020	}
2021
2022	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2023		return out, metadata, &smithy.SerializationError{Err: err}
2024	}
2025
2026	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2027		return out, metadata, &smithy.SerializationError{Err: err}
2028	}
2029	in.Request = request
2030
2031	return next.HandleSerialize(ctx, in)
2032}
2033
2034type awsAwsjson11_serializeOpPutKMSEncryptionKey struct {
2035}
2036
2037func (*awsAwsjson11_serializeOpPutKMSEncryptionKey) ID() string {
2038	return "OperationSerializer"
2039}
2040
2041func (m *awsAwsjson11_serializeOpPutKMSEncryptionKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2042	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2043) {
2044	request, ok := in.Request.(*smithyhttp.Request)
2045	if !ok {
2046		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2047	}
2048
2049	input, ok := in.Parameters.(*PutKMSEncryptionKeyInput)
2050	_ = input
2051	if !ok {
2052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2053	}
2054
2055	request.Request.URL.Path = "/"
2056	request.Request.Method = "POST"
2057	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2058	if err != nil {
2059		return out, metadata, &smithy.SerializationError{Err: err}
2060	}
2061	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2062	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutKMSEncryptionKey")
2063
2064	jsonEncoder := smithyjson.NewEncoder()
2065	if err := awsAwsjson11_serializeOpDocumentPutKMSEncryptionKeyInput(input, jsonEncoder.Value); err != nil {
2066		return out, metadata, &smithy.SerializationError{Err: err}
2067	}
2068
2069	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2070		return out, metadata, &smithy.SerializationError{Err: err}
2071	}
2072
2073	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2074		return out, metadata, &smithy.SerializationError{Err: err}
2075	}
2076	in.Request = request
2077
2078	return next.HandleSerialize(ctx, in)
2079}
2080
2081type awsAwsjson11_serializeOpPutLabel struct {
2082}
2083
2084func (*awsAwsjson11_serializeOpPutLabel) ID() string {
2085	return "OperationSerializer"
2086}
2087
2088func (m *awsAwsjson11_serializeOpPutLabel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2089	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2090) {
2091	request, ok := in.Request.(*smithyhttp.Request)
2092	if !ok {
2093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2094	}
2095
2096	input, ok := in.Parameters.(*PutLabelInput)
2097	_ = input
2098	if !ok {
2099		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2100	}
2101
2102	request.Request.URL.Path = "/"
2103	request.Request.Method = "POST"
2104	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2105	if err != nil {
2106		return out, metadata, &smithy.SerializationError{Err: err}
2107	}
2108	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2109	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutLabel")
2110
2111	jsonEncoder := smithyjson.NewEncoder()
2112	if err := awsAwsjson11_serializeOpDocumentPutLabelInput(input, jsonEncoder.Value); err != nil {
2113		return out, metadata, &smithy.SerializationError{Err: err}
2114	}
2115
2116	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2117		return out, metadata, &smithy.SerializationError{Err: err}
2118	}
2119
2120	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2121		return out, metadata, &smithy.SerializationError{Err: err}
2122	}
2123	in.Request = request
2124
2125	return next.HandleSerialize(ctx, in)
2126}
2127
2128type awsAwsjson11_serializeOpPutOutcome struct {
2129}
2130
2131func (*awsAwsjson11_serializeOpPutOutcome) ID() string {
2132	return "OperationSerializer"
2133}
2134
2135func (m *awsAwsjson11_serializeOpPutOutcome) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2136	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2137) {
2138	request, ok := in.Request.(*smithyhttp.Request)
2139	if !ok {
2140		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2141	}
2142
2143	input, ok := in.Parameters.(*PutOutcomeInput)
2144	_ = input
2145	if !ok {
2146		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2147	}
2148
2149	request.Request.URL.Path = "/"
2150	request.Request.Method = "POST"
2151	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2152	if err != nil {
2153		return out, metadata, &smithy.SerializationError{Err: err}
2154	}
2155	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2156	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.PutOutcome")
2157
2158	jsonEncoder := smithyjson.NewEncoder()
2159	if err := awsAwsjson11_serializeOpDocumentPutOutcomeInput(input, jsonEncoder.Value); err != nil {
2160		return out, metadata, &smithy.SerializationError{Err: err}
2161	}
2162
2163	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2164		return out, metadata, &smithy.SerializationError{Err: err}
2165	}
2166
2167	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2168		return out, metadata, &smithy.SerializationError{Err: err}
2169	}
2170	in.Request = request
2171
2172	return next.HandleSerialize(ctx, in)
2173}
2174
2175type awsAwsjson11_serializeOpTagResource struct {
2176}
2177
2178func (*awsAwsjson11_serializeOpTagResource) ID() string {
2179	return "OperationSerializer"
2180}
2181
2182func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2183	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2184) {
2185	request, ok := in.Request.(*smithyhttp.Request)
2186	if !ok {
2187		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2188	}
2189
2190	input, ok := in.Parameters.(*TagResourceInput)
2191	_ = input
2192	if !ok {
2193		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2194	}
2195
2196	request.Request.URL.Path = "/"
2197	request.Request.Method = "POST"
2198	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2199	if err != nil {
2200		return out, metadata, &smithy.SerializationError{Err: err}
2201	}
2202	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2203	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.TagResource")
2204
2205	jsonEncoder := smithyjson.NewEncoder()
2206	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
2207		return out, metadata, &smithy.SerializationError{Err: err}
2208	}
2209
2210	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2211		return out, metadata, &smithy.SerializationError{Err: err}
2212	}
2213
2214	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2215		return out, metadata, &smithy.SerializationError{Err: err}
2216	}
2217	in.Request = request
2218
2219	return next.HandleSerialize(ctx, in)
2220}
2221
2222type awsAwsjson11_serializeOpUntagResource struct {
2223}
2224
2225func (*awsAwsjson11_serializeOpUntagResource) ID() string {
2226	return "OperationSerializer"
2227}
2228
2229func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2230	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2231) {
2232	request, ok := in.Request.(*smithyhttp.Request)
2233	if !ok {
2234		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2235	}
2236
2237	input, ok := in.Parameters.(*UntagResourceInput)
2238	_ = input
2239	if !ok {
2240		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2241	}
2242
2243	request.Request.URL.Path = "/"
2244	request.Request.Method = "POST"
2245	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2246	if err != nil {
2247		return out, metadata, &smithy.SerializationError{Err: err}
2248	}
2249	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2250	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UntagResource")
2251
2252	jsonEncoder := smithyjson.NewEncoder()
2253	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
2254		return out, metadata, &smithy.SerializationError{Err: err}
2255	}
2256
2257	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2258		return out, metadata, &smithy.SerializationError{Err: err}
2259	}
2260
2261	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2262		return out, metadata, &smithy.SerializationError{Err: err}
2263	}
2264	in.Request = request
2265
2266	return next.HandleSerialize(ctx, in)
2267}
2268
2269type awsAwsjson11_serializeOpUpdateDetectorVersion struct {
2270}
2271
2272func (*awsAwsjson11_serializeOpUpdateDetectorVersion) ID() string {
2273	return "OperationSerializer"
2274}
2275
2276func (m *awsAwsjson11_serializeOpUpdateDetectorVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2277	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2278) {
2279	request, ok := in.Request.(*smithyhttp.Request)
2280	if !ok {
2281		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2282	}
2283
2284	input, ok := in.Parameters.(*UpdateDetectorVersionInput)
2285	_ = input
2286	if !ok {
2287		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2288	}
2289
2290	request.Request.URL.Path = "/"
2291	request.Request.Method = "POST"
2292	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2293	if err != nil {
2294		return out, metadata, &smithy.SerializationError{Err: err}
2295	}
2296	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2297	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateDetectorVersion")
2298
2299	jsonEncoder := smithyjson.NewEncoder()
2300	if err := awsAwsjson11_serializeOpDocumentUpdateDetectorVersionInput(input, jsonEncoder.Value); err != nil {
2301		return out, metadata, &smithy.SerializationError{Err: err}
2302	}
2303
2304	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2305		return out, metadata, &smithy.SerializationError{Err: err}
2306	}
2307
2308	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2309		return out, metadata, &smithy.SerializationError{Err: err}
2310	}
2311	in.Request = request
2312
2313	return next.HandleSerialize(ctx, in)
2314}
2315
2316type awsAwsjson11_serializeOpUpdateDetectorVersionMetadata struct {
2317}
2318
2319func (*awsAwsjson11_serializeOpUpdateDetectorVersionMetadata) ID() string {
2320	return "OperationSerializer"
2321}
2322
2323func (m *awsAwsjson11_serializeOpUpdateDetectorVersionMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2324	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2325) {
2326	request, ok := in.Request.(*smithyhttp.Request)
2327	if !ok {
2328		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2329	}
2330
2331	input, ok := in.Parameters.(*UpdateDetectorVersionMetadataInput)
2332	_ = input
2333	if !ok {
2334		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2335	}
2336
2337	request.Request.URL.Path = "/"
2338	request.Request.Method = "POST"
2339	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2340	if err != nil {
2341		return out, metadata, &smithy.SerializationError{Err: err}
2342	}
2343	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2344	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateDetectorVersionMetadata")
2345
2346	jsonEncoder := smithyjson.NewEncoder()
2347	if err := awsAwsjson11_serializeOpDocumentUpdateDetectorVersionMetadataInput(input, jsonEncoder.Value); err != nil {
2348		return out, metadata, &smithy.SerializationError{Err: err}
2349	}
2350
2351	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2352		return out, metadata, &smithy.SerializationError{Err: err}
2353	}
2354
2355	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2356		return out, metadata, &smithy.SerializationError{Err: err}
2357	}
2358	in.Request = request
2359
2360	return next.HandleSerialize(ctx, in)
2361}
2362
2363type awsAwsjson11_serializeOpUpdateDetectorVersionStatus struct {
2364}
2365
2366func (*awsAwsjson11_serializeOpUpdateDetectorVersionStatus) ID() string {
2367	return "OperationSerializer"
2368}
2369
2370func (m *awsAwsjson11_serializeOpUpdateDetectorVersionStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2371	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2372) {
2373	request, ok := in.Request.(*smithyhttp.Request)
2374	if !ok {
2375		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2376	}
2377
2378	input, ok := in.Parameters.(*UpdateDetectorVersionStatusInput)
2379	_ = input
2380	if !ok {
2381		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2382	}
2383
2384	request.Request.URL.Path = "/"
2385	request.Request.Method = "POST"
2386	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2387	if err != nil {
2388		return out, metadata, &smithy.SerializationError{Err: err}
2389	}
2390	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2391	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateDetectorVersionStatus")
2392
2393	jsonEncoder := smithyjson.NewEncoder()
2394	if err := awsAwsjson11_serializeOpDocumentUpdateDetectorVersionStatusInput(input, jsonEncoder.Value); err != nil {
2395		return out, metadata, &smithy.SerializationError{Err: err}
2396	}
2397
2398	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2399		return out, metadata, &smithy.SerializationError{Err: err}
2400	}
2401
2402	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2403		return out, metadata, &smithy.SerializationError{Err: err}
2404	}
2405	in.Request = request
2406
2407	return next.HandleSerialize(ctx, in)
2408}
2409
2410type awsAwsjson11_serializeOpUpdateModel struct {
2411}
2412
2413func (*awsAwsjson11_serializeOpUpdateModel) ID() string {
2414	return "OperationSerializer"
2415}
2416
2417func (m *awsAwsjson11_serializeOpUpdateModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2418	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2419) {
2420	request, ok := in.Request.(*smithyhttp.Request)
2421	if !ok {
2422		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2423	}
2424
2425	input, ok := in.Parameters.(*UpdateModelInput)
2426	_ = input
2427	if !ok {
2428		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2429	}
2430
2431	request.Request.URL.Path = "/"
2432	request.Request.Method = "POST"
2433	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2434	if err != nil {
2435		return out, metadata, &smithy.SerializationError{Err: err}
2436	}
2437	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2438	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateModel")
2439
2440	jsonEncoder := smithyjson.NewEncoder()
2441	if err := awsAwsjson11_serializeOpDocumentUpdateModelInput(input, jsonEncoder.Value); err != nil {
2442		return out, metadata, &smithy.SerializationError{Err: err}
2443	}
2444
2445	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2446		return out, metadata, &smithy.SerializationError{Err: err}
2447	}
2448
2449	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2450		return out, metadata, &smithy.SerializationError{Err: err}
2451	}
2452	in.Request = request
2453
2454	return next.HandleSerialize(ctx, in)
2455}
2456
2457type awsAwsjson11_serializeOpUpdateModelVersion struct {
2458}
2459
2460func (*awsAwsjson11_serializeOpUpdateModelVersion) ID() string {
2461	return "OperationSerializer"
2462}
2463
2464func (m *awsAwsjson11_serializeOpUpdateModelVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2465	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2466) {
2467	request, ok := in.Request.(*smithyhttp.Request)
2468	if !ok {
2469		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2470	}
2471
2472	input, ok := in.Parameters.(*UpdateModelVersionInput)
2473	_ = input
2474	if !ok {
2475		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2476	}
2477
2478	request.Request.URL.Path = "/"
2479	request.Request.Method = "POST"
2480	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2481	if err != nil {
2482		return out, metadata, &smithy.SerializationError{Err: err}
2483	}
2484	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2485	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateModelVersion")
2486
2487	jsonEncoder := smithyjson.NewEncoder()
2488	if err := awsAwsjson11_serializeOpDocumentUpdateModelVersionInput(input, jsonEncoder.Value); err != nil {
2489		return out, metadata, &smithy.SerializationError{Err: err}
2490	}
2491
2492	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2493		return out, metadata, &smithy.SerializationError{Err: err}
2494	}
2495
2496	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2497		return out, metadata, &smithy.SerializationError{Err: err}
2498	}
2499	in.Request = request
2500
2501	return next.HandleSerialize(ctx, in)
2502}
2503
2504type awsAwsjson11_serializeOpUpdateModelVersionStatus struct {
2505}
2506
2507func (*awsAwsjson11_serializeOpUpdateModelVersionStatus) ID() string {
2508	return "OperationSerializer"
2509}
2510
2511func (m *awsAwsjson11_serializeOpUpdateModelVersionStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2512	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2513) {
2514	request, ok := in.Request.(*smithyhttp.Request)
2515	if !ok {
2516		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2517	}
2518
2519	input, ok := in.Parameters.(*UpdateModelVersionStatusInput)
2520	_ = input
2521	if !ok {
2522		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2523	}
2524
2525	request.Request.URL.Path = "/"
2526	request.Request.Method = "POST"
2527	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2528	if err != nil {
2529		return out, metadata, &smithy.SerializationError{Err: err}
2530	}
2531	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2532	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateModelVersionStatus")
2533
2534	jsonEncoder := smithyjson.NewEncoder()
2535	if err := awsAwsjson11_serializeOpDocumentUpdateModelVersionStatusInput(input, jsonEncoder.Value); err != nil {
2536		return out, metadata, &smithy.SerializationError{Err: err}
2537	}
2538
2539	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2540		return out, metadata, &smithy.SerializationError{Err: err}
2541	}
2542
2543	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2544		return out, metadata, &smithy.SerializationError{Err: err}
2545	}
2546	in.Request = request
2547
2548	return next.HandleSerialize(ctx, in)
2549}
2550
2551type awsAwsjson11_serializeOpUpdateRuleMetadata struct {
2552}
2553
2554func (*awsAwsjson11_serializeOpUpdateRuleMetadata) ID() string {
2555	return "OperationSerializer"
2556}
2557
2558func (m *awsAwsjson11_serializeOpUpdateRuleMetadata) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2559	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2560) {
2561	request, ok := in.Request.(*smithyhttp.Request)
2562	if !ok {
2563		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2564	}
2565
2566	input, ok := in.Parameters.(*UpdateRuleMetadataInput)
2567	_ = input
2568	if !ok {
2569		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2570	}
2571
2572	request.Request.URL.Path = "/"
2573	request.Request.Method = "POST"
2574	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2575	if err != nil {
2576		return out, metadata, &smithy.SerializationError{Err: err}
2577	}
2578	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2579	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateRuleMetadata")
2580
2581	jsonEncoder := smithyjson.NewEncoder()
2582	if err := awsAwsjson11_serializeOpDocumentUpdateRuleMetadataInput(input, jsonEncoder.Value); err != nil {
2583		return out, metadata, &smithy.SerializationError{Err: err}
2584	}
2585
2586	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2587		return out, metadata, &smithy.SerializationError{Err: err}
2588	}
2589
2590	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2591		return out, metadata, &smithy.SerializationError{Err: err}
2592	}
2593	in.Request = request
2594
2595	return next.HandleSerialize(ctx, in)
2596}
2597
2598type awsAwsjson11_serializeOpUpdateRuleVersion struct {
2599}
2600
2601func (*awsAwsjson11_serializeOpUpdateRuleVersion) ID() string {
2602	return "OperationSerializer"
2603}
2604
2605func (m *awsAwsjson11_serializeOpUpdateRuleVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2606	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2607) {
2608	request, ok := in.Request.(*smithyhttp.Request)
2609	if !ok {
2610		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2611	}
2612
2613	input, ok := in.Parameters.(*UpdateRuleVersionInput)
2614	_ = input
2615	if !ok {
2616		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2617	}
2618
2619	request.Request.URL.Path = "/"
2620	request.Request.Method = "POST"
2621	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2622	if err != nil {
2623		return out, metadata, &smithy.SerializationError{Err: err}
2624	}
2625	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2626	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateRuleVersion")
2627
2628	jsonEncoder := smithyjson.NewEncoder()
2629	if err := awsAwsjson11_serializeOpDocumentUpdateRuleVersionInput(input, jsonEncoder.Value); err != nil {
2630		return out, metadata, &smithy.SerializationError{Err: err}
2631	}
2632
2633	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2634		return out, metadata, &smithy.SerializationError{Err: err}
2635	}
2636
2637	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2638		return out, metadata, &smithy.SerializationError{Err: err}
2639	}
2640	in.Request = request
2641
2642	return next.HandleSerialize(ctx, in)
2643}
2644
2645type awsAwsjson11_serializeOpUpdateVariable struct {
2646}
2647
2648func (*awsAwsjson11_serializeOpUpdateVariable) ID() string {
2649	return "OperationSerializer"
2650}
2651
2652func (m *awsAwsjson11_serializeOpUpdateVariable) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2653	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2654) {
2655	request, ok := in.Request.(*smithyhttp.Request)
2656	if !ok {
2657		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2658	}
2659
2660	input, ok := in.Parameters.(*UpdateVariableInput)
2661	_ = input
2662	if !ok {
2663		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2664	}
2665
2666	request.Request.URL.Path = "/"
2667	request.Request.Method = "POST"
2668	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2669	if err != nil {
2670		return out, metadata, &smithy.SerializationError{Err: err}
2671	}
2672	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2673	httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSHawksNestServiceFacade.UpdateVariable")
2674
2675	jsonEncoder := smithyjson.NewEncoder()
2676	if err := awsAwsjson11_serializeOpDocumentUpdateVariableInput(input, jsonEncoder.Value); err != nil {
2677		return out, metadata, &smithy.SerializationError{Err: err}
2678	}
2679
2680	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2681		return out, metadata, &smithy.SerializationError{Err: err}
2682	}
2683
2684	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2685		return out, metadata, &smithy.SerializationError{Err: err}
2686	}
2687	in.Request = request
2688
2689	return next.HandleSerialize(ctx, in)
2690}
2691func awsAwsjson11_serializeDocumentCsvIndexToVariableMap(v map[string]string, value smithyjson.Value) error {
2692	object := value.Object()
2693	defer object.Close()
2694
2695	for key := range v {
2696		om := object.Key(key)
2697		om.String(v[key])
2698	}
2699	return nil
2700}
2701
2702func awsAwsjson11_serializeDocumentEntity(v *types.Entity, value smithyjson.Value) error {
2703	object := value.Object()
2704	defer object.Close()
2705
2706	if v.EntityId != nil {
2707		ok := object.Key("entityId")
2708		ok.String(*v.EntityId)
2709	}
2710
2711	if v.EntityType != nil {
2712		ok := object.Key("entityType")
2713		ok.String(*v.EntityType)
2714	}
2715
2716	return nil
2717}
2718
2719func awsAwsjson11_serializeDocumentEventVariableMap(v map[string]string, value smithyjson.Value) error {
2720	object := value.Object()
2721	defer object.Close()
2722
2723	for key := range v {
2724		om := object.Key(key)
2725		om.String(v[key])
2726	}
2727	return nil
2728}
2729
2730func awsAwsjson11_serializeDocumentExternalEventsDetail(v *types.ExternalEventsDetail, value smithyjson.Value) error {
2731	object := value.Object()
2732	defer object.Close()
2733
2734	if v.DataAccessRoleArn != nil {
2735		ok := object.Key("dataAccessRoleArn")
2736		ok.String(*v.DataAccessRoleArn)
2737	}
2738
2739	if v.DataLocation != nil {
2740		ok := object.Key("dataLocation")
2741		ok.String(*v.DataLocation)
2742	}
2743
2744	return nil
2745}
2746
2747func awsAwsjson11_serializeDocumentExternalModelEndpointDataBlobMap(v map[string]types.ModelEndpointDataBlob, value smithyjson.Value) error {
2748	object := value.Object()
2749	defer object.Close()
2750
2751	for key := range v {
2752		om := object.Key(key)
2753		mapVar := v[key]
2754		if err := awsAwsjson11_serializeDocumentModelEndpointDataBlob(&mapVar, om); err != nil {
2755			return err
2756		}
2757	}
2758	return nil
2759}
2760
2761func awsAwsjson11_serializeDocumentJsonKeyToVariableMap(v map[string]string, value smithyjson.Value) error {
2762	object := value.Object()
2763	defer object.Close()
2764
2765	for key := range v {
2766		om := object.Key(key)
2767		om.String(v[key])
2768	}
2769	return nil
2770}
2771
2772func awsAwsjson11_serializeDocumentLabelMapper(v map[string][]string, value smithyjson.Value) error {
2773	object := value.Object()
2774	defer object.Close()
2775
2776	for key := range v {
2777		om := object.Key(key)
2778		if vv := v[key]; vv == nil {
2779			continue
2780		}
2781		if err := awsAwsjson11_serializeDocumentListOfStrings(v[key], om); err != nil {
2782			return err
2783		}
2784	}
2785	return nil
2786}
2787
2788func awsAwsjson11_serializeDocumentLabelSchema(v *types.LabelSchema, value smithyjson.Value) error {
2789	object := value.Object()
2790	defer object.Close()
2791
2792	if v.LabelMapper != nil {
2793		ok := object.Key("labelMapper")
2794		if err := awsAwsjson11_serializeDocumentLabelMapper(v.LabelMapper, ok); err != nil {
2795			return err
2796		}
2797	}
2798
2799	return nil
2800}
2801
2802func awsAwsjson11_serializeDocumentListOfEntities(v []types.Entity, value smithyjson.Value) error {
2803	array := value.Array()
2804	defer array.Close()
2805
2806	for i := range v {
2807		av := array.Value()
2808		if err := awsAwsjson11_serializeDocumentEntity(&v[i], av); err != nil {
2809			return err
2810		}
2811	}
2812	return nil
2813}
2814
2815func awsAwsjson11_serializeDocumentListOfModelVersions(v []types.ModelVersion, value smithyjson.Value) error {
2816	array := value.Array()
2817	defer array.Close()
2818
2819	for i := range v {
2820		av := array.Value()
2821		if err := awsAwsjson11_serializeDocumentModelVersion(&v[i], av); err != nil {
2822			return err
2823		}
2824	}
2825	return nil
2826}
2827
2828func awsAwsjson11_serializeDocumentListOfStrings(v []string, value smithyjson.Value) error {
2829	array := value.Array()
2830	defer array.Close()
2831
2832	for i := range v {
2833		av := array.Value()
2834		av.String(v[i])
2835	}
2836	return nil
2837}
2838
2839func awsAwsjson11_serializeDocumentModelEndpointDataBlob(v *types.ModelEndpointDataBlob, value smithyjson.Value) error {
2840	object := value.Object()
2841	defer object.Close()
2842
2843	if v.ByteBuffer != nil {
2844		ok := object.Key("byteBuffer")
2845		ok.Base64EncodeBytes(v.ByteBuffer)
2846	}
2847
2848	if v.ContentType != nil {
2849		ok := object.Key("contentType")
2850		ok.String(*v.ContentType)
2851	}
2852
2853	return nil
2854}
2855
2856func awsAwsjson11_serializeDocumentModelInputConfiguration(v *types.ModelInputConfiguration, value smithyjson.Value) error {
2857	object := value.Object()
2858	defer object.Close()
2859
2860	if v.CsvInputTemplate != nil {
2861		ok := object.Key("csvInputTemplate")
2862		ok.String(*v.CsvInputTemplate)
2863	}
2864
2865	if v.EventTypeName != nil {
2866		ok := object.Key("eventTypeName")
2867		ok.String(*v.EventTypeName)
2868	}
2869
2870	if len(v.Format) > 0 {
2871		ok := object.Key("format")
2872		ok.String(string(v.Format))
2873	}
2874
2875	if v.JsonInputTemplate != nil {
2876		ok := object.Key("jsonInputTemplate")
2877		ok.String(*v.JsonInputTemplate)
2878	}
2879
2880	if v.UseEventVariables != nil {
2881		ok := object.Key("useEventVariables")
2882		ok.Boolean(*v.UseEventVariables)
2883	}
2884
2885	return nil
2886}
2887
2888func awsAwsjson11_serializeDocumentModelOutputConfiguration(v *types.ModelOutputConfiguration, value smithyjson.Value) error {
2889	object := value.Object()
2890	defer object.Close()
2891
2892	if v.CsvIndexToVariableMap != nil {
2893		ok := object.Key("csvIndexToVariableMap")
2894		if err := awsAwsjson11_serializeDocumentCsvIndexToVariableMap(v.CsvIndexToVariableMap, ok); err != nil {
2895			return err
2896		}
2897	}
2898
2899	if len(v.Format) > 0 {
2900		ok := object.Key("format")
2901		ok.String(string(v.Format))
2902	}
2903
2904	if v.JsonKeyToVariableMap != nil {
2905		ok := object.Key("jsonKeyToVariableMap")
2906		if err := awsAwsjson11_serializeDocumentJsonKeyToVariableMap(v.JsonKeyToVariableMap, ok); err != nil {
2907			return err
2908		}
2909	}
2910
2911	return nil
2912}
2913
2914func awsAwsjson11_serializeDocumentModelVersion(v *types.ModelVersion, value smithyjson.Value) error {
2915	object := value.Object()
2916	defer object.Close()
2917
2918	if v.Arn != nil {
2919		ok := object.Key("arn")
2920		ok.String(*v.Arn)
2921	}
2922
2923	if v.ModelId != nil {
2924		ok := object.Key("modelId")
2925		ok.String(*v.ModelId)
2926	}
2927
2928	if len(v.ModelType) > 0 {
2929		ok := object.Key("modelType")
2930		ok.String(string(v.ModelType))
2931	}
2932
2933	if v.ModelVersionNumber != nil {
2934		ok := object.Key("modelVersionNumber")
2935		ok.String(*v.ModelVersionNumber)
2936	}
2937
2938	return nil
2939}
2940
2941func awsAwsjson11_serializeDocumentNameList(v []string, value smithyjson.Value) error {
2942	array := value.Array()
2943	defer array.Close()
2944
2945	for i := range v {
2946		av := array.Value()
2947		av.String(v[i])
2948	}
2949	return nil
2950}
2951
2952func awsAwsjson11_serializeDocumentNonEmptyListOfStrings(v []string, value smithyjson.Value) error {
2953	array := value.Array()
2954	defer array.Close()
2955
2956	for i := range v {
2957		av := array.Value()
2958		av.String(v[i])
2959	}
2960	return nil
2961}
2962
2963func awsAwsjson11_serializeDocumentRule(v *types.Rule, value smithyjson.Value) error {
2964	object := value.Object()
2965	defer object.Close()
2966
2967	if v.DetectorId != nil {
2968		ok := object.Key("detectorId")
2969		ok.String(*v.DetectorId)
2970	}
2971
2972	if v.RuleId != nil {
2973		ok := object.Key("ruleId")
2974		ok.String(*v.RuleId)
2975	}
2976
2977	if v.RuleVersion != nil {
2978		ok := object.Key("ruleVersion")
2979		ok.String(*v.RuleVersion)
2980	}
2981
2982	return nil
2983}
2984
2985func awsAwsjson11_serializeDocumentRuleList(v []types.Rule, value smithyjson.Value) error {
2986	array := value.Array()
2987	defer array.Close()
2988
2989	for i := range v {
2990		av := array.Value()
2991		if err := awsAwsjson11_serializeDocumentRule(&v[i], av); err != nil {
2992			return err
2993		}
2994	}
2995	return nil
2996}
2997
2998func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2999	object := value.Object()
3000	defer object.Close()
3001
3002	if v.Key != nil {
3003		ok := object.Key("key")
3004		ok.String(*v.Key)
3005	}
3006
3007	if v.Value != nil {
3008		ok := object.Key("value")
3009		ok.String(*v.Value)
3010	}
3011
3012	return nil
3013}
3014
3015func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
3016	array := value.Array()
3017	defer array.Close()
3018
3019	for i := range v {
3020		av := array.Value()
3021		av.String(v[i])
3022	}
3023	return nil
3024}
3025
3026func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
3027	array := value.Array()
3028	defer array.Close()
3029
3030	for i := range v {
3031		av := array.Value()
3032		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
3033			return err
3034		}
3035	}
3036	return nil
3037}
3038
3039func awsAwsjson11_serializeDocumentTrainingDataSchema(v *types.TrainingDataSchema, value smithyjson.Value) error {
3040	object := value.Object()
3041	defer object.Close()
3042
3043	if v.LabelSchema != nil {
3044		ok := object.Key("labelSchema")
3045		if err := awsAwsjson11_serializeDocumentLabelSchema(v.LabelSchema, ok); err != nil {
3046			return err
3047		}
3048	}
3049
3050	if v.ModelVariables != nil {
3051		ok := object.Key("modelVariables")
3052		if err := awsAwsjson11_serializeDocumentListOfStrings(v.ModelVariables, ok); err != nil {
3053			return err
3054		}
3055	}
3056
3057	return nil
3058}
3059
3060func awsAwsjson11_serializeDocumentVariableEntry(v *types.VariableEntry, value smithyjson.Value) error {
3061	object := value.Object()
3062	defer object.Close()
3063
3064	if v.DataSource != nil {
3065		ok := object.Key("dataSource")
3066		ok.String(*v.DataSource)
3067	}
3068
3069	if v.DataType != nil {
3070		ok := object.Key("dataType")
3071		ok.String(*v.DataType)
3072	}
3073
3074	if v.DefaultValue != nil {
3075		ok := object.Key("defaultValue")
3076		ok.String(*v.DefaultValue)
3077	}
3078
3079	if v.Description != nil {
3080		ok := object.Key("description")
3081		ok.String(*v.Description)
3082	}
3083
3084	if v.Name != nil {
3085		ok := object.Key("name")
3086		ok.String(*v.Name)
3087	}
3088
3089	if v.VariableType != nil {
3090		ok := object.Key("variableType")
3091		ok.String(*v.VariableType)
3092	}
3093
3094	return nil
3095}
3096
3097func awsAwsjson11_serializeDocumentVariableEntryList(v []types.VariableEntry, value smithyjson.Value) error {
3098	array := value.Array()
3099	defer array.Close()
3100
3101	for i := range v {
3102		av := array.Value()
3103		if err := awsAwsjson11_serializeDocumentVariableEntry(&v[i], av); err != nil {
3104			return err
3105		}
3106	}
3107	return nil
3108}
3109
3110func awsAwsjson11_serializeOpDocumentBatchCreateVariableInput(v *BatchCreateVariableInput, value smithyjson.Value) error {
3111	object := value.Object()
3112	defer object.Close()
3113
3114	if v.Tags != nil {
3115		ok := object.Key("tags")
3116		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3117			return err
3118		}
3119	}
3120
3121	if v.VariableEntries != nil {
3122		ok := object.Key("variableEntries")
3123		if err := awsAwsjson11_serializeDocumentVariableEntryList(v.VariableEntries, ok); err != nil {
3124			return err
3125		}
3126	}
3127
3128	return nil
3129}
3130
3131func awsAwsjson11_serializeOpDocumentBatchGetVariableInput(v *BatchGetVariableInput, value smithyjson.Value) error {
3132	object := value.Object()
3133	defer object.Close()
3134
3135	if v.Names != nil {
3136		ok := object.Key("names")
3137		if err := awsAwsjson11_serializeDocumentNameList(v.Names, ok); err != nil {
3138			return err
3139		}
3140	}
3141
3142	return nil
3143}
3144
3145func awsAwsjson11_serializeOpDocumentCancelBatchPredictionJobInput(v *CancelBatchPredictionJobInput, value smithyjson.Value) error {
3146	object := value.Object()
3147	defer object.Close()
3148
3149	if v.JobId != nil {
3150		ok := object.Key("jobId")
3151		ok.String(*v.JobId)
3152	}
3153
3154	return nil
3155}
3156
3157func awsAwsjson11_serializeOpDocumentCreateBatchPredictionJobInput(v *CreateBatchPredictionJobInput, value smithyjson.Value) error {
3158	object := value.Object()
3159	defer object.Close()
3160
3161	if v.DetectorName != nil {
3162		ok := object.Key("detectorName")
3163		ok.String(*v.DetectorName)
3164	}
3165
3166	if v.DetectorVersion != nil {
3167		ok := object.Key("detectorVersion")
3168		ok.String(*v.DetectorVersion)
3169	}
3170
3171	if v.EventTypeName != nil {
3172		ok := object.Key("eventTypeName")
3173		ok.String(*v.EventTypeName)
3174	}
3175
3176	if v.IamRoleArn != nil {
3177		ok := object.Key("iamRoleArn")
3178		ok.String(*v.IamRoleArn)
3179	}
3180
3181	if v.InputPath != nil {
3182		ok := object.Key("inputPath")
3183		ok.String(*v.InputPath)
3184	}
3185
3186	if v.JobId != nil {
3187		ok := object.Key("jobId")
3188		ok.String(*v.JobId)
3189	}
3190
3191	if v.OutputPath != nil {
3192		ok := object.Key("outputPath")
3193		ok.String(*v.OutputPath)
3194	}
3195
3196	if v.Tags != nil {
3197		ok := object.Key("tags")
3198		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3199			return err
3200		}
3201	}
3202
3203	return nil
3204}
3205
3206func awsAwsjson11_serializeOpDocumentCreateDetectorVersionInput(v *CreateDetectorVersionInput, value smithyjson.Value) error {
3207	object := value.Object()
3208	defer object.Close()
3209
3210	if v.Description != nil {
3211		ok := object.Key("description")
3212		ok.String(*v.Description)
3213	}
3214
3215	if v.DetectorId != nil {
3216		ok := object.Key("detectorId")
3217		ok.String(*v.DetectorId)
3218	}
3219
3220	if v.ExternalModelEndpoints != nil {
3221		ok := object.Key("externalModelEndpoints")
3222		if err := awsAwsjson11_serializeDocumentListOfStrings(v.ExternalModelEndpoints, ok); err != nil {
3223			return err
3224		}
3225	}
3226
3227	if v.ModelVersions != nil {
3228		ok := object.Key("modelVersions")
3229		if err := awsAwsjson11_serializeDocumentListOfModelVersions(v.ModelVersions, ok); err != nil {
3230			return err
3231		}
3232	}
3233
3234	if len(v.RuleExecutionMode) > 0 {
3235		ok := object.Key("ruleExecutionMode")
3236		ok.String(string(v.RuleExecutionMode))
3237	}
3238
3239	if v.Rules != nil {
3240		ok := object.Key("rules")
3241		if err := awsAwsjson11_serializeDocumentRuleList(v.Rules, ok); err != nil {
3242			return err
3243		}
3244	}
3245
3246	if v.Tags != nil {
3247		ok := object.Key("tags")
3248		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3249			return err
3250		}
3251	}
3252
3253	return nil
3254}
3255
3256func awsAwsjson11_serializeOpDocumentCreateModelInput(v *CreateModelInput, value smithyjson.Value) error {
3257	object := value.Object()
3258	defer object.Close()
3259
3260	if v.Description != nil {
3261		ok := object.Key("description")
3262		ok.String(*v.Description)
3263	}
3264
3265	if v.EventTypeName != nil {
3266		ok := object.Key("eventTypeName")
3267		ok.String(*v.EventTypeName)
3268	}
3269
3270	if v.ModelId != nil {
3271		ok := object.Key("modelId")
3272		ok.String(*v.ModelId)
3273	}
3274
3275	if len(v.ModelType) > 0 {
3276		ok := object.Key("modelType")
3277		ok.String(string(v.ModelType))
3278	}
3279
3280	if v.Tags != nil {
3281		ok := object.Key("tags")
3282		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3283			return err
3284		}
3285	}
3286
3287	return nil
3288}
3289
3290func awsAwsjson11_serializeOpDocumentCreateModelVersionInput(v *CreateModelVersionInput, value smithyjson.Value) error {
3291	object := value.Object()
3292	defer object.Close()
3293
3294	if v.ExternalEventsDetail != nil {
3295		ok := object.Key("externalEventsDetail")
3296		if err := awsAwsjson11_serializeDocumentExternalEventsDetail(v.ExternalEventsDetail, ok); err != nil {
3297			return err
3298		}
3299	}
3300
3301	if v.ModelId != nil {
3302		ok := object.Key("modelId")
3303		ok.String(*v.ModelId)
3304	}
3305
3306	if len(v.ModelType) > 0 {
3307		ok := object.Key("modelType")
3308		ok.String(string(v.ModelType))
3309	}
3310
3311	if v.Tags != nil {
3312		ok := object.Key("tags")
3313		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3314			return err
3315		}
3316	}
3317
3318	if v.TrainingDataSchema != nil {
3319		ok := object.Key("trainingDataSchema")
3320		if err := awsAwsjson11_serializeDocumentTrainingDataSchema(v.TrainingDataSchema, ok); err != nil {
3321			return err
3322		}
3323	}
3324
3325	if len(v.TrainingDataSource) > 0 {
3326		ok := object.Key("trainingDataSource")
3327		ok.String(string(v.TrainingDataSource))
3328	}
3329
3330	return nil
3331}
3332
3333func awsAwsjson11_serializeOpDocumentCreateRuleInput(v *CreateRuleInput, value smithyjson.Value) error {
3334	object := value.Object()
3335	defer object.Close()
3336
3337	if v.Description != nil {
3338		ok := object.Key("description")
3339		ok.String(*v.Description)
3340	}
3341
3342	if v.DetectorId != nil {
3343		ok := object.Key("detectorId")
3344		ok.String(*v.DetectorId)
3345	}
3346
3347	if v.Expression != nil {
3348		ok := object.Key("expression")
3349		ok.String(*v.Expression)
3350	}
3351
3352	if len(v.Language) > 0 {
3353		ok := object.Key("language")
3354		ok.String(string(v.Language))
3355	}
3356
3357	if v.Outcomes != nil {
3358		ok := object.Key("outcomes")
3359		if err := awsAwsjson11_serializeDocumentNonEmptyListOfStrings(v.Outcomes, ok); err != nil {
3360			return err
3361		}
3362	}
3363
3364	if v.RuleId != nil {
3365		ok := object.Key("ruleId")
3366		ok.String(*v.RuleId)
3367	}
3368
3369	if v.Tags != nil {
3370		ok := object.Key("tags")
3371		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3372			return err
3373		}
3374	}
3375
3376	return nil
3377}
3378
3379func awsAwsjson11_serializeOpDocumentCreateVariableInput(v *CreateVariableInput, value smithyjson.Value) error {
3380	object := value.Object()
3381	defer object.Close()
3382
3383	if len(v.DataSource) > 0 {
3384		ok := object.Key("dataSource")
3385		ok.String(string(v.DataSource))
3386	}
3387
3388	if len(v.DataType) > 0 {
3389		ok := object.Key("dataType")
3390		ok.String(string(v.DataType))
3391	}
3392
3393	if v.DefaultValue != nil {
3394		ok := object.Key("defaultValue")
3395		ok.String(*v.DefaultValue)
3396	}
3397
3398	if v.Description != nil {
3399		ok := object.Key("description")
3400		ok.String(*v.Description)
3401	}
3402
3403	if v.Name != nil {
3404		ok := object.Key("name")
3405		ok.String(*v.Name)
3406	}
3407
3408	if v.Tags != nil {
3409		ok := object.Key("tags")
3410		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3411			return err
3412		}
3413	}
3414
3415	if v.VariableType != nil {
3416		ok := object.Key("variableType")
3417		ok.String(*v.VariableType)
3418	}
3419
3420	return nil
3421}
3422
3423func awsAwsjson11_serializeOpDocumentDeleteBatchPredictionJobInput(v *DeleteBatchPredictionJobInput, value smithyjson.Value) error {
3424	object := value.Object()
3425	defer object.Close()
3426
3427	if v.JobId != nil {
3428		ok := object.Key("jobId")
3429		ok.String(*v.JobId)
3430	}
3431
3432	return nil
3433}
3434
3435func awsAwsjson11_serializeOpDocumentDeleteDetectorInput(v *DeleteDetectorInput, value smithyjson.Value) error {
3436	object := value.Object()
3437	defer object.Close()
3438
3439	if v.DetectorId != nil {
3440		ok := object.Key("detectorId")
3441		ok.String(*v.DetectorId)
3442	}
3443
3444	return nil
3445}
3446
3447func awsAwsjson11_serializeOpDocumentDeleteDetectorVersionInput(v *DeleteDetectorVersionInput, value smithyjson.Value) error {
3448	object := value.Object()
3449	defer object.Close()
3450
3451	if v.DetectorId != nil {
3452		ok := object.Key("detectorId")
3453		ok.String(*v.DetectorId)
3454	}
3455
3456	if v.DetectorVersionId != nil {
3457		ok := object.Key("detectorVersionId")
3458		ok.String(*v.DetectorVersionId)
3459	}
3460
3461	return nil
3462}
3463
3464func awsAwsjson11_serializeOpDocumentDeleteEntityTypeInput(v *DeleteEntityTypeInput, value smithyjson.Value) error {
3465	object := value.Object()
3466	defer object.Close()
3467
3468	if v.Name != nil {
3469		ok := object.Key("name")
3470		ok.String(*v.Name)
3471	}
3472
3473	return nil
3474}
3475
3476func awsAwsjson11_serializeOpDocumentDeleteEventInput(v *DeleteEventInput, value smithyjson.Value) error {
3477	object := value.Object()
3478	defer object.Close()
3479
3480	if v.EventId != nil {
3481		ok := object.Key("eventId")
3482		ok.String(*v.EventId)
3483	}
3484
3485	if v.EventTypeName != nil {
3486		ok := object.Key("eventTypeName")
3487		ok.String(*v.EventTypeName)
3488	}
3489
3490	return nil
3491}
3492
3493func awsAwsjson11_serializeOpDocumentDeleteEventTypeInput(v *DeleteEventTypeInput, value smithyjson.Value) error {
3494	object := value.Object()
3495	defer object.Close()
3496
3497	if v.Name != nil {
3498		ok := object.Key("name")
3499		ok.String(*v.Name)
3500	}
3501
3502	return nil
3503}
3504
3505func awsAwsjson11_serializeOpDocumentDeleteExternalModelInput(v *DeleteExternalModelInput, value smithyjson.Value) error {
3506	object := value.Object()
3507	defer object.Close()
3508
3509	if v.ModelEndpoint != nil {
3510		ok := object.Key("modelEndpoint")
3511		ok.String(*v.ModelEndpoint)
3512	}
3513
3514	return nil
3515}
3516
3517func awsAwsjson11_serializeOpDocumentDeleteLabelInput(v *DeleteLabelInput, value smithyjson.Value) error {
3518	object := value.Object()
3519	defer object.Close()
3520
3521	if v.Name != nil {
3522		ok := object.Key("name")
3523		ok.String(*v.Name)
3524	}
3525
3526	return nil
3527}
3528
3529func awsAwsjson11_serializeOpDocumentDeleteModelInput(v *DeleteModelInput, value smithyjson.Value) error {
3530	object := value.Object()
3531	defer object.Close()
3532
3533	if v.ModelId != nil {
3534		ok := object.Key("modelId")
3535		ok.String(*v.ModelId)
3536	}
3537
3538	if len(v.ModelType) > 0 {
3539		ok := object.Key("modelType")
3540		ok.String(string(v.ModelType))
3541	}
3542
3543	return nil
3544}
3545
3546func awsAwsjson11_serializeOpDocumentDeleteModelVersionInput(v *DeleteModelVersionInput, value smithyjson.Value) error {
3547	object := value.Object()
3548	defer object.Close()
3549
3550	if v.ModelId != nil {
3551		ok := object.Key("modelId")
3552		ok.String(*v.ModelId)
3553	}
3554
3555	if len(v.ModelType) > 0 {
3556		ok := object.Key("modelType")
3557		ok.String(string(v.ModelType))
3558	}
3559
3560	if v.ModelVersionNumber != nil {
3561		ok := object.Key("modelVersionNumber")
3562		ok.String(*v.ModelVersionNumber)
3563	}
3564
3565	return nil
3566}
3567
3568func awsAwsjson11_serializeOpDocumentDeleteOutcomeInput(v *DeleteOutcomeInput, value smithyjson.Value) error {
3569	object := value.Object()
3570	defer object.Close()
3571
3572	if v.Name != nil {
3573		ok := object.Key("name")
3574		ok.String(*v.Name)
3575	}
3576
3577	return nil
3578}
3579
3580func awsAwsjson11_serializeOpDocumentDeleteRuleInput(v *DeleteRuleInput, value smithyjson.Value) error {
3581	object := value.Object()
3582	defer object.Close()
3583
3584	if v.Rule != nil {
3585		ok := object.Key("rule")
3586		if err := awsAwsjson11_serializeDocumentRule(v.Rule, ok); err != nil {
3587			return err
3588		}
3589	}
3590
3591	return nil
3592}
3593
3594func awsAwsjson11_serializeOpDocumentDeleteVariableInput(v *DeleteVariableInput, value smithyjson.Value) error {
3595	object := value.Object()
3596	defer object.Close()
3597
3598	if v.Name != nil {
3599		ok := object.Key("name")
3600		ok.String(*v.Name)
3601	}
3602
3603	return nil
3604}
3605
3606func awsAwsjson11_serializeOpDocumentDescribeDetectorInput(v *DescribeDetectorInput, value smithyjson.Value) error {
3607	object := value.Object()
3608	defer object.Close()
3609
3610	if v.DetectorId != nil {
3611		ok := object.Key("detectorId")
3612		ok.String(*v.DetectorId)
3613	}
3614
3615	if v.MaxResults != nil {
3616		ok := object.Key("maxResults")
3617		ok.Integer(*v.MaxResults)
3618	}
3619
3620	if v.NextToken != nil {
3621		ok := object.Key("nextToken")
3622		ok.String(*v.NextToken)
3623	}
3624
3625	return nil
3626}
3627
3628func awsAwsjson11_serializeOpDocumentDescribeModelVersionsInput(v *DescribeModelVersionsInput, value smithyjson.Value) error {
3629	object := value.Object()
3630	defer object.Close()
3631
3632	if v.MaxResults != nil {
3633		ok := object.Key("maxResults")
3634		ok.Integer(*v.MaxResults)
3635	}
3636
3637	if v.ModelId != nil {
3638		ok := object.Key("modelId")
3639		ok.String(*v.ModelId)
3640	}
3641
3642	if len(v.ModelType) > 0 {
3643		ok := object.Key("modelType")
3644		ok.String(string(v.ModelType))
3645	}
3646
3647	if v.ModelVersionNumber != nil {
3648		ok := object.Key("modelVersionNumber")
3649		ok.String(*v.ModelVersionNumber)
3650	}
3651
3652	if v.NextToken != nil {
3653		ok := object.Key("nextToken")
3654		ok.String(*v.NextToken)
3655	}
3656
3657	return nil
3658}
3659
3660func awsAwsjson11_serializeOpDocumentGetBatchPredictionJobsInput(v *GetBatchPredictionJobsInput, value smithyjson.Value) error {
3661	object := value.Object()
3662	defer object.Close()
3663
3664	if v.JobId != nil {
3665		ok := object.Key("jobId")
3666		ok.String(*v.JobId)
3667	}
3668
3669	if v.MaxResults != nil {
3670		ok := object.Key("maxResults")
3671		ok.Integer(*v.MaxResults)
3672	}
3673
3674	if v.NextToken != nil {
3675		ok := object.Key("nextToken")
3676		ok.String(*v.NextToken)
3677	}
3678
3679	return nil
3680}
3681
3682func awsAwsjson11_serializeOpDocumentGetDetectorsInput(v *GetDetectorsInput, value smithyjson.Value) error {
3683	object := value.Object()
3684	defer object.Close()
3685
3686	if v.DetectorId != nil {
3687		ok := object.Key("detectorId")
3688		ok.String(*v.DetectorId)
3689	}
3690
3691	if v.MaxResults != nil {
3692		ok := object.Key("maxResults")
3693		ok.Integer(*v.MaxResults)
3694	}
3695
3696	if v.NextToken != nil {
3697		ok := object.Key("nextToken")
3698		ok.String(*v.NextToken)
3699	}
3700
3701	return nil
3702}
3703
3704func awsAwsjson11_serializeOpDocumentGetDetectorVersionInput(v *GetDetectorVersionInput, value smithyjson.Value) error {
3705	object := value.Object()
3706	defer object.Close()
3707
3708	if v.DetectorId != nil {
3709		ok := object.Key("detectorId")
3710		ok.String(*v.DetectorId)
3711	}
3712
3713	if v.DetectorVersionId != nil {
3714		ok := object.Key("detectorVersionId")
3715		ok.String(*v.DetectorVersionId)
3716	}
3717
3718	return nil
3719}
3720
3721func awsAwsjson11_serializeOpDocumentGetEntityTypesInput(v *GetEntityTypesInput, value smithyjson.Value) error {
3722	object := value.Object()
3723	defer object.Close()
3724
3725	if v.MaxResults != nil {
3726		ok := object.Key("maxResults")
3727		ok.Integer(*v.MaxResults)
3728	}
3729
3730	if v.Name != nil {
3731		ok := object.Key("name")
3732		ok.String(*v.Name)
3733	}
3734
3735	if v.NextToken != nil {
3736		ok := object.Key("nextToken")
3737		ok.String(*v.NextToken)
3738	}
3739
3740	return nil
3741}
3742
3743func awsAwsjson11_serializeOpDocumentGetEventPredictionInput(v *GetEventPredictionInput, value smithyjson.Value) error {
3744	object := value.Object()
3745	defer object.Close()
3746
3747	if v.DetectorId != nil {
3748		ok := object.Key("detectorId")
3749		ok.String(*v.DetectorId)
3750	}
3751
3752	if v.DetectorVersionId != nil {
3753		ok := object.Key("detectorVersionId")
3754		ok.String(*v.DetectorVersionId)
3755	}
3756
3757	if v.Entities != nil {
3758		ok := object.Key("entities")
3759		if err := awsAwsjson11_serializeDocumentListOfEntities(v.Entities, ok); err != nil {
3760			return err
3761		}
3762	}
3763
3764	if v.EventId != nil {
3765		ok := object.Key("eventId")
3766		ok.String(*v.EventId)
3767	}
3768
3769	if v.EventTimestamp != nil {
3770		ok := object.Key("eventTimestamp")
3771		ok.String(*v.EventTimestamp)
3772	}
3773
3774	if v.EventTypeName != nil {
3775		ok := object.Key("eventTypeName")
3776		ok.String(*v.EventTypeName)
3777	}
3778
3779	if v.EventVariables != nil {
3780		ok := object.Key("eventVariables")
3781		if err := awsAwsjson11_serializeDocumentEventVariableMap(v.EventVariables, ok); err != nil {
3782			return err
3783		}
3784	}
3785
3786	if v.ExternalModelEndpointDataBlobs != nil {
3787		ok := object.Key("externalModelEndpointDataBlobs")
3788		if err := awsAwsjson11_serializeDocumentExternalModelEndpointDataBlobMap(v.ExternalModelEndpointDataBlobs, ok); err != nil {
3789			return err
3790		}
3791	}
3792
3793	return nil
3794}
3795
3796func awsAwsjson11_serializeOpDocumentGetEventTypesInput(v *GetEventTypesInput, value smithyjson.Value) error {
3797	object := value.Object()
3798	defer object.Close()
3799
3800	if v.MaxResults != nil {
3801		ok := object.Key("maxResults")
3802		ok.Integer(*v.MaxResults)
3803	}
3804
3805	if v.Name != nil {
3806		ok := object.Key("name")
3807		ok.String(*v.Name)
3808	}
3809
3810	if v.NextToken != nil {
3811		ok := object.Key("nextToken")
3812		ok.String(*v.NextToken)
3813	}
3814
3815	return nil
3816}
3817
3818func awsAwsjson11_serializeOpDocumentGetExternalModelsInput(v *GetExternalModelsInput, value smithyjson.Value) error {
3819	object := value.Object()
3820	defer object.Close()
3821
3822	if v.MaxResults != nil {
3823		ok := object.Key("maxResults")
3824		ok.Integer(*v.MaxResults)
3825	}
3826
3827	if v.ModelEndpoint != nil {
3828		ok := object.Key("modelEndpoint")
3829		ok.String(*v.ModelEndpoint)
3830	}
3831
3832	if v.NextToken != nil {
3833		ok := object.Key("nextToken")
3834		ok.String(*v.NextToken)
3835	}
3836
3837	return nil
3838}
3839
3840func awsAwsjson11_serializeOpDocumentGetLabelsInput(v *GetLabelsInput, value smithyjson.Value) error {
3841	object := value.Object()
3842	defer object.Close()
3843
3844	if v.MaxResults != nil {
3845		ok := object.Key("maxResults")
3846		ok.Integer(*v.MaxResults)
3847	}
3848
3849	if v.Name != nil {
3850		ok := object.Key("name")
3851		ok.String(*v.Name)
3852	}
3853
3854	if v.NextToken != nil {
3855		ok := object.Key("nextToken")
3856		ok.String(*v.NextToken)
3857	}
3858
3859	return nil
3860}
3861
3862func awsAwsjson11_serializeOpDocumentGetModelsInput(v *GetModelsInput, value smithyjson.Value) error {
3863	object := value.Object()
3864	defer object.Close()
3865
3866	if v.MaxResults != nil {
3867		ok := object.Key("maxResults")
3868		ok.Integer(*v.MaxResults)
3869	}
3870
3871	if v.ModelId != nil {
3872		ok := object.Key("modelId")
3873		ok.String(*v.ModelId)
3874	}
3875
3876	if len(v.ModelType) > 0 {
3877		ok := object.Key("modelType")
3878		ok.String(string(v.ModelType))
3879	}
3880
3881	if v.NextToken != nil {
3882		ok := object.Key("nextToken")
3883		ok.String(*v.NextToken)
3884	}
3885
3886	return nil
3887}
3888
3889func awsAwsjson11_serializeOpDocumentGetModelVersionInput(v *GetModelVersionInput, value smithyjson.Value) error {
3890	object := value.Object()
3891	defer object.Close()
3892
3893	if v.ModelId != nil {
3894		ok := object.Key("modelId")
3895		ok.String(*v.ModelId)
3896	}
3897
3898	if len(v.ModelType) > 0 {
3899		ok := object.Key("modelType")
3900		ok.String(string(v.ModelType))
3901	}
3902
3903	if v.ModelVersionNumber != nil {
3904		ok := object.Key("modelVersionNumber")
3905		ok.String(*v.ModelVersionNumber)
3906	}
3907
3908	return nil
3909}
3910
3911func awsAwsjson11_serializeOpDocumentGetOutcomesInput(v *GetOutcomesInput, value smithyjson.Value) error {
3912	object := value.Object()
3913	defer object.Close()
3914
3915	if v.MaxResults != nil {
3916		ok := object.Key("maxResults")
3917		ok.Integer(*v.MaxResults)
3918	}
3919
3920	if v.Name != nil {
3921		ok := object.Key("name")
3922		ok.String(*v.Name)
3923	}
3924
3925	if v.NextToken != nil {
3926		ok := object.Key("nextToken")
3927		ok.String(*v.NextToken)
3928	}
3929
3930	return nil
3931}
3932
3933func awsAwsjson11_serializeOpDocumentGetRulesInput(v *GetRulesInput, value smithyjson.Value) error {
3934	object := value.Object()
3935	defer object.Close()
3936
3937	if v.DetectorId != nil {
3938		ok := object.Key("detectorId")
3939		ok.String(*v.DetectorId)
3940	}
3941
3942	if v.MaxResults != nil {
3943		ok := object.Key("maxResults")
3944		ok.Integer(*v.MaxResults)
3945	}
3946
3947	if v.NextToken != nil {
3948		ok := object.Key("nextToken")
3949		ok.String(*v.NextToken)
3950	}
3951
3952	if v.RuleId != nil {
3953		ok := object.Key("ruleId")
3954		ok.String(*v.RuleId)
3955	}
3956
3957	if v.RuleVersion != nil {
3958		ok := object.Key("ruleVersion")
3959		ok.String(*v.RuleVersion)
3960	}
3961
3962	return nil
3963}
3964
3965func awsAwsjson11_serializeOpDocumentGetVariablesInput(v *GetVariablesInput, value smithyjson.Value) error {
3966	object := value.Object()
3967	defer object.Close()
3968
3969	if v.MaxResults != nil {
3970		ok := object.Key("maxResults")
3971		ok.Integer(*v.MaxResults)
3972	}
3973
3974	if v.Name != nil {
3975		ok := object.Key("name")
3976		ok.String(*v.Name)
3977	}
3978
3979	if v.NextToken != nil {
3980		ok := object.Key("nextToken")
3981		ok.String(*v.NextToken)
3982	}
3983
3984	return nil
3985}
3986
3987func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
3988	object := value.Object()
3989	defer object.Close()
3990
3991	if v.MaxResults != nil {
3992		ok := object.Key("maxResults")
3993		ok.Integer(*v.MaxResults)
3994	}
3995
3996	if v.NextToken != nil {
3997		ok := object.Key("nextToken")
3998		ok.String(*v.NextToken)
3999	}
4000
4001	if v.ResourceARN != nil {
4002		ok := object.Key("resourceARN")
4003		ok.String(*v.ResourceARN)
4004	}
4005
4006	return nil
4007}
4008
4009func awsAwsjson11_serializeOpDocumentPutDetectorInput(v *PutDetectorInput, value smithyjson.Value) error {
4010	object := value.Object()
4011	defer object.Close()
4012
4013	if v.Description != nil {
4014		ok := object.Key("description")
4015		ok.String(*v.Description)
4016	}
4017
4018	if v.DetectorId != nil {
4019		ok := object.Key("detectorId")
4020		ok.String(*v.DetectorId)
4021	}
4022
4023	if v.EventTypeName != nil {
4024		ok := object.Key("eventTypeName")
4025		ok.String(*v.EventTypeName)
4026	}
4027
4028	if v.Tags != nil {
4029		ok := object.Key("tags")
4030		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4031			return err
4032		}
4033	}
4034
4035	return nil
4036}
4037
4038func awsAwsjson11_serializeOpDocumentPutEntityTypeInput(v *PutEntityTypeInput, value smithyjson.Value) error {
4039	object := value.Object()
4040	defer object.Close()
4041
4042	if v.Description != nil {
4043		ok := object.Key("description")
4044		ok.String(*v.Description)
4045	}
4046
4047	if v.Name != nil {
4048		ok := object.Key("name")
4049		ok.String(*v.Name)
4050	}
4051
4052	if v.Tags != nil {
4053		ok := object.Key("tags")
4054		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4055			return err
4056		}
4057	}
4058
4059	return nil
4060}
4061
4062func awsAwsjson11_serializeOpDocumentPutEventTypeInput(v *PutEventTypeInput, value smithyjson.Value) error {
4063	object := value.Object()
4064	defer object.Close()
4065
4066	if v.Description != nil {
4067		ok := object.Key("description")
4068		ok.String(*v.Description)
4069	}
4070
4071	if v.EntityTypes != nil {
4072		ok := object.Key("entityTypes")
4073		if err := awsAwsjson11_serializeDocumentNonEmptyListOfStrings(v.EntityTypes, ok); err != nil {
4074			return err
4075		}
4076	}
4077
4078	if v.EventVariables != nil {
4079		ok := object.Key("eventVariables")
4080		if err := awsAwsjson11_serializeDocumentNonEmptyListOfStrings(v.EventVariables, ok); err != nil {
4081			return err
4082		}
4083	}
4084
4085	if v.Labels != nil {
4086		ok := object.Key("labels")
4087		if err := awsAwsjson11_serializeDocumentListOfStrings(v.Labels, ok); err != nil {
4088			return err
4089		}
4090	}
4091
4092	if v.Name != nil {
4093		ok := object.Key("name")
4094		ok.String(*v.Name)
4095	}
4096
4097	if v.Tags != nil {
4098		ok := object.Key("tags")
4099		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4100			return err
4101		}
4102	}
4103
4104	return nil
4105}
4106
4107func awsAwsjson11_serializeOpDocumentPutExternalModelInput(v *PutExternalModelInput, value smithyjson.Value) error {
4108	object := value.Object()
4109	defer object.Close()
4110
4111	if v.InputConfiguration != nil {
4112		ok := object.Key("inputConfiguration")
4113		if err := awsAwsjson11_serializeDocumentModelInputConfiguration(v.InputConfiguration, ok); err != nil {
4114			return err
4115		}
4116	}
4117
4118	if v.InvokeModelEndpointRoleArn != nil {
4119		ok := object.Key("invokeModelEndpointRoleArn")
4120		ok.String(*v.InvokeModelEndpointRoleArn)
4121	}
4122
4123	if v.ModelEndpoint != nil {
4124		ok := object.Key("modelEndpoint")
4125		ok.String(*v.ModelEndpoint)
4126	}
4127
4128	if len(v.ModelEndpointStatus) > 0 {
4129		ok := object.Key("modelEndpointStatus")
4130		ok.String(string(v.ModelEndpointStatus))
4131	}
4132
4133	if len(v.ModelSource) > 0 {
4134		ok := object.Key("modelSource")
4135		ok.String(string(v.ModelSource))
4136	}
4137
4138	if v.OutputConfiguration != nil {
4139		ok := object.Key("outputConfiguration")
4140		if err := awsAwsjson11_serializeDocumentModelOutputConfiguration(v.OutputConfiguration, ok); err != nil {
4141			return err
4142		}
4143	}
4144
4145	if v.Tags != nil {
4146		ok := object.Key("tags")
4147		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4148			return err
4149		}
4150	}
4151
4152	return nil
4153}
4154
4155func awsAwsjson11_serializeOpDocumentPutKMSEncryptionKeyInput(v *PutKMSEncryptionKeyInput, value smithyjson.Value) error {
4156	object := value.Object()
4157	defer object.Close()
4158
4159	if v.KmsEncryptionKeyArn != nil {
4160		ok := object.Key("kmsEncryptionKeyArn")
4161		ok.String(*v.KmsEncryptionKeyArn)
4162	}
4163
4164	return nil
4165}
4166
4167func awsAwsjson11_serializeOpDocumentPutLabelInput(v *PutLabelInput, value smithyjson.Value) error {
4168	object := value.Object()
4169	defer object.Close()
4170
4171	if v.Description != nil {
4172		ok := object.Key("description")
4173		ok.String(*v.Description)
4174	}
4175
4176	if v.Name != nil {
4177		ok := object.Key("name")
4178		ok.String(*v.Name)
4179	}
4180
4181	if v.Tags != nil {
4182		ok := object.Key("tags")
4183		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4184			return err
4185		}
4186	}
4187
4188	return nil
4189}
4190
4191func awsAwsjson11_serializeOpDocumentPutOutcomeInput(v *PutOutcomeInput, value smithyjson.Value) error {
4192	object := value.Object()
4193	defer object.Close()
4194
4195	if v.Description != nil {
4196		ok := object.Key("description")
4197		ok.String(*v.Description)
4198	}
4199
4200	if v.Name != nil {
4201		ok := object.Key("name")
4202		ok.String(*v.Name)
4203	}
4204
4205	if v.Tags != nil {
4206		ok := object.Key("tags")
4207		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4208			return err
4209		}
4210	}
4211
4212	return nil
4213}
4214
4215func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
4216	object := value.Object()
4217	defer object.Close()
4218
4219	if v.ResourceARN != nil {
4220		ok := object.Key("resourceARN")
4221		ok.String(*v.ResourceARN)
4222	}
4223
4224	if v.Tags != nil {
4225		ok := object.Key("tags")
4226		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4227			return err
4228		}
4229	}
4230
4231	return nil
4232}
4233
4234func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
4235	object := value.Object()
4236	defer object.Close()
4237
4238	if v.ResourceARN != nil {
4239		ok := object.Key("resourceARN")
4240		ok.String(*v.ResourceARN)
4241	}
4242
4243	if v.TagKeys != nil {
4244		ok := object.Key("tagKeys")
4245		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
4246			return err
4247		}
4248	}
4249
4250	return nil
4251}
4252
4253func awsAwsjson11_serializeOpDocumentUpdateDetectorVersionInput(v *UpdateDetectorVersionInput, value smithyjson.Value) error {
4254	object := value.Object()
4255	defer object.Close()
4256
4257	if v.Description != nil {
4258		ok := object.Key("description")
4259		ok.String(*v.Description)
4260	}
4261
4262	if v.DetectorId != nil {
4263		ok := object.Key("detectorId")
4264		ok.String(*v.DetectorId)
4265	}
4266
4267	if v.DetectorVersionId != nil {
4268		ok := object.Key("detectorVersionId")
4269		ok.String(*v.DetectorVersionId)
4270	}
4271
4272	if v.ExternalModelEndpoints != nil {
4273		ok := object.Key("externalModelEndpoints")
4274		if err := awsAwsjson11_serializeDocumentListOfStrings(v.ExternalModelEndpoints, ok); err != nil {
4275			return err
4276		}
4277	}
4278
4279	if v.ModelVersions != nil {
4280		ok := object.Key("modelVersions")
4281		if err := awsAwsjson11_serializeDocumentListOfModelVersions(v.ModelVersions, ok); err != nil {
4282			return err
4283		}
4284	}
4285
4286	if len(v.RuleExecutionMode) > 0 {
4287		ok := object.Key("ruleExecutionMode")
4288		ok.String(string(v.RuleExecutionMode))
4289	}
4290
4291	if v.Rules != nil {
4292		ok := object.Key("rules")
4293		if err := awsAwsjson11_serializeDocumentRuleList(v.Rules, ok); err != nil {
4294			return err
4295		}
4296	}
4297
4298	return nil
4299}
4300
4301func awsAwsjson11_serializeOpDocumentUpdateDetectorVersionMetadataInput(v *UpdateDetectorVersionMetadataInput, value smithyjson.Value) error {
4302	object := value.Object()
4303	defer object.Close()
4304
4305	if v.Description != nil {
4306		ok := object.Key("description")
4307		ok.String(*v.Description)
4308	}
4309
4310	if v.DetectorId != nil {
4311		ok := object.Key("detectorId")
4312		ok.String(*v.DetectorId)
4313	}
4314
4315	if v.DetectorVersionId != nil {
4316		ok := object.Key("detectorVersionId")
4317		ok.String(*v.DetectorVersionId)
4318	}
4319
4320	return nil
4321}
4322
4323func awsAwsjson11_serializeOpDocumentUpdateDetectorVersionStatusInput(v *UpdateDetectorVersionStatusInput, value smithyjson.Value) error {
4324	object := value.Object()
4325	defer object.Close()
4326
4327	if v.DetectorId != nil {
4328		ok := object.Key("detectorId")
4329		ok.String(*v.DetectorId)
4330	}
4331
4332	if v.DetectorVersionId != nil {
4333		ok := object.Key("detectorVersionId")
4334		ok.String(*v.DetectorVersionId)
4335	}
4336
4337	if len(v.Status) > 0 {
4338		ok := object.Key("status")
4339		ok.String(string(v.Status))
4340	}
4341
4342	return nil
4343}
4344
4345func awsAwsjson11_serializeOpDocumentUpdateModelInput(v *UpdateModelInput, value smithyjson.Value) error {
4346	object := value.Object()
4347	defer object.Close()
4348
4349	if v.Description != nil {
4350		ok := object.Key("description")
4351		ok.String(*v.Description)
4352	}
4353
4354	if v.ModelId != nil {
4355		ok := object.Key("modelId")
4356		ok.String(*v.ModelId)
4357	}
4358
4359	if len(v.ModelType) > 0 {
4360		ok := object.Key("modelType")
4361		ok.String(string(v.ModelType))
4362	}
4363
4364	return nil
4365}
4366
4367func awsAwsjson11_serializeOpDocumentUpdateModelVersionInput(v *UpdateModelVersionInput, value smithyjson.Value) error {
4368	object := value.Object()
4369	defer object.Close()
4370
4371	if v.ExternalEventsDetail != nil {
4372		ok := object.Key("externalEventsDetail")
4373		if err := awsAwsjson11_serializeDocumentExternalEventsDetail(v.ExternalEventsDetail, ok); err != nil {
4374			return err
4375		}
4376	}
4377
4378	if v.MajorVersionNumber != nil {
4379		ok := object.Key("majorVersionNumber")
4380		ok.String(*v.MajorVersionNumber)
4381	}
4382
4383	if v.ModelId != nil {
4384		ok := object.Key("modelId")
4385		ok.String(*v.ModelId)
4386	}
4387
4388	if len(v.ModelType) > 0 {
4389		ok := object.Key("modelType")
4390		ok.String(string(v.ModelType))
4391	}
4392
4393	if v.Tags != nil {
4394		ok := object.Key("tags")
4395		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4396			return err
4397		}
4398	}
4399
4400	return nil
4401}
4402
4403func awsAwsjson11_serializeOpDocumentUpdateModelVersionStatusInput(v *UpdateModelVersionStatusInput, value smithyjson.Value) error {
4404	object := value.Object()
4405	defer object.Close()
4406
4407	if v.ModelId != nil {
4408		ok := object.Key("modelId")
4409		ok.String(*v.ModelId)
4410	}
4411
4412	if len(v.ModelType) > 0 {
4413		ok := object.Key("modelType")
4414		ok.String(string(v.ModelType))
4415	}
4416
4417	if v.ModelVersionNumber != nil {
4418		ok := object.Key("modelVersionNumber")
4419		ok.String(*v.ModelVersionNumber)
4420	}
4421
4422	if len(v.Status) > 0 {
4423		ok := object.Key("status")
4424		ok.String(string(v.Status))
4425	}
4426
4427	return nil
4428}
4429
4430func awsAwsjson11_serializeOpDocumentUpdateRuleMetadataInput(v *UpdateRuleMetadataInput, value smithyjson.Value) error {
4431	object := value.Object()
4432	defer object.Close()
4433
4434	if v.Description != nil {
4435		ok := object.Key("description")
4436		ok.String(*v.Description)
4437	}
4438
4439	if v.Rule != nil {
4440		ok := object.Key("rule")
4441		if err := awsAwsjson11_serializeDocumentRule(v.Rule, ok); err != nil {
4442			return err
4443		}
4444	}
4445
4446	return nil
4447}
4448
4449func awsAwsjson11_serializeOpDocumentUpdateRuleVersionInput(v *UpdateRuleVersionInput, value smithyjson.Value) error {
4450	object := value.Object()
4451	defer object.Close()
4452
4453	if v.Description != nil {
4454		ok := object.Key("description")
4455		ok.String(*v.Description)
4456	}
4457
4458	if v.Expression != nil {
4459		ok := object.Key("expression")
4460		ok.String(*v.Expression)
4461	}
4462
4463	if len(v.Language) > 0 {
4464		ok := object.Key("language")
4465		ok.String(string(v.Language))
4466	}
4467
4468	if v.Outcomes != nil {
4469		ok := object.Key("outcomes")
4470		if err := awsAwsjson11_serializeDocumentNonEmptyListOfStrings(v.Outcomes, ok); err != nil {
4471			return err
4472		}
4473	}
4474
4475	if v.Rule != nil {
4476		ok := object.Key("rule")
4477		if err := awsAwsjson11_serializeDocumentRule(v.Rule, ok); err != nil {
4478			return err
4479		}
4480	}
4481
4482	if v.Tags != nil {
4483		ok := object.Key("tags")
4484		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
4485			return err
4486		}
4487	}
4488
4489	return nil
4490}
4491
4492func awsAwsjson11_serializeOpDocumentUpdateVariableInput(v *UpdateVariableInput, value smithyjson.Value) error {
4493	object := value.Object()
4494	defer object.Close()
4495
4496	if v.DefaultValue != nil {
4497		ok := object.Key("defaultValue")
4498		ok.String(*v.DefaultValue)
4499	}
4500
4501	if v.Description != nil {
4502		ok := object.Key("description")
4503		ok.String(*v.Description)
4504	}
4505
4506	if v.Name != nil {
4507		ok := object.Key("name")
4508		ok.String(*v.Name)
4509	}
4510
4511	if v.VariableType != nil {
4512		ok := object.Key("variableType")
4513		ok.String(*v.VariableType)
4514	}
4515
4516	return nil
4517}
4518