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