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