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