1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package detective
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/detective/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsRestjson1_serializeOpAcceptInvitation struct {
18}
19
20func (*awsRestjson1_serializeOpAcceptInvitation) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpAcceptInvitation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*AcceptInvitationInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	opPath, opQuery := httpbinding.SplitURI("/invitation")
39	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
40	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
41	request.Method = "PUT"
42	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
43	if err != nil {
44		return out, metadata, &smithy.SerializationError{Err: err}
45	}
46
47	restEncoder.SetHeader("Content-Type").String("application/json")
48
49	jsonEncoder := smithyjson.NewEncoder()
50	if err := awsRestjson1_serializeOpDocumentAcceptInvitationInput(input, jsonEncoder.Value); err != nil {
51		return out, metadata, &smithy.SerializationError{Err: err}
52	}
53
54	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
55		return out, metadata, &smithy.SerializationError{Err: err}
56	}
57
58	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
59		return out, metadata, &smithy.SerializationError{Err: err}
60	}
61	in.Request = request
62
63	return next.HandleSerialize(ctx, in)
64}
65func awsRestjson1_serializeOpHttpBindingsAcceptInvitationInput(v *AcceptInvitationInput, encoder *httpbinding.Encoder) error {
66	if v == nil {
67		return fmt.Errorf("unsupported serialization of nil %T", v)
68	}
69
70	return nil
71}
72
73func awsRestjson1_serializeOpDocumentAcceptInvitationInput(v *AcceptInvitationInput, value smithyjson.Value) error {
74	object := value.Object()
75	defer object.Close()
76
77	if v.GraphArn != nil {
78		ok := object.Key("GraphArn")
79		ok.String(*v.GraphArn)
80	}
81
82	return nil
83}
84
85type awsRestjson1_serializeOpCreateGraph struct {
86}
87
88func (*awsRestjson1_serializeOpCreateGraph) ID() string {
89	return "OperationSerializer"
90}
91
92func (m *awsRestjson1_serializeOpCreateGraph) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
93	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
94) {
95	request, ok := in.Request.(*smithyhttp.Request)
96	if !ok {
97		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
98	}
99
100	input, ok := in.Parameters.(*CreateGraphInput)
101	_ = input
102	if !ok {
103		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
104	}
105
106	opPath, opQuery := httpbinding.SplitURI("/graph")
107	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
108	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
109	request.Method = "POST"
110	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
111	if err != nil {
112		return out, metadata, &smithy.SerializationError{Err: err}
113	}
114
115	restEncoder.SetHeader("Content-Type").String("application/json")
116
117	jsonEncoder := smithyjson.NewEncoder()
118	if err := awsRestjson1_serializeOpDocumentCreateGraphInput(input, jsonEncoder.Value); err != nil {
119		return out, metadata, &smithy.SerializationError{Err: err}
120	}
121
122	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
123		return out, metadata, &smithy.SerializationError{Err: err}
124	}
125
126	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
127		return out, metadata, &smithy.SerializationError{Err: err}
128	}
129	in.Request = request
130
131	return next.HandleSerialize(ctx, in)
132}
133func awsRestjson1_serializeOpHttpBindingsCreateGraphInput(v *CreateGraphInput, encoder *httpbinding.Encoder) error {
134	if v == nil {
135		return fmt.Errorf("unsupported serialization of nil %T", v)
136	}
137
138	return nil
139}
140
141func awsRestjson1_serializeOpDocumentCreateGraphInput(v *CreateGraphInput, value smithyjson.Value) error {
142	object := value.Object()
143	defer object.Close()
144
145	if v.Tags != nil {
146		ok := object.Key("Tags")
147		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
148			return err
149		}
150	}
151
152	return nil
153}
154
155type awsRestjson1_serializeOpCreateMembers struct {
156}
157
158func (*awsRestjson1_serializeOpCreateMembers) ID() string {
159	return "OperationSerializer"
160}
161
162func (m *awsRestjson1_serializeOpCreateMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
163	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
164) {
165	request, ok := in.Request.(*smithyhttp.Request)
166	if !ok {
167		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
168	}
169
170	input, ok := in.Parameters.(*CreateMembersInput)
171	_ = input
172	if !ok {
173		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
174	}
175
176	opPath, opQuery := httpbinding.SplitURI("/graph/members")
177	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
178	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
179	request.Method = "POST"
180	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
181	if err != nil {
182		return out, metadata, &smithy.SerializationError{Err: err}
183	}
184
185	restEncoder.SetHeader("Content-Type").String("application/json")
186
187	jsonEncoder := smithyjson.NewEncoder()
188	if err := awsRestjson1_serializeOpDocumentCreateMembersInput(input, jsonEncoder.Value); err != nil {
189		return out, metadata, &smithy.SerializationError{Err: err}
190	}
191
192	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
193		return out, metadata, &smithy.SerializationError{Err: err}
194	}
195
196	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
197		return out, metadata, &smithy.SerializationError{Err: err}
198	}
199	in.Request = request
200
201	return next.HandleSerialize(ctx, in)
202}
203func awsRestjson1_serializeOpHttpBindingsCreateMembersInput(v *CreateMembersInput, encoder *httpbinding.Encoder) error {
204	if v == nil {
205		return fmt.Errorf("unsupported serialization of nil %T", v)
206	}
207
208	return nil
209}
210
211func awsRestjson1_serializeOpDocumentCreateMembersInput(v *CreateMembersInput, value smithyjson.Value) error {
212	object := value.Object()
213	defer object.Close()
214
215	if v.Accounts != nil {
216		ok := object.Key("Accounts")
217		if err := awsRestjson1_serializeDocumentAccountList(v.Accounts, ok); err != nil {
218			return err
219		}
220	}
221
222	if v.DisableEmailNotification {
223		ok := object.Key("DisableEmailNotification")
224		ok.Boolean(v.DisableEmailNotification)
225	}
226
227	if v.GraphArn != nil {
228		ok := object.Key("GraphArn")
229		ok.String(*v.GraphArn)
230	}
231
232	if v.Message != nil {
233		ok := object.Key("Message")
234		ok.String(*v.Message)
235	}
236
237	return nil
238}
239
240type awsRestjson1_serializeOpDeleteGraph struct {
241}
242
243func (*awsRestjson1_serializeOpDeleteGraph) ID() string {
244	return "OperationSerializer"
245}
246
247func (m *awsRestjson1_serializeOpDeleteGraph) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
249) {
250	request, ok := in.Request.(*smithyhttp.Request)
251	if !ok {
252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
253	}
254
255	input, ok := in.Parameters.(*DeleteGraphInput)
256	_ = input
257	if !ok {
258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
259	}
260
261	opPath, opQuery := httpbinding.SplitURI("/graph/removal")
262	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
263	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
264	request.Method = "POST"
265	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
266	if err != nil {
267		return out, metadata, &smithy.SerializationError{Err: err}
268	}
269
270	restEncoder.SetHeader("Content-Type").String("application/json")
271
272	jsonEncoder := smithyjson.NewEncoder()
273	if err := awsRestjson1_serializeOpDocumentDeleteGraphInput(input, jsonEncoder.Value); err != nil {
274		return out, metadata, &smithy.SerializationError{Err: err}
275	}
276
277	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280
281	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
282		return out, metadata, &smithy.SerializationError{Err: err}
283	}
284	in.Request = request
285
286	return next.HandleSerialize(ctx, in)
287}
288func awsRestjson1_serializeOpHttpBindingsDeleteGraphInput(v *DeleteGraphInput, encoder *httpbinding.Encoder) error {
289	if v == nil {
290		return fmt.Errorf("unsupported serialization of nil %T", v)
291	}
292
293	return nil
294}
295
296func awsRestjson1_serializeOpDocumentDeleteGraphInput(v *DeleteGraphInput, value smithyjson.Value) error {
297	object := value.Object()
298	defer object.Close()
299
300	if v.GraphArn != nil {
301		ok := object.Key("GraphArn")
302		ok.String(*v.GraphArn)
303	}
304
305	return nil
306}
307
308type awsRestjson1_serializeOpDeleteMembers struct {
309}
310
311func (*awsRestjson1_serializeOpDeleteMembers) ID() string {
312	return "OperationSerializer"
313}
314
315func (m *awsRestjson1_serializeOpDeleteMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
316	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
317) {
318	request, ok := in.Request.(*smithyhttp.Request)
319	if !ok {
320		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
321	}
322
323	input, ok := in.Parameters.(*DeleteMembersInput)
324	_ = input
325	if !ok {
326		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
327	}
328
329	opPath, opQuery := httpbinding.SplitURI("/graph/members/removal")
330	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
331	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
332	request.Method = "POST"
333	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
334	if err != nil {
335		return out, metadata, &smithy.SerializationError{Err: err}
336	}
337
338	restEncoder.SetHeader("Content-Type").String("application/json")
339
340	jsonEncoder := smithyjson.NewEncoder()
341	if err := awsRestjson1_serializeOpDocumentDeleteMembersInput(input, jsonEncoder.Value); err != nil {
342		return out, metadata, &smithy.SerializationError{Err: err}
343	}
344
345	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
346		return out, metadata, &smithy.SerializationError{Err: err}
347	}
348
349	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
350		return out, metadata, &smithy.SerializationError{Err: err}
351	}
352	in.Request = request
353
354	return next.HandleSerialize(ctx, in)
355}
356func awsRestjson1_serializeOpHttpBindingsDeleteMembersInput(v *DeleteMembersInput, encoder *httpbinding.Encoder) error {
357	if v == nil {
358		return fmt.Errorf("unsupported serialization of nil %T", v)
359	}
360
361	return nil
362}
363
364func awsRestjson1_serializeOpDocumentDeleteMembersInput(v *DeleteMembersInput, value smithyjson.Value) error {
365	object := value.Object()
366	defer object.Close()
367
368	if v.AccountIds != nil {
369		ok := object.Key("AccountIds")
370		if err := awsRestjson1_serializeDocumentAccountIdList(v.AccountIds, ok); err != nil {
371			return err
372		}
373	}
374
375	if v.GraphArn != nil {
376		ok := object.Key("GraphArn")
377		ok.String(*v.GraphArn)
378	}
379
380	return nil
381}
382
383type awsRestjson1_serializeOpDisassociateMembership struct {
384}
385
386func (*awsRestjson1_serializeOpDisassociateMembership) ID() string {
387	return "OperationSerializer"
388}
389
390func (m *awsRestjson1_serializeOpDisassociateMembership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
391	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
392) {
393	request, ok := in.Request.(*smithyhttp.Request)
394	if !ok {
395		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
396	}
397
398	input, ok := in.Parameters.(*DisassociateMembershipInput)
399	_ = input
400	if !ok {
401		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
402	}
403
404	opPath, opQuery := httpbinding.SplitURI("/membership/removal")
405	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
406	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
407	request.Method = "POST"
408	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
409	if err != nil {
410		return out, metadata, &smithy.SerializationError{Err: err}
411	}
412
413	restEncoder.SetHeader("Content-Type").String("application/json")
414
415	jsonEncoder := smithyjson.NewEncoder()
416	if err := awsRestjson1_serializeOpDocumentDisassociateMembershipInput(input, jsonEncoder.Value); err != nil {
417		return out, metadata, &smithy.SerializationError{Err: err}
418	}
419
420	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
421		return out, metadata, &smithy.SerializationError{Err: err}
422	}
423
424	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427	in.Request = request
428
429	return next.HandleSerialize(ctx, in)
430}
431func awsRestjson1_serializeOpHttpBindingsDisassociateMembershipInput(v *DisassociateMembershipInput, encoder *httpbinding.Encoder) error {
432	if v == nil {
433		return fmt.Errorf("unsupported serialization of nil %T", v)
434	}
435
436	return nil
437}
438
439func awsRestjson1_serializeOpDocumentDisassociateMembershipInput(v *DisassociateMembershipInput, value smithyjson.Value) error {
440	object := value.Object()
441	defer object.Close()
442
443	if v.GraphArn != nil {
444		ok := object.Key("GraphArn")
445		ok.String(*v.GraphArn)
446	}
447
448	return nil
449}
450
451type awsRestjson1_serializeOpGetMembers struct {
452}
453
454func (*awsRestjson1_serializeOpGetMembers) ID() string {
455	return "OperationSerializer"
456}
457
458func (m *awsRestjson1_serializeOpGetMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
459	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
460) {
461	request, ok := in.Request.(*smithyhttp.Request)
462	if !ok {
463		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
464	}
465
466	input, ok := in.Parameters.(*GetMembersInput)
467	_ = input
468	if !ok {
469		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
470	}
471
472	opPath, opQuery := httpbinding.SplitURI("/graph/members/get")
473	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
474	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
475	request.Method = "POST"
476	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
477	if err != nil {
478		return out, metadata, &smithy.SerializationError{Err: err}
479	}
480
481	restEncoder.SetHeader("Content-Type").String("application/json")
482
483	jsonEncoder := smithyjson.NewEncoder()
484	if err := awsRestjson1_serializeOpDocumentGetMembersInput(input, jsonEncoder.Value); err != nil {
485		return out, metadata, &smithy.SerializationError{Err: err}
486	}
487
488	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
489		return out, metadata, &smithy.SerializationError{Err: err}
490	}
491
492	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
493		return out, metadata, &smithy.SerializationError{Err: err}
494	}
495	in.Request = request
496
497	return next.HandleSerialize(ctx, in)
498}
499func awsRestjson1_serializeOpHttpBindingsGetMembersInput(v *GetMembersInput, encoder *httpbinding.Encoder) error {
500	if v == nil {
501		return fmt.Errorf("unsupported serialization of nil %T", v)
502	}
503
504	return nil
505}
506
507func awsRestjson1_serializeOpDocumentGetMembersInput(v *GetMembersInput, value smithyjson.Value) error {
508	object := value.Object()
509	defer object.Close()
510
511	if v.AccountIds != nil {
512		ok := object.Key("AccountIds")
513		if err := awsRestjson1_serializeDocumentAccountIdList(v.AccountIds, ok); err != nil {
514			return err
515		}
516	}
517
518	if v.GraphArn != nil {
519		ok := object.Key("GraphArn")
520		ok.String(*v.GraphArn)
521	}
522
523	return nil
524}
525
526type awsRestjson1_serializeOpListGraphs struct {
527}
528
529func (*awsRestjson1_serializeOpListGraphs) ID() string {
530	return "OperationSerializer"
531}
532
533func (m *awsRestjson1_serializeOpListGraphs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
534	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
535) {
536	request, ok := in.Request.(*smithyhttp.Request)
537	if !ok {
538		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
539	}
540
541	input, ok := in.Parameters.(*ListGraphsInput)
542	_ = input
543	if !ok {
544		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
545	}
546
547	opPath, opQuery := httpbinding.SplitURI("/graphs/list")
548	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
549	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
550	request.Method = "POST"
551	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
552	if err != nil {
553		return out, metadata, &smithy.SerializationError{Err: err}
554	}
555
556	restEncoder.SetHeader("Content-Type").String("application/json")
557
558	jsonEncoder := smithyjson.NewEncoder()
559	if err := awsRestjson1_serializeOpDocumentListGraphsInput(input, jsonEncoder.Value); err != nil {
560		return out, metadata, &smithy.SerializationError{Err: err}
561	}
562
563	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
564		return out, metadata, &smithy.SerializationError{Err: err}
565	}
566
567	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
568		return out, metadata, &smithy.SerializationError{Err: err}
569	}
570	in.Request = request
571
572	return next.HandleSerialize(ctx, in)
573}
574func awsRestjson1_serializeOpHttpBindingsListGraphsInput(v *ListGraphsInput, encoder *httpbinding.Encoder) error {
575	if v == nil {
576		return fmt.Errorf("unsupported serialization of nil %T", v)
577	}
578
579	return nil
580}
581
582func awsRestjson1_serializeOpDocumentListGraphsInput(v *ListGraphsInput, value smithyjson.Value) error {
583	object := value.Object()
584	defer object.Close()
585
586	if v.MaxResults != nil {
587		ok := object.Key("MaxResults")
588		ok.Integer(*v.MaxResults)
589	}
590
591	if v.NextToken != nil {
592		ok := object.Key("NextToken")
593		ok.String(*v.NextToken)
594	}
595
596	return nil
597}
598
599type awsRestjson1_serializeOpListInvitations struct {
600}
601
602func (*awsRestjson1_serializeOpListInvitations) ID() string {
603	return "OperationSerializer"
604}
605
606func (m *awsRestjson1_serializeOpListInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
607	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
608) {
609	request, ok := in.Request.(*smithyhttp.Request)
610	if !ok {
611		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
612	}
613
614	input, ok := in.Parameters.(*ListInvitationsInput)
615	_ = input
616	if !ok {
617		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
618	}
619
620	opPath, opQuery := httpbinding.SplitURI("/invitations/list")
621	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
622	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
623	request.Method = "POST"
624	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
625	if err != nil {
626		return out, metadata, &smithy.SerializationError{Err: err}
627	}
628
629	restEncoder.SetHeader("Content-Type").String("application/json")
630
631	jsonEncoder := smithyjson.NewEncoder()
632	if err := awsRestjson1_serializeOpDocumentListInvitationsInput(input, jsonEncoder.Value); err != nil {
633		return out, metadata, &smithy.SerializationError{Err: err}
634	}
635
636	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
637		return out, metadata, &smithy.SerializationError{Err: err}
638	}
639
640	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
641		return out, metadata, &smithy.SerializationError{Err: err}
642	}
643	in.Request = request
644
645	return next.HandleSerialize(ctx, in)
646}
647func awsRestjson1_serializeOpHttpBindingsListInvitationsInput(v *ListInvitationsInput, encoder *httpbinding.Encoder) error {
648	if v == nil {
649		return fmt.Errorf("unsupported serialization of nil %T", v)
650	}
651
652	return nil
653}
654
655func awsRestjson1_serializeOpDocumentListInvitationsInput(v *ListInvitationsInput, value smithyjson.Value) error {
656	object := value.Object()
657	defer object.Close()
658
659	if v.MaxResults != nil {
660		ok := object.Key("MaxResults")
661		ok.Integer(*v.MaxResults)
662	}
663
664	if v.NextToken != nil {
665		ok := object.Key("NextToken")
666		ok.String(*v.NextToken)
667	}
668
669	return nil
670}
671
672type awsRestjson1_serializeOpListMembers struct {
673}
674
675func (*awsRestjson1_serializeOpListMembers) ID() string {
676	return "OperationSerializer"
677}
678
679func (m *awsRestjson1_serializeOpListMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
680	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
681) {
682	request, ok := in.Request.(*smithyhttp.Request)
683	if !ok {
684		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
685	}
686
687	input, ok := in.Parameters.(*ListMembersInput)
688	_ = input
689	if !ok {
690		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
691	}
692
693	opPath, opQuery := httpbinding.SplitURI("/graph/members/list")
694	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
695	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
696	request.Method = "POST"
697	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
698	if err != nil {
699		return out, metadata, &smithy.SerializationError{Err: err}
700	}
701
702	restEncoder.SetHeader("Content-Type").String("application/json")
703
704	jsonEncoder := smithyjson.NewEncoder()
705	if err := awsRestjson1_serializeOpDocumentListMembersInput(input, jsonEncoder.Value); err != nil {
706		return out, metadata, &smithy.SerializationError{Err: err}
707	}
708
709	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
710		return out, metadata, &smithy.SerializationError{Err: err}
711	}
712
713	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
714		return out, metadata, &smithy.SerializationError{Err: err}
715	}
716	in.Request = request
717
718	return next.HandleSerialize(ctx, in)
719}
720func awsRestjson1_serializeOpHttpBindingsListMembersInput(v *ListMembersInput, encoder *httpbinding.Encoder) error {
721	if v == nil {
722		return fmt.Errorf("unsupported serialization of nil %T", v)
723	}
724
725	return nil
726}
727
728func awsRestjson1_serializeOpDocumentListMembersInput(v *ListMembersInput, value smithyjson.Value) error {
729	object := value.Object()
730	defer object.Close()
731
732	if v.GraphArn != nil {
733		ok := object.Key("GraphArn")
734		ok.String(*v.GraphArn)
735	}
736
737	if v.MaxResults != nil {
738		ok := object.Key("MaxResults")
739		ok.Integer(*v.MaxResults)
740	}
741
742	if v.NextToken != nil {
743		ok := object.Key("NextToken")
744		ok.String(*v.NextToken)
745	}
746
747	return nil
748}
749
750type awsRestjson1_serializeOpListTagsForResource struct {
751}
752
753func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
754	return "OperationSerializer"
755}
756
757func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
758	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
759) {
760	request, ok := in.Request.(*smithyhttp.Request)
761	if !ok {
762		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
763	}
764
765	input, ok := in.Parameters.(*ListTagsForResourceInput)
766	_ = input
767	if !ok {
768		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
769	}
770
771	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
772	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
773	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
774	request.Method = "GET"
775	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
776	if err != nil {
777		return out, metadata, &smithy.SerializationError{Err: err}
778	}
779
780	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
781		return out, metadata, &smithy.SerializationError{Err: err}
782	}
783
784	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
785		return out, metadata, &smithy.SerializationError{Err: err}
786	}
787	in.Request = request
788
789	return next.HandleSerialize(ctx, in)
790}
791func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
792	if v == nil {
793		return fmt.Errorf("unsupported serialization of nil %T", v)
794	}
795
796	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
797		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
798	}
799	if v.ResourceArn != nil {
800		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
801			return err
802		}
803	}
804
805	return nil
806}
807
808type awsRestjson1_serializeOpRejectInvitation struct {
809}
810
811func (*awsRestjson1_serializeOpRejectInvitation) ID() string {
812	return "OperationSerializer"
813}
814
815func (m *awsRestjson1_serializeOpRejectInvitation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
816	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
817) {
818	request, ok := in.Request.(*smithyhttp.Request)
819	if !ok {
820		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
821	}
822
823	input, ok := in.Parameters.(*RejectInvitationInput)
824	_ = input
825	if !ok {
826		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
827	}
828
829	opPath, opQuery := httpbinding.SplitURI("/invitation/removal")
830	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
831	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
832	request.Method = "POST"
833	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
834	if err != nil {
835		return out, metadata, &smithy.SerializationError{Err: err}
836	}
837
838	restEncoder.SetHeader("Content-Type").String("application/json")
839
840	jsonEncoder := smithyjson.NewEncoder()
841	if err := awsRestjson1_serializeOpDocumentRejectInvitationInput(input, jsonEncoder.Value); err != nil {
842		return out, metadata, &smithy.SerializationError{Err: err}
843	}
844
845	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
846		return out, metadata, &smithy.SerializationError{Err: err}
847	}
848
849	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
850		return out, metadata, &smithy.SerializationError{Err: err}
851	}
852	in.Request = request
853
854	return next.HandleSerialize(ctx, in)
855}
856func awsRestjson1_serializeOpHttpBindingsRejectInvitationInput(v *RejectInvitationInput, encoder *httpbinding.Encoder) error {
857	if v == nil {
858		return fmt.Errorf("unsupported serialization of nil %T", v)
859	}
860
861	return nil
862}
863
864func awsRestjson1_serializeOpDocumentRejectInvitationInput(v *RejectInvitationInput, value smithyjson.Value) error {
865	object := value.Object()
866	defer object.Close()
867
868	if v.GraphArn != nil {
869		ok := object.Key("GraphArn")
870		ok.String(*v.GraphArn)
871	}
872
873	return nil
874}
875
876type awsRestjson1_serializeOpStartMonitoringMember struct {
877}
878
879func (*awsRestjson1_serializeOpStartMonitoringMember) ID() string {
880	return "OperationSerializer"
881}
882
883func (m *awsRestjson1_serializeOpStartMonitoringMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
884	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
885) {
886	request, ok := in.Request.(*smithyhttp.Request)
887	if !ok {
888		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
889	}
890
891	input, ok := in.Parameters.(*StartMonitoringMemberInput)
892	_ = input
893	if !ok {
894		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
895	}
896
897	opPath, opQuery := httpbinding.SplitURI("/graph/member/monitoringstate")
898	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
899	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
900	request.Method = "POST"
901	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
902	if err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905
906	restEncoder.SetHeader("Content-Type").String("application/json")
907
908	jsonEncoder := smithyjson.NewEncoder()
909	if err := awsRestjson1_serializeOpDocumentStartMonitoringMemberInput(input, jsonEncoder.Value); err != nil {
910		return out, metadata, &smithy.SerializationError{Err: err}
911	}
912
913	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
914		return out, metadata, &smithy.SerializationError{Err: err}
915	}
916
917	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
918		return out, metadata, &smithy.SerializationError{Err: err}
919	}
920	in.Request = request
921
922	return next.HandleSerialize(ctx, in)
923}
924func awsRestjson1_serializeOpHttpBindingsStartMonitoringMemberInput(v *StartMonitoringMemberInput, encoder *httpbinding.Encoder) error {
925	if v == nil {
926		return fmt.Errorf("unsupported serialization of nil %T", v)
927	}
928
929	return nil
930}
931
932func awsRestjson1_serializeOpDocumentStartMonitoringMemberInput(v *StartMonitoringMemberInput, value smithyjson.Value) error {
933	object := value.Object()
934	defer object.Close()
935
936	if v.AccountId != nil {
937		ok := object.Key("AccountId")
938		ok.String(*v.AccountId)
939	}
940
941	if v.GraphArn != nil {
942		ok := object.Key("GraphArn")
943		ok.String(*v.GraphArn)
944	}
945
946	return nil
947}
948
949type awsRestjson1_serializeOpTagResource struct {
950}
951
952func (*awsRestjson1_serializeOpTagResource) ID() string {
953	return "OperationSerializer"
954}
955
956func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
957	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
958) {
959	request, ok := in.Request.(*smithyhttp.Request)
960	if !ok {
961		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
962	}
963
964	input, ok := in.Parameters.(*TagResourceInput)
965	_ = input
966	if !ok {
967		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
968	}
969
970	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
971	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
972	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
973	request.Method = "POST"
974	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
975	if err != nil {
976		return out, metadata, &smithy.SerializationError{Err: err}
977	}
978
979	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
980		return out, metadata, &smithy.SerializationError{Err: err}
981	}
982
983	restEncoder.SetHeader("Content-Type").String("application/json")
984
985	jsonEncoder := smithyjson.NewEncoder()
986	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
987		return out, metadata, &smithy.SerializationError{Err: err}
988	}
989
990	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
991		return out, metadata, &smithy.SerializationError{Err: err}
992	}
993
994	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
995		return out, metadata, &smithy.SerializationError{Err: err}
996	}
997	in.Request = request
998
999	return next.HandleSerialize(ctx, in)
1000}
1001func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
1002	if v == nil {
1003		return fmt.Errorf("unsupported serialization of nil %T", v)
1004	}
1005
1006	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
1007		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
1008	}
1009	if v.ResourceArn != nil {
1010		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
1011			return err
1012		}
1013	}
1014
1015	return nil
1016}
1017
1018func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
1019	object := value.Object()
1020	defer object.Close()
1021
1022	if v.Tags != nil {
1023		ok := object.Key("Tags")
1024		if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
1025			return err
1026		}
1027	}
1028
1029	return nil
1030}
1031
1032type awsRestjson1_serializeOpUntagResource struct {
1033}
1034
1035func (*awsRestjson1_serializeOpUntagResource) ID() string {
1036	return "OperationSerializer"
1037}
1038
1039func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1040	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1041) {
1042	request, ok := in.Request.(*smithyhttp.Request)
1043	if !ok {
1044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1045	}
1046
1047	input, ok := in.Parameters.(*UntagResourceInput)
1048	_ = input
1049	if !ok {
1050		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1051	}
1052
1053	opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
1054	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1055	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1056	request.Method = "DELETE"
1057	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1058	if err != nil {
1059		return out, metadata, &smithy.SerializationError{Err: err}
1060	}
1061
1062	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
1063		return out, metadata, &smithy.SerializationError{Err: err}
1064	}
1065
1066	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1067		return out, metadata, &smithy.SerializationError{Err: err}
1068	}
1069	in.Request = request
1070
1071	return next.HandleSerialize(ctx, in)
1072}
1073func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
1074	if v == nil {
1075		return fmt.Errorf("unsupported serialization of nil %T", v)
1076	}
1077
1078	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
1079		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
1080	}
1081	if v.ResourceArn != nil {
1082		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
1083			return err
1084		}
1085	}
1086
1087	if v.TagKeys != nil {
1088		for i := range v.TagKeys {
1089			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
1090		}
1091	}
1092
1093	return nil
1094}
1095
1096func awsRestjson1_serializeDocumentAccount(v *types.Account, value smithyjson.Value) error {
1097	object := value.Object()
1098	defer object.Close()
1099
1100	if v.AccountId != nil {
1101		ok := object.Key("AccountId")
1102		ok.String(*v.AccountId)
1103	}
1104
1105	if v.EmailAddress != nil {
1106		ok := object.Key("EmailAddress")
1107		ok.String(*v.EmailAddress)
1108	}
1109
1110	return nil
1111}
1112
1113func awsRestjson1_serializeDocumentAccountIdList(v []string, value smithyjson.Value) error {
1114	array := value.Array()
1115	defer array.Close()
1116
1117	for i := range v {
1118		av := array.Value()
1119		av.String(v[i])
1120	}
1121	return nil
1122}
1123
1124func awsRestjson1_serializeDocumentAccountList(v []types.Account, value smithyjson.Value) error {
1125	array := value.Array()
1126	defer array.Close()
1127
1128	for i := range v {
1129		av := array.Value()
1130		if err := awsRestjson1_serializeDocumentAccount(&v[i], av); err != nil {
1131			return err
1132		}
1133	}
1134	return nil
1135}
1136
1137func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
1138	object := value.Object()
1139	defer object.Close()
1140
1141	for key := range v {
1142		om := object.Key(key)
1143		om.String(v[key])
1144	}
1145	return nil
1146}
1147