1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package guardduty
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/guardduty/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsRestjson1_serializeOpAcceptInvitation struct {
18}
19
20func (*awsRestjson1_serializeOpAcceptInvitation) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpAcceptInvitation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*AcceptInvitationInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/master")
39	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
40	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
41	request.Method = "POST"
42	restEncoder, 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
47	if err := awsRestjson1_serializeOpHttpBindingsAcceptInvitationInput(input, restEncoder); err != nil {
48		return out, metadata, &smithy.SerializationError{Err: err}
49	}
50
51	restEncoder.SetHeader("Content-Type").String("application/json")
52
53	jsonEncoder := smithyjson.NewEncoder()
54	if err := awsRestjson1_serializeOpDocumentAcceptInvitationInput(input, jsonEncoder.Value); err != nil {
55		return out, metadata, &smithy.SerializationError{Err: err}
56	}
57
58	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
59		return out, metadata, &smithy.SerializationError{Err: err}
60	}
61
62	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
63		return out, metadata, &smithy.SerializationError{Err: err}
64	}
65	in.Request = request
66
67	return next.HandleSerialize(ctx, in)
68}
69func awsRestjson1_serializeOpHttpBindingsAcceptInvitationInput(v *AcceptInvitationInput, encoder *httpbinding.Encoder) error {
70	if v == nil {
71		return fmt.Errorf("unsupported serialization of nil %T", v)
72	}
73
74	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
75		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
76	}
77	if v.DetectorId != nil {
78		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
79			return err
80		}
81	}
82
83	return nil
84}
85
86func awsRestjson1_serializeOpDocumentAcceptInvitationInput(v *AcceptInvitationInput, value smithyjson.Value) error {
87	object := value.Object()
88	defer object.Close()
89
90	if v.InvitationId != nil {
91		ok := object.Key("invitationId")
92		ok.String(*v.InvitationId)
93	}
94
95	if v.MasterId != nil {
96		ok := object.Key("masterId")
97		ok.String(*v.MasterId)
98	}
99
100	return nil
101}
102
103type awsRestjson1_serializeOpArchiveFindings struct {
104}
105
106func (*awsRestjson1_serializeOpArchiveFindings) ID() string {
107	return "OperationSerializer"
108}
109
110func (m *awsRestjson1_serializeOpArchiveFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
111	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
112) {
113	request, ok := in.Request.(*smithyhttp.Request)
114	if !ok {
115		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
116	}
117
118	input, ok := in.Parameters.(*ArchiveFindingsInput)
119	_ = input
120	if !ok {
121		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
122	}
123
124	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/archive")
125	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
126	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
127	request.Method = "POST"
128	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
129	if err != nil {
130		return out, metadata, &smithy.SerializationError{Err: err}
131	}
132
133	if err := awsRestjson1_serializeOpHttpBindingsArchiveFindingsInput(input, restEncoder); err != nil {
134		return out, metadata, &smithy.SerializationError{Err: err}
135	}
136
137	restEncoder.SetHeader("Content-Type").String("application/json")
138
139	jsonEncoder := smithyjson.NewEncoder()
140	if err := awsRestjson1_serializeOpDocumentArchiveFindingsInput(input, jsonEncoder.Value); err != nil {
141		return out, metadata, &smithy.SerializationError{Err: err}
142	}
143
144	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
145		return out, metadata, &smithy.SerializationError{Err: err}
146	}
147
148	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
149		return out, metadata, &smithy.SerializationError{Err: err}
150	}
151	in.Request = request
152
153	return next.HandleSerialize(ctx, in)
154}
155func awsRestjson1_serializeOpHttpBindingsArchiveFindingsInput(v *ArchiveFindingsInput, encoder *httpbinding.Encoder) error {
156	if v == nil {
157		return fmt.Errorf("unsupported serialization of nil %T", v)
158	}
159
160	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
161		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
162	}
163	if v.DetectorId != nil {
164		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
165			return err
166		}
167	}
168
169	return nil
170}
171
172func awsRestjson1_serializeOpDocumentArchiveFindingsInput(v *ArchiveFindingsInput, value smithyjson.Value) error {
173	object := value.Object()
174	defer object.Close()
175
176	if v.FindingIds != nil {
177		ok := object.Key("findingIds")
178		if err := awsRestjson1_serializeDocumentFindingIds(v.FindingIds, ok); err != nil {
179			return err
180		}
181	}
182
183	return nil
184}
185
186type awsRestjson1_serializeOpCreateDetector struct {
187}
188
189func (*awsRestjson1_serializeOpCreateDetector) ID() string {
190	return "OperationSerializer"
191}
192
193func (m *awsRestjson1_serializeOpCreateDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
194	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
195) {
196	request, ok := in.Request.(*smithyhttp.Request)
197	if !ok {
198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
199	}
200
201	input, ok := in.Parameters.(*CreateDetectorInput)
202	_ = input
203	if !ok {
204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
205	}
206
207	opPath, opQuery := httpbinding.SplitURI("/detector")
208	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
209	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
210	request.Method = "POST"
211	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
212	if err != nil {
213		return out, metadata, &smithy.SerializationError{Err: err}
214	}
215
216	restEncoder.SetHeader("Content-Type").String("application/json")
217
218	jsonEncoder := smithyjson.NewEncoder()
219	if err := awsRestjson1_serializeOpDocumentCreateDetectorInput(input, jsonEncoder.Value); err != nil {
220		return out, metadata, &smithy.SerializationError{Err: err}
221	}
222
223	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
224		return out, metadata, &smithy.SerializationError{Err: err}
225	}
226
227	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
228		return out, metadata, &smithy.SerializationError{Err: err}
229	}
230	in.Request = request
231
232	return next.HandleSerialize(ctx, in)
233}
234func awsRestjson1_serializeOpHttpBindingsCreateDetectorInput(v *CreateDetectorInput, encoder *httpbinding.Encoder) error {
235	if v == nil {
236		return fmt.Errorf("unsupported serialization of nil %T", v)
237	}
238
239	return nil
240}
241
242func awsRestjson1_serializeOpDocumentCreateDetectorInput(v *CreateDetectorInput, value smithyjson.Value) error {
243	object := value.Object()
244	defer object.Close()
245
246	if v.ClientToken != nil {
247		ok := object.Key("clientToken")
248		ok.String(*v.ClientToken)
249	}
250
251	if v.DataSources != nil {
252		ok := object.Key("dataSources")
253		if err := awsRestjson1_serializeDocumentDataSourceConfigurations(v.DataSources, ok); err != nil {
254			return err
255		}
256	}
257
258	{
259		ok := object.Key("enable")
260		ok.Boolean(v.Enable)
261	}
262
263	if len(v.FindingPublishingFrequency) > 0 {
264		ok := object.Key("findingPublishingFrequency")
265		ok.String(string(v.FindingPublishingFrequency))
266	}
267
268	if v.Tags != nil {
269		ok := object.Key("tags")
270		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
271			return err
272		}
273	}
274
275	return nil
276}
277
278type awsRestjson1_serializeOpCreateFilter struct {
279}
280
281func (*awsRestjson1_serializeOpCreateFilter) ID() string {
282	return "OperationSerializer"
283}
284
285func (m *awsRestjson1_serializeOpCreateFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
286	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
287) {
288	request, ok := in.Request.(*smithyhttp.Request)
289	if !ok {
290		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
291	}
292
293	input, ok := in.Parameters.(*CreateFilterInput)
294	_ = input
295	if !ok {
296		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
297	}
298
299	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/filter")
300	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
301	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
302	request.Method = "POST"
303	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
304	if err != nil {
305		return out, metadata, &smithy.SerializationError{Err: err}
306	}
307
308	if err := awsRestjson1_serializeOpHttpBindingsCreateFilterInput(input, restEncoder); err != nil {
309		return out, metadata, &smithy.SerializationError{Err: err}
310	}
311
312	restEncoder.SetHeader("Content-Type").String("application/json")
313
314	jsonEncoder := smithyjson.NewEncoder()
315	if err := awsRestjson1_serializeOpDocumentCreateFilterInput(input, jsonEncoder.Value); err != nil {
316		return out, metadata, &smithy.SerializationError{Err: err}
317	}
318
319	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
320		return out, metadata, &smithy.SerializationError{Err: err}
321	}
322
323	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
324		return out, metadata, &smithy.SerializationError{Err: err}
325	}
326	in.Request = request
327
328	return next.HandleSerialize(ctx, in)
329}
330func awsRestjson1_serializeOpHttpBindingsCreateFilterInput(v *CreateFilterInput, encoder *httpbinding.Encoder) error {
331	if v == nil {
332		return fmt.Errorf("unsupported serialization of nil %T", v)
333	}
334
335	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
336		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
337	}
338	if v.DetectorId != nil {
339		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
340			return err
341		}
342	}
343
344	return nil
345}
346
347func awsRestjson1_serializeOpDocumentCreateFilterInput(v *CreateFilterInput, value smithyjson.Value) error {
348	object := value.Object()
349	defer object.Close()
350
351	if len(v.Action) > 0 {
352		ok := object.Key("action")
353		ok.String(string(v.Action))
354	}
355
356	if v.ClientToken != nil {
357		ok := object.Key("clientToken")
358		ok.String(*v.ClientToken)
359	}
360
361	if v.Description != nil {
362		ok := object.Key("description")
363		ok.String(*v.Description)
364	}
365
366	if v.FindingCriteria != nil {
367		ok := object.Key("findingCriteria")
368		if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil {
369			return err
370		}
371	}
372
373	if v.Name != nil {
374		ok := object.Key("name")
375		ok.String(*v.Name)
376	}
377
378	if v.Rank != 0 {
379		ok := object.Key("rank")
380		ok.Integer(v.Rank)
381	}
382
383	if v.Tags != nil {
384		ok := object.Key("tags")
385		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
386			return err
387		}
388	}
389
390	return nil
391}
392
393type awsRestjson1_serializeOpCreateIPSet struct {
394}
395
396func (*awsRestjson1_serializeOpCreateIPSet) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsRestjson1_serializeOpCreateIPSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
401	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
402) {
403	request, ok := in.Request.(*smithyhttp.Request)
404	if !ok {
405		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
406	}
407
408	input, ok := in.Parameters.(*CreateIPSetInput)
409	_ = input
410	if !ok {
411		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
412	}
413
414	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/ipset")
415	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
416	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
417	request.Method = "POST"
418	restEncoder, 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
423	if err := awsRestjson1_serializeOpHttpBindingsCreateIPSetInput(input, restEncoder); err != nil {
424		return out, metadata, &smithy.SerializationError{Err: err}
425	}
426
427	restEncoder.SetHeader("Content-Type").String("application/json")
428
429	jsonEncoder := smithyjson.NewEncoder()
430	if err := awsRestjson1_serializeOpDocumentCreateIPSetInput(input, jsonEncoder.Value); err != nil {
431		return out, metadata, &smithy.SerializationError{Err: err}
432	}
433
434	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
435		return out, metadata, &smithy.SerializationError{Err: err}
436	}
437
438	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
439		return out, metadata, &smithy.SerializationError{Err: err}
440	}
441	in.Request = request
442
443	return next.HandleSerialize(ctx, in)
444}
445func awsRestjson1_serializeOpHttpBindingsCreateIPSetInput(v *CreateIPSetInput, encoder *httpbinding.Encoder) error {
446	if v == nil {
447		return fmt.Errorf("unsupported serialization of nil %T", v)
448	}
449
450	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
451		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
452	}
453	if v.DetectorId != nil {
454		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
455			return err
456		}
457	}
458
459	return nil
460}
461
462func awsRestjson1_serializeOpDocumentCreateIPSetInput(v *CreateIPSetInput, value smithyjson.Value) error {
463	object := value.Object()
464	defer object.Close()
465
466	{
467		ok := object.Key("activate")
468		ok.Boolean(v.Activate)
469	}
470
471	if v.ClientToken != nil {
472		ok := object.Key("clientToken")
473		ok.String(*v.ClientToken)
474	}
475
476	if len(v.Format) > 0 {
477		ok := object.Key("format")
478		ok.String(string(v.Format))
479	}
480
481	if v.Location != nil {
482		ok := object.Key("location")
483		ok.String(*v.Location)
484	}
485
486	if v.Name != nil {
487		ok := object.Key("name")
488		ok.String(*v.Name)
489	}
490
491	if v.Tags != nil {
492		ok := object.Key("tags")
493		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
494			return err
495		}
496	}
497
498	return nil
499}
500
501type awsRestjson1_serializeOpCreateMembers struct {
502}
503
504func (*awsRestjson1_serializeOpCreateMembers) ID() string {
505	return "OperationSerializer"
506}
507
508func (m *awsRestjson1_serializeOpCreateMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
509	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
510) {
511	request, ok := in.Request.(*smithyhttp.Request)
512	if !ok {
513		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
514	}
515
516	input, ok := in.Parameters.(*CreateMembersInput)
517	_ = input
518	if !ok {
519		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
520	}
521
522	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member")
523	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
524	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
525	request.Method = "POST"
526	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
527	if err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530
531	if err := awsRestjson1_serializeOpHttpBindingsCreateMembersInput(input, restEncoder); err != nil {
532		return out, metadata, &smithy.SerializationError{Err: err}
533	}
534
535	restEncoder.SetHeader("Content-Type").String("application/json")
536
537	jsonEncoder := smithyjson.NewEncoder()
538	if err := awsRestjson1_serializeOpDocumentCreateMembersInput(input, jsonEncoder.Value); err != nil {
539		return out, metadata, &smithy.SerializationError{Err: err}
540	}
541
542	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
543		return out, metadata, &smithy.SerializationError{Err: err}
544	}
545
546	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
547		return out, metadata, &smithy.SerializationError{Err: err}
548	}
549	in.Request = request
550
551	return next.HandleSerialize(ctx, in)
552}
553func awsRestjson1_serializeOpHttpBindingsCreateMembersInput(v *CreateMembersInput, encoder *httpbinding.Encoder) error {
554	if v == nil {
555		return fmt.Errorf("unsupported serialization of nil %T", v)
556	}
557
558	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
559		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
560	}
561	if v.DetectorId != nil {
562		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
563			return err
564		}
565	}
566
567	return nil
568}
569
570func awsRestjson1_serializeOpDocumentCreateMembersInput(v *CreateMembersInput, value smithyjson.Value) error {
571	object := value.Object()
572	defer object.Close()
573
574	if v.AccountDetails != nil {
575		ok := object.Key("accountDetails")
576		if err := awsRestjson1_serializeDocumentAccountDetails(v.AccountDetails, ok); err != nil {
577			return err
578		}
579	}
580
581	return nil
582}
583
584type awsRestjson1_serializeOpCreatePublishingDestination struct {
585}
586
587func (*awsRestjson1_serializeOpCreatePublishingDestination) ID() string {
588	return "OperationSerializer"
589}
590
591func (m *awsRestjson1_serializeOpCreatePublishingDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
592	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
593) {
594	request, ok := in.Request.(*smithyhttp.Request)
595	if !ok {
596		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
597	}
598
599	input, ok := in.Parameters.(*CreatePublishingDestinationInput)
600	_ = input
601	if !ok {
602		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
603	}
604
605	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/publishingDestination")
606	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
607	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
608	request.Method = "POST"
609	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
610	if err != nil {
611		return out, metadata, &smithy.SerializationError{Err: err}
612	}
613
614	if err := awsRestjson1_serializeOpHttpBindingsCreatePublishingDestinationInput(input, restEncoder); err != nil {
615		return out, metadata, &smithy.SerializationError{Err: err}
616	}
617
618	restEncoder.SetHeader("Content-Type").String("application/json")
619
620	jsonEncoder := smithyjson.NewEncoder()
621	if err := awsRestjson1_serializeOpDocumentCreatePublishingDestinationInput(input, jsonEncoder.Value); err != nil {
622		return out, metadata, &smithy.SerializationError{Err: err}
623	}
624
625	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
626		return out, metadata, &smithy.SerializationError{Err: err}
627	}
628
629	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
630		return out, metadata, &smithy.SerializationError{Err: err}
631	}
632	in.Request = request
633
634	return next.HandleSerialize(ctx, in)
635}
636func awsRestjson1_serializeOpHttpBindingsCreatePublishingDestinationInput(v *CreatePublishingDestinationInput, encoder *httpbinding.Encoder) error {
637	if v == nil {
638		return fmt.Errorf("unsupported serialization of nil %T", v)
639	}
640
641	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
642		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
643	}
644	if v.DetectorId != nil {
645		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
646			return err
647		}
648	}
649
650	return nil
651}
652
653func awsRestjson1_serializeOpDocumentCreatePublishingDestinationInput(v *CreatePublishingDestinationInput, value smithyjson.Value) error {
654	object := value.Object()
655	defer object.Close()
656
657	if v.ClientToken != nil {
658		ok := object.Key("clientToken")
659		ok.String(*v.ClientToken)
660	}
661
662	if v.DestinationProperties != nil {
663		ok := object.Key("destinationProperties")
664		if err := awsRestjson1_serializeDocumentDestinationProperties(v.DestinationProperties, ok); err != nil {
665			return err
666		}
667	}
668
669	if len(v.DestinationType) > 0 {
670		ok := object.Key("destinationType")
671		ok.String(string(v.DestinationType))
672	}
673
674	return nil
675}
676
677type awsRestjson1_serializeOpCreateSampleFindings struct {
678}
679
680func (*awsRestjson1_serializeOpCreateSampleFindings) ID() string {
681	return "OperationSerializer"
682}
683
684func (m *awsRestjson1_serializeOpCreateSampleFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
685	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
686) {
687	request, ok := in.Request.(*smithyhttp.Request)
688	if !ok {
689		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
690	}
691
692	input, ok := in.Parameters.(*CreateSampleFindingsInput)
693	_ = input
694	if !ok {
695		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
696	}
697
698	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/create")
699	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
700	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
701	request.Method = "POST"
702	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
703	if err != nil {
704		return out, metadata, &smithy.SerializationError{Err: err}
705	}
706
707	if err := awsRestjson1_serializeOpHttpBindingsCreateSampleFindingsInput(input, restEncoder); err != nil {
708		return out, metadata, &smithy.SerializationError{Err: err}
709	}
710
711	restEncoder.SetHeader("Content-Type").String("application/json")
712
713	jsonEncoder := smithyjson.NewEncoder()
714	if err := awsRestjson1_serializeOpDocumentCreateSampleFindingsInput(input, jsonEncoder.Value); err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717
718	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
719		return out, metadata, &smithy.SerializationError{Err: err}
720	}
721
722	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
723		return out, metadata, &smithy.SerializationError{Err: err}
724	}
725	in.Request = request
726
727	return next.HandleSerialize(ctx, in)
728}
729func awsRestjson1_serializeOpHttpBindingsCreateSampleFindingsInput(v *CreateSampleFindingsInput, encoder *httpbinding.Encoder) error {
730	if v == nil {
731		return fmt.Errorf("unsupported serialization of nil %T", v)
732	}
733
734	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
735		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
736	}
737	if v.DetectorId != nil {
738		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
739			return err
740		}
741	}
742
743	return nil
744}
745
746func awsRestjson1_serializeOpDocumentCreateSampleFindingsInput(v *CreateSampleFindingsInput, value smithyjson.Value) error {
747	object := value.Object()
748	defer object.Close()
749
750	if v.FindingTypes != nil {
751		ok := object.Key("findingTypes")
752		if err := awsRestjson1_serializeDocumentFindingTypes(v.FindingTypes, ok); err != nil {
753			return err
754		}
755	}
756
757	return nil
758}
759
760type awsRestjson1_serializeOpCreateThreatIntelSet struct {
761}
762
763func (*awsRestjson1_serializeOpCreateThreatIntelSet) ID() string {
764	return "OperationSerializer"
765}
766
767func (m *awsRestjson1_serializeOpCreateThreatIntelSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
768	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
769) {
770	request, ok := in.Request.(*smithyhttp.Request)
771	if !ok {
772		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
773	}
774
775	input, ok := in.Parameters.(*CreateThreatIntelSetInput)
776	_ = input
777	if !ok {
778		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
779	}
780
781	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/threatintelset")
782	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
783	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
784	request.Method = "POST"
785	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
786	if err != nil {
787		return out, metadata, &smithy.SerializationError{Err: err}
788	}
789
790	if err := awsRestjson1_serializeOpHttpBindingsCreateThreatIntelSetInput(input, restEncoder); err != nil {
791		return out, metadata, &smithy.SerializationError{Err: err}
792	}
793
794	restEncoder.SetHeader("Content-Type").String("application/json")
795
796	jsonEncoder := smithyjson.NewEncoder()
797	if err := awsRestjson1_serializeOpDocumentCreateThreatIntelSetInput(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 = restEncoder.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}
812func awsRestjson1_serializeOpHttpBindingsCreateThreatIntelSetInput(v *CreateThreatIntelSetInput, encoder *httpbinding.Encoder) error {
813	if v == nil {
814		return fmt.Errorf("unsupported serialization of nil %T", v)
815	}
816
817	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
818		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
819	}
820	if v.DetectorId != nil {
821		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
822			return err
823		}
824	}
825
826	return nil
827}
828
829func awsRestjson1_serializeOpDocumentCreateThreatIntelSetInput(v *CreateThreatIntelSetInput, value smithyjson.Value) error {
830	object := value.Object()
831	defer object.Close()
832
833	{
834		ok := object.Key("activate")
835		ok.Boolean(v.Activate)
836	}
837
838	if v.ClientToken != nil {
839		ok := object.Key("clientToken")
840		ok.String(*v.ClientToken)
841	}
842
843	if len(v.Format) > 0 {
844		ok := object.Key("format")
845		ok.String(string(v.Format))
846	}
847
848	if v.Location != nil {
849		ok := object.Key("location")
850		ok.String(*v.Location)
851	}
852
853	if v.Name != nil {
854		ok := object.Key("name")
855		ok.String(*v.Name)
856	}
857
858	if v.Tags != nil {
859		ok := object.Key("tags")
860		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
861			return err
862		}
863	}
864
865	return nil
866}
867
868type awsRestjson1_serializeOpDeclineInvitations struct {
869}
870
871func (*awsRestjson1_serializeOpDeclineInvitations) ID() string {
872	return "OperationSerializer"
873}
874
875func (m *awsRestjson1_serializeOpDeclineInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
876	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
877) {
878	request, ok := in.Request.(*smithyhttp.Request)
879	if !ok {
880		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
881	}
882
883	input, ok := in.Parameters.(*DeclineInvitationsInput)
884	_ = input
885	if !ok {
886		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
887	}
888
889	opPath, opQuery := httpbinding.SplitURI("/invitation/decline")
890	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
891	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
892	request.Method = "POST"
893	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
894	if err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897
898	restEncoder.SetHeader("Content-Type").String("application/json")
899
900	jsonEncoder := smithyjson.NewEncoder()
901	if err := awsRestjson1_serializeOpDocumentDeclineInvitationsInput(input, jsonEncoder.Value); err != nil {
902		return out, metadata, &smithy.SerializationError{Err: err}
903	}
904
905	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
906		return out, metadata, &smithy.SerializationError{Err: err}
907	}
908
909	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
910		return out, metadata, &smithy.SerializationError{Err: err}
911	}
912	in.Request = request
913
914	return next.HandleSerialize(ctx, in)
915}
916func awsRestjson1_serializeOpHttpBindingsDeclineInvitationsInput(v *DeclineInvitationsInput, encoder *httpbinding.Encoder) error {
917	if v == nil {
918		return fmt.Errorf("unsupported serialization of nil %T", v)
919	}
920
921	return nil
922}
923
924func awsRestjson1_serializeOpDocumentDeclineInvitationsInput(v *DeclineInvitationsInput, value smithyjson.Value) error {
925	object := value.Object()
926	defer object.Close()
927
928	if v.AccountIds != nil {
929		ok := object.Key("accountIds")
930		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
931			return err
932		}
933	}
934
935	return nil
936}
937
938type awsRestjson1_serializeOpDeleteDetector struct {
939}
940
941func (*awsRestjson1_serializeOpDeleteDetector) ID() string {
942	return "OperationSerializer"
943}
944
945func (m *awsRestjson1_serializeOpDeleteDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
946	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
947) {
948	request, ok := in.Request.(*smithyhttp.Request)
949	if !ok {
950		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
951	}
952
953	input, ok := in.Parameters.(*DeleteDetectorInput)
954	_ = input
955	if !ok {
956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
957	}
958
959	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}")
960	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
961	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
962	request.Method = "DELETE"
963	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
964	if err != nil {
965		return out, metadata, &smithy.SerializationError{Err: err}
966	}
967
968	if err := awsRestjson1_serializeOpHttpBindingsDeleteDetectorInput(input, restEncoder); err != nil {
969		return out, metadata, &smithy.SerializationError{Err: err}
970	}
971
972	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
973		return out, metadata, &smithy.SerializationError{Err: err}
974	}
975	in.Request = request
976
977	return next.HandleSerialize(ctx, in)
978}
979func awsRestjson1_serializeOpHttpBindingsDeleteDetectorInput(v *DeleteDetectorInput, encoder *httpbinding.Encoder) error {
980	if v == nil {
981		return fmt.Errorf("unsupported serialization of nil %T", v)
982	}
983
984	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
985		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
986	}
987	if v.DetectorId != nil {
988		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
989			return err
990		}
991	}
992
993	return nil
994}
995
996type awsRestjson1_serializeOpDeleteFilter struct {
997}
998
999func (*awsRestjson1_serializeOpDeleteFilter) ID() string {
1000	return "OperationSerializer"
1001}
1002
1003func (m *awsRestjson1_serializeOpDeleteFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1004	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1005) {
1006	request, ok := in.Request.(*smithyhttp.Request)
1007	if !ok {
1008		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1009	}
1010
1011	input, ok := in.Parameters.(*DeleteFilterInput)
1012	_ = input
1013	if !ok {
1014		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1015	}
1016
1017	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/filter/{FilterName}")
1018	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1019	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1020	request.Method = "DELETE"
1021	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1022	if err != nil {
1023		return out, metadata, &smithy.SerializationError{Err: err}
1024	}
1025
1026	if err := awsRestjson1_serializeOpHttpBindingsDeleteFilterInput(input, restEncoder); err != nil {
1027		return out, metadata, &smithy.SerializationError{Err: err}
1028	}
1029
1030	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1031		return out, metadata, &smithy.SerializationError{Err: err}
1032	}
1033	in.Request = request
1034
1035	return next.HandleSerialize(ctx, in)
1036}
1037func awsRestjson1_serializeOpHttpBindingsDeleteFilterInput(v *DeleteFilterInput, encoder *httpbinding.Encoder) error {
1038	if v == nil {
1039		return fmt.Errorf("unsupported serialization of nil %T", v)
1040	}
1041
1042	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1043		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1044	}
1045	if v.DetectorId != nil {
1046		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1047			return err
1048		}
1049	}
1050
1051	if v.FilterName == nil || len(*v.FilterName) == 0 {
1052		return &smithy.SerializationError{Err: fmt.Errorf("input member FilterName must not be empty")}
1053	}
1054	if v.FilterName != nil {
1055		if err := encoder.SetURI("FilterName").String(*v.FilterName); err != nil {
1056			return err
1057		}
1058	}
1059
1060	return nil
1061}
1062
1063type awsRestjson1_serializeOpDeleteInvitations struct {
1064}
1065
1066func (*awsRestjson1_serializeOpDeleteInvitations) ID() string {
1067	return "OperationSerializer"
1068}
1069
1070func (m *awsRestjson1_serializeOpDeleteInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1071	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1072) {
1073	request, ok := in.Request.(*smithyhttp.Request)
1074	if !ok {
1075		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1076	}
1077
1078	input, ok := in.Parameters.(*DeleteInvitationsInput)
1079	_ = input
1080	if !ok {
1081		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1082	}
1083
1084	opPath, opQuery := httpbinding.SplitURI("/invitation/delete")
1085	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1086	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1087	request.Method = "POST"
1088	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1089	if err != nil {
1090		return out, metadata, &smithy.SerializationError{Err: err}
1091	}
1092
1093	restEncoder.SetHeader("Content-Type").String("application/json")
1094
1095	jsonEncoder := smithyjson.NewEncoder()
1096	if err := awsRestjson1_serializeOpDocumentDeleteInvitationsInput(input, jsonEncoder.Value); err != nil {
1097		return out, metadata, &smithy.SerializationError{Err: err}
1098	}
1099
1100	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1101		return out, metadata, &smithy.SerializationError{Err: err}
1102	}
1103
1104	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1105		return out, metadata, &smithy.SerializationError{Err: err}
1106	}
1107	in.Request = request
1108
1109	return next.HandleSerialize(ctx, in)
1110}
1111func awsRestjson1_serializeOpHttpBindingsDeleteInvitationsInput(v *DeleteInvitationsInput, encoder *httpbinding.Encoder) error {
1112	if v == nil {
1113		return fmt.Errorf("unsupported serialization of nil %T", v)
1114	}
1115
1116	return nil
1117}
1118
1119func awsRestjson1_serializeOpDocumentDeleteInvitationsInput(v *DeleteInvitationsInput, value smithyjson.Value) error {
1120	object := value.Object()
1121	defer object.Close()
1122
1123	if v.AccountIds != nil {
1124		ok := object.Key("accountIds")
1125		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
1126			return err
1127		}
1128	}
1129
1130	return nil
1131}
1132
1133type awsRestjson1_serializeOpDeleteIPSet struct {
1134}
1135
1136func (*awsRestjson1_serializeOpDeleteIPSet) ID() string {
1137	return "OperationSerializer"
1138}
1139
1140func (m *awsRestjson1_serializeOpDeleteIPSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1141	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	request, ok := in.Request.(*smithyhttp.Request)
1144	if !ok {
1145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1146	}
1147
1148	input, ok := in.Parameters.(*DeleteIPSetInput)
1149	_ = input
1150	if !ok {
1151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1152	}
1153
1154	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/ipset/{IpSetId}")
1155	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1156	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1157	request.Method = "DELETE"
1158	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1159	if err != nil {
1160		return out, metadata, &smithy.SerializationError{Err: err}
1161	}
1162
1163	if err := awsRestjson1_serializeOpHttpBindingsDeleteIPSetInput(input, restEncoder); err != nil {
1164		return out, metadata, &smithy.SerializationError{Err: err}
1165	}
1166
1167	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1168		return out, metadata, &smithy.SerializationError{Err: err}
1169	}
1170	in.Request = request
1171
1172	return next.HandleSerialize(ctx, in)
1173}
1174func awsRestjson1_serializeOpHttpBindingsDeleteIPSetInput(v *DeleteIPSetInput, encoder *httpbinding.Encoder) error {
1175	if v == nil {
1176		return fmt.Errorf("unsupported serialization of nil %T", v)
1177	}
1178
1179	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1180		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1181	}
1182	if v.DetectorId != nil {
1183		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1184			return err
1185		}
1186	}
1187
1188	if v.IpSetId == nil || len(*v.IpSetId) == 0 {
1189		return &smithy.SerializationError{Err: fmt.Errorf("input member IpSetId must not be empty")}
1190	}
1191	if v.IpSetId != nil {
1192		if err := encoder.SetURI("IpSetId").String(*v.IpSetId); err != nil {
1193			return err
1194		}
1195	}
1196
1197	return nil
1198}
1199
1200type awsRestjson1_serializeOpDeleteMembers struct {
1201}
1202
1203func (*awsRestjson1_serializeOpDeleteMembers) ID() string {
1204	return "OperationSerializer"
1205}
1206
1207func (m *awsRestjson1_serializeOpDeleteMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1208	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1209) {
1210	request, ok := in.Request.(*smithyhttp.Request)
1211	if !ok {
1212		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1213	}
1214
1215	input, ok := in.Parameters.(*DeleteMembersInput)
1216	_ = input
1217	if !ok {
1218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1219	}
1220
1221	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/delete")
1222	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1223	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1224	request.Method = "POST"
1225	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1226	if err != nil {
1227		return out, metadata, &smithy.SerializationError{Err: err}
1228	}
1229
1230	if err := awsRestjson1_serializeOpHttpBindingsDeleteMembersInput(input, restEncoder); err != nil {
1231		return out, metadata, &smithy.SerializationError{Err: err}
1232	}
1233
1234	restEncoder.SetHeader("Content-Type").String("application/json")
1235
1236	jsonEncoder := smithyjson.NewEncoder()
1237	if err := awsRestjson1_serializeOpDocumentDeleteMembersInput(input, jsonEncoder.Value); err != nil {
1238		return out, metadata, &smithy.SerializationError{Err: err}
1239	}
1240
1241	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1242		return out, metadata, &smithy.SerializationError{Err: err}
1243	}
1244
1245	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1246		return out, metadata, &smithy.SerializationError{Err: err}
1247	}
1248	in.Request = request
1249
1250	return next.HandleSerialize(ctx, in)
1251}
1252func awsRestjson1_serializeOpHttpBindingsDeleteMembersInput(v *DeleteMembersInput, encoder *httpbinding.Encoder) error {
1253	if v == nil {
1254		return fmt.Errorf("unsupported serialization of nil %T", v)
1255	}
1256
1257	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1258		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1259	}
1260	if v.DetectorId != nil {
1261		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1262			return err
1263		}
1264	}
1265
1266	return nil
1267}
1268
1269func awsRestjson1_serializeOpDocumentDeleteMembersInput(v *DeleteMembersInput, value smithyjson.Value) error {
1270	object := value.Object()
1271	defer object.Close()
1272
1273	if v.AccountIds != nil {
1274		ok := object.Key("accountIds")
1275		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
1276			return err
1277		}
1278	}
1279
1280	return nil
1281}
1282
1283type awsRestjson1_serializeOpDeletePublishingDestination struct {
1284}
1285
1286func (*awsRestjson1_serializeOpDeletePublishingDestination) ID() string {
1287	return "OperationSerializer"
1288}
1289
1290func (m *awsRestjson1_serializeOpDeletePublishingDestination) 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.(*DeletePublishingDestinationInput)
1299	_ = input
1300	if !ok {
1301		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1302	}
1303
1304	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/publishingDestination/{DestinationId}")
1305	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1306	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1307	request.Method = "DELETE"
1308	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1309	if err != nil {
1310		return out, metadata, &smithy.SerializationError{Err: err}
1311	}
1312
1313	if err := awsRestjson1_serializeOpHttpBindingsDeletePublishingDestinationInput(input, restEncoder); err != nil {
1314		return out, metadata, &smithy.SerializationError{Err: err}
1315	}
1316
1317	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320	in.Request = request
1321
1322	return next.HandleSerialize(ctx, in)
1323}
1324func awsRestjson1_serializeOpHttpBindingsDeletePublishingDestinationInput(v *DeletePublishingDestinationInput, encoder *httpbinding.Encoder) error {
1325	if v == nil {
1326		return fmt.Errorf("unsupported serialization of nil %T", v)
1327	}
1328
1329	if v.DestinationId == nil || len(*v.DestinationId) == 0 {
1330		return &smithy.SerializationError{Err: fmt.Errorf("input member DestinationId must not be empty")}
1331	}
1332	if v.DestinationId != nil {
1333		if err := encoder.SetURI("DestinationId").String(*v.DestinationId); err != nil {
1334			return err
1335		}
1336	}
1337
1338	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1339		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1340	}
1341	if v.DetectorId != nil {
1342		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1343			return err
1344		}
1345	}
1346
1347	return nil
1348}
1349
1350type awsRestjson1_serializeOpDeleteThreatIntelSet struct {
1351}
1352
1353func (*awsRestjson1_serializeOpDeleteThreatIntelSet) ID() string {
1354	return "OperationSerializer"
1355}
1356
1357func (m *awsRestjson1_serializeOpDeleteThreatIntelSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1358	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1359) {
1360	request, ok := in.Request.(*smithyhttp.Request)
1361	if !ok {
1362		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1363	}
1364
1365	input, ok := in.Parameters.(*DeleteThreatIntelSetInput)
1366	_ = input
1367	if !ok {
1368		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1369	}
1370
1371	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}")
1372	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1373	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1374	request.Method = "DELETE"
1375	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1376	if err != nil {
1377		return out, metadata, &smithy.SerializationError{Err: err}
1378	}
1379
1380	if err := awsRestjson1_serializeOpHttpBindingsDeleteThreatIntelSetInput(input, restEncoder); err != nil {
1381		return out, metadata, &smithy.SerializationError{Err: err}
1382	}
1383
1384	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1385		return out, metadata, &smithy.SerializationError{Err: err}
1386	}
1387	in.Request = request
1388
1389	return next.HandleSerialize(ctx, in)
1390}
1391func awsRestjson1_serializeOpHttpBindingsDeleteThreatIntelSetInput(v *DeleteThreatIntelSetInput, encoder *httpbinding.Encoder) error {
1392	if v == nil {
1393		return fmt.Errorf("unsupported serialization of nil %T", v)
1394	}
1395
1396	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1397		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1398	}
1399	if v.DetectorId != nil {
1400		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1401			return err
1402		}
1403	}
1404
1405	if v.ThreatIntelSetId == nil || len(*v.ThreatIntelSetId) == 0 {
1406		return &smithy.SerializationError{Err: fmt.Errorf("input member ThreatIntelSetId must not be empty")}
1407	}
1408	if v.ThreatIntelSetId != nil {
1409		if err := encoder.SetURI("ThreatIntelSetId").String(*v.ThreatIntelSetId); err != nil {
1410			return err
1411		}
1412	}
1413
1414	return nil
1415}
1416
1417type awsRestjson1_serializeOpDescribeOrganizationConfiguration struct {
1418}
1419
1420func (*awsRestjson1_serializeOpDescribeOrganizationConfiguration) ID() string {
1421	return "OperationSerializer"
1422}
1423
1424func (m *awsRestjson1_serializeOpDescribeOrganizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1425	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1426) {
1427	request, ok := in.Request.(*smithyhttp.Request)
1428	if !ok {
1429		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1430	}
1431
1432	input, ok := in.Parameters.(*DescribeOrganizationConfigurationInput)
1433	_ = input
1434	if !ok {
1435		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1436	}
1437
1438	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/admin")
1439	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1440	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1441	request.Method = "GET"
1442	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1443	if err != nil {
1444		return out, metadata, &smithy.SerializationError{Err: err}
1445	}
1446
1447	if err := awsRestjson1_serializeOpHttpBindingsDescribeOrganizationConfigurationInput(input, restEncoder); err != nil {
1448		return out, metadata, &smithy.SerializationError{Err: err}
1449	}
1450
1451	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	in.Request = request
1455
1456	return next.HandleSerialize(ctx, in)
1457}
1458func awsRestjson1_serializeOpHttpBindingsDescribeOrganizationConfigurationInput(v *DescribeOrganizationConfigurationInput, encoder *httpbinding.Encoder) error {
1459	if v == nil {
1460		return fmt.Errorf("unsupported serialization of nil %T", v)
1461	}
1462
1463	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1464		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1465	}
1466	if v.DetectorId != nil {
1467		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1468			return err
1469		}
1470	}
1471
1472	return nil
1473}
1474
1475type awsRestjson1_serializeOpDescribePublishingDestination struct {
1476}
1477
1478func (*awsRestjson1_serializeOpDescribePublishingDestination) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsRestjson1_serializeOpDescribePublishingDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1483	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1484) {
1485	request, ok := in.Request.(*smithyhttp.Request)
1486	if !ok {
1487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1488	}
1489
1490	input, ok := in.Parameters.(*DescribePublishingDestinationInput)
1491	_ = input
1492	if !ok {
1493		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1494	}
1495
1496	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/publishingDestination/{DestinationId}")
1497	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1498	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1499	request.Method = "GET"
1500	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1501	if err != nil {
1502		return out, metadata, &smithy.SerializationError{Err: err}
1503	}
1504
1505	if err := awsRestjson1_serializeOpHttpBindingsDescribePublishingDestinationInput(input, restEncoder); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512	in.Request = request
1513
1514	return next.HandleSerialize(ctx, in)
1515}
1516func awsRestjson1_serializeOpHttpBindingsDescribePublishingDestinationInput(v *DescribePublishingDestinationInput, encoder *httpbinding.Encoder) error {
1517	if v == nil {
1518		return fmt.Errorf("unsupported serialization of nil %T", v)
1519	}
1520
1521	if v.DestinationId == nil || len(*v.DestinationId) == 0 {
1522		return &smithy.SerializationError{Err: fmt.Errorf("input member DestinationId must not be empty")}
1523	}
1524	if v.DestinationId != nil {
1525		if err := encoder.SetURI("DestinationId").String(*v.DestinationId); err != nil {
1526			return err
1527		}
1528	}
1529
1530	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1531		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1532	}
1533	if v.DetectorId != nil {
1534		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1535			return err
1536		}
1537	}
1538
1539	return nil
1540}
1541
1542type awsRestjson1_serializeOpDisableOrganizationAdminAccount struct {
1543}
1544
1545func (*awsRestjson1_serializeOpDisableOrganizationAdminAccount) ID() string {
1546	return "OperationSerializer"
1547}
1548
1549func (m *awsRestjson1_serializeOpDisableOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1550	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1551) {
1552	request, ok := in.Request.(*smithyhttp.Request)
1553	if !ok {
1554		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1555	}
1556
1557	input, ok := in.Parameters.(*DisableOrganizationAdminAccountInput)
1558	_ = input
1559	if !ok {
1560		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1561	}
1562
1563	opPath, opQuery := httpbinding.SplitURI("/admin/disable")
1564	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1565	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1566	request.Method = "POST"
1567	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1568	if err != nil {
1569		return out, metadata, &smithy.SerializationError{Err: err}
1570	}
1571
1572	restEncoder.SetHeader("Content-Type").String("application/json")
1573
1574	jsonEncoder := smithyjson.NewEncoder()
1575	if err := awsRestjson1_serializeOpDocumentDisableOrganizationAdminAccountInput(input, jsonEncoder.Value); err != nil {
1576		return out, metadata, &smithy.SerializationError{Err: err}
1577	}
1578
1579	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1580		return out, metadata, &smithy.SerializationError{Err: err}
1581	}
1582
1583	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1584		return out, metadata, &smithy.SerializationError{Err: err}
1585	}
1586	in.Request = request
1587
1588	return next.HandleSerialize(ctx, in)
1589}
1590func awsRestjson1_serializeOpHttpBindingsDisableOrganizationAdminAccountInput(v *DisableOrganizationAdminAccountInput, encoder *httpbinding.Encoder) error {
1591	if v == nil {
1592		return fmt.Errorf("unsupported serialization of nil %T", v)
1593	}
1594
1595	return nil
1596}
1597
1598func awsRestjson1_serializeOpDocumentDisableOrganizationAdminAccountInput(v *DisableOrganizationAdminAccountInput, value smithyjson.Value) error {
1599	object := value.Object()
1600	defer object.Close()
1601
1602	if v.AdminAccountId != nil {
1603		ok := object.Key("adminAccountId")
1604		ok.String(*v.AdminAccountId)
1605	}
1606
1607	return nil
1608}
1609
1610type awsRestjson1_serializeOpDisassociateFromMasterAccount struct {
1611}
1612
1613func (*awsRestjson1_serializeOpDisassociateFromMasterAccount) ID() string {
1614	return "OperationSerializer"
1615}
1616
1617func (m *awsRestjson1_serializeOpDisassociateFromMasterAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1618	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1619) {
1620	request, ok := in.Request.(*smithyhttp.Request)
1621	if !ok {
1622		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1623	}
1624
1625	input, ok := in.Parameters.(*DisassociateFromMasterAccountInput)
1626	_ = input
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1629	}
1630
1631	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/master/disassociate")
1632	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1633	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1634	request.Method = "POST"
1635	restEncoder, 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
1640	if err := awsRestjson1_serializeOpHttpBindingsDisassociateFromMasterAccountInput(input, restEncoder); err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643
1644	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1645		return out, metadata, &smithy.SerializationError{Err: err}
1646	}
1647	in.Request = request
1648
1649	return next.HandleSerialize(ctx, in)
1650}
1651func awsRestjson1_serializeOpHttpBindingsDisassociateFromMasterAccountInput(v *DisassociateFromMasterAccountInput, encoder *httpbinding.Encoder) error {
1652	if v == nil {
1653		return fmt.Errorf("unsupported serialization of nil %T", v)
1654	}
1655
1656	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1657		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1658	}
1659	if v.DetectorId != nil {
1660		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1661			return err
1662		}
1663	}
1664
1665	return nil
1666}
1667
1668type awsRestjson1_serializeOpDisassociateMembers struct {
1669}
1670
1671func (*awsRestjson1_serializeOpDisassociateMembers) ID() string {
1672	return "OperationSerializer"
1673}
1674
1675func (m *awsRestjson1_serializeOpDisassociateMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1676	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1677) {
1678	request, ok := in.Request.(*smithyhttp.Request)
1679	if !ok {
1680		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1681	}
1682
1683	input, ok := in.Parameters.(*DisassociateMembersInput)
1684	_ = input
1685	if !ok {
1686		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1687	}
1688
1689	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/disassociate")
1690	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1691	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1692	request.Method = "POST"
1693	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1694	if err != nil {
1695		return out, metadata, &smithy.SerializationError{Err: err}
1696	}
1697
1698	if err := awsRestjson1_serializeOpHttpBindingsDisassociateMembersInput(input, restEncoder); err != nil {
1699		return out, metadata, &smithy.SerializationError{Err: err}
1700	}
1701
1702	restEncoder.SetHeader("Content-Type").String("application/json")
1703
1704	jsonEncoder := smithyjson.NewEncoder()
1705	if err := awsRestjson1_serializeOpDocumentDisassociateMembersInput(input, jsonEncoder.Value); err != nil {
1706		return out, metadata, &smithy.SerializationError{Err: err}
1707	}
1708
1709	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1710		return out, metadata, &smithy.SerializationError{Err: err}
1711	}
1712
1713	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1714		return out, metadata, &smithy.SerializationError{Err: err}
1715	}
1716	in.Request = request
1717
1718	return next.HandleSerialize(ctx, in)
1719}
1720func awsRestjson1_serializeOpHttpBindingsDisassociateMembersInput(v *DisassociateMembersInput, encoder *httpbinding.Encoder) error {
1721	if v == nil {
1722		return fmt.Errorf("unsupported serialization of nil %T", v)
1723	}
1724
1725	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1726		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1727	}
1728	if v.DetectorId != nil {
1729		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1730			return err
1731		}
1732	}
1733
1734	return nil
1735}
1736
1737func awsRestjson1_serializeOpDocumentDisassociateMembersInput(v *DisassociateMembersInput, value smithyjson.Value) error {
1738	object := value.Object()
1739	defer object.Close()
1740
1741	if v.AccountIds != nil {
1742		ok := object.Key("accountIds")
1743		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
1744			return err
1745		}
1746	}
1747
1748	return nil
1749}
1750
1751type awsRestjson1_serializeOpEnableOrganizationAdminAccount struct {
1752}
1753
1754func (*awsRestjson1_serializeOpEnableOrganizationAdminAccount) ID() string {
1755	return "OperationSerializer"
1756}
1757
1758func (m *awsRestjson1_serializeOpEnableOrganizationAdminAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1759	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1760) {
1761	request, ok := in.Request.(*smithyhttp.Request)
1762	if !ok {
1763		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1764	}
1765
1766	input, ok := in.Parameters.(*EnableOrganizationAdminAccountInput)
1767	_ = input
1768	if !ok {
1769		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1770	}
1771
1772	opPath, opQuery := httpbinding.SplitURI("/admin/enable")
1773	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1774	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1775	request.Method = "POST"
1776	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1777	if err != nil {
1778		return out, metadata, &smithy.SerializationError{Err: err}
1779	}
1780
1781	restEncoder.SetHeader("Content-Type").String("application/json")
1782
1783	jsonEncoder := smithyjson.NewEncoder()
1784	if err := awsRestjson1_serializeOpDocumentEnableOrganizationAdminAccountInput(input, jsonEncoder.Value); err != nil {
1785		return out, metadata, &smithy.SerializationError{Err: err}
1786	}
1787
1788	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1789		return out, metadata, &smithy.SerializationError{Err: err}
1790	}
1791
1792	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1793		return out, metadata, &smithy.SerializationError{Err: err}
1794	}
1795	in.Request = request
1796
1797	return next.HandleSerialize(ctx, in)
1798}
1799func awsRestjson1_serializeOpHttpBindingsEnableOrganizationAdminAccountInput(v *EnableOrganizationAdminAccountInput, encoder *httpbinding.Encoder) error {
1800	if v == nil {
1801		return fmt.Errorf("unsupported serialization of nil %T", v)
1802	}
1803
1804	return nil
1805}
1806
1807func awsRestjson1_serializeOpDocumentEnableOrganizationAdminAccountInput(v *EnableOrganizationAdminAccountInput, value smithyjson.Value) error {
1808	object := value.Object()
1809	defer object.Close()
1810
1811	if v.AdminAccountId != nil {
1812		ok := object.Key("adminAccountId")
1813		ok.String(*v.AdminAccountId)
1814	}
1815
1816	return nil
1817}
1818
1819type awsRestjson1_serializeOpGetDetector struct {
1820}
1821
1822func (*awsRestjson1_serializeOpGetDetector) ID() string {
1823	return "OperationSerializer"
1824}
1825
1826func (m *awsRestjson1_serializeOpGetDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1827	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1828) {
1829	request, ok := in.Request.(*smithyhttp.Request)
1830	if !ok {
1831		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1832	}
1833
1834	input, ok := in.Parameters.(*GetDetectorInput)
1835	_ = input
1836	if !ok {
1837		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1838	}
1839
1840	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}")
1841	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1842	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1843	request.Method = "GET"
1844	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1845	if err != nil {
1846		return out, metadata, &smithy.SerializationError{Err: err}
1847	}
1848
1849	if err := awsRestjson1_serializeOpHttpBindingsGetDetectorInput(input, restEncoder); err != nil {
1850		return out, metadata, &smithy.SerializationError{Err: err}
1851	}
1852
1853	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1854		return out, metadata, &smithy.SerializationError{Err: err}
1855	}
1856	in.Request = request
1857
1858	return next.HandleSerialize(ctx, in)
1859}
1860func awsRestjson1_serializeOpHttpBindingsGetDetectorInput(v *GetDetectorInput, encoder *httpbinding.Encoder) error {
1861	if v == nil {
1862		return fmt.Errorf("unsupported serialization of nil %T", v)
1863	}
1864
1865	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1866		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1867	}
1868	if v.DetectorId != nil {
1869		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1870			return err
1871		}
1872	}
1873
1874	return nil
1875}
1876
1877type awsRestjson1_serializeOpGetFilter struct {
1878}
1879
1880func (*awsRestjson1_serializeOpGetFilter) ID() string {
1881	return "OperationSerializer"
1882}
1883
1884func (m *awsRestjson1_serializeOpGetFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1885	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1886) {
1887	request, ok := in.Request.(*smithyhttp.Request)
1888	if !ok {
1889		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1890	}
1891
1892	input, ok := in.Parameters.(*GetFilterInput)
1893	_ = input
1894	if !ok {
1895		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1896	}
1897
1898	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/filter/{FilterName}")
1899	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1900	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1901	request.Method = "GET"
1902	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1903	if err != nil {
1904		return out, metadata, &smithy.SerializationError{Err: err}
1905	}
1906
1907	if err := awsRestjson1_serializeOpHttpBindingsGetFilterInput(input, restEncoder); err != nil {
1908		return out, metadata, &smithy.SerializationError{Err: err}
1909	}
1910
1911	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1912		return out, metadata, &smithy.SerializationError{Err: err}
1913	}
1914	in.Request = request
1915
1916	return next.HandleSerialize(ctx, in)
1917}
1918func awsRestjson1_serializeOpHttpBindingsGetFilterInput(v *GetFilterInput, encoder *httpbinding.Encoder) error {
1919	if v == nil {
1920		return fmt.Errorf("unsupported serialization of nil %T", v)
1921	}
1922
1923	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
1924		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
1925	}
1926	if v.DetectorId != nil {
1927		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
1928			return err
1929		}
1930	}
1931
1932	if v.FilterName == nil || len(*v.FilterName) == 0 {
1933		return &smithy.SerializationError{Err: fmt.Errorf("input member FilterName must not be empty")}
1934	}
1935	if v.FilterName != nil {
1936		if err := encoder.SetURI("FilterName").String(*v.FilterName); err != nil {
1937			return err
1938		}
1939	}
1940
1941	return nil
1942}
1943
1944type awsRestjson1_serializeOpGetFindings struct {
1945}
1946
1947func (*awsRestjson1_serializeOpGetFindings) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsRestjson1_serializeOpGetFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1952	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1953) {
1954	request, ok := in.Request.(*smithyhttp.Request)
1955	if !ok {
1956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1957	}
1958
1959	input, ok := in.Parameters.(*GetFindingsInput)
1960	_ = input
1961	if !ok {
1962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1963	}
1964
1965	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/get")
1966	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1967	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1968	request.Method = "POST"
1969	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1970	if err != nil {
1971		return out, metadata, &smithy.SerializationError{Err: err}
1972	}
1973
1974	if err := awsRestjson1_serializeOpHttpBindingsGetFindingsInput(input, restEncoder); err != nil {
1975		return out, metadata, &smithy.SerializationError{Err: err}
1976	}
1977
1978	restEncoder.SetHeader("Content-Type").String("application/json")
1979
1980	jsonEncoder := smithyjson.NewEncoder()
1981	if err := awsRestjson1_serializeOpDocumentGetFindingsInput(input, jsonEncoder.Value); err != nil {
1982		return out, metadata, &smithy.SerializationError{Err: err}
1983	}
1984
1985	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1986		return out, metadata, &smithy.SerializationError{Err: err}
1987	}
1988
1989	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1990		return out, metadata, &smithy.SerializationError{Err: err}
1991	}
1992	in.Request = request
1993
1994	return next.HandleSerialize(ctx, in)
1995}
1996func awsRestjson1_serializeOpHttpBindingsGetFindingsInput(v *GetFindingsInput, encoder *httpbinding.Encoder) error {
1997	if v == nil {
1998		return fmt.Errorf("unsupported serialization of nil %T", v)
1999	}
2000
2001	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2002		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2003	}
2004	if v.DetectorId != nil {
2005		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2006			return err
2007		}
2008	}
2009
2010	return nil
2011}
2012
2013func awsRestjson1_serializeOpDocumentGetFindingsInput(v *GetFindingsInput, value smithyjson.Value) error {
2014	object := value.Object()
2015	defer object.Close()
2016
2017	if v.FindingIds != nil {
2018		ok := object.Key("findingIds")
2019		if err := awsRestjson1_serializeDocumentFindingIds(v.FindingIds, ok); err != nil {
2020			return err
2021		}
2022	}
2023
2024	if v.SortCriteria != nil {
2025		ok := object.Key("sortCriteria")
2026		if err := awsRestjson1_serializeDocumentSortCriteria(v.SortCriteria, ok); err != nil {
2027			return err
2028		}
2029	}
2030
2031	return nil
2032}
2033
2034type awsRestjson1_serializeOpGetFindingsStatistics struct {
2035}
2036
2037func (*awsRestjson1_serializeOpGetFindingsStatistics) ID() string {
2038	return "OperationSerializer"
2039}
2040
2041func (m *awsRestjson1_serializeOpGetFindingsStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2042	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2043) {
2044	request, ok := in.Request.(*smithyhttp.Request)
2045	if !ok {
2046		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2047	}
2048
2049	input, ok := in.Parameters.(*GetFindingsStatisticsInput)
2050	_ = input
2051	if !ok {
2052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2053	}
2054
2055	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/statistics")
2056	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2057	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2058	request.Method = "POST"
2059	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2060	if err != nil {
2061		return out, metadata, &smithy.SerializationError{Err: err}
2062	}
2063
2064	if err := awsRestjson1_serializeOpHttpBindingsGetFindingsStatisticsInput(input, restEncoder); err != nil {
2065		return out, metadata, &smithy.SerializationError{Err: err}
2066	}
2067
2068	restEncoder.SetHeader("Content-Type").String("application/json")
2069
2070	jsonEncoder := smithyjson.NewEncoder()
2071	if err := awsRestjson1_serializeOpDocumentGetFindingsStatisticsInput(input, jsonEncoder.Value); err != nil {
2072		return out, metadata, &smithy.SerializationError{Err: err}
2073	}
2074
2075	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2076		return out, metadata, &smithy.SerializationError{Err: err}
2077	}
2078
2079	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2080		return out, metadata, &smithy.SerializationError{Err: err}
2081	}
2082	in.Request = request
2083
2084	return next.HandleSerialize(ctx, in)
2085}
2086func awsRestjson1_serializeOpHttpBindingsGetFindingsStatisticsInput(v *GetFindingsStatisticsInput, encoder *httpbinding.Encoder) error {
2087	if v == nil {
2088		return fmt.Errorf("unsupported serialization of nil %T", v)
2089	}
2090
2091	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2092		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2093	}
2094	if v.DetectorId != nil {
2095		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2096			return err
2097		}
2098	}
2099
2100	return nil
2101}
2102
2103func awsRestjson1_serializeOpDocumentGetFindingsStatisticsInput(v *GetFindingsStatisticsInput, value smithyjson.Value) error {
2104	object := value.Object()
2105	defer object.Close()
2106
2107	if v.FindingCriteria != nil {
2108		ok := object.Key("findingCriteria")
2109		if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil {
2110			return err
2111		}
2112	}
2113
2114	if v.FindingStatisticTypes != nil {
2115		ok := object.Key("findingStatisticTypes")
2116		if err := awsRestjson1_serializeDocumentFindingStatisticTypes(v.FindingStatisticTypes, ok); err != nil {
2117			return err
2118		}
2119	}
2120
2121	return nil
2122}
2123
2124type awsRestjson1_serializeOpGetInvitationsCount struct {
2125}
2126
2127func (*awsRestjson1_serializeOpGetInvitationsCount) ID() string {
2128	return "OperationSerializer"
2129}
2130
2131func (m *awsRestjson1_serializeOpGetInvitationsCount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2132	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2133) {
2134	request, ok := in.Request.(*smithyhttp.Request)
2135	if !ok {
2136		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2137	}
2138
2139	input, ok := in.Parameters.(*GetInvitationsCountInput)
2140	_ = input
2141	if !ok {
2142		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2143	}
2144
2145	opPath, opQuery := httpbinding.SplitURI("/invitation/count")
2146	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2147	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2148	request.Method = "GET"
2149	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2150	if err != nil {
2151		return out, metadata, &smithy.SerializationError{Err: err}
2152	}
2153
2154	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2155		return out, metadata, &smithy.SerializationError{Err: err}
2156	}
2157	in.Request = request
2158
2159	return next.HandleSerialize(ctx, in)
2160}
2161func awsRestjson1_serializeOpHttpBindingsGetInvitationsCountInput(v *GetInvitationsCountInput, encoder *httpbinding.Encoder) error {
2162	if v == nil {
2163		return fmt.Errorf("unsupported serialization of nil %T", v)
2164	}
2165
2166	return nil
2167}
2168
2169type awsRestjson1_serializeOpGetIPSet struct {
2170}
2171
2172func (*awsRestjson1_serializeOpGetIPSet) ID() string {
2173	return "OperationSerializer"
2174}
2175
2176func (m *awsRestjson1_serializeOpGetIPSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2177	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2178) {
2179	request, ok := in.Request.(*smithyhttp.Request)
2180	if !ok {
2181		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2182	}
2183
2184	input, ok := in.Parameters.(*GetIPSetInput)
2185	_ = input
2186	if !ok {
2187		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2188	}
2189
2190	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/ipset/{IpSetId}")
2191	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2192	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2193	request.Method = "GET"
2194	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2195	if err != nil {
2196		return out, metadata, &smithy.SerializationError{Err: err}
2197	}
2198
2199	if err := awsRestjson1_serializeOpHttpBindingsGetIPSetInput(input, restEncoder); err != nil {
2200		return out, metadata, &smithy.SerializationError{Err: err}
2201	}
2202
2203	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2204		return out, metadata, &smithy.SerializationError{Err: err}
2205	}
2206	in.Request = request
2207
2208	return next.HandleSerialize(ctx, in)
2209}
2210func awsRestjson1_serializeOpHttpBindingsGetIPSetInput(v *GetIPSetInput, encoder *httpbinding.Encoder) error {
2211	if v == nil {
2212		return fmt.Errorf("unsupported serialization of nil %T", v)
2213	}
2214
2215	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2216		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2217	}
2218	if v.DetectorId != nil {
2219		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2220			return err
2221		}
2222	}
2223
2224	if v.IpSetId == nil || len(*v.IpSetId) == 0 {
2225		return &smithy.SerializationError{Err: fmt.Errorf("input member IpSetId must not be empty")}
2226	}
2227	if v.IpSetId != nil {
2228		if err := encoder.SetURI("IpSetId").String(*v.IpSetId); err != nil {
2229			return err
2230		}
2231	}
2232
2233	return nil
2234}
2235
2236type awsRestjson1_serializeOpGetMasterAccount struct {
2237}
2238
2239func (*awsRestjson1_serializeOpGetMasterAccount) ID() string {
2240	return "OperationSerializer"
2241}
2242
2243func (m *awsRestjson1_serializeOpGetMasterAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2244	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2245) {
2246	request, ok := in.Request.(*smithyhttp.Request)
2247	if !ok {
2248		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2249	}
2250
2251	input, ok := in.Parameters.(*GetMasterAccountInput)
2252	_ = input
2253	if !ok {
2254		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2255	}
2256
2257	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/master")
2258	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2259	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2260	request.Method = "GET"
2261	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2262	if err != nil {
2263		return out, metadata, &smithy.SerializationError{Err: err}
2264	}
2265
2266	if err := awsRestjson1_serializeOpHttpBindingsGetMasterAccountInput(input, restEncoder); err != nil {
2267		return out, metadata, &smithy.SerializationError{Err: err}
2268	}
2269
2270	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2271		return out, metadata, &smithy.SerializationError{Err: err}
2272	}
2273	in.Request = request
2274
2275	return next.HandleSerialize(ctx, in)
2276}
2277func awsRestjson1_serializeOpHttpBindingsGetMasterAccountInput(v *GetMasterAccountInput, encoder *httpbinding.Encoder) error {
2278	if v == nil {
2279		return fmt.Errorf("unsupported serialization of nil %T", v)
2280	}
2281
2282	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2283		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2284	}
2285	if v.DetectorId != nil {
2286		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2287			return err
2288		}
2289	}
2290
2291	return nil
2292}
2293
2294type awsRestjson1_serializeOpGetMemberDetectors struct {
2295}
2296
2297func (*awsRestjson1_serializeOpGetMemberDetectors) ID() string {
2298	return "OperationSerializer"
2299}
2300
2301func (m *awsRestjson1_serializeOpGetMemberDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2302	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2303) {
2304	request, ok := in.Request.(*smithyhttp.Request)
2305	if !ok {
2306		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2307	}
2308
2309	input, ok := in.Parameters.(*GetMemberDetectorsInput)
2310	_ = input
2311	if !ok {
2312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2313	}
2314
2315	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/detector/get")
2316	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2317	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2318	request.Method = "POST"
2319	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2320	if err != nil {
2321		return out, metadata, &smithy.SerializationError{Err: err}
2322	}
2323
2324	if err := awsRestjson1_serializeOpHttpBindingsGetMemberDetectorsInput(input, restEncoder); err != nil {
2325		return out, metadata, &smithy.SerializationError{Err: err}
2326	}
2327
2328	restEncoder.SetHeader("Content-Type").String("application/json")
2329
2330	jsonEncoder := smithyjson.NewEncoder()
2331	if err := awsRestjson1_serializeOpDocumentGetMemberDetectorsInput(input, jsonEncoder.Value); err != nil {
2332		return out, metadata, &smithy.SerializationError{Err: err}
2333	}
2334
2335	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2336		return out, metadata, &smithy.SerializationError{Err: err}
2337	}
2338
2339	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2340		return out, metadata, &smithy.SerializationError{Err: err}
2341	}
2342	in.Request = request
2343
2344	return next.HandleSerialize(ctx, in)
2345}
2346func awsRestjson1_serializeOpHttpBindingsGetMemberDetectorsInput(v *GetMemberDetectorsInput, encoder *httpbinding.Encoder) error {
2347	if v == nil {
2348		return fmt.Errorf("unsupported serialization of nil %T", v)
2349	}
2350
2351	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2352		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2353	}
2354	if v.DetectorId != nil {
2355		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2356			return err
2357		}
2358	}
2359
2360	return nil
2361}
2362
2363func awsRestjson1_serializeOpDocumentGetMemberDetectorsInput(v *GetMemberDetectorsInput, value smithyjson.Value) error {
2364	object := value.Object()
2365	defer object.Close()
2366
2367	if v.AccountIds != nil {
2368		ok := object.Key("accountIds")
2369		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
2370			return err
2371		}
2372	}
2373
2374	return nil
2375}
2376
2377type awsRestjson1_serializeOpGetMembers struct {
2378}
2379
2380func (*awsRestjson1_serializeOpGetMembers) ID() string {
2381	return "OperationSerializer"
2382}
2383
2384func (m *awsRestjson1_serializeOpGetMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2385	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2386) {
2387	request, ok := in.Request.(*smithyhttp.Request)
2388	if !ok {
2389		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2390	}
2391
2392	input, ok := in.Parameters.(*GetMembersInput)
2393	_ = input
2394	if !ok {
2395		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2396	}
2397
2398	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/get")
2399	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2400	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2401	request.Method = "POST"
2402	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2403	if err != nil {
2404		return out, metadata, &smithy.SerializationError{Err: err}
2405	}
2406
2407	if err := awsRestjson1_serializeOpHttpBindingsGetMembersInput(input, restEncoder); err != nil {
2408		return out, metadata, &smithy.SerializationError{Err: err}
2409	}
2410
2411	restEncoder.SetHeader("Content-Type").String("application/json")
2412
2413	jsonEncoder := smithyjson.NewEncoder()
2414	if err := awsRestjson1_serializeOpDocumentGetMembersInput(input, jsonEncoder.Value); err != nil {
2415		return out, metadata, &smithy.SerializationError{Err: err}
2416	}
2417
2418	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2419		return out, metadata, &smithy.SerializationError{Err: err}
2420	}
2421
2422	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2423		return out, metadata, &smithy.SerializationError{Err: err}
2424	}
2425	in.Request = request
2426
2427	return next.HandleSerialize(ctx, in)
2428}
2429func awsRestjson1_serializeOpHttpBindingsGetMembersInput(v *GetMembersInput, encoder *httpbinding.Encoder) error {
2430	if v == nil {
2431		return fmt.Errorf("unsupported serialization of nil %T", v)
2432	}
2433
2434	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2435		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2436	}
2437	if v.DetectorId != nil {
2438		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2439			return err
2440		}
2441	}
2442
2443	return nil
2444}
2445
2446func awsRestjson1_serializeOpDocumentGetMembersInput(v *GetMembersInput, value smithyjson.Value) error {
2447	object := value.Object()
2448	defer object.Close()
2449
2450	if v.AccountIds != nil {
2451		ok := object.Key("accountIds")
2452		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
2453			return err
2454		}
2455	}
2456
2457	return nil
2458}
2459
2460type awsRestjson1_serializeOpGetThreatIntelSet struct {
2461}
2462
2463func (*awsRestjson1_serializeOpGetThreatIntelSet) ID() string {
2464	return "OperationSerializer"
2465}
2466
2467func (m *awsRestjson1_serializeOpGetThreatIntelSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2468	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2469) {
2470	request, ok := in.Request.(*smithyhttp.Request)
2471	if !ok {
2472		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2473	}
2474
2475	input, ok := in.Parameters.(*GetThreatIntelSetInput)
2476	_ = input
2477	if !ok {
2478		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2479	}
2480
2481	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}")
2482	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2483	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2484	request.Method = "GET"
2485	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2486	if err != nil {
2487		return out, metadata, &smithy.SerializationError{Err: err}
2488	}
2489
2490	if err := awsRestjson1_serializeOpHttpBindingsGetThreatIntelSetInput(input, restEncoder); err != nil {
2491		return out, metadata, &smithy.SerializationError{Err: err}
2492	}
2493
2494	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2495		return out, metadata, &smithy.SerializationError{Err: err}
2496	}
2497	in.Request = request
2498
2499	return next.HandleSerialize(ctx, in)
2500}
2501func awsRestjson1_serializeOpHttpBindingsGetThreatIntelSetInput(v *GetThreatIntelSetInput, encoder *httpbinding.Encoder) error {
2502	if v == nil {
2503		return fmt.Errorf("unsupported serialization of nil %T", v)
2504	}
2505
2506	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2507		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2508	}
2509	if v.DetectorId != nil {
2510		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2511			return err
2512		}
2513	}
2514
2515	if v.ThreatIntelSetId == nil || len(*v.ThreatIntelSetId) == 0 {
2516		return &smithy.SerializationError{Err: fmt.Errorf("input member ThreatIntelSetId must not be empty")}
2517	}
2518	if v.ThreatIntelSetId != nil {
2519		if err := encoder.SetURI("ThreatIntelSetId").String(*v.ThreatIntelSetId); err != nil {
2520			return err
2521		}
2522	}
2523
2524	return nil
2525}
2526
2527type awsRestjson1_serializeOpGetUsageStatistics struct {
2528}
2529
2530func (*awsRestjson1_serializeOpGetUsageStatistics) ID() string {
2531	return "OperationSerializer"
2532}
2533
2534func (m *awsRestjson1_serializeOpGetUsageStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2535	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2536) {
2537	request, ok := in.Request.(*smithyhttp.Request)
2538	if !ok {
2539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2540	}
2541
2542	input, ok := in.Parameters.(*GetUsageStatisticsInput)
2543	_ = input
2544	if !ok {
2545		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2546	}
2547
2548	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/usage/statistics")
2549	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2550	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2551	request.Method = "POST"
2552	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2553	if err != nil {
2554		return out, metadata, &smithy.SerializationError{Err: err}
2555	}
2556
2557	if err := awsRestjson1_serializeOpHttpBindingsGetUsageStatisticsInput(input, restEncoder); err != nil {
2558		return out, metadata, &smithy.SerializationError{Err: err}
2559	}
2560
2561	restEncoder.SetHeader("Content-Type").String("application/json")
2562
2563	jsonEncoder := smithyjson.NewEncoder()
2564	if err := awsRestjson1_serializeOpDocumentGetUsageStatisticsInput(input, jsonEncoder.Value); err != nil {
2565		return out, metadata, &smithy.SerializationError{Err: err}
2566	}
2567
2568	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2569		return out, metadata, &smithy.SerializationError{Err: err}
2570	}
2571
2572	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2573		return out, metadata, &smithy.SerializationError{Err: err}
2574	}
2575	in.Request = request
2576
2577	return next.HandleSerialize(ctx, in)
2578}
2579func awsRestjson1_serializeOpHttpBindingsGetUsageStatisticsInput(v *GetUsageStatisticsInput, encoder *httpbinding.Encoder) error {
2580	if v == nil {
2581		return fmt.Errorf("unsupported serialization of nil %T", v)
2582	}
2583
2584	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2585		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2586	}
2587	if v.DetectorId != nil {
2588		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2589			return err
2590		}
2591	}
2592
2593	return nil
2594}
2595
2596func awsRestjson1_serializeOpDocumentGetUsageStatisticsInput(v *GetUsageStatisticsInput, value smithyjson.Value) error {
2597	object := value.Object()
2598	defer object.Close()
2599
2600	if v.MaxResults != 0 {
2601		ok := object.Key("maxResults")
2602		ok.Integer(v.MaxResults)
2603	}
2604
2605	if v.NextToken != nil {
2606		ok := object.Key("nextToken")
2607		ok.String(*v.NextToken)
2608	}
2609
2610	if v.Unit != nil {
2611		ok := object.Key("unit")
2612		ok.String(*v.Unit)
2613	}
2614
2615	if v.UsageCriteria != nil {
2616		ok := object.Key("usageCriteria")
2617		if err := awsRestjson1_serializeDocumentUsageCriteria(v.UsageCriteria, ok); err != nil {
2618			return err
2619		}
2620	}
2621
2622	if len(v.UsageStatisticType) > 0 {
2623		ok := object.Key("usageStatisticsType")
2624		ok.String(string(v.UsageStatisticType))
2625	}
2626
2627	return nil
2628}
2629
2630type awsRestjson1_serializeOpInviteMembers struct {
2631}
2632
2633func (*awsRestjson1_serializeOpInviteMembers) ID() string {
2634	return "OperationSerializer"
2635}
2636
2637func (m *awsRestjson1_serializeOpInviteMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2638	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2639) {
2640	request, ok := in.Request.(*smithyhttp.Request)
2641	if !ok {
2642		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2643	}
2644
2645	input, ok := in.Parameters.(*InviteMembersInput)
2646	_ = input
2647	if !ok {
2648		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2649	}
2650
2651	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/invite")
2652	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2653	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2654	request.Method = "POST"
2655	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2656	if err != nil {
2657		return out, metadata, &smithy.SerializationError{Err: err}
2658	}
2659
2660	if err := awsRestjson1_serializeOpHttpBindingsInviteMembersInput(input, restEncoder); err != nil {
2661		return out, metadata, &smithy.SerializationError{Err: err}
2662	}
2663
2664	restEncoder.SetHeader("Content-Type").String("application/json")
2665
2666	jsonEncoder := smithyjson.NewEncoder()
2667	if err := awsRestjson1_serializeOpDocumentInviteMembersInput(input, jsonEncoder.Value); err != nil {
2668		return out, metadata, &smithy.SerializationError{Err: err}
2669	}
2670
2671	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2672		return out, metadata, &smithy.SerializationError{Err: err}
2673	}
2674
2675	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2676		return out, metadata, &smithy.SerializationError{Err: err}
2677	}
2678	in.Request = request
2679
2680	return next.HandleSerialize(ctx, in)
2681}
2682func awsRestjson1_serializeOpHttpBindingsInviteMembersInput(v *InviteMembersInput, encoder *httpbinding.Encoder) error {
2683	if v == nil {
2684		return fmt.Errorf("unsupported serialization of nil %T", v)
2685	}
2686
2687	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2688		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2689	}
2690	if v.DetectorId != nil {
2691		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2692			return err
2693		}
2694	}
2695
2696	return nil
2697}
2698
2699func awsRestjson1_serializeOpDocumentInviteMembersInput(v *InviteMembersInput, value smithyjson.Value) error {
2700	object := value.Object()
2701	defer object.Close()
2702
2703	if v.AccountIds != nil {
2704		ok := object.Key("accountIds")
2705		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
2706			return err
2707		}
2708	}
2709
2710	if v.DisableEmailNotification {
2711		ok := object.Key("disableEmailNotification")
2712		ok.Boolean(v.DisableEmailNotification)
2713	}
2714
2715	if v.Message != nil {
2716		ok := object.Key("message")
2717		ok.String(*v.Message)
2718	}
2719
2720	return nil
2721}
2722
2723type awsRestjson1_serializeOpListDetectors struct {
2724}
2725
2726func (*awsRestjson1_serializeOpListDetectors) ID() string {
2727	return "OperationSerializer"
2728}
2729
2730func (m *awsRestjson1_serializeOpListDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2732) {
2733	request, ok := in.Request.(*smithyhttp.Request)
2734	if !ok {
2735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2736	}
2737
2738	input, ok := in.Parameters.(*ListDetectorsInput)
2739	_ = input
2740	if !ok {
2741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2742	}
2743
2744	opPath, opQuery := httpbinding.SplitURI("/detector")
2745	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2746	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2747	request.Method = "GET"
2748	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2749	if err != nil {
2750		return out, metadata, &smithy.SerializationError{Err: err}
2751	}
2752
2753	if err := awsRestjson1_serializeOpHttpBindingsListDetectorsInput(input, restEncoder); err != nil {
2754		return out, metadata, &smithy.SerializationError{Err: err}
2755	}
2756
2757	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2758		return out, metadata, &smithy.SerializationError{Err: err}
2759	}
2760	in.Request = request
2761
2762	return next.HandleSerialize(ctx, in)
2763}
2764func awsRestjson1_serializeOpHttpBindingsListDetectorsInput(v *ListDetectorsInput, encoder *httpbinding.Encoder) error {
2765	if v == nil {
2766		return fmt.Errorf("unsupported serialization of nil %T", v)
2767	}
2768
2769	if v.MaxResults != 0 {
2770		encoder.SetQuery("maxResults").Integer(v.MaxResults)
2771	}
2772
2773	if v.NextToken != nil {
2774		encoder.SetQuery("nextToken").String(*v.NextToken)
2775	}
2776
2777	return nil
2778}
2779
2780type awsRestjson1_serializeOpListFilters struct {
2781}
2782
2783func (*awsRestjson1_serializeOpListFilters) ID() string {
2784	return "OperationSerializer"
2785}
2786
2787func (m *awsRestjson1_serializeOpListFilters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2788	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2789) {
2790	request, ok := in.Request.(*smithyhttp.Request)
2791	if !ok {
2792		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2793	}
2794
2795	input, ok := in.Parameters.(*ListFiltersInput)
2796	_ = input
2797	if !ok {
2798		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2799	}
2800
2801	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/filter")
2802	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2803	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2804	request.Method = "GET"
2805	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2806	if err != nil {
2807		return out, metadata, &smithy.SerializationError{Err: err}
2808	}
2809
2810	if err := awsRestjson1_serializeOpHttpBindingsListFiltersInput(input, restEncoder); err != nil {
2811		return out, metadata, &smithy.SerializationError{Err: err}
2812	}
2813
2814	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2815		return out, metadata, &smithy.SerializationError{Err: err}
2816	}
2817	in.Request = request
2818
2819	return next.HandleSerialize(ctx, in)
2820}
2821func awsRestjson1_serializeOpHttpBindingsListFiltersInput(v *ListFiltersInput, encoder *httpbinding.Encoder) error {
2822	if v == nil {
2823		return fmt.Errorf("unsupported serialization of nil %T", v)
2824	}
2825
2826	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2827		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2828	}
2829	if v.DetectorId != nil {
2830		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2831			return err
2832		}
2833	}
2834
2835	if v.MaxResults != 0 {
2836		encoder.SetQuery("maxResults").Integer(v.MaxResults)
2837	}
2838
2839	if v.NextToken != nil {
2840		encoder.SetQuery("nextToken").String(*v.NextToken)
2841	}
2842
2843	return nil
2844}
2845
2846type awsRestjson1_serializeOpListFindings struct {
2847}
2848
2849func (*awsRestjson1_serializeOpListFindings) ID() string {
2850	return "OperationSerializer"
2851}
2852
2853func (m *awsRestjson1_serializeOpListFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2854	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2855) {
2856	request, ok := in.Request.(*smithyhttp.Request)
2857	if !ok {
2858		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2859	}
2860
2861	input, ok := in.Parameters.(*ListFindingsInput)
2862	_ = input
2863	if !ok {
2864		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2865	}
2866
2867	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings")
2868	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2869	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2870	request.Method = "POST"
2871	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2872	if err != nil {
2873		return out, metadata, &smithy.SerializationError{Err: err}
2874	}
2875
2876	if err := awsRestjson1_serializeOpHttpBindingsListFindingsInput(input, restEncoder); err != nil {
2877		return out, metadata, &smithy.SerializationError{Err: err}
2878	}
2879
2880	restEncoder.SetHeader("Content-Type").String("application/json")
2881
2882	jsonEncoder := smithyjson.NewEncoder()
2883	if err := awsRestjson1_serializeOpDocumentListFindingsInput(input, jsonEncoder.Value); err != nil {
2884		return out, metadata, &smithy.SerializationError{Err: err}
2885	}
2886
2887	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2888		return out, metadata, &smithy.SerializationError{Err: err}
2889	}
2890
2891	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2892		return out, metadata, &smithy.SerializationError{Err: err}
2893	}
2894	in.Request = request
2895
2896	return next.HandleSerialize(ctx, in)
2897}
2898func awsRestjson1_serializeOpHttpBindingsListFindingsInput(v *ListFindingsInput, encoder *httpbinding.Encoder) error {
2899	if v == nil {
2900		return fmt.Errorf("unsupported serialization of nil %T", v)
2901	}
2902
2903	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
2904		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
2905	}
2906	if v.DetectorId != nil {
2907		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
2908			return err
2909		}
2910	}
2911
2912	return nil
2913}
2914
2915func awsRestjson1_serializeOpDocumentListFindingsInput(v *ListFindingsInput, value smithyjson.Value) error {
2916	object := value.Object()
2917	defer object.Close()
2918
2919	if v.FindingCriteria != nil {
2920		ok := object.Key("findingCriteria")
2921		if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil {
2922			return err
2923		}
2924	}
2925
2926	if v.MaxResults != 0 {
2927		ok := object.Key("maxResults")
2928		ok.Integer(v.MaxResults)
2929	}
2930
2931	if v.NextToken != nil {
2932		ok := object.Key("nextToken")
2933		ok.String(*v.NextToken)
2934	}
2935
2936	if v.SortCriteria != nil {
2937		ok := object.Key("sortCriteria")
2938		if err := awsRestjson1_serializeDocumentSortCriteria(v.SortCriteria, ok); err != nil {
2939			return err
2940		}
2941	}
2942
2943	return nil
2944}
2945
2946type awsRestjson1_serializeOpListInvitations struct {
2947}
2948
2949func (*awsRestjson1_serializeOpListInvitations) ID() string {
2950	return "OperationSerializer"
2951}
2952
2953func (m *awsRestjson1_serializeOpListInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2954	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2955) {
2956	request, ok := in.Request.(*smithyhttp.Request)
2957	if !ok {
2958		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2959	}
2960
2961	input, ok := in.Parameters.(*ListInvitationsInput)
2962	_ = input
2963	if !ok {
2964		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2965	}
2966
2967	opPath, opQuery := httpbinding.SplitURI("/invitation")
2968	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2969	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2970	request.Method = "GET"
2971	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2972	if err != nil {
2973		return out, metadata, &smithy.SerializationError{Err: err}
2974	}
2975
2976	if err := awsRestjson1_serializeOpHttpBindingsListInvitationsInput(input, restEncoder); err != nil {
2977		return out, metadata, &smithy.SerializationError{Err: err}
2978	}
2979
2980	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2981		return out, metadata, &smithy.SerializationError{Err: err}
2982	}
2983	in.Request = request
2984
2985	return next.HandleSerialize(ctx, in)
2986}
2987func awsRestjson1_serializeOpHttpBindingsListInvitationsInput(v *ListInvitationsInput, encoder *httpbinding.Encoder) error {
2988	if v == nil {
2989		return fmt.Errorf("unsupported serialization of nil %T", v)
2990	}
2991
2992	if v.MaxResults != 0 {
2993		encoder.SetQuery("maxResults").Integer(v.MaxResults)
2994	}
2995
2996	if v.NextToken != nil {
2997		encoder.SetQuery("nextToken").String(*v.NextToken)
2998	}
2999
3000	return nil
3001}
3002
3003type awsRestjson1_serializeOpListIPSets struct {
3004}
3005
3006func (*awsRestjson1_serializeOpListIPSets) ID() string {
3007	return "OperationSerializer"
3008}
3009
3010func (m *awsRestjson1_serializeOpListIPSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3011	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3012) {
3013	request, ok := in.Request.(*smithyhttp.Request)
3014	if !ok {
3015		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3016	}
3017
3018	input, ok := in.Parameters.(*ListIPSetsInput)
3019	_ = input
3020	if !ok {
3021		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3022	}
3023
3024	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/ipset")
3025	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3026	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3027	request.Method = "GET"
3028	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3029	if err != nil {
3030		return out, metadata, &smithy.SerializationError{Err: err}
3031	}
3032
3033	if err := awsRestjson1_serializeOpHttpBindingsListIPSetsInput(input, restEncoder); err != nil {
3034		return out, metadata, &smithy.SerializationError{Err: err}
3035	}
3036
3037	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3038		return out, metadata, &smithy.SerializationError{Err: err}
3039	}
3040	in.Request = request
3041
3042	return next.HandleSerialize(ctx, in)
3043}
3044func awsRestjson1_serializeOpHttpBindingsListIPSetsInput(v *ListIPSetsInput, encoder *httpbinding.Encoder) error {
3045	if v == nil {
3046		return fmt.Errorf("unsupported serialization of nil %T", v)
3047	}
3048
3049	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3050		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3051	}
3052	if v.DetectorId != nil {
3053		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3054			return err
3055		}
3056	}
3057
3058	if v.MaxResults != 0 {
3059		encoder.SetQuery("maxResults").Integer(v.MaxResults)
3060	}
3061
3062	if v.NextToken != nil {
3063		encoder.SetQuery("nextToken").String(*v.NextToken)
3064	}
3065
3066	return nil
3067}
3068
3069type awsRestjson1_serializeOpListMembers struct {
3070}
3071
3072func (*awsRestjson1_serializeOpListMembers) ID() string {
3073	return "OperationSerializer"
3074}
3075
3076func (m *awsRestjson1_serializeOpListMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3077	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3078) {
3079	request, ok := in.Request.(*smithyhttp.Request)
3080	if !ok {
3081		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3082	}
3083
3084	input, ok := in.Parameters.(*ListMembersInput)
3085	_ = input
3086	if !ok {
3087		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3088	}
3089
3090	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member")
3091	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3092	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3093	request.Method = "GET"
3094	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3095	if err != nil {
3096		return out, metadata, &smithy.SerializationError{Err: err}
3097	}
3098
3099	if err := awsRestjson1_serializeOpHttpBindingsListMembersInput(input, restEncoder); err != nil {
3100		return out, metadata, &smithy.SerializationError{Err: err}
3101	}
3102
3103	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3104		return out, metadata, &smithy.SerializationError{Err: err}
3105	}
3106	in.Request = request
3107
3108	return next.HandleSerialize(ctx, in)
3109}
3110func awsRestjson1_serializeOpHttpBindingsListMembersInput(v *ListMembersInput, encoder *httpbinding.Encoder) error {
3111	if v == nil {
3112		return fmt.Errorf("unsupported serialization of nil %T", v)
3113	}
3114
3115	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3116		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3117	}
3118	if v.DetectorId != nil {
3119		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3120			return err
3121		}
3122	}
3123
3124	if v.MaxResults != 0 {
3125		encoder.SetQuery("maxResults").Integer(v.MaxResults)
3126	}
3127
3128	if v.NextToken != nil {
3129		encoder.SetQuery("nextToken").String(*v.NextToken)
3130	}
3131
3132	if v.OnlyAssociated != nil {
3133		encoder.SetQuery("onlyAssociated").String(*v.OnlyAssociated)
3134	}
3135
3136	return nil
3137}
3138
3139type awsRestjson1_serializeOpListOrganizationAdminAccounts struct {
3140}
3141
3142func (*awsRestjson1_serializeOpListOrganizationAdminAccounts) ID() string {
3143	return "OperationSerializer"
3144}
3145
3146func (m *awsRestjson1_serializeOpListOrganizationAdminAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3147	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3148) {
3149	request, ok := in.Request.(*smithyhttp.Request)
3150	if !ok {
3151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3152	}
3153
3154	input, ok := in.Parameters.(*ListOrganizationAdminAccountsInput)
3155	_ = input
3156	if !ok {
3157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3158	}
3159
3160	opPath, opQuery := httpbinding.SplitURI("/admin")
3161	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3162	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3163	request.Method = "GET"
3164	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3165	if err != nil {
3166		return out, metadata, &smithy.SerializationError{Err: err}
3167	}
3168
3169	if err := awsRestjson1_serializeOpHttpBindingsListOrganizationAdminAccountsInput(input, restEncoder); err != nil {
3170		return out, metadata, &smithy.SerializationError{Err: err}
3171	}
3172
3173	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3174		return out, metadata, &smithy.SerializationError{Err: err}
3175	}
3176	in.Request = request
3177
3178	return next.HandleSerialize(ctx, in)
3179}
3180func awsRestjson1_serializeOpHttpBindingsListOrganizationAdminAccountsInput(v *ListOrganizationAdminAccountsInput, encoder *httpbinding.Encoder) error {
3181	if v == nil {
3182		return fmt.Errorf("unsupported serialization of nil %T", v)
3183	}
3184
3185	if v.MaxResults != 0 {
3186		encoder.SetQuery("maxResults").Integer(v.MaxResults)
3187	}
3188
3189	if v.NextToken != nil {
3190		encoder.SetQuery("nextToken").String(*v.NextToken)
3191	}
3192
3193	return nil
3194}
3195
3196type awsRestjson1_serializeOpListPublishingDestinations struct {
3197}
3198
3199func (*awsRestjson1_serializeOpListPublishingDestinations) ID() string {
3200	return "OperationSerializer"
3201}
3202
3203func (m *awsRestjson1_serializeOpListPublishingDestinations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3204	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3205) {
3206	request, ok := in.Request.(*smithyhttp.Request)
3207	if !ok {
3208		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3209	}
3210
3211	input, ok := in.Parameters.(*ListPublishingDestinationsInput)
3212	_ = input
3213	if !ok {
3214		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3215	}
3216
3217	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/publishingDestination")
3218	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3219	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3220	request.Method = "GET"
3221	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3222	if err != nil {
3223		return out, metadata, &smithy.SerializationError{Err: err}
3224	}
3225
3226	if err := awsRestjson1_serializeOpHttpBindingsListPublishingDestinationsInput(input, restEncoder); err != nil {
3227		return out, metadata, &smithy.SerializationError{Err: err}
3228	}
3229
3230	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3231		return out, metadata, &smithy.SerializationError{Err: err}
3232	}
3233	in.Request = request
3234
3235	return next.HandleSerialize(ctx, in)
3236}
3237func awsRestjson1_serializeOpHttpBindingsListPublishingDestinationsInput(v *ListPublishingDestinationsInput, encoder *httpbinding.Encoder) error {
3238	if v == nil {
3239		return fmt.Errorf("unsupported serialization of nil %T", v)
3240	}
3241
3242	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3243		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3244	}
3245	if v.DetectorId != nil {
3246		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3247			return err
3248		}
3249	}
3250
3251	if v.MaxResults != 0 {
3252		encoder.SetQuery("maxResults").Integer(v.MaxResults)
3253	}
3254
3255	if v.NextToken != nil {
3256		encoder.SetQuery("nextToken").String(*v.NextToken)
3257	}
3258
3259	return nil
3260}
3261
3262type awsRestjson1_serializeOpListTagsForResource struct {
3263}
3264
3265func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
3266	return "OperationSerializer"
3267}
3268
3269func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3270	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3271) {
3272	request, ok := in.Request.(*smithyhttp.Request)
3273	if !ok {
3274		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3275	}
3276
3277	input, ok := in.Parameters.(*ListTagsForResourceInput)
3278	_ = input
3279	if !ok {
3280		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3281	}
3282
3283	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
3284	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3285	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3286	request.Method = "GET"
3287	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3288	if err != nil {
3289		return out, metadata, &smithy.SerializationError{Err: err}
3290	}
3291
3292	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
3293		return out, metadata, &smithy.SerializationError{Err: err}
3294	}
3295
3296	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3297		return out, metadata, &smithy.SerializationError{Err: err}
3298	}
3299	in.Request = request
3300
3301	return next.HandleSerialize(ctx, in)
3302}
3303func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
3304	if v == nil {
3305		return fmt.Errorf("unsupported serialization of nil %T", v)
3306	}
3307
3308	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
3309		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
3310	}
3311	if v.ResourceArn != nil {
3312		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
3313			return err
3314		}
3315	}
3316
3317	return nil
3318}
3319
3320type awsRestjson1_serializeOpListThreatIntelSets struct {
3321}
3322
3323func (*awsRestjson1_serializeOpListThreatIntelSets) ID() string {
3324	return "OperationSerializer"
3325}
3326
3327func (m *awsRestjson1_serializeOpListThreatIntelSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3328	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3329) {
3330	request, ok := in.Request.(*smithyhttp.Request)
3331	if !ok {
3332		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3333	}
3334
3335	input, ok := in.Parameters.(*ListThreatIntelSetsInput)
3336	_ = input
3337	if !ok {
3338		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3339	}
3340
3341	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/threatintelset")
3342	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3343	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3344	request.Method = "GET"
3345	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3346	if err != nil {
3347		return out, metadata, &smithy.SerializationError{Err: err}
3348	}
3349
3350	if err := awsRestjson1_serializeOpHttpBindingsListThreatIntelSetsInput(input, restEncoder); err != nil {
3351		return out, metadata, &smithy.SerializationError{Err: err}
3352	}
3353
3354	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3355		return out, metadata, &smithy.SerializationError{Err: err}
3356	}
3357	in.Request = request
3358
3359	return next.HandleSerialize(ctx, in)
3360}
3361func awsRestjson1_serializeOpHttpBindingsListThreatIntelSetsInput(v *ListThreatIntelSetsInput, encoder *httpbinding.Encoder) error {
3362	if v == nil {
3363		return fmt.Errorf("unsupported serialization of nil %T", v)
3364	}
3365
3366	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3367		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3368	}
3369	if v.DetectorId != nil {
3370		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3371			return err
3372		}
3373	}
3374
3375	if v.MaxResults != 0 {
3376		encoder.SetQuery("maxResults").Integer(v.MaxResults)
3377	}
3378
3379	if v.NextToken != nil {
3380		encoder.SetQuery("nextToken").String(*v.NextToken)
3381	}
3382
3383	return nil
3384}
3385
3386type awsRestjson1_serializeOpStartMonitoringMembers struct {
3387}
3388
3389func (*awsRestjson1_serializeOpStartMonitoringMembers) ID() string {
3390	return "OperationSerializer"
3391}
3392
3393func (m *awsRestjson1_serializeOpStartMonitoringMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3394	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3395) {
3396	request, ok := in.Request.(*smithyhttp.Request)
3397	if !ok {
3398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3399	}
3400
3401	input, ok := in.Parameters.(*StartMonitoringMembersInput)
3402	_ = input
3403	if !ok {
3404		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3405	}
3406
3407	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/start")
3408	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3409	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3410	request.Method = "POST"
3411	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3412	if err != nil {
3413		return out, metadata, &smithy.SerializationError{Err: err}
3414	}
3415
3416	if err := awsRestjson1_serializeOpHttpBindingsStartMonitoringMembersInput(input, restEncoder); err != nil {
3417		return out, metadata, &smithy.SerializationError{Err: err}
3418	}
3419
3420	restEncoder.SetHeader("Content-Type").String("application/json")
3421
3422	jsonEncoder := smithyjson.NewEncoder()
3423	if err := awsRestjson1_serializeOpDocumentStartMonitoringMembersInput(input, jsonEncoder.Value); err != nil {
3424		return out, metadata, &smithy.SerializationError{Err: err}
3425	}
3426
3427	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3428		return out, metadata, &smithy.SerializationError{Err: err}
3429	}
3430
3431	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3432		return out, metadata, &smithy.SerializationError{Err: err}
3433	}
3434	in.Request = request
3435
3436	return next.HandleSerialize(ctx, in)
3437}
3438func awsRestjson1_serializeOpHttpBindingsStartMonitoringMembersInput(v *StartMonitoringMembersInput, encoder *httpbinding.Encoder) error {
3439	if v == nil {
3440		return fmt.Errorf("unsupported serialization of nil %T", v)
3441	}
3442
3443	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3444		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3445	}
3446	if v.DetectorId != nil {
3447		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3448			return err
3449		}
3450	}
3451
3452	return nil
3453}
3454
3455func awsRestjson1_serializeOpDocumentStartMonitoringMembersInput(v *StartMonitoringMembersInput, value smithyjson.Value) error {
3456	object := value.Object()
3457	defer object.Close()
3458
3459	if v.AccountIds != nil {
3460		ok := object.Key("accountIds")
3461		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
3462			return err
3463		}
3464	}
3465
3466	return nil
3467}
3468
3469type awsRestjson1_serializeOpStopMonitoringMembers struct {
3470}
3471
3472func (*awsRestjson1_serializeOpStopMonitoringMembers) ID() string {
3473	return "OperationSerializer"
3474}
3475
3476func (m *awsRestjson1_serializeOpStopMonitoringMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3477	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3478) {
3479	request, ok := in.Request.(*smithyhttp.Request)
3480	if !ok {
3481		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3482	}
3483
3484	input, ok := in.Parameters.(*StopMonitoringMembersInput)
3485	_ = input
3486	if !ok {
3487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3488	}
3489
3490	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/stop")
3491	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3492	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3493	request.Method = "POST"
3494	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3495	if err != nil {
3496		return out, metadata, &smithy.SerializationError{Err: err}
3497	}
3498
3499	if err := awsRestjson1_serializeOpHttpBindingsStopMonitoringMembersInput(input, restEncoder); err != nil {
3500		return out, metadata, &smithy.SerializationError{Err: err}
3501	}
3502
3503	restEncoder.SetHeader("Content-Type").String("application/json")
3504
3505	jsonEncoder := smithyjson.NewEncoder()
3506	if err := awsRestjson1_serializeOpDocumentStopMonitoringMembersInput(input, jsonEncoder.Value); err != nil {
3507		return out, metadata, &smithy.SerializationError{Err: err}
3508	}
3509
3510	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3511		return out, metadata, &smithy.SerializationError{Err: err}
3512	}
3513
3514	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3515		return out, metadata, &smithy.SerializationError{Err: err}
3516	}
3517	in.Request = request
3518
3519	return next.HandleSerialize(ctx, in)
3520}
3521func awsRestjson1_serializeOpHttpBindingsStopMonitoringMembersInput(v *StopMonitoringMembersInput, encoder *httpbinding.Encoder) error {
3522	if v == nil {
3523		return fmt.Errorf("unsupported serialization of nil %T", v)
3524	}
3525
3526	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3527		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3528	}
3529	if v.DetectorId != nil {
3530		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3531			return err
3532		}
3533	}
3534
3535	return nil
3536}
3537
3538func awsRestjson1_serializeOpDocumentStopMonitoringMembersInput(v *StopMonitoringMembersInput, value smithyjson.Value) error {
3539	object := value.Object()
3540	defer object.Close()
3541
3542	if v.AccountIds != nil {
3543		ok := object.Key("accountIds")
3544		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
3545			return err
3546		}
3547	}
3548
3549	return nil
3550}
3551
3552type awsRestjson1_serializeOpTagResource struct {
3553}
3554
3555func (*awsRestjson1_serializeOpTagResource) ID() string {
3556	return "OperationSerializer"
3557}
3558
3559func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3560	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3561) {
3562	request, ok := in.Request.(*smithyhttp.Request)
3563	if !ok {
3564		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3565	}
3566
3567	input, ok := in.Parameters.(*TagResourceInput)
3568	_ = input
3569	if !ok {
3570		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3571	}
3572
3573	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
3574	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3575	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3576	request.Method = "POST"
3577	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3578	if err != nil {
3579		return out, metadata, &smithy.SerializationError{Err: err}
3580	}
3581
3582	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
3583		return out, metadata, &smithy.SerializationError{Err: err}
3584	}
3585
3586	restEncoder.SetHeader("Content-Type").String("application/json")
3587
3588	jsonEncoder := smithyjson.NewEncoder()
3589	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
3590		return out, metadata, &smithy.SerializationError{Err: err}
3591	}
3592
3593	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3594		return out, metadata, &smithy.SerializationError{Err: err}
3595	}
3596
3597	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3598		return out, metadata, &smithy.SerializationError{Err: err}
3599	}
3600	in.Request = request
3601
3602	return next.HandleSerialize(ctx, in)
3603}
3604func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
3605	if v == nil {
3606		return fmt.Errorf("unsupported serialization of nil %T", v)
3607	}
3608
3609	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
3610		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
3611	}
3612	if v.ResourceArn != nil {
3613		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
3614			return err
3615		}
3616	}
3617
3618	return nil
3619}
3620
3621func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
3622	object := value.Object()
3623	defer object.Close()
3624
3625	if v.Tags != nil {
3626		ok := object.Key("tags")
3627		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
3628			return err
3629		}
3630	}
3631
3632	return nil
3633}
3634
3635type awsRestjson1_serializeOpUnarchiveFindings struct {
3636}
3637
3638func (*awsRestjson1_serializeOpUnarchiveFindings) ID() string {
3639	return "OperationSerializer"
3640}
3641
3642func (m *awsRestjson1_serializeOpUnarchiveFindings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3643	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3644) {
3645	request, ok := in.Request.(*smithyhttp.Request)
3646	if !ok {
3647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3648	}
3649
3650	input, ok := in.Parameters.(*UnarchiveFindingsInput)
3651	_ = input
3652	if !ok {
3653		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3654	}
3655
3656	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/unarchive")
3657	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3658	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3659	request.Method = "POST"
3660	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3661	if err != nil {
3662		return out, metadata, &smithy.SerializationError{Err: err}
3663	}
3664
3665	if err := awsRestjson1_serializeOpHttpBindingsUnarchiveFindingsInput(input, restEncoder); err != nil {
3666		return out, metadata, &smithy.SerializationError{Err: err}
3667	}
3668
3669	restEncoder.SetHeader("Content-Type").String("application/json")
3670
3671	jsonEncoder := smithyjson.NewEncoder()
3672	if err := awsRestjson1_serializeOpDocumentUnarchiveFindingsInput(input, jsonEncoder.Value); err != nil {
3673		return out, metadata, &smithy.SerializationError{Err: err}
3674	}
3675
3676	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3677		return out, metadata, &smithy.SerializationError{Err: err}
3678	}
3679
3680	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3681		return out, metadata, &smithy.SerializationError{Err: err}
3682	}
3683	in.Request = request
3684
3685	return next.HandleSerialize(ctx, in)
3686}
3687func awsRestjson1_serializeOpHttpBindingsUnarchiveFindingsInput(v *UnarchiveFindingsInput, encoder *httpbinding.Encoder) error {
3688	if v == nil {
3689		return fmt.Errorf("unsupported serialization of nil %T", v)
3690	}
3691
3692	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3693		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3694	}
3695	if v.DetectorId != nil {
3696		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3697			return err
3698		}
3699	}
3700
3701	return nil
3702}
3703
3704func awsRestjson1_serializeOpDocumentUnarchiveFindingsInput(v *UnarchiveFindingsInput, value smithyjson.Value) error {
3705	object := value.Object()
3706	defer object.Close()
3707
3708	if v.FindingIds != nil {
3709		ok := object.Key("findingIds")
3710		if err := awsRestjson1_serializeDocumentFindingIds(v.FindingIds, ok); err != nil {
3711			return err
3712		}
3713	}
3714
3715	return nil
3716}
3717
3718type awsRestjson1_serializeOpUntagResource struct {
3719}
3720
3721func (*awsRestjson1_serializeOpUntagResource) ID() string {
3722	return "OperationSerializer"
3723}
3724
3725func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3726	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3727) {
3728	request, ok := in.Request.(*smithyhttp.Request)
3729	if !ok {
3730		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3731	}
3732
3733	input, ok := in.Parameters.(*UntagResourceInput)
3734	_ = input
3735	if !ok {
3736		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3737	}
3738
3739	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
3740	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3741	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3742	request.Method = "DELETE"
3743	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3744	if err != nil {
3745		return out, metadata, &smithy.SerializationError{Err: err}
3746	}
3747
3748	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
3749		return out, metadata, &smithy.SerializationError{Err: err}
3750	}
3751
3752	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3753		return out, metadata, &smithy.SerializationError{Err: err}
3754	}
3755	in.Request = request
3756
3757	return next.HandleSerialize(ctx, in)
3758}
3759func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
3760	if v == nil {
3761		return fmt.Errorf("unsupported serialization of nil %T", v)
3762	}
3763
3764	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
3765		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
3766	}
3767	if v.ResourceArn != nil {
3768		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
3769			return err
3770		}
3771	}
3772
3773	if v.TagKeys != nil {
3774		for i := range v.TagKeys {
3775			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
3776		}
3777	}
3778
3779	return nil
3780}
3781
3782type awsRestjson1_serializeOpUpdateDetector struct {
3783}
3784
3785func (*awsRestjson1_serializeOpUpdateDetector) ID() string {
3786	return "OperationSerializer"
3787}
3788
3789func (m *awsRestjson1_serializeOpUpdateDetector) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3790	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3791) {
3792	request, ok := in.Request.(*smithyhttp.Request)
3793	if !ok {
3794		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3795	}
3796
3797	input, ok := in.Parameters.(*UpdateDetectorInput)
3798	_ = input
3799	if !ok {
3800		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3801	}
3802
3803	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}")
3804	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3805	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3806	request.Method = "POST"
3807	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3808	if err != nil {
3809		return out, metadata, &smithy.SerializationError{Err: err}
3810	}
3811
3812	if err := awsRestjson1_serializeOpHttpBindingsUpdateDetectorInput(input, restEncoder); err != nil {
3813		return out, metadata, &smithy.SerializationError{Err: err}
3814	}
3815
3816	restEncoder.SetHeader("Content-Type").String("application/json")
3817
3818	jsonEncoder := smithyjson.NewEncoder()
3819	if err := awsRestjson1_serializeOpDocumentUpdateDetectorInput(input, jsonEncoder.Value); err != nil {
3820		return out, metadata, &smithy.SerializationError{Err: err}
3821	}
3822
3823	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3824		return out, metadata, &smithy.SerializationError{Err: err}
3825	}
3826
3827	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3828		return out, metadata, &smithy.SerializationError{Err: err}
3829	}
3830	in.Request = request
3831
3832	return next.HandleSerialize(ctx, in)
3833}
3834func awsRestjson1_serializeOpHttpBindingsUpdateDetectorInput(v *UpdateDetectorInput, encoder *httpbinding.Encoder) error {
3835	if v == nil {
3836		return fmt.Errorf("unsupported serialization of nil %T", v)
3837	}
3838
3839	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3840		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3841	}
3842	if v.DetectorId != nil {
3843		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3844			return err
3845		}
3846	}
3847
3848	return nil
3849}
3850
3851func awsRestjson1_serializeOpDocumentUpdateDetectorInput(v *UpdateDetectorInput, value smithyjson.Value) error {
3852	object := value.Object()
3853	defer object.Close()
3854
3855	if v.DataSources != nil {
3856		ok := object.Key("dataSources")
3857		if err := awsRestjson1_serializeDocumentDataSourceConfigurations(v.DataSources, ok); err != nil {
3858			return err
3859		}
3860	}
3861
3862	if v.Enable {
3863		ok := object.Key("enable")
3864		ok.Boolean(v.Enable)
3865	}
3866
3867	if len(v.FindingPublishingFrequency) > 0 {
3868		ok := object.Key("findingPublishingFrequency")
3869		ok.String(string(v.FindingPublishingFrequency))
3870	}
3871
3872	return nil
3873}
3874
3875type awsRestjson1_serializeOpUpdateFilter struct {
3876}
3877
3878func (*awsRestjson1_serializeOpUpdateFilter) ID() string {
3879	return "OperationSerializer"
3880}
3881
3882func (m *awsRestjson1_serializeOpUpdateFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3883	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3884) {
3885	request, ok := in.Request.(*smithyhttp.Request)
3886	if !ok {
3887		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3888	}
3889
3890	input, ok := in.Parameters.(*UpdateFilterInput)
3891	_ = input
3892	if !ok {
3893		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3894	}
3895
3896	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/filter/{FilterName}")
3897	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3898	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3899	request.Method = "POST"
3900	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3901	if err != nil {
3902		return out, metadata, &smithy.SerializationError{Err: err}
3903	}
3904
3905	if err := awsRestjson1_serializeOpHttpBindingsUpdateFilterInput(input, restEncoder); err != nil {
3906		return out, metadata, &smithy.SerializationError{Err: err}
3907	}
3908
3909	restEncoder.SetHeader("Content-Type").String("application/json")
3910
3911	jsonEncoder := smithyjson.NewEncoder()
3912	if err := awsRestjson1_serializeOpDocumentUpdateFilterInput(input, jsonEncoder.Value); err != nil {
3913		return out, metadata, &smithy.SerializationError{Err: err}
3914	}
3915
3916	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3917		return out, metadata, &smithy.SerializationError{Err: err}
3918	}
3919
3920	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3921		return out, metadata, &smithy.SerializationError{Err: err}
3922	}
3923	in.Request = request
3924
3925	return next.HandleSerialize(ctx, in)
3926}
3927func awsRestjson1_serializeOpHttpBindingsUpdateFilterInput(v *UpdateFilterInput, encoder *httpbinding.Encoder) error {
3928	if v == nil {
3929		return fmt.Errorf("unsupported serialization of nil %T", v)
3930	}
3931
3932	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
3933		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
3934	}
3935	if v.DetectorId != nil {
3936		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
3937			return err
3938		}
3939	}
3940
3941	if v.FilterName == nil || len(*v.FilterName) == 0 {
3942		return &smithy.SerializationError{Err: fmt.Errorf("input member FilterName must not be empty")}
3943	}
3944	if v.FilterName != nil {
3945		if err := encoder.SetURI("FilterName").String(*v.FilterName); err != nil {
3946			return err
3947		}
3948	}
3949
3950	return nil
3951}
3952
3953func awsRestjson1_serializeOpDocumentUpdateFilterInput(v *UpdateFilterInput, value smithyjson.Value) error {
3954	object := value.Object()
3955	defer object.Close()
3956
3957	if len(v.Action) > 0 {
3958		ok := object.Key("action")
3959		ok.String(string(v.Action))
3960	}
3961
3962	if v.Description != nil {
3963		ok := object.Key("description")
3964		ok.String(*v.Description)
3965	}
3966
3967	if v.FindingCriteria != nil {
3968		ok := object.Key("findingCriteria")
3969		if err := awsRestjson1_serializeDocumentFindingCriteria(v.FindingCriteria, ok); err != nil {
3970			return err
3971		}
3972	}
3973
3974	if v.Rank != 0 {
3975		ok := object.Key("rank")
3976		ok.Integer(v.Rank)
3977	}
3978
3979	return nil
3980}
3981
3982type awsRestjson1_serializeOpUpdateFindingsFeedback struct {
3983}
3984
3985func (*awsRestjson1_serializeOpUpdateFindingsFeedback) ID() string {
3986	return "OperationSerializer"
3987}
3988
3989func (m *awsRestjson1_serializeOpUpdateFindingsFeedback) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3990	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3991) {
3992	request, ok := in.Request.(*smithyhttp.Request)
3993	if !ok {
3994		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3995	}
3996
3997	input, ok := in.Parameters.(*UpdateFindingsFeedbackInput)
3998	_ = input
3999	if !ok {
4000		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4001	}
4002
4003	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/findings/feedback")
4004	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4005	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4006	request.Method = "POST"
4007	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4008	if err != nil {
4009		return out, metadata, &smithy.SerializationError{Err: err}
4010	}
4011
4012	if err := awsRestjson1_serializeOpHttpBindingsUpdateFindingsFeedbackInput(input, restEncoder); err != nil {
4013		return out, metadata, &smithy.SerializationError{Err: err}
4014	}
4015
4016	restEncoder.SetHeader("Content-Type").String("application/json")
4017
4018	jsonEncoder := smithyjson.NewEncoder()
4019	if err := awsRestjson1_serializeOpDocumentUpdateFindingsFeedbackInput(input, jsonEncoder.Value); err != nil {
4020		return out, metadata, &smithy.SerializationError{Err: err}
4021	}
4022
4023	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4024		return out, metadata, &smithy.SerializationError{Err: err}
4025	}
4026
4027	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4028		return out, metadata, &smithy.SerializationError{Err: err}
4029	}
4030	in.Request = request
4031
4032	return next.HandleSerialize(ctx, in)
4033}
4034func awsRestjson1_serializeOpHttpBindingsUpdateFindingsFeedbackInput(v *UpdateFindingsFeedbackInput, encoder *httpbinding.Encoder) error {
4035	if v == nil {
4036		return fmt.Errorf("unsupported serialization of nil %T", v)
4037	}
4038
4039	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4040		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4041	}
4042	if v.DetectorId != nil {
4043		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4044			return err
4045		}
4046	}
4047
4048	return nil
4049}
4050
4051func awsRestjson1_serializeOpDocumentUpdateFindingsFeedbackInput(v *UpdateFindingsFeedbackInput, value smithyjson.Value) error {
4052	object := value.Object()
4053	defer object.Close()
4054
4055	if v.Comments != nil {
4056		ok := object.Key("comments")
4057		ok.String(*v.Comments)
4058	}
4059
4060	if len(v.Feedback) > 0 {
4061		ok := object.Key("feedback")
4062		ok.String(string(v.Feedback))
4063	}
4064
4065	if v.FindingIds != nil {
4066		ok := object.Key("findingIds")
4067		if err := awsRestjson1_serializeDocumentFindingIds(v.FindingIds, ok); err != nil {
4068			return err
4069		}
4070	}
4071
4072	return nil
4073}
4074
4075type awsRestjson1_serializeOpUpdateIPSet struct {
4076}
4077
4078func (*awsRestjson1_serializeOpUpdateIPSet) ID() string {
4079	return "OperationSerializer"
4080}
4081
4082func (m *awsRestjson1_serializeOpUpdateIPSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4083	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4084) {
4085	request, ok := in.Request.(*smithyhttp.Request)
4086	if !ok {
4087		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4088	}
4089
4090	input, ok := in.Parameters.(*UpdateIPSetInput)
4091	_ = input
4092	if !ok {
4093		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4094	}
4095
4096	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/ipset/{IpSetId}")
4097	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4098	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4099	request.Method = "POST"
4100	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4101	if err != nil {
4102		return out, metadata, &smithy.SerializationError{Err: err}
4103	}
4104
4105	if err := awsRestjson1_serializeOpHttpBindingsUpdateIPSetInput(input, restEncoder); err != nil {
4106		return out, metadata, &smithy.SerializationError{Err: err}
4107	}
4108
4109	restEncoder.SetHeader("Content-Type").String("application/json")
4110
4111	jsonEncoder := smithyjson.NewEncoder()
4112	if err := awsRestjson1_serializeOpDocumentUpdateIPSetInput(input, jsonEncoder.Value); err != nil {
4113		return out, metadata, &smithy.SerializationError{Err: err}
4114	}
4115
4116	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4117		return out, metadata, &smithy.SerializationError{Err: err}
4118	}
4119
4120	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4121		return out, metadata, &smithy.SerializationError{Err: err}
4122	}
4123	in.Request = request
4124
4125	return next.HandleSerialize(ctx, in)
4126}
4127func awsRestjson1_serializeOpHttpBindingsUpdateIPSetInput(v *UpdateIPSetInput, encoder *httpbinding.Encoder) error {
4128	if v == nil {
4129		return fmt.Errorf("unsupported serialization of nil %T", v)
4130	}
4131
4132	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4133		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4134	}
4135	if v.DetectorId != nil {
4136		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4137			return err
4138		}
4139	}
4140
4141	if v.IpSetId == nil || len(*v.IpSetId) == 0 {
4142		return &smithy.SerializationError{Err: fmt.Errorf("input member IpSetId must not be empty")}
4143	}
4144	if v.IpSetId != nil {
4145		if err := encoder.SetURI("IpSetId").String(*v.IpSetId); err != nil {
4146			return err
4147		}
4148	}
4149
4150	return nil
4151}
4152
4153func awsRestjson1_serializeOpDocumentUpdateIPSetInput(v *UpdateIPSetInput, value smithyjson.Value) error {
4154	object := value.Object()
4155	defer object.Close()
4156
4157	if v.Activate {
4158		ok := object.Key("activate")
4159		ok.Boolean(v.Activate)
4160	}
4161
4162	if v.Location != nil {
4163		ok := object.Key("location")
4164		ok.String(*v.Location)
4165	}
4166
4167	if v.Name != nil {
4168		ok := object.Key("name")
4169		ok.String(*v.Name)
4170	}
4171
4172	return nil
4173}
4174
4175type awsRestjson1_serializeOpUpdateMemberDetectors struct {
4176}
4177
4178func (*awsRestjson1_serializeOpUpdateMemberDetectors) ID() string {
4179	return "OperationSerializer"
4180}
4181
4182func (m *awsRestjson1_serializeOpUpdateMemberDetectors) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4183	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4184) {
4185	request, ok := in.Request.(*smithyhttp.Request)
4186	if !ok {
4187		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4188	}
4189
4190	input, ok := in.Parameters.(*UpdateMemberDetectorsInput)
4191	_ = input
4192	if !ok {
4193		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4194	}
4195
4196	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/member/detector/update")
4197	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4198	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4199	request.Method = "POST"
4200	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4201	if err != nil {
4202		return out, metadata, &smithy.SerializationError{Err: err}
4203	}
4204
4205	if err := awsRestjson1_serializeOpHttpBindingsUpdateMemberDetectorsInput(input, restEncoder); err != nil {
4206		return out, metadata, &smithy.SerializationError{Err: err}
4207	}
4208
4209	restEncoder.SetHeader("Content-Type").String("application/json")
4210
4211	jsonEncoder := smithyjson.NewEncoder()
4212	if err := awsRestjson1_serializeOpDocumentUpdateMemberDetectorsInput(input, jsonEncoder.Value); err != nil {
4213		return out, metadata, &smithy.SerializationError{Err: err}
4214	}
4215
4216	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4217		return out, metadata, &smithy.SerializationError{Err: err}
4218	}
4219
4220	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4221		return out, metadata, &smithy.SerializationError{Err: err}
4222	}
4223	in.Request = request
4224
4225	return next.HandleSerialize(ctx, in)
4226}
4227func awsRestjson1_serializeOpHttpBindingsUpdateMemberDetectorsInput(v *UpdateMemberDetectorsInput, encoder *httpbinding.Encoder) error {
4228	if v == nil {
4229		return fmt.Errorf("unsupported serialization of nil %T", v)
4230	}
4231
4232	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4233		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4234	}
4235	if v.DetectorId != nil {
4236		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4237			return err
4238		}
4239	}
4240
4241	return nil
4242}
4243
4244func awsRestjson1_serializeOpDocumentUpdateMemberDetectorsInput(v *UpdateMemberDetectorsInput, value smithyjson.Value) error {
4245	object := value.Object()
4246	defer object.Close()
4247
4248	if v.AccountIds != nil {
4249		ok := object.Key("accountIds")
4250		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
4251			return err
4252		}
4253	}
4254
4255	if v.DataSources != nil {
4256		ok := object.Key("dataSources")
4257		if err := awsRestjson1_serializeDocumentDataSourceConfigurations(v.DataSources, ok); err != nil {
4258			return err
4259		}
4260	}
4261
4262	return nil
4263}
4264
4265type awsRestjson1_serializeOpUpdateOrganizationConfiguration struct {
4266}
4267
4268func (*awsRestjson1_serializeOpUpdateOrganizationConfiguration) ID() string {
4269	return "OperationSerializer"
4270}
4271
4272func (m *awsRestjson1_serializeOpUpdateOrganizationConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4273	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4274) {
4275	request, ok := in.Request.(*smithyhttp.Request)
4276	if !ok {
4277		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4278	}
4279
4280	input, ok := in.Parameters.(*UpdateOrganizationConfigurationInput)
4281	_ = input
4282	if !ok {
4283		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4284	}
4285
4286	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/admin")
4287	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4288	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4289	request.Method = "POST"
4290	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4291	if err != nil {
4292		return out, metadata, &smithy.SerializationError{Err: err}
4293	}
4294
4295	if err := awsRestjson1_serializeOpHttpBindingsUpdateOrganizationConfigurationInput(input, restEncoder); err != nil {
4296		return out, metadata, &smithy.SerializationError{Err: err}
4297	}
4298
4299	restEncoder.SetHeader("Content-Type").String("application/json")
4300
4301	jsonEncoder := smithyjson.NewEncoder()
4302	if err := awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(input, jsonEncoder.Value); err != nil {
4303		return out, metadata, &smithy.SerializationError{Err: err}
4304	}
4305
4306	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4307		return out, metadata, &smithy.SerializationError{Err: err}
4308	}
4309
4310	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4311		return out, metadata, &smithy.SerializationError{Err: err}
4312	}
4313	in.Request = request
4314
4315	return next.HandleSerialize(ctx, in)
4316}
4317func awsRestjson1_serializeOpHttpBindingsUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, encoder *httpbinding.Encoder) error {
4318	if v == nil {
4319		return fmt.Errorf("unsupported serialization of nil %T", v)
4320	}
4321
4322	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4323		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4324	}
4325	if v.DetectorId != nil {
4326		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4327			return err
4328		}
4329	}
4330
4331	return nil
4332}
4333
4334func awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, value smithyjson.Value) error {
4335	object := value.Object()
4336	defer object.Close()
4337
4338	{
4339		ok := object.Key("autoEnable")
4340		ok.Boolean(v.AutoEnable)
4341	}
4342
4343	if v.DataSources != nil {
4344		ok := object.Key("dataSources")
4345		if err := awsRestjson1_serializeDocumentOrganizationDataSourceConfigurations(v.DataSources, ok); err != nil {
4346			return err
4347		}
4348	}
4349
4350	return nil
4351}
4352
4353type awsRestjson1_serializeOpUpdatePublishingDestination struct {
4354}
4355
4356func (*awsRestjson1_serializeOpUpdatePublishingDestination) ID() string {
4357	return "OperationSerializer"
4358}
4359
4360func (m *awsRestjson1_serializeOpUpdatePublishingDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4361	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4362) {
4363	request, ok := in.Request.(*smithyhttp.Request)
4364	if !ok {
4365		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4366	}
4367
4368	input, ok := in.Parameters.(*UpdatePublishingDestinationInput)
4369	_ = input
4370	if !ok {
4371		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4372	}
4373
4374	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/publishingDestination/{DestinationId}")
4375	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4376	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4377	request.Method = "POST"
4378	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4379	if err != nil {
4380		return out, metadata, &smithy.SerializationError{Err: err}
4381	}
4382
4383	if err := awsRestjson1_serializeOpHttpBindingsUpdatePublishingDestinationInput(input, restEncoder); err != nil {
4384		return out, metadata, &smithy.SerializationError{Err: err}
4385	}
4386
4387	restEncoder.SetHeader("Content-Type").String("application/json")
4388
4389	jsonEncoder := smithyjson.NewEncoder()
4390	if err := awsRestjson1_serializeOpDocumentUpdatePublishingDestinationInput(input, jsonEncoder.Value); err != nil {
4391		return out, metadata, &smithy.SerializationError{Err: err}
4392	}
4393
4394	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4395		return out, metadata, &smithy.SerializationError{Err: err}
4396	}
4397
4398	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4399		return out, metadata, &smithy.SerializationError{Err: err}
4400	}
4401	in.Request = request
4402
4403	return next.HandleSerialize(ctx, in)
4404}
4405func awsRestjson1_serializeOpHttpBindingsUpdatePublishingDestinationInput(v *UpdatePublishingDestinationInput, encoder *httpbinding.Encoder) error {
4406	if v == nil {
4407		return fmt.Errorf("unsupported serialization of nil %T", v)
4408	}
4409
4410	if v.DestinationId == nil || len(*v.DestinationId) == 0 {
4411		return &smithy.SerializationError{Err: fmt.Errorf("input member DestinationId must not be empty")}
4412	}
4413	if v.DestinationId != nil {
4414		if err := encoder.SetURI("DestinationId").String(*v.DestinationId); err != nil {
4415			return err
4416		}
4417	}
4418
4419	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4420		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4421	}
4422	if v.DetectorId != nil {
4423		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4424			return err
4425		}
4426	}
4427
4428	return nil
4429}
4430
4431func awsRestjson1_serializeOpDocumentUpdatePublishingDestinationInput(v *UpdatePublishingDestinationInput, value smithyjson.Value) error {
4432	object := value.Object()
4433	defer object.Close()
4434
4435	if v.DestinationProperties != nil {
4436		ok := object.Key("destinationProperties")
4437		if err := awsRestjson1_serializeDocumentDestinationProperties(v.DestinationProperties, ok); err != nil {
4438			return err
4439		}
4440	}
4441
4442	return nil
4443}
4444
4445type awsRestjson1_serializeOpUpdateThreatIntelSet struct {
4446}
4447
4448func (*awsRestjson1_serializeOpUpdateThreatIntelSet) ID() string {
4449	return "OperationSerializer"
4450}
4451
4452func (m *awsRestjson1_serializeOpUpdateThreatIntelSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4453	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4454) {
4455	request, ok := in.Request.(*smithyhttp.Request)
4456	if !ok {
4457		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4458	}
4459
4460	input, ok := in.Parameters.(*UpdateThreatIntelSetInput)
4461	_ = input
4462	if !ok {
4463		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4464	}
4465
4466	opPath, opQuery := httpbinding.SplitURI("/detector/{DetectorId}/threatintelset/{ThreatIntelSetId}")
4467	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4468	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4469	request.Method = "POST"
4470	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4471	if err != nil {
4472		return out, metadata, &smithy.SerializationError{Err: err}
4473	}
4474
4475	if err := awsRestjson1_serializeOpHttpBindingsUpdateThreatIntelSetInput(input, restEncoder); err != nil {
4476		return out, metadata, &smithy.SerializationError{Err: err}
4477	}
4478
4479	restEncoder.SetHeader("Content-Type").String("application/json")
4480
4481	jsonEncoder := smithyjson.NewEncoder()
4482	if err := awsRestjson1_serializeOpDocumentUpdateThreatIntelSetInput(input, jsonEncoder.Value); err != nil {
4483		return out, metadata, &smithy.SerializationError{Err: err}
4484	}
4485
4486	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4487		return out, metadata, &smithy.SerializationError{Err: err}
4488	}
4489
4490	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4491		return out, metadata, &smithy.SerializationError{Err: err}
4492	}
4493	in.Request = request
4494
4495	return next.HandleSerialize(ctx, in)
4496}
4497func awsRestjson1_serializeOpHttpBindingsUpdateThreatIntelSetInput(v *UpdateThreatIntelSetInput, encoder *httpbinding.Encoder) error {
4498	if v == nil {
4499		return fmt.Errorf("unsupported serialization of nil %T", v)
4500	}
4501
4502	if v.DetectorId == nil || len(*v.DetectorId) == 0 {
4503		return &smithy.SerializationError{Err: fmt.Errorf("input member DetectorId must not be empty")}
4504	}
4505	if v.DetectorId != nil {
4506		if err := encoder.SetURI("DetectorId").String(*v.DetectorId); err != nil {
4507			return err
4508		}
4509	}
4510
4511	if v.ThreatIntelSetId == nil || len(*v.ThreatIntelSetId) == 0 {
4512		return &smithy.SerializationError{Err: fmt.Errorf("input member ThreatIntelSetId must not be empty")}
4513	}
4514	if v.ThreatIntelSetId != nil {
4515		if err := encoder.SetURI("ThreatIntelSetId").String(*v.ThreatIntelSetId); err != nil {
4516			return err
4517		}
4518	}
4519
4520	return nil
4521}
4522
4523func awsRestjson1_serializeOpDocumentUpdateThreatIntelSetInput(v *UpdateThreatIntelSetInput, value smithyjson.Value) error {
4524	object := value.Object()
4525	defer object.Close()
4526
4527	if v.Activate {
4528		ok := object.Key("activate")
4529		ok.Boolean(v.Activate)
4530	}
4531
4532	if v.Location != nil {
4533		ok := object.Key("location")
4534		ok.String(*v.Location)
4535	}
4536
4537	if v.Name != nil {
4538		ok := object.Key("name")
4539		ok.String(*v.Name)
4540	}
4541
4542	return nil
4543}
4544
4545func awsRestjson1_serializeDocumentAccountDetail(v *types.AccountDetail, value smithyjson.Value) error {
4546	object := value.Object()
4547	defer object.Close()
4548
4549	if v.AccountId != nil {
4550		ok := object.Key("accountId")
4551		ok.String(*v.AccountId)
4552	}
4553
4554	if v.Email != nil {
4555		ok := object.Key("email")
4556		ok.String(*v.Email)
4557	}
4558
4559	return nil
4560}
4561
4562func awsRestjson1_serializeDocumentAccountDetails(v []types.AccountDetail, value smithyjson.Value) error {
4563	array := value.Array()
4564	defer array.Close()
4565
4566	for i := range v {
4567		av := array.Value()
4568		if err := awsRestjson1_serializeDocumentAccountDetail(&v[i], av); err != nil {
4569			return err
4570		}
4571	}
4572	return nil
4573}
4574
4575func awsRestjson1_serializeDocumentAccountIds(v []string, value smithyjson.Value) error {
4576	array := value.Array()
4577	defer array.Close()
4578
4579	for i := range v {
4580		av := array.Value()
4581		av.String(v[i])
4582	}
4583	return nil
4584}
4585
4586func awsRestjson1_serializeDocumentCondition(v *types.Condition, value smithyjson.Value) error {
4587	object := value.Object()
4588	defer object.Close()
4589
4590	if v.Eq != nil {
4591		ok := object.Key("eq")
4592		if err := awsRestjson1_serializeDocumentEq(v.Eq, ok); err != nil {
4593			return err
4594		}
4595	}
4596
4597	if v.Equals != nil {
4598		ok := object.Key("equals")
4599		if err := awsRestjson1_serializeDocumentEquals(v.Equals, ok); err != nil {
4600			return err
4601		}
4602	}
4603
4604	if v.GreaterThan != 0 {
4605		ok := object.Key("greaterThan")
4606		ok.Long(v.GreaterThan)
4607	}
4608
4609	if v.GreaterThanOrEqual != 0 {
4610		ok := object.Key("greaterThanOrEqual")
4611		ok.Long(v.GreaterThanOrEqual)
4612	}
4613
4614	if v.Gt != 0 {
4615		ok := object.Key("gt")
4616		ok.Integer(v.Gt)
4617	}
4618
4619	if v.Gte != 0 {
4620		ok := object.Key("gte")
4621		ok.Integer(v.Gte)
4622	}
4623
4624	if v.LessThan != 0 {
4625		ok := object.Key("lessThan")
4626		ok.Long(v.LessThan)
4627	}
4628
4629	if v.LessThanOrEqual != 0 {
4630		ok := object.Key("lessThanOrEqual")
4631		ok.Long(v.LessThanOrEqual)
4632	}
4633
4634	if v.Lt != 0 {
4635		ok := object.Key("lt")
4636		ok.Integer(v.Lt)
4637	}
4638
4639	if v.Lte != 0 {
4640		ok := object.Key("lte")
4641		ok.Integer(v.Lte)
4642	}
4643
4644	if v.Neq != nil {
4645		ok := object.Key("neq")
4646		if err := awsRestjson1_serializeDocumentNeq(v.Neq, ok); err != nil {
4647			return err
4648		}
4649	}
4650
4651	if v.NotEquals != nil {
4652		ok := object.Key("notEquals")
4653		if err := awsRestjson1_serializeDocumentNotEquals(v.NotEquals, ok); err != nil {
4654			return err
4655		}
4656	}
4657
4658	return nil
4659}
4660
4661func awsRestjson1_serializeDocumentCriterion(v map[string]types.Condition, value smithyjson.Value) error {
4662	object := value.Object()
4663	defer object.Close()
4664
4665	for key := range v {
4666		om := object.Key(key)
4667		mapVar := v[key]
4668		if err := awsRestjson1_serializeDocumentCondition(&mapVar, om); err != nil {
4669			return err
4670		}
4671	}
4672	return nil
4673}
4674
4675func awsRestjson1_serializeDocumentDataSourceConfigurations(v *types.DataSourceConfigurations, value smithyjson.Value) error {
4676	object := value.Object()
4677	defer object.Close()
4678
4679	if v.S3Logs != nil {
4680		ok := object.Key("s3Logs")
4681		if err := awsRestjson1_serializeDocumentS3LogsConfiguration(v.S3Logs, ok); err != nil {
4682			return err
4683		}
4684	}
4685
4686	return nil
4687}
4688
4689func awsRestjson1_serializeDocumentDataSourceList(v []types.DataSource, value smithyjson.Value) error {
4690	array := value.Array()
4691	defer array.Close()
4692
4693	for i := range v {
4694		av := array.Value()
4695		av.String(string(v[i]))
4696	}
4697	return nil
4698}
4699
4700func awsRestjson1_serializeDocumentDestinationProperties(v *types.DestinationProperties, value smithyjson.Value) error {
4701	object := value.Object()
4702	defer object.Close()
4703
4704	if v.DestinationArn != nil {
4705		ok := object.Key("destinationArn")
4706		ok.String(*v.DestinationArn)
4707	}
4708
4709	if v.KmsKeyArn != nil {
4710		ok := object.Key("kmsKeyArn")
4711		ok.String(*v.KmsKeyArn)
4712	}
4713
4714	return nil
4715}
4716
4717func awsRestjson1_serializeDocumentEq(v []string, value smithyjson.Value) error {
4718	array := value.Array()
4719	defer array.Close()
4720
4721	for i := range v {
4722		av := array.Value()
4723		av.String(v[i])
4724	}
4725	return nil
4726}
4727
4728func awsRestjson1_serializeDocumentEquals(v []string, value smithyjson.Value) error {
4729	array := value.Array()
4730	defer array.Close()
4731
4732	for i := range v {
4733		av := array.Value()
4734		av.String(v[i])
4735	}
4736	return nil
4737}
4738
4739func awsRestjson1_serializeDocumentFindingCriteria(v *types.FindingCriteria, value smithyjson.Value) error {
4740	object := value.Object()
4741	defer object.Close()
4742
4743	if v.Criterion != nil {
4744		ok := object.Key("criterion")
4745		if err := awsRestjson1_serializeDocumentCriterion(v.Criterion, ok); err != nil {
4746			return err
4747		}
4748	}
4749
4750	return nil
4751}
4752
4753func awsRestjson1_serializeDocumentFindingIds(v []string, value smithyjson.Value) error {
4754	array := value.Array()
4755	defer array.Close()
4756
4757	for i := range v {
4758		av := array.Value()
4759		av.String(v[i])
4760	}
4761	return nil
4762}
4763
4764func awsRestjson1_serializeDocumentFindingStatisticTypes(v []types.FindingStatisticType, value smithyjson.Value) error {
4765	array := value.Array()
4766	defer array.Close()
4767
4768	for i := range v {
4769		av := array.Value()
4770		av.String(string(v[i]))
4771	}
4772	return nil
4773}
4774
4775func awsRestjson1_serializeDocumentFindingTypes(v []string, value smithyjson.Value) error {
4776	array := value.Array()
4777	defer array.Close()
4778
4779	for i := range v {
4780		av := array.Value()
4781		av.String(v[i])
4782	}
4783	return nil
4784}
4785
4786func awsRestjson1_serializeDocumentNeq(v []string, value smithyjson.Value) error {
4787	array := value.Array()
4788	defer array.Close()
4789
4790	for i := range v {
4791		av := array.Value()
4792		av.String(v[i])
4793	}
4794	return nil
4795}
4796
4797func awsRestjson1_serializeDocumentNotEquals(v []string, value smithyjson.Value) error {
4798	array := value.Array()
4799	defer array.Close()
4800
4801	for i := range v {
4802		av := array.Value()
4803		av.String(v[i])
4804	}
4805	return nil
4806}
4807
4808func awsRestjson1_serializeDocumentOrganizationDataSourceConfigurations(v *types.OrganizationDataSourceConfigurations, value smithyjson.Value) error {
4809	object := value.Object()
4810	defer object.Close()
4811
4812	if v.S3Logs != nil {
4813		ok := object.Key("s3Logs")
4814		if err := awsRestjson1_serializeDocumentOrganizationS3LogsConfiguration(v.S3Logs, ok); err != nil {
4815			return err
4816		}
4817	}
4818
4819	return nil
4820}
4821
4822func awsRestjson1_serializeDocumentOrganizationS3LogsConfiguration(v *types.OrganizationS3LogsConfiguration, value smithyjson.Value) error {
4823	object := value.Object()
4824	defer object.Close()
4825
4826	{
4827		ok := object.Key("autoEnable")
4828		ok.Boolean(v.AutoEnable)
4829	}
4830
4831	return nil
4832}
4833
4834func awsRestjson1_serializeDocumentResourceList(v []string, value smithyjson.Value) error {
4835	array := value.Array()
4836	defer array.Close()
4837
4838	for i := range v {
4839		av := array.Value()
4840		av.String(v[i])
4841	}
4842	return nil
4843}
4844
4845func awsRestjson1_serializeDocumentS3LogsConfiguration(v *types.S3LogsConfiguration, value smithyjson.Value) error {
4846	object := value.Object()
4847	defer object.Close()
4848
4849	{
4850		ok := object.Key("enable")
4851		ok.Boolean(v.Enable)
4852	}
4853
4854	return nil
4855}
4856
4857func awsRestjson1_serializeDocumentSortCriteria(v *types.SortCriteria, value smithyjson.Value) error {
4858	object := value.Object()
4859	defer object.Close()
4860
4861	if v.AttributeName != nil {
4862		ok := object.Key("attributeName")
4863		ok.String(*v.AttributeName)
4864	}
4865
4866	if len(v.OrderBy) > 0 {
4867		ok := object.Key("orderBy")
4868		ok.String(string(v.OrderBy))
4869	}
4870
4871	return nil
4872}
4873
4874func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
4875	object := value.Object()
4876	defer object.Close()
4877
4878	for key := range v {
4879		om := object.Key(key)
4880		om.String(v[key])
4881	}
4882	return nil
4883}
4884
4885func awsRestjson1_serializeDocumentUsageCriteria(v *types.UsageCriteria, value smithyjson.Value) error {
4886	object := value.Object()
4887	defer object.Close()
4888
4889	if v.AccountIds != nil {
4890		ok := object.Key("accountIds")
4891		if err := awsRestjson1_serializeDocumentAccountIds(v.AccountIds, ok); err != nil {
4892			return err
4893		}
4894	}
4895
4896	if v.DataSources != nil {
4897		ok := object.Key("dataSources")
4898		if err := awsRestjson1_serializeDocumentDataSourceList(v.DataSources, ok); err != nil {
4899			return err
4900		}
4901	}
4902
4903	if v.Resources != nil {
4904		ok := object.Key("resources")
4905		if err := awsRestjson1_serializeDocumentResourceList(v.Resources, ok); err != nil {
4906			return err
4907		}
4908	}
4909
4910	return nil
4911}
4912