1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package workmail
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/workmail/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 awsAwsjson11_serializeOpAssociateDelegateToResource struct {
18}
19
20func (*awsAwsjson11_serializeOpAssociateDelegateToResource) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpAssociateDelegateToResource) 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.(*AssociateDelegateToResourceInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	request.Request.URL.Path = "/"
39	request.Request.Method = "POST"
40	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
41	if err != nil {
42		return out, metadata, &smithy.SerializationError{Err: err}
43	}
44	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
45	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.AssociateDelegateToResource")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentAssociateDelegateToResourceInput(input, jsonEncoder.Value); err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
53		return out, metadata, &smithy.SerializationError{Err: err}
54	}
55
56	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
57		return out, metadata, &smithy.SerializationError{Err: err}
58	}
59	in.Request = request
60
61	return next.HandleSerialize(ctx, in)
62}
63
64type awsAwsjson11_serializeOpAssociateMemberToGroup struct {
65}
66
67func (*awsAwsjson11_serializeOpAssociateMemberToGroup) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpAssociateMemberToGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
72	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
73) {
74	request, ok := in.Request.(*smithyhttp.Request)
75	if !ok {
76		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
77	}
78
79	input, ok := in.Parameters.(*AssociateMemberToGroupInput)
80	_ = input
81	if !ok {
82		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
83	}
84
85	request.Request.URL.Path = "/"
86	request.Request.Method = "POST"
87	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
88	if err != nil {
89		return out, metadata, &smithy.SerializationError{Err: err}
90	}
91	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
92	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.AssociateMemberToGroup")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentAssociateMemberToGroupInput(input, jsonEncoder.Value); err != nil {
96		return out, metadata, &smithy.SerializationError{Err: err}
97	}
98
99	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
100		return out, metadata, &smithy.SerializationError{Err: err}
101	}
102
103	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
104		return out, metadata, &smithy.SerializationError{Err: err}
105	}
106	in.Request = request
107
108	return next.HandleSerialize(ctx, in)
109}
110
111type awsAwsjson11_serializeOpCancelMailboxExportJob struct {
112}
113
114func (*awsAwsjson11_serializeOpCancelMailboxExportJob) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpCancelMailboxExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
119	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
120) {
121	request, ok := in.Request.(*smithyhttp.Request)
122	if !ok {
123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
124	}
125
126	input, ok := in.Parameters.(*CancelMailboxExportJobInput)
127	_ = input
128	if !ok {
129		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
130	}
131
132	request.Request.URL.Path = "/"
133	request.Request.Method = "POST"
134	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
135	if err != nil {
136		return out, metadata, &smithy.SerializationError{Err: err}
137	}
138	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
139	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CancelMailboxExportJob")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentCancelMailboxExportJobInput(input, jsonEncoder.Value); err != nil {
143		return out, metadata, &smithy.SerializationError{Err: err}
144	}
145
146	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
147		return out, metadata, &smithy.SerializationError{Err: err}
148	}
149
150	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
151		return out, metadata, &smithy.SerializationError{Err: err}
152	}
153	in.Request = request
154
155	return next.HandleSerialize(ctx, in)
156}
157
158type awsAwsjson11_serializeOpCreateAlias struct {
159}
160
161func (*awsAwsjson11_serializeOpCreateAlias) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCreateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
166	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
167) {
168	request, ok := in.Request.(*smithyhttp.Request)
169	if !ok {
170		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
171	}
172
173	input, ok := in.Parameters.(*CreateAliasInput)
174	_ = input
175	if !ok {
176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
177	}
178
179	request.Request.URL.Path = "/"
180	request.Request.Method = "POST"
181	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
182	if err != nil {
183		return out, metadata, &smithy.SerializationError{Err: err}
184	}
185	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
186	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateAlias")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCreateAliasInput(input, jsonEncoder.Value); err != nil {
190		return out, metadata, &smithy.SerializationError{Err: err}
191	}
192
193	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
194		return out, metadata, &smithy.SerializationError{Err: err}
195	}
196
197	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
198		return out, metadata, &smithy.SerializationError{Err: err}
199	}
200	in.Request = request
201
202	return next.HandleSerialize(ctx, in)
203}
204
205type awsAwsjson11_serializeOpCreateGroup struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateGroup) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
213	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
214) {
215	request, ok := in.Request.(*smithyhttp.Request)
216	if !ok {
217		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
218	}
219
220	input, ok := in.Parameters.(*CreateGroupInput)
221	_ = input
222	if !ok {
223		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
224	}
225
226	request.Request.URL.Path = "/"
227	request.Request.Method = "POST"
228	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
229	if err != nil {
230		return out, metadata, &smithy.SerializationError{Err: err}
231	}
232	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
233	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateGroup")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateGroupInput(input, jsonEncoder.Value); err != nil {
237		return out, metadata, &smithy.SerializationError{Err: err}
238	}
239
240	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
241		return out, metadata, &smithy.SerializationError{Err: err}
242	}
243
244	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
245		return out, metadata, &smithy.SerializationError{Err: err}
246	}
247	in.Request = request
248
249	return next.HandleSerialize(ctx, in)
250}
251
252type awsAwsjson11_serializeOpCreateMobileDeviceAccessRule struct {
253}
254
255func (*awsAwsjson11_serializeOpCreateMobileDeviceAccessRule) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpCreateMobileDeviceAccessRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
260	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
261) {
262	request, ok := in.Request.(*smithyhttp.Request)
263	if !ok {
264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
265	}
266
267	input, ok := in.Parameters.(*CreateMobileDeviceAccessRuleInput)
268	_ = input
269	if !ok {
270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
271	}
272
273	request.Request.URL.Path = "/"
274	request.Request.Method = "POST"
275	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
276	if err != nil {
277		return out, metadata, &smithy.SerializationError{Err: err}
278	}
279	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
280	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateMobileDeviceAccessRule")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentCreateMobileDeviceAccessRuleInput(input, jsonEncoder.Value); err != nil {
284		return out, metadata, &smithy.SerializationError{Err: err}
285	}
286
287	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
288		return out, metadata, &smithy.SerializationError{Err: err}
289	}
290
291	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
292		return out, metadata, &smithy.SerializationError{Err: err}
293	}
294	in.Request = request
295
296	return next.HandleSerialize(ctx, in)
297}
298
299type awsAwsjson11_serializeOpCreateOrganization struct {
300}
301
302func (*awsAwsjson11_serializeOpCreateOrganization) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpCreateOrganization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
308) {
309	request, ok := in.Request.(*smithyhttp.Request)
310	if !ok {
311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
312	}
313
314	input, ok := in.Parameters.(*CreateOrganizationInput)
315	_ = input
316	if !ok {
317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
318	}
319
320	request.Request.URL.Path = "/"
321	request.Request.Method = "POST"
322	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
323	if err != nil {
324		return out, metadata, &smithy.SerializationError{Err: err}
325	}
326	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
327	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateOrganization")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentCreateOrganizationInput(input, jsonEncoder.Value); err != nil {
331		return out, metadata, &smithy.SerializationError{Err: err}
332	}
333
334	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
335		return out, metadata, &smithy.SerializationError{Err: err}
336	}
337
338	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341	in.Request = request
342
343	return next.HandleSerialize(ctx, in)
344}
345
346type awsAwsjson11_serializeOpCreateResource struct {
347}
348
349func (*awsAwsjson11_serializeOpCreateResource) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpCreateResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
354	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
355) {
356	request, ok := in.Request.(*smithyhttp.Request)
357	if !ok {
358		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
359	}
360
361	input, ok := in.Parameters.(*CreateResourceInput)
362	_ = input
363	if !ok {
364		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
365	}
366
367	request.Request.URL.Path = "/"
368	request.Request.Method = "POST"
369	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
370	if err != nil {
371		return out, metadata, &smithy.SerializationError{Err: err}
372	}
373	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
374	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateResource")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentCreateResourceInput(input, jsonEncoder.Value); err != nil {
378		return out, metadata, &smithy.SerializationError{Err: err}
379	}
380
381	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
382		return out, metadata, &smithy.SerializationError{Err: err}
383	}
384
385	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
386		return out, metadata, &smithy.SerializationError{Err: err}
387	}
388	in.Request = request
389
390	return next.HandleSerialize(ctx, in)
391}
392
393type awsAwsjson11_serializeOpCreateUser struct {
394}
395
396func (*awsAwsjson11_serializeOpCreateUser) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpCreateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
401	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
402) {
403	request, ok := in.Request.(*smithyhttp.Request)
404	if !ok {
405		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
406	}
407
408	input, ok := in.Parameters.(*CreateUserInput)
409	_ = input
410	if !ok {
411		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
412	}
413
414	request.Request.URL.Path = "/"
415	request.Request.Method = "POST"
416	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
417	if err != nil {
418		return out, metadata, &smithy.SerializationError{Err: err}
419	}
420	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
421	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.CreateUser")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentCreateUserInput(input, jsonEncoder.Value); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427
428	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
429		return out, metadata, &smithy.SerializationError{Err: err}
430	}
431
432	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
433		return out, metadata, &smithy.SerializationError{Err: err}
434	}
435	in.Request = request
436
437	return next.HandleSerialize(ctx, in)
438}
439
440type awsAwsjson11_serializeOpDeleteAccessControlRule struct {
441}
442
443func (*awsAwsjson11_serializeOpDeleteAccessControlRule) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpDeleteAccessControlRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
448	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
449) {
450	request, ok := in.Request.(*smithyhttp.Request)
451	if !ok {
452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
453	}
454
455	input, ok := in.Parameters.(*DeleteAccessControlRuleInput)
456	_ = input
457	if !ok {
458		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
459	}
460
461	request.Request.URL.Path = "/"
462	request.Request.Method = "POST"
463	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
464	if err != nil {
465		return out, metadata, &smithy.SerializationError{Err: err}
466	}
467	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
468	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteAccessControlRule")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentDeleteAccessControlRuleInput(input, jsonEncoder.Value); err != nil {
472		return out, metadata, &smithy.SerializationError{Err: err}
473	}
474
475	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
476		return out, metadata, &smithy.SerializationError{Err: err}
477	}
478
479	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
480		return out, metadata, &smithy.SerializationError{Err: err}
481	}
482	in.Request = request
483
484	return next.HandleSerialize(ctx, in)
485}
486
487type awsAwsjson11_serializeOpDeleteAlias struct {
488}
489
490func (*awsAwsjson11_serializeOpDeleteAlias) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDeleteAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
495	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
496) {
497	request, ok := in.Request.(*smithyhttp.Request)
498	if !ok {
499		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
500	}
501
502	input, ok := in.Parameters.(*DeleteAliasInput)
503	_ = input
504	if !ok {
505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
506	}
507
508	request.Request.URL.Path = "/"
509	request.Request.Method = "POST"
510	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
511	if err != nil {
512		return out, metadata, &smithy.SerializationError{Err: err}
513	}
514	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
515	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteAlias")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDeleteAliasInput(input, jsonEncoder.Value); err != nil {
519		return out, metadata, &smithy.SerializationError{Err: err}
520	}
521
522	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
523		return out, metadata, &smithy.SerializationError{Err: err}
524	}
525
526	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
527		return out, metadata, &smithy.SerializationError{Err: err}
528	}
529	in.Request = request
530
531	return next.HandleSerialize(ctx, in)
532}
533
534type awsAwsjson11_serializeOpDeleteGroup struct {
535}
536
537func (*awsAwsjson11_serializeOpDeleteGroup) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
542	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
543) {
544	request, ok := in.Request.(*smithyhttp.Request)
545	if !ok {
546		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
547	}
548
549	input, ok := in.Parameters.(*DeleteGroupInput)
550	_ = input
551	if !ok {
552		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
553	}
554
555	request.Request.URL.Path = "/"
556	request.Request.Method = "POST"
557	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
558	if err != nil {
559		return out, metadata, &smithy.SerializationError{Err: err}
560	}
561	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
562	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteGroup")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDeleteGroupInput(input, jsonEncoder.Value); err != nil {
566		return out, metadata, &smithy.SerializationError{Err: err}
567	}
568
569	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
570		return out, metadata, &smithy.SerializationError{Err: err}
571	}
572
573	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
574		return out, metadata, &smithy.SerializationError{Err: err}
575	}
576	in.Request = request
577
578	return next.HandleSerialize(ctx, in)
579}
580
581type awsAwsjson11_serializeOpDeleteMailboxPermissions struct {
582}
583
584func (*awsAwsjson11_serializeOpDeleteMailboxPermissions) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDeleteMailboxPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
589	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
590) {
591	request, ok := in.Request.(*smithyhttp.Request)
592	if !ok {
593		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
594	}
595
596	input, ok := in.Parameters.(*DeleteMailboxPermissionsInput)
597	_ = input
598	if !ok {
599		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
600	}
601
602	request.Request.URL.Path = "/"
603	request.Request.Method = "POST"
604	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
605	if err != nil {
606		return out, metadata, &smithy.SerializationError{Err: err}
607	}
608	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
609	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteMailboxPermissions")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDeleteMailboxPermissionsInput(input, jsonEncoder.Value); err != nil {
613		return out, metadata, &smithy.SerializationError{Err: err}
614	}
615
616	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
617		return out, metadata, &smithy.SerializationError{Err: err}
618	}
619
620	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
621		return out, metadata, &smithy.SerializationError{Err: err}
622	}
623	in.Request = request
624
625	return next.HandleSerialize(ctx, in)
626}
627
628type awsAwsjson11_serializeOpDeleteMobileDeviceAccessRule struct {
629}
630
631func (*awsAwsjson11_serializeOpDeleteMobileDeviceAccessRule) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpDeleteMobileDeviceAccessRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
636	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
637) {
638	request, ok := in.Request.(*smithyhttp.Request)
639	if !ok {
640		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
641	}
642
643	input, ok := in.Parameters.(*DeleteMobileDeviceAccessRuleInput)
644	_ = input
645	if !ok {
646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
647	}
648
649	request.Request.URL.Path = "/"
650	request.Request.Method = "POST"
651	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
652	if err != nil {
653		return out, metadata, &smithy.SerializationError{Err: err}
654	}
655	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
656	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteMobileDeviceAccessRule")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentDeleteMobileDeviceAccessRuleInput(input, jsonEncoder.Value); err != nil {
660		return out, metadata, &smithy.SerializationError{Err: err}
661	}
662
663	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
664		return out, metadata, &smithy.SerializationError{Err: err}
665	}
666
667	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
668		return out, metadata, &smithy.SerializationError{Err: err}
669	}
670	in.Request = request
671
672	return next.HandleSerialize(ctx, in)
673}
674
675type awsAwsjson11_serializeOpDeleteOrganization struct {
676}
677
678func (*awsAwsjson11_serializeOpDeleteOrganization) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDeleteOrganization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
683	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
684) {
685	request, ok := in.Request.(*smithyhttp.Request)
686	if !ok {
687		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
688	}
689
690	input, ok := in.Parameters.(*DeleteOrganizationInput)
691	_ = input
692	if !ok {
693		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
694	}
695
696	request.Request.URL.Path = "/"
697	request.Request.Method = "POST"
698	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
699	if err != nil {
700		return out, metadata, &smithy.SerializationError{Err: err}
701	}
702	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
703	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteOrganization")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDeleteOrganizationInput(input, jsonEncoder.Value); err != nil {
707		return out, metadata, &smithy.SerializationError{Err: err}
708	}
709
710	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
711		return out, metadata, &smithy.SerializationError{Err: err}
712	}
713
714	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717	in.Request = request
718
719	return next.HandleSerialize(ctx, in)
720}
721
722type awsAwsjson11_serializeOpDeleteResource struct {
723}
724
725func (*awsAwsjson11_serializeOpDeleteResource) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDeleteResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
730	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
731) {
732	request, ok := in.Request.(*smithyhttp.Request)
733	if !ok {
734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
735	}
736
737	input, ok := in.Parameters.(*DeleteResourceInput)
738	_ = input
739	if !ok {
740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
741	}
742
743	request.Request.URL.Path = "/"
744	request.Request.Method = "POST"
745	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
746	if err != nil {
747		return out, metadata, &smithy.SerializationError{Err: err}
748	}
749	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
750	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteResource")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDeleteResourceInput(input, jsonEncoder.Value); err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760
761	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
762		return out, metadata, &smithy.SerializationError{Err: err}
763	}
764	in.Request = request
765
766	return next.HandleSerialize(ctx, in)
767}
768
769type awsAwsjson11_serializeOpDeleteRetentionPolicy struct {
770}
771
772func (*awsAwsjson11_serializeOpDeleteRetentionPolicy) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDeleteRetentionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
777	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
778) {
779	request, ok := in.Request.(*smithyhttp.Request)
780	if !ok {
781		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
782	}
783
784	input, ok := in.Parameters.(*DeleteRetentionPolicyInput)
785	_ = input
786	if !ok {
787		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
788	}
789
790	request.Request.URL.Path = "/"
791	request.Request.Method = "POST"
792	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
793	if err != nil {
794		return out, metadata, &smithy.SerializationError{Err: err}
795	}
796	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
797	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteRetentionPolicy")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDeleteRetentionPolicyInput(input, jsonEncoder.Value); err != nil {
801		return out, metadata, &smithy.SerializationError{Err: err}
802	}
803
804	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
805		return out, metadata, &smithy.SerializationError{Err: err}
806	}
807
808	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
809		return out, metadata, &smithy.SerializationError{Err: err}
810	}
811	in.Request = request
812
813	return next.HandleSerialize(ctx, in)
814}
815
816type awsAwsjson11_serializeOpDeleteUser struct {
817}
818
819func (*awsAwsjson11_serializeOpDeleteUser) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDeleteUser) 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.(*DeleteUserInput)
832	_ = input
833	if !ok {
834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
835	}
836
837	request.Request.URL.Path = "/"
838	request.Request.Method = "POST"
839	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
840	if err != nil {
841		return out, metadata, &smithy.SerializationError{Err: err}
842	}
843	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
844	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeleteUser")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDeleteUserInput(input, jsonEncoder.Value); err != nil {
848		return out, metadata, &smithy.SerializationError{Err: err}
849	}
850
851	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
852		return out, metadata, &smithy.SerializationError{Err: err}
853	}
854
855	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
856		return out, metadata, &smithy.SerializationError{Err: err}
857	}
858	in.Request = request
859
860	return next.HandleSerialize(ctx, in)
861}
862
863type awsAwsjson11_serializeOpDeregisterFromWorkMail struct {
864}
865
866func (*awsAwsjson11_serializeOpDeregisterFromWorkMail) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDeregisterFromWorkMail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
871	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
872) {
873	request, ok := in.Request.(*smithyhttp.Request)
874	if !ok {
875		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
876	}
877
878	input, ok := in.Parameters.(*DeregisterFromWorkMailInput)
879	_ = input
880	if !ok {
881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
882	}
883
884	request.Request.URL.Path = "/"
885	request.Request.Method = "POST"
886	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
887	if err != nil {
888		return out, metadata, &smithy.SerializationError{Err: err}
889	}
890	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
891	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DeregisterFromWorkMail")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDeregisterFromWorkMailInput(input, jsonEncoder.Value); err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897
898	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905	in.Request = request
906
907	return next.HandleSerialize(ctx, in)
908}
909
910type awsAwsjson11_serializeOpDescribeGroup struct {
911}
912
913func (*awsAwsjson11_serializeOpDescribeGroup) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDescribeGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
918	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
919) {
920	request, ok := in.Request.(*smithyhttp.Request)
921	if !ok {
922		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
923	}
924
925	input, ok := in.Parameters.(*DescribeGroupInput)
926	_ = input
927	if !ok {
928		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
929	}
930
931	request.Request.URL.Path = "/"
932	request.Request.Method = "POST"
933	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
934	if err != nil {
935		return out, metadata, &smithy.SerializationError{Err: err}
936	}
937	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
938	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DescribeGroup")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDescribeGroupInput(input, jsonEncoder.Value); err != nil {
942		return out, metadata, &smithy.SerializationError{Err: err}
943	}
944
945	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
946		return out, metadata, &smithy.SerializationError{Err: err}
947	}
948
949	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
950		return out, metadata, &smithy.SerializationError{Err: err}
951	}
952	in.Request = request
953
954	return next.HandleSerialize(ctx, in)
955}
956
957type awsAwsjson11_serializeOpDescribeMailboxExportJob struct {
958}
959
960func (*awsAwsjson11_serializeOpDescribeMailboxExportJob) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDescribeMailboxExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
966) {
967	request, ok := in.Request.(*smithyhttp.Request)
968	if !ok {
969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
970	}
971
972	input, ok := in.Parameters.(*DescribeMailboxExportJobInput)
973	_ = input
974	if !ok {
975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
976	}
977
978	request.Request.URL.Path = "/"
979	request.Request.Method = "POST"
980	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
981	if err != nil {
982		return out, metadata, &smithy.SerializationError{Err: err}
983	}
984	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
985	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DescribeMailboxExportJob")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDescribeMailboxExportJobInput(input, jsonEncoder.Value); err != nil {
989		return out, metadata, &smithy.SerializationError{Err: err}
990	}
991
992	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
993		return out, metadata, &smithy.SerializationError{Err: err}
994	}
995
996	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
997		return out, metadata, &smithy.SerializationError{Err: err}
998	}
999	in.Request = request
1000
1001	return next.HandleSerialize(ctx, in)
1002}
1003
1004type awsAwsjson11_serializeOpDescribeOrganization struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpDescribeOrganization) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpDescribeOrganization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1012	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1013) {
1014	request, ok := in.Request.(*smithyhttp.Request)
1015	if !ok {
1016		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1017	}
1018
1019	input, ok := in.Parameters.(*DescribeOrganizationInput)
1020	_ = input
1021	if !ok {
1022		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1023	}
1024
1025	request.Request.URL.Path = "/"
1026	request.Request.Method = "POST"
1027	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1028	if err != nil {
1029		return out, metadata, &smithy.SerializationError{Err: err}
1030	}
1031	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1032	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DescribeOrganization")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentDescribeOrganizationInput(input, jsonEncoder.Value); err != nil {
1036		return out, metadata, &smithy.SerializationError{Err: err}
1037	}
1038
1039	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1040		return out, metadata, &smithy.SerializationError{Err: err}
1041	}
1042
1043	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1044		return out, metadata, &smithy.SerializationError{Err: err}
1045	}
1046	in.Request = request
1047
1048	return next.HandleSerialize(ctx, in)
1049}
1050
1051type awsAwsjson11_serializeOpDescribeResource struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpDescribeResource) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpDescribeResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1059	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1060) {
1061	request, ok := in.Request.(*smithyhttp.Request)
1062	if !ok {
1063		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1064	}
1065
1066	input, ok := in.Parameters.(*DescribeResourceInput)
1067	_ = input
1068	if !ok {
1069		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1070	}
1071
1072	request.Request.URL.Path = "/"
1073	request.Request.Method = "POST"
1074	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1075	if err != nil {
1076		return out, metadata, &smithy.SerializationError{Err: err}
1077	}
1078	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1079	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DescribeResource")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentDescribeResourceInput(input, jsonEncoder.Value); err != nil {
1083		return out, metadata, &smithy.SerializationError{Err: err}
1084	}
1085
1086	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1087		return out, metadata, &smithy.SerializationError{Err: err}
1088	}
1089
1090	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1091		return out, metadata, &smithy.SerializationError{Err: err}
1092	}
1093	in.Request = request
1094
1095	return next.HandleSerialize(ctx, in)
1096}
1097
1098type awsAwsjson11_serializeOpDescribeUser struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpDescribeUser) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpDescribeUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1106	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1107) {
1108	request, ok := in.Request.(*smithyhttp.Request)
1109	if !ok {
1110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1111	}
1112
1113	input, ok := in.Parameters.(*DescribeUserInput)
1114	_ = input
1115	if !ok {
1116		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1117	}
1118
1119	request.Request.URL.Path = "/"
1120	request.Request.Method = "POST"
1121	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1122	if err != nil {
1123		return out, metadata, &smithy.SerializationError{Err: err}
1124	}
1125	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1126	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DescribeUser")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentDescribeUserInput(input, jsonEncoder.Value); err != nil {
1130		return out, metadata, &smithy.SerializationError{Err: err}
1131	}
1132
1133	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1134		return out, metadata, &smithy.SerializationError{Err: err}
1135	}
1136
1137	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1138		return out, metadata, &smithy.SerializationError{Err: err}
1139	}
1140	in.Request = request
1141
1142	return next.HandleSerialize(ctx, in)
1143}
1144
1145type awsAwsjson11_serializeOpDisassociateDelegateFromResource struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpDisassociateDelegateFromResource) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpDisassociateDelegateFromResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1153	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1154) {
1155	request, ok := in.Request.(*smithyhttp.Request)
1156	if !ok {
1157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1158	}
1159
1160	input, ok := in.Parameters.(*DisassociateDelegateFromResourceInput)
1161	_ = input
1162	if !ok {
1163		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1164	}
1165
1166	request.Request.URL.Path = "/"
1167	request.Request.Method = "POST"
1168	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1169	if err != nil {
1170		return out, metadata, &smithy.SerializationError{Err: err}
1171	}
1172	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1173	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DisassociateDelegateFromResource")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentDisassociateDelegateFromResourceInput(input, jsonEncoder.Value); err != nil {
1177		return out, metadata, &smithy.SerializationError{Err: err}
1178	}
1179
1180	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1181		return out, metadata, &smithy.SerializationError{Err: err}
1182	}
1183
1184	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1185		return out, metadata, &smithy.SerializationError{Err: err}
1186	}
1187	in.Request = request
1188
1189	return next.HandleSerialize(ctx, in)
1190}
1191
1192type awsAwsjson11_serializeOpDisassociateMemberFromGroup struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpDisassociateMemberFromGroup) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpDisassociateMemberFromGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1200	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	request, ok := in.Request.(*smithyhttp.Request)
1203	if !ok {
1204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1205	}
1206
1207	input, ok := in.Parameters.(*DisassociateMemberFromGroupInput)
1208	_ = input
1209	if !ok {
1210		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1211	}
1212
1213	request.Request.URL.Path = "/"
1214	request.Request.Method = "POST"
1215	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1216	if err != nil {
1217		return out, metadata, &smithy.SerializationError{Err: err}
1218	}
1219	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1220	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.DisassociateMemberFromGroup")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentDisassociateMemberFromGroupInput(input, jsonEncoder.Value); err != nil {
1224		return out, metadata, &smithy.SerializationError{Err: err}
1225	}
1226
1227	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1228		return out, metadata, &smithy.SerializationError{Err: err}
1229	}
1230
1231	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1232		return out, metadata, &smithy.SerializationError{Err: err}
1233	}
1234	in.Request = request
1235
1236	return next.HandleSerialize(ctx, in)
1237}
1238
1239type awsAwsjson11_serializeOpGetAccessControlEffect struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpGetAccessControlEffect) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpGetAccessControlEffect) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1247	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1248) {
1249	request, ok := in.Request.(*smithyhttp.Request)
1250	if !ok {
1251		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1252	}
1253
1254	input, ok := in.Parameters.(*GetAccessControlEffectInput)
1255	_ = input
1256	if !ok {
1257		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1258	}
1259
1260	request.Request.URL.Path = "/"
1261	request.Request.Method = "POST"
1262	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1263	if err != nil {
1264		return out, metadata, &smithy.SerializationError{Err: err}
1265	}
1266	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1267	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.GetAccessControlEffect")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentGetAccessControlEffectInput(input, jsonEncoder.Value); err != nil {
1271		return out, metadata, &smithy.SerializationError{Err: err}
1272	}
1273
1274	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277
1278	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1279		return out, metadata, &smithy.SerializationError{Err: err}
1280	}
1281	in.Request = request
1282
1283	return next.HandleSerialize(ctx, in)
1284}
1285
1286type awsAwsjson11_serializeOpGetDefaultRetentionPolicy struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpGetDefaultRetentionPolicy) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpGetDefaultRetentionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	request, ok := in.Request.(*smithyhttp.Request)
1297	if !ok {
1298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1299	}
1300
1301	input, ok := in.Parameters.(*GetDefaultRetentionPolicyInput)
1302	_ = input
1303	if !ok {
1304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1305	}
1306
1307	request.Request.URL.Path = "/"
1308	request.Request.Method = "POST"
1309	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1310	if err != nil {
1311		return out, metadata, &smithy.SerializationError{Err: err}
1312	}
1313	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1314	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.GetDefaultRetentionPolicy")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentGetDefaultRetentionPolicyInput(input, jsonEncoder.Value); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320
1321	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1322		return out, metadata, &smithy.SerializationError{Err: err}
1323	}
1324
1325	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328	in.Request = request
1329
1330	return next.HandleSerialize(ctx, in)
1331}
1332
1333type awsAwsjson11_serializeOpGetMailboxDetails struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpGetMailboxDetails) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpGetMailboxDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1341	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	request, ok := in.Request.(*smithyhttp.Request)
1344	if !ok {
1345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1346	}
1347
1348	input, ok := in.Parameters.(*GetMailboxDetailsInput)
1349	_ = input
1350	if !ok {
1351		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1352	}
1353
1354	request.Request.URL.Path = "/"
1355	request.Request.Method = "POST"
1356	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1357	if err != nil {
1358		return out, metadata, &smithy.SerializationError{Err: err}
1359	}
1360	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1361	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.GetMailboxDetails")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentGetMailboxDetailsInput(input, jsonEncoder.Value); err != nil {
1365		return out, metadata, &smithy.SerializationError{Err: err}
1366	}
1367
1368	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1369		return out, metadata, &smithy.SerializationError{Err: err}
1370	}
1371
1372	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1373		return out, metadata, &smithy.SerializationError{Err: err}
1374	}
1375	in.Request = request
1376
1377	return next.HandleSerialize(ctx, in)
1378}
1379
1380type awsAwsjson11_serializeOpGetMobileDeviceAccessEffect struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpGetMobileDeviceAccessEffect) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpGetMobileDeviceAccessEffect) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1388	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1389) {
1390	request, ok := in.Request.(*smithyhttp.Request)
1391	if !ok {
1392		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1393	}
1394
1395	input, ok := in.Parameters.(*GetMobileDeviceAccessEffectInput)
1396	_ = input
1397	if !ok {
1398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1399	}
1400
1401	request.Request.URL.Path = "/"
1402	request.Request.Method = "POST"
1403	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1404	if err != nil {
1405		return out, metadata, &smithy.SerializationError{Err: err}
1406	}
1407	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1408	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.GetMobileDeviceAccessEffect")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentGetMobileDeviceAccessEffectInput(input, jsonEncoder.Value); err != nil {
1412		return out, metadata, &smithy.SerializationError{Err: err}
1413	}
1414
1415	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1416		return out, metadata, &smithy.SerializationError{Err: err}
1417	}
1418
1419	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1420		return out, metadata, &smithy.SerializationError{Err: err}
1421	}
1422	in.Request = request
1423
1424	return next.HandleSerialize(ctx, in)
1425}
1426
1427type awsAwsjson11_serializeOpListAccessControlRules struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpListAccessControlRules) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpListAccessControlRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1435	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1436) {
1437	request, ok := in.Request.(*smithyhttp.Request)
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1440	}
1441
1442	input, ok := in.Parameters.(*ListAccessControlRulesInput)
1443	_ = input
1444	if !ok {
1445		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1446	}
1447
1448	request.Request.URL.Path = "/"
1449	request.Request.Method = "POST"
1450	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1451	if err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1455	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListAccessControlRules")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentListAccessControlRulesInput(input, jsonEncoder.Value); err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsjson11_serializeOpListAliases struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpListAliases) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpListAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*ListAliasesInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1502	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListAliases")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentListAliasesInput(input, jsonEncoder.Value); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1514		return out, metadata, &smithy.SerializationError{Err: err}
1515	}
1516	in.Request = request
1517
1518	return next.HandleSerialize(ctx, in)
1519}
1520
1521type awsAwsjson11_serializeOpListGroupMembers struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpListGroupMembers) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpListGroupMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1530) {
1531	request, ok := in.Request.(*smithyhttp.Request)
1532	if !ok {
1533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1534	}
1535
1536	input, ok := in.Parameters.(*ListGroupMembersInput)
1537	_ = input
1538	if !ok {
1539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1540	}
1541
1542	request.Request.URL.Path = "/"
1543	request.Request.Method = "POST"
1544	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1549	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListGroupMembers")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentListGroupMembersInput(input, jsonEncoder.Value); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563	in.Request = request
1564
1565	return next.HandleSerialize(ctx, in)
1566}
1567
1568type awsAwsjson11_serializeOpListGroups struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpListGroups) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpListGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1576	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1577) {
1578	request, ok := in.Request.(*smithyhttp.Request)
1579	if !ok {
1580		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1581	}
1582
1583	input, ok := in.Parameters.(*ListGroupsInput)
1584	_ = input
1585	if !ok {
1586		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1587	}
1588
1589	request.Request.URL.Path = "/"
1590	request.Request.Method = "POST"
1591	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1592	if err != nil {
1593		return out, metadata, &smithy.SerializationError{Err: err}
1594	}
1595	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1596	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListGroups")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentListGroupsInput(input, jsonEncoder.Value); err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606
1607	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1608		return out, metadata, &smithy.SerializationError{Err: err}
1609	}
1610	in.Request = request
1611
1612	return next.HandleSerialize(ctx, in)
1613}
1614
1615type awsAwsjson11_serializeOpListMailboxExportJobs struct {
1616}
1617
1618func (*awsAwsjson11_serializeOpListMailboxExportJobs) ID() string {
1619	return "OperationSerializer"
1620}
1621
1622func (m *awsAwsjson11_serializeOpListMailboxExportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1623	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1624) {
1625	request, ok := in.Request.(*smithyhttp.Request)
1626	if !ok {
1627		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1628	}
1629
1630	input, ok := in.Parameters.(*ListMailboxExportJobsInput)
1631	_ = input
1632	if !ok {
1633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1634	}
1635
1636	request.Request.URL.Path = "/"
1637	request.Request.Method = "POST"
1638	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1639	if err != nil {
1640		return out, metadata, &smithy.SerializationError{Err: err}
1641	}
1642	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1643	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListMailboxExportJobs")
1644
1645	jsonEncoder := smithyjson.NewEncoder()
1646	if err := awsAwsjson11_serializeOpDocumentListMailboxExportJobsInput(input, jsonEncoder.Value); err != nil {
1647		return out, metadata, &smithy.SerializationError{Err: err}
1648	}
1649
1650	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1651		return out, metadata, &smithy.SerializationError{Err: err}
1652	}
1653
1654	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1655		return out, metadata, &smithy.SerializationError{Err: err}
1656	}
1657	in.Request = request
1658
1659	return next.HandleSerialize(ctx, in)
1660}
1661
1662type awsAwsjson11_serializeOpListMailboxPermissions struct {
1663}
1664
1665func (*awsAwsjson11_serializeOpListMailboxPermissions) ID() string {
1666	return "OperationSerializer"
1667}
1668
1669func (m *awsAwsjson11_serializeOpListMailboxPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1670	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1671) {
1672	request, ok := in.Request.(*smithyhttp.Request)
1673	if !ok {
1674		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1675	}
1676
1677	input, ok := in.Parameters.(*ListMailboxPermissionsInput)
1678	_ = input
1679	if !ok {
1680		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1681	}
1682
1683	request.Request.URL.Path = "/"
1684	request.Request.Method = "POST"
1685	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1686	if err != nil {
1687		return out, metadata, &smithy.SerializationError{Err: err}
1688	}
1689	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1690	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListMailboxPermissions")
1691
1692	jsonEncoder := smithyjson.NewEncoder()
1693	if err := awsAwsjson11_serializeOpDocumentListMailboxPermissionsInput(input, jsonEncoder.Value); err != nil {
1694		return out, metadata, &smithy.SerializationError{Err: err}
1695	}
1696
1697	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1698		return out, metadata, &smithy.SerializationError{Err: err}
1699	}
1700
1701	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1702		return out, metadata, &smithy.SerializationError{Err: err}
1703	}
1704	in.Request = request
1705
1706	return next.HandleSerialize(ctx, in)
1707}
1708
1709type awsAwsjson11_serializeOpListMobileDeviceAccessRules struct {
1710}
1711
1712func (*awsAwsjson11_serializeOpListMobileDeviceAccessRules) ID() string {
1713	return "OperationSerializer"
1714}
1715
1716func (m *awsAwsjson11_serializeOpListMobileDeviceAccessRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1717	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1718) {
1719	request, ok := in.Request.(*smithyhttp.Request)
1720	if !ok {
1721		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1722	}
1723
1724	input, ok := in.Parameters.(*ListMobileDeviceAccessRulesInput)
1725	_ = input
1726	if !ok {
1727		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1728	}
1729
1730	request.Request.URL.Path = "/"
1731	request.Request.Method = "POST"
1732	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1733	if err != nil {
1734		return out, metadata, &smithy.SerializationError{Err: err}
1735	}
1736	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1737	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListMobileDeviceAccessRules")
1738
1739	jsonEncoder := smithyjson.NewEncoder()
1740	if err := awsAwsjson11_serializeOpDocumentListMobileDeviceAccessRulesInput(input, jsonEncoder.Value); err != nil {
1741		return out, metadata, &smithy.SerializationError{Err: err}
1742	}
1743
1744	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1745		return out, metadata, &smithy.SerializationError{Err: err}
1746	}
1747
1748	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1749		return out, metadata, &smithy.SerializationError{Err: err}
1750	}
1751	in.Request = request
1752
1753	return next.HandleSerialize(ctx, in)
1754}
1755
1756type awsAwsjson11_serializeOpListOrganizations struct {
1757}
1758
1759func (*awsAwsjson11_serializeOpListOrganizations) ID() string {
1760	return "OperationSerializer"
1761}
1762
1763func (m *awsAwsjson11_serializeOpListOrganizations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1764	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1765) {
1766	request, ok := in.Request.(*smithyhttp.Request)
1767	if !ok {
1768		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1769	}
1770
1771	input, ok := in.Parameters.(*ListOrganizationsInput)
1772	_ = input
1773	if !ok {
1774		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1775	}
1776
1777	request.Request.URL.Path = "/"
1778	request.Request.Method = "POST"
1779	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1780	if err != nil {
1781		return out, metadata, &smithy.SerializationError{Err: err}
1782	}
1783	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1784	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListOrganizations")
1785
1786	jsonEncoder := smithyjson.NewEncoder()
1787	if err := awsAwsjson11_serializeOpDocumentListOrganizationsInput(input, jsonEncoder.Value); err != nil {
1788		return out, metadata, &smithy.SerializationError{Err: err}
1789	}
1790
1791	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1792		return out, metadata, &smithy.SerializationError{Err: err}
1793	}
1794
1795	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1796		return out, metadata, &smithy.SerializationError{Err: err}
1797	}
1798	in.Request = request
1799
1800	return next.HandleSerialize(ctx, in)
1801}
1802
1803type awsAwsjson11_serializeOpListResourceDelegates struct {
1804}
1805
1806func (*awsAwsjson11_serializeOpListResourceDelegates) ID() string {
1807	return "OperationSerializer"
1808}
1809
1810func (m *awsAwsjson11_serializeOpListResourceDelegates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1811	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1812) {
1813	request, ok := in.Request.(*smithyhttp.Request)
1814	if !ok {
1815		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1816	}
1817
1818	input, ok := in.Parameters.(*ListResourceDelegatesInput)
1819	_ = input
1820	if !ok {
1821		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1822	}
1823
1824	request.Request.URL.Path = "/"
1825	request.Request.Method = "POST"
1826	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1827	if err != nil {
1828		return out, metadata, &smithy.SerializationError{Err: err}
1829	}
1830	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1831	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListResourceDelegates")
1832
1833	jsonEncoder := smithyjson.NewEncoder()
1834	if err := awsAwsjson11_serializeOpDocumentListResourceDelegatesInput(input, jsonEncoder.Value); err != nil {
1835		return out, metadata, &smithy.SerializationError{Err: err}
1836	}
1837
1838	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1839		return out, metadata, &smithy.SerializationError{Err: err}
1840	}
1841
1842	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1843		return out, metadata, &smithy.SerializationError{Err: err}
1844	}
1845	in.Request = request
1846
1847	return next.HandleSerialize(ctx, in)
1848}
1849
1850type awsAwsjson11_serializeOpListResources struct {
1851}
1852
1853func (*awsAwsjson11_serializeOpListResources) ID() string {
1854	return "OperationSerializer"
1855}
1856
1857func (m *awsAwsjson11_serializeOpListResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1858	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1859) {
1860	request, ok := in.Request.(*smithyhttp.Request)
1861	if !ok {
1862		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1863	}
1864
1865	input, ok := in.Parameters.(*ListResourcesInput)
1866	_ = input
1867	if !ok {
1868		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1869	}
1870
1871	request.Request.URL.Path = "/"
1872	request.Request.Method = "POST"
1873	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1874	if err != nil {
1875		return out, metadata, &smithy.SerializationError{Err: err}
1876	}
1877	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1878	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListResources")
1879
1880	jsonEncoder := smithyjson.NewEncoder()
1881	if err := awsAwsjson11_serializeOpDocumentListResourcesInput(input, jsonEncoder.Value); err != nil {
1882		return out, metadata, &smithy.SerializationError{Err: err}
1883	}
1884
1885	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1886		return out, metadata, &smithy.SerializationError{Err: err}
1887	}
1888
1889	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1890		return out, metadata, &smithy.SerializationError{Err: err}
1891	}
1892	in.Request = request
1893
1894	return next.HandleSerialize(ctx, in)
1895}
1896
1897type awsAwsjson11_serializeOpListTagsForResource struct {
1898}
1899
1900func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1901	return "OperationSerializer"
1902}
1903
1904func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1905	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1906) {
1907	request, ok := in.Request.(*smithyhttp.Request)
1908	if !ok {
1909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1910	}
1911
1912	input, ok := in.Parameters.(*ListTagsForResourceInput)
1913	_ = input
1914	if !ok {
1915		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1916	}
1917
1918	request.Request.URL.Path = "/"
1919	request.Request.Method = "POST"
1920	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1921	if err != nil {
1922		return out, metadata, &smithy.SerializationError{Err: err}
1923	}
1924	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1925	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListTagsForResource")
1926
1927	jsonEncoder := smithyjson.NewEncoder()
1928	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
1929		return out, metadata, &smithy.SerializationError{Err: err}
1930	}
1931
1932	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1933		return out, metadata, &smithy.SerializationError{Err: err}
1934	}
1935
1936	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1937		return out, metadata, &smithy.SerializationError{Err: err}
1938	}
1939	in.Request = request
1940
1941	return next.HandleSerialize(ctx, in)
1942}
1943
1944type awsAwsjson11_serializeOpListUsers struct {
1945}
1946
1947func (*awsAwsjson11_serializeOpListUsers) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsAwsjson11_serializeOpListUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1952	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1953) {
1954	request, ok := in.Request.(*smithyhttp.Request)
1955	if !ok {
1956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1957	}
1958
1959	input, ok := in.Parameters.(*ListUsersInput)
1960	_ = input
1961	if !ok {
1962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1963	}
1964
1965	request.Request.URL.Path = "/"
1966	request.Request.Method = "POST"
1967	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1968	if err != nil {
1969		return out, metadata, &smithy.SerializationError{Err: err}
1970	}
1971	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1972	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ListUsers")
1973
1974	jsonEncoder := smithyjson.NewEncoder()
1975	if err := awsAwsjson11_serializeOpDocumentListUsersInput(input, jsonEncoder.Value); err != nil {
1976		return out, metadata, &smithy.SerializationError{Err: err}
1977	}
1978
1979	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1980		return out, metadata, &smithy.SerializationError{Err: err}
1981	}
1982
1983	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1984		return out, metadata, &smithy.SerializationError{Err: err}
1985	}
1986	in.Request = request
1987
1988	return next.HandleSerialize(ctx, in)
1989}
1990
1991type awsAwsjson11_serializeOpPutAccessControlRule struct {
1992}
1993
1994func (*awsAwsjson11_serializeOpPutAccessControlRule) ID() string {
1995	return "OperationSerializer"
1996}
1997
1998func (m *awsAwsjson11_serializeOpPutAccessControlRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1999	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2000) {
2001	request, ok := in.Request.(*smithyhttp.Request)
2002	if !ok {
2003		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2004	}
2005
2006	input, ok := in.Parameters.(*PutAccessControlRuleInput)
2007	_ = input
2008	if !ok {
2009		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2010	}
2011
2012	request.Request.URL.Path = "/"
2013	request.Request.Method = "POST"
2014	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2015	if err != nil {
2016		return out, metadata, &smithy.SerializationError{Err: err}
2017	}
2018	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2019	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.PutAccessControlRule")
2020
2021	jsonEncoder := smithyjson.NewEncoder()
2022	if err := awsAwsjson11_serializeOpDocumentPutAccessControlRuleInput(input, jsonEncoder.Value); err != nil {
2023		return out, metadata, &smithy.SerializationError{Err: err}
2024	}
2025
2026	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2027		return out, metadata, &smithy.SerializationError{Err: err}
2028	}
2029
2030	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2031		return out, metadata, &smithy.SerializationError{Err: err}
2032	}
2033	in.Request = request
2034
2035	return next.HandleSerialize(ctx, in)
2036}
2037
2038type awsAwsjson11_serializeOpPutMailboxPermissions struct {
2039}
2040
2041func (*awsAwsjson11_serializeOpPutMailboxPermissions) ID() string {
2042	return "OperationSerializer"
2043}
2044
2045func (m *awsAwsjson11_serializeOpPutMailboxPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2046	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2047) {
2048	request, ok := in.Request.(*smithyhttp.Request)
2049	if !ok {
2050		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2051	}
2052
2053	input, ok := in.Parameters.(*PutMailboxPermissionsInput)
2054	_ = input
2055	if !ok {
2056		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2057	}
2058
2059	request.Request.URL.Path = "/"
2060	request.Request.Method = "POST"
2061	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2062	if err != nil {
2063		return out, metadata, &smithy.SerializationError{Err: err}
2064	}
2065	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2066	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.PutMailboxPermissions")
2067
2068	jsonEncoder := smithyjson.NewEncoder()
2069	if err := awsAwsjson11_serializeOpDocumentPutMailboxPermissionsInput(input, jsonEncoder.Value); err != nil {
2070		return out, metadata, &smithy.SerializationError{Err: err}
2071	}
2072
2073	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2074		return out, metadata, &smithy.SerializationError{Err: err}
2075	}
2076
2077	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2078		return out, metadata, &smithy.SerializationError{Err: err}
2079	}
2080	in.Request = request
2081
2082	return next.HandleSerialize(ctx, in)
2083}
2084
2085type awsAwsjson11_serializeOpPutRetentionPolicy struct {
2086}
2087
2088func (*awsAwsjson11_serializeOpPutRetentionPolicy) ID() string {
2089	return "OperationSerializer"
2090}
2091
2092func (m *awsAwsjson11_serializeOpPutRetentionPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2093	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2094) {
2095	request, ok := in.Request.(*smithyhttp.Request)
2096	if !ok {
2097		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2098	}
2099
2100	input, ok := in.Parameters.(*PutRetentionPolicyInput)
2101	_ = input
2102	if !ok {
2103		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2104	}
2105
2106	request.Request.URL.Path = "/"
2107	request.Request.Method = "POST"
2108	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2109	if err != nil {
2110		return out, metadata, &smithy.SerializationError{Err: err}
2111	}
2112	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2113	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.PutRetentionPolicy")
2114
2115	jsonEncoder := smithyjson.NewEncoder()
2116	if err := awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(input, jsonEncoder.Value); err != nil {
2117		return out, metadata, &smithy.SerializationError{Err: err}
2118	}
2119
2120	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2121		return out, metadata, &smithy.SerializationError{Err: err}
2122	}
2123
2124	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2125		return out, metadata, &smithy.SerializationError{Err: err}
2126	}
2127	in.Request = request
2128
2129	return next.HandleSerialize(ctx, in)
2130}
2131
2132type awsAwsjson11_serializeOpRegisterToWorkMail struct {
2133}
2134
2135func (*awsAwsjson11_serializeOpRegisterToWorkMail) ID() string {
2136	return "OperationSerializer"
2137}
2138
2139func (m *awsAwsjson11_serializeOpRegisterToWorkMail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2140	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2141) {
2142	request, ok := in.Request.(*smithyhttp.Request)
2143	if !ok {
2144		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2145	}
2146
2147	input, ok := in.Parameters.(*RegisterToWorkMailInput)
2148	_ = input
2149	if !ok {
2150		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2151	}
2152
2153	request.Request.URL.Path = "/"
2154	request.Request.Method = "POST"
2155	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2156	if err != nil {
2157		return out, metadata, &smithy.SerializationError{Err: err}
2158	}
2159	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2160	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.RegisterToWorkMail")
2161
2162	jsonEncoder := smithyjson.NewEncoder()
2163	if err := awsAwsjson11_serializeOpDocumentRegisterToWorkMailInput(input, jsonEncoder.Value); err != nil {
2164		return out, metadata, &smithy.SerializationError{Err: err}
2165	}
2166
2167	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2168		return out, metadata, &smithy.SerializationError{Err: err}
2169	}
2170
2171	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2172		return out, metadata, &smithy.SerializationError{Err: err}
2173	}
2174	in.Request = request
2175
2176	return next.HandleSerialize(ctx, in)
2177}
2178
2179type awsAwsjson11_serializeOpResetPassword struct {
2180}
2181
2182func (*awsAwsjson11_serializeOpResetPassword) ID() string {
2183	return "OperationSerializer"
2184}
2185
2186func (m *awsAwsjson11_serializeOpResetPassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2187	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2188) {
2189	request, ok := in.Request.(*smithyhttp.Request)
2190	if !ok {
2191		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2192	}
2193
2194	input, ok := in.Parameters.(*ResetPasswordInput)
2195	_ = input
2196	if !ok {
2197		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2198	}
2199
2200	request.Request.URL.Path = "/"
2201	request.Request.Method = "POST"
2202	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2203	if err != nil {
2204		return out, metadata, &smithy.SerializationError{Err: err}
2205	}
2206	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2207	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.ResetPassword")
2208
2209	jsonEncoder := smithyjson.NewEncoder()
2210	if err := awsAwsjson11_serializeOpDocumentResetPasswordInput(input, jsonEncoder.Value); err != nil {
2211		return out, metadata, &smithy.SerializationError{Err: err}
2212	}
2213
2214	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2215		return out, metadata, &smithy.SerializationError{Err: err}
2216	}
2217
2218	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2219		return out, metadata, &smithy.SerializationError{Err: err}
2220	}
2221	in.Request = request
2222
2223	return next.HandleSerialize(ctx, in)
2224}
2225
2226type awsAwsjson11_serializeOpStartMailboxExportJob struct {
2227}
2228
2229func (*awsAwsjson11_serializeOpStartMailboxExportJob) ID() string {
2230	return "OperationSerializer"
2231}
2232
2233func (m *awsAwsjson11_serializeOpStartMailboxExportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2234	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2235) {
2236	request, ok := in.Request.(*smithyhttp.Request)
2237	if !ok {
2238		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2239	}
2240
2241	input, ok := in.Parameters.(*StartMailboxExportJobInput)
2242	_ = input
2243	if !ok {
2244		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2245	}
2246
2247	request.Request.URL.Path = "/"
2248	request.Request.Method = "POST"
2249	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2250	if err != nil {
2251		return out, metadata, &smithy.SerializationError{Err: err}
2252	}
2253	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2254	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.StartMailboxExportJob")
2255
2256	jsonEncoder := smithyjson.NewEncoder()
2257	if err := awsAwsjson11_serializeOpDocumentStartMailboxExportJobInput(input, jsonEncoder.Value); err != nil {
2258		return out, metadata, &smithy.SerializationError{Err: err}
2259	}
2260
2261	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2262		return out, metadata, &smithy.SerializationError{Err: err}
2263	}
2264
2265	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2266		return out, metadata, &smithy.SerializationError{Err: err}
2267	}
2268	in.Request = request
2269
2270	return next.HandleSerialize(ctx, in)
2271}
2272
2273type awsAwsjson11_serializeOpTagResource struct {
2274}
2275
2276func (*awsAwsjson11_serializeOpTagResource) ID() string {
2277	return "OperationSerializer"
2278}
2279
2280func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2281	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2282) {
2283	request, ok := in.Request.(*smithyhttp.Request)
2284	if !ok {
2285		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2286	}
2287
2288	input, ok := in.Parameters.(*TagResourceInput)
2289	_ = input
2290	if !ok {
2291		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2292	}
2293
2294	request.Request.URL.Path = "/"
2295	request.Request.Method = "POST"
2296	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2297	if err != nil {
2298		return out, metadata, &smithy.SerializationError{Err: err}
2299	}
2300	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2301	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.TagResource")
2302
2303	jsonEncoder := smithyjson.NewEncoder()
2304	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
2305		return out, metadata, &smithy.SerializationError{Err: err}
2306	}
2307
2308	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2309		return out, metadata, &smithy.SerializationError{Err: err}
2310	}
2311
2312	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2313		return out, metadata, &smithy.SerializationError{Err: err}
2314	}
2315	in.Request = request
2316
2317	return next.HandleSerialize(ctx, in)
2318}
2319
2320type awsAwsjson11_serializeOpUntagResource struct {
2321}
2322
2323func (*awsAwsjson11_serializeOpUntagResource) ID() string {
2324	return "OperationSerializer"
2325}
2326
2327func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2328	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2329) {
2330	request, ok := in.Request.(*smithyhttp.Request)
2331	if !ok {
2332		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2333	}
2334
2335	input, ok := in.Parameters.(*UntagResourceInput)
2336	_ = input
2337	if !ok {
2338		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2339	}
2340
2341	request.Request.URL.Path = "/"
2342	request.Request.Method = "POST"
2343	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2344	if err != nil {
2345		return out, metadata, &smithy.SerializationError{Err: err}
2346	}
2347	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2348	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.UntagResource")
2349
2350	jsonEncoder := smithyjson.NewEncoder()
2351	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
2352		return out, metadata, &smithy.SerializationError{Err: err}
2353	}
2354
2355	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2356		return out, metadata, &smithy.SerializationError{Err: err}
2357	}
2358
2359	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2360		return out, metadata, &smithy.SerializationError{Err: err}
2361	}
2362	in.Request = request
2363
2364	return next.HandleSerialize(ctx, in)
2365}
2366
2367type awsAwsjson11_serializeOpUpdateMailboxQuota struct {
2368}
2369
2370func (*awsAwsjson11_serializeOpUpdateMailboxQuota) ID() string {
2371	return "OperationSerializer"
2372}
2373
2374func (m *awsAwsjson11_serializeOpUpdateMailboxQuota) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2375	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2376) {
2377	request, ok := in.Request.(*smithyhttp.Request)
2378	if !ok {
2379		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2380	}
2381
2382	input, ok := in.Parameters.(*UpdateMailboxQuotaInput)
2383	_ = input
2384	if !ok {
2385		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2386	}
2387
2388	request.Request.URL.Path = "/"
2389	request.Request.Method = "POST"
2390	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2391	if err != nil {
2392		return out, metadata, &smithy.SerializationError{Err: err}
2393	}
2394	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2395	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.UpdateMailboxQuota")
2396
2397	jsonEncoder := smithyjson.NewEncoder()
2398	if err := awsAwsjson11_serializeOpDocumentUpdateMailboxQuotaInput(input, jsonEncoder.Value); err != nil {
2399		return out, metadata, &smithy.SerializationError{Err: err}
2400	}
2401
2402	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2403		return out, metadata, &smithy.SerializationError{Err: err}
2404	}
2405
2406	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2407		return out, metadata, &smithy.SerializationError{Err: err}
2408	}
2409	in.Request = request
2410
2411	return next.HandleSerialize(ctx, in)
2412}
2413
2414type awsAwsjson11_serializeOpUpdateMobileDeviceAccessRule struct {
2415}
2416
2417func (*awsAwsjson11_serializeOpUpdateMobileDeviceAccessRule) ID() string {
2418	return "OperationSerializer"
2419}
2420
2421func (m *awsAwsjson11_serializeOpUpdateMobileDeviceAccessRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2422	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2423) {
2424	request, ok := in.Request.(*smithyhttp.Request)
2425	if !ok {
2426		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2427	}
2428
2429	input, ok := in.Parameters.(*UpdateMobileDeviceAccessRuleInput)
2430	_ = input
2431	if !ok {
2432		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2433	}
2434
2435	request.Request.URL.Path = "/"
2436	request.Request.Method = "POST"
2437	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2438	if err != nil {
2439		return out, metadata, &smithy.SerializationError{Err: err}
2440	}
2441	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2442	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.UpdateMobileDeviceAccessRule")
2443
2444	jsonEncoder := smithyjson.NewEncoder()
2445	if err := awsAwsjson11_serializeOpDocumentUpdateMobileDeviceAccessRuleInput(input, jsonEncoder.Value); err != nil {
2446		return out, metadata, &smithy.SerializationError{Err: err}
2447	}
2448
2449	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2450		return out, metadata, &smithy.SerializationError{Err: err}
2451	}
2452
2453	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2454		return out, metadata, &smithy.SerializationError{Err: err}
2455	}
2456	in.Request = request
2457
2458	return next.HandleSerialize(ctx, in)
2459}
2460
2461type awsAwsjson11_serializeOpUpdatePrimaryEmailAddress struct {
2462}
2463
2464func (*awsAwsjson11_serializeOpUpdatePrimaryEmailAddress) ID() string {
2465	return "OperationSerializer"
2466}
2467
2468func (m *awsAwsjson11_serializeOpUpdatePrimaryEmailAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2469	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2470) {
2471	request, ok := in.Request.(*smithyhttp.Request)
2472	if !ok {
2473		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2474	}
2475
2476	input, ok := in.Parameters.(*UpdatePrimaryEmailAddressInput)
2477	_ = input
2478	if !ok {
2479		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2480	}
2481
2482	request.Request.URL.Path = "/"
2483	request.Request.Method = "POST"
2484	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2485	if err != nil {
2486		return out, metadata, &smithy.SerializationError{Err: err}
2487	}
2488	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2489	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.UpdatePrimaryEmailAddress")
2490
2491	jsonEncoder := smithyjson.NewEncoder()
2492	if err := awsAwsjson11_serializeOpDocumentUpdatePrimaryEmailAddressInput(input, jsonEncoder.Value); err != nil {
2493		return out, metadata, &smithy.SerializationError{Err: err}
2494	}
2495
2496	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2497		return out, metadata, &smithy.SerializationError{Err: err}
2498	}
2499
2500	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2501		return out, metadata, &smithy.SerializationError{Err: err}
2502	}
2503	in.Request = request
2504
2505	return next.HandleSerialize(ctx, in)
2506}
2507
2508type awsAwsjson11_serializeOpUpdateResource struct {
2509}
2510
2511func (*awsAwsjson11_serializeOpUpdateResource) ID() string {
2512	return "OperationSerializer"
2513}
2514
2515func (m *awsAwsjson11_serializeOpUpdateResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2516	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2517) {
2518	request, ok := in.Request.(*smithyhttp.Request)
2519	if !ok {
2520		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2521	}
2522
2523	input, ok := in.Parameters.(*UpdateResourceInput)
2524	_ = input
2525	if !ok {
2526		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2527	}
2528
2529	request.Request.URL.Path = "/"
2530	request.Request.Method = "POST"
2531	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2532	if err != nil {
2533		return out, metadata, &smithy.SerializationError{Err: err}
2534	}
2535	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2536	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkMailService.UpdateResource")
2537
2538	jsonEncoder := smithyjson.NewEncoder()
2539	if err := awsAwsjson11_serializeOpDocumentUpdateResourceInput(input, jsonEncoder.Value); err != nil {
2540		return out, metadata, &smithy.SerializationError{Err: err}
2541	}
2542
2543	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2544		return out, metadata, &smithy.SerializationError{Err: err}
2545	}
2546
2547	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2548		return out, metadata, &smithy.SerializationError{Err: err}
2549	}
2550	in.Request = request
2551
2552	return next.HandleSerialize(ctx, in)
2553}
2554func awsAwsjson11_serializeDocumentActionsList(v []string, value smithyjson.Value) error {
2555	array := value.Array()
2556	defer array.Close()
2557
2558	for i := range v {
2559		av := array.Value()
2560		av.String(v[i])
2561	}
2562	return nil
2563}
2564
2565func awsAwsjson11_serializeDocumentBookingOptions(v *types.BookingOptions, value smithyjson.Value) error {
2566	object := value.Object()
2567	defer object.Close()
2568
2569	if v.AutoAcceptRequests {
2570		ok := object.Key("AutoAcceptRequests")
2571		ok.Boolean(v.AutoAcceptRequests)
2572	}
2573
2574	if v.AutoDeclineConflictingRequests {
2575		ok := object.Key("AutoDeclineConflictingRequests")
2576		ok.Boolean(v.AutoDeclineConflictingRequests)
2577	}
2578
2579	if v.AutoDeclineRecurringRequests {
2580		ok := object.Key("AutoDeclineRecurringRequests")
2581		ok.Boolean(v.AutoDeclineRecurringRequests)
2582	}
2583
2584	return nil
2585}
2586
2587func awsAwsjson11_serializeDocumentDeviceModelList(v []string, value smithyjson.Value) error {
2588	array := value.Array()
2589	defer array.Close()
2590
2591	for i := range v {
2592		av := array.Value()
2593		av.String(v[i])
2594	}
2595	return nil
2596}
2597
2598func awsAwsjson11_serializeDocumentDeviceOperatingSystemList(v []string, value smithyjson.Value) error {
2599	array := value.Array()
2600	defer array.Close()
2601
2602	for i := range v {
2603		av := array.Value()
2604		av.String(v[i])
2605	}
2606	return nil
2607}
2608
2609func awsAwsjson11_serializeDocumentDeviceTypeList(v []string, value smithyjson.Value) error {
2610	array := value.Array()
2611	defer array.Close()
2612
2613	for i := range v {
2614		av := array.Value()
2615		av.String(v[i])
2616	}
2617	return nil
2618}
2619
2620func awsAwsjson11_serializeDocumentDeviceUserAgentList(v []string, value smithyjson.Value) error {
2621	array := value.Array()
2622	defer array.Close()
2623
2624	for i := range v {
2625		av := array.Value()
2626		av.String(v[i])
2627	}
2628	return nil
2629}
2630
2631func awsAwsjson11_serializeDocumentDomain(v *types.Domain, value smithyjson.Value) error {
2632	object := value.Object()
2633	defer object.Close()
2634
2635	if v.DomainName != nil {
2636		ok := object.Key("DomainName")
2637		ok.String(*v.DomainName)
2638	}
2639
2640	if v.HostedZoneId != nil {
2641		ok := object.Key("HostedZoneId")
2642		ok.String(*v.HostedZoneId)
2643	}
2644
2645	return nil
2646}
2647
2648func awsAwsjson11_serializeDocumentDomains(v []types.Domain, value smithyjson.Value) error {
2649	array := value.Array()
2650	defer array.Close()
2651
2652	for i := range v {
2653		av := array.Value()
2654		if err := awsAwsjson11_serializeDocumentDomain(&v[i], av); err != nil {
2655			return err
2656		}
2657	}
2658	return nil
2659}
2660
2661func awsAwsjson11_serializeDocumentFolderConfiguration(v *types.FolderConfiguration, value smithyjson.Value) error {
2662	object := value.Object()
2663	defer object.Close()
2664
2665	if len(v.Action) > 0 {
2666		ok := object.Key("Action")
2667		ok.String(string(v.Action))
2668	}
2669
2670	if len(v.Name) > 0 {
2671		ok := object.Key("Name")
2672		ok.String(string(v.Name))
2673	}
2674
2675	if v.Period != nil {
2676		ok := object.Key("Period")
2677		ok.Integer(*v.Period)
2678	}
2679
2680	return nil
2681}
2682
2683func awsAwsjson11_serializeDocumentFolderConfigurations(v []types.FolderConfiguration, value smithyjson.Value) error {
2684	array := value.Array()
2685	defer array.Close()
2686
2687	for i := range v {
2688		av := array.Value()
2689		if err := awsAwsjson11_serializeDocumentFolderConfiguration(&v[i], av); err != nil {
2690			return err
2691		}
2692	}
2693	return nil
2694}
2695
2696func awsAwsjson11_serializeDocumentIpRangeList(v []string, value smithyjson.Value) error {
2697	array := value.Array()
2698	defer array.Close()
2699
2700	for i := range v {
2701		av := array.Value()
2702		av.String(v[i])
2703	}
2704	return nil
2705}
2706
2707func awsAwsjson11_serializeDocumentPermissionValues(v []types.PermissionType, value smithyjson.Value) error {
2708	array := value.Array()
2709	defer array.Close()
2710
2711	for i := range v {
2712		av := array.Value()
2713		av.String(string(v[i]))
2714	}
2715	return nil
2716}
2717
2718func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2719	object := value.Object()
2720	defer object.Close()
2721
2722	if v.Key != nil {
2723		ok := object.Key("Key")
2724		ok.String(*v.Key)
2725	}
2726
2727	if v.Value != nil {
2728		ok := object.Key("Value")
2729		ok.String(*v.Value)
2730	}
2731
2732	return nil
2733}
2734
2735func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
2736	array := value.Array()
2737	defer array.Close()
2738
2739	for i := range v {
2740		av := array.Value()
2741		av.String(v[i])
2742	}
2743	return nil
2744}
2745
2746func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
2747	array := value.Array()
2748	defer array.Close()
2749
2750	for i := range v {
2751		av := array.Value()
2752		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
2753			return err
2754		}
2755	}
2756	return nil
2757}
2758
2759func awsAwsjson11_serializeDocumentUserIdList(v []string, value smithyjson.Value) error {
2760	array := value.Array()
2761	defer array.Close()
2762
2763	for i := range v {
2764		av := array.Value()
2765		av.String(v[i])
2766	}
2767	return nil
2768}
2769
2770func awsAwsjson11_serializeOpDocumentAssociateDelegateToResourceInput(v *AssociateDelegateToResourceInput, value smithyjson.Value) error {
2771	object := value.Object()
2772	defer object.Close()
2773
2774	if v.EntityId != nil {
2775		ok := object.Key("EntityId")
2776		ok.String(*v.EntityId)
2777	}
2778
2779	if v.OrganizationId != nil {
2780		ok := object.Key("OrganizationId")
2781		ok.String(*v.OrganizationId)
2782	}
2783
2784	if v.ResourceId != nil {
2785		ok := object.Key("ResourceId")
2786		ok.String(*v.ResourceId)
2787	}
2788
2789	return nil
2790}
2791
2792func awsAwsjson11_serializeOpDocumentAssociateMemberToGroupInput(v *AssociateMemberToGroupInput, value smithyjson.Value) error {
2793	object := value.Object()
2794	defer object.Close()
2795
2796	if v.GroupId != nil {
2797		ok := object.Key("GroupId")
2798		ok.String(*v.GroupId)
2799	}
2800
2801	if v.MemberId != nil {
2802		ok := object.Key("MemberId")
2803		ok.String(*v.MemberId)
2804	}
2805
2806	if v.OrganizationId != nil {
2807		ok := object.Key("OrganizationId")
2808		ok.String(*v.OrganizationId)
2809	}
2810
2811	return nil
2812}
2813
2814func awsAwsjson11_serializeOpDocumentCancelMailboxExportJobInput(v *CancelMailboxExportJobInput, value smithyjson.Value) error {
2815	object := value.Object()
2816	defer object.Close()
2817
2818	if v.ClientToken != nil {
2819		ok := object.Key("ClientToken")
2820		ok.String(*v.ClientToken)
2821	}
2822
2823	if v.JobId != nil {
2824		ok := object.Key("JobId")
2825		ok.String(*v.JobId)
2826	}
2827
2828	if v.OrganizationId != nil {
2829		ok := object.Key("OrganizationId")
2830		ok.String(*v.OrganizationId)
2831	}
2832
2833	return nil
2834}
2835
2836func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error {
2837	object := value.Object()
2838	defer object.Close()
2839
2840	if v.Alias != nil {
2841		ok := object.Key("Alias")
2842		ok.String(*v.Alias)
2843	}
2844
2845	if v.EntityId != nil {
2846		ok := object.Key("EntityId")
2847		ok.String(*v.EntityId)
2848	}
2849
2850	if v.OrganizationId != nil {
2851		ok := object.Key("OrganizationId")
2852		ok.String(*v.OrganizationId)
2853	}
2854
2855	return nil
2856}
2857
2858func awsAwsjson11_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error {
2859	object := value.Object()
2860	defer object.Close()
2861
2862	if v.Name != nil {
2863		ok := object.Key("Name")
2864		ok.String(*v.Name)
2865	}
2866
2867	if v.OrganizationId != nil {
2868		ok := object.Key("OrganizationId")
2869		ok.String(*v.OrganizationId)
2870	}
2871
2872	return nil
2873}
2874
2875func awsAwsjson11_serializeOpDocumentCreateMobileDeviceAccessRuleInput(v *CreateMobileDeviceAccessRuleInput, value smithyjson.Value) error {
2876	object := value.Object()
2877	defer object.Close()
2878
2879	if v.ClientToken != nil {
2880		ok := object.Key("ClientToken")
2881		ok.String(*v.ClientToken)
2882	}
2883
2884	if v.Description != nil {
2885		ok := object.Key("Description")
2886		ok.String(*v.Description)
2887	}
2888
2889	if v.DeviceModels != nil {
2890		ok := object.Key("DeviceModels")
2891		if err := awsAwsjson11_serializeDocumentDeviceModelList(v.DeviceModels, ok); err != nil {
2892			return err
2893		}
2894	}
2895
2896	if v.DeviceOperatingSystems != nil {
2897		ok := object.Key("DeviceOperatingSystems")
2898		if err := awsAwsjson11_serializeDocumentDeviceOperatingSystemList(v.DeviceOperatingSystems, ok); err != nil {
2899			return err
2900		}
2901	}
2902
2903	if v.DeviceTypes != nil {
2904		ok := object.Key("DeviceTypes")
2905		if err := awsAwsjson11_serializeDocumentDeviceTypeList(v.DeviceTypes, ok); err != nil {
2906			return err
2907		}
2908	}
2909
2910	if v.DeviceUserAgents != nil {
2911		ok := object.Key("DeviceUserAgents")
2912		if err := awsAwsjson11_serializeDocumentDeviceUserAgentList(v.DeviceUserAgents, ok); err != nil {
2913			return err
2914		}
2915	}
2916
2917	if len(v.Effect) > 0 {
2918		ok := object.Key("Effect")
2919		ok.String(string(v.Effect))
2920	}
2921
2922	if v.Name != nil {
2923		ok := object.Key("Name")
2924		ok.String(*v.Name)
2925	}
2926
2927	if v.NotDeviceModels != nil {
2928		ok := object.Key("NotDeviceModels")
2929		if err := awsAwsjson11_serializeDocumentDeviceModelList(v.NotDeviceModels, ok); err != nil {
2930			return err
2931		}
2932	}
2933
2934	if v.NotDeviceOperatingSystems != nil {
2935		ok := object.Key("NotDeviceOperatingSystems")
2936		if err := awsAwsjson11_serializeDocumentDeviceOperatingSystemList(v.NotDeviceOperatingSystems, ok); err != nil {
2937			return err
2938		}
2939	}
2940
2941	if v.NotDeviceTypes != nil {
2942		ok := object.Key("NotDeviceTypes")
2943		if err := awsAwsjson11_serializeDocumentDeviceTypeList(v.NotDeviceTypes, ok); err != nil {
2944			return err
2945		}
2946	}
2947
2948	if v.NotDeviceUserAgents != nil {
2949		ok := object.Key("NotDeviceUserAgents")
2950		if err := awsAwsjson11_serializeDocumentDeviceUserAgentList(v.NotDeviceUserAgents, ok); err != nil {
2951			return err
2952		}
2953	}
2954
2955	if v.OrganizationId != nil {
2956		ok := object.Key("OrganizationId")
2957		ok.String(*v.OrganizationId)
2958	}
2959
2960	return nil
2961}
2962
2963func awsAwsjson11_serializeOpDocumentCreateOrganizationInput(v *CreateOrganizationInput, value smithyjson.Value) error {
2964	object := value.Object()
2965	defer object.Close()
2966
2967	if v.Alias != nil {
2968		ok := object.Key("Alias")
2969		ok.String(*v.Alias)
2970	}
2971
2972	if v.ClientToken != nil {
2973		ok := object.Key("ClientToken")
2974		ok.String(*v.ClientToken)
2975	}
2976
2977	if v.DirectoryId != nil {
2978		ok := object.Key("DirectoryId")
2979		ok.String(*v.DirectoryId)
2980	}
2981
2982	if v.Domains != nil {
2983		ok := object.Key("Domains")
2984		if err := awsAwsjson11_serializeDocumentDomains(v.Domains, ok); err != nil {
2985			return err
2986		}
2987	}
2988
2989	if v.EnableInteroperability {
2990		ok := object.Key("EnableInteroperability")
2991		ok.Boolean(v.EnableInteroperability)
2992	}
2993
2994	if v.KmsKeyArn != nil {
2995		ok := object.Key("KmsKeyArn")
2996		ok.String(*v.KmsKeyArn)
2997	}
2998
2999	return nil
3000}
3001
3002func awsAwsjson11_serializeOpDocumentCreateResourceInput(v *CreateResourceInput, value smithyjson.Value) error {
3003	object := value.Object()
3004	defer object.Close()
3005
3006	if v.Name != nil {
3007		ok := object.Key("Name")
3008		ok.String(*v.Name)
3009	}
3010
3011	if v.OrganizationId != nil {
3012		ok := object.Key("OrganizationId")
3013		ok.String(*v.OrganizationId)
3014	}
3015
3016	if len(v.Type) > 0 {
3017		ok := object.Key("Type")
3018		ok.String(string(v.Type))
3019	}
3020
3021	return nil
3022}
3023
3024func awsAwsjson11_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error {
3025	object := value.Object()
3026	defer object.Close()
3027
3028	if v.DisplayName != nil {
3029		ok := object.Key("DisplayName")
3030		ok.String(*v.DisplayName)
3031	}
3032
3033	if v.Name != nil {
3034		ok := object.Key("Name")
3035		ok.String(*v.Name)
3036	}
3037
3038	if v.OrganizationId != nil {
3039		ok := object.Key("OrganizationId")
3040		ok.String(*v.OrganizationId)
3041	}
3042
3043	if v.Password != nil {
3044		ok := object.Key("Password")
3045		ok.String(*v.Password)
3046	}
3047
3048	return nil
3049}
3050
3051func awsAwsjson11_serializeOpDocumentDeleteAccessControlRuleInput(v *DeleteAccessControlRuleInput, value smithyjson.Value) error {
3052	object := value.Object()
3053	defer object.Close()
3054
3055	if v.Name != nil {
3056		ok := object.Key("Name")
3057		ok.String(*v.Name)
3058	}
3059
3060	if v.OrganizationId != nil {
3061		ok := object.Key("OrganizationId")
3062		ok.String(*v.OrganizationId)
3063	}
3064
3065	return nil
3066}
3067
3068func awsAwsjson11_serializeOpDocumentDeleteAliasInput(v *DeleteAliasInput, value smithyjson.Value) error {
3069	object := value.Object()
3070	defer object.Close()
3071
3072	if v.Alias != nil {
3073		ok := object.Key("Alias")
3074		ok.String(*v.Alias)
3075	}
3076
3077	if v.EntityId != nil {
3078		ok := object.Key("EntityId")
3079		ok.String(*v.EntityId)
3080	}
3081
3082	if v.OrganizationId != nil {
3083		ok := object.Key("OrganizationId")
3084		ok.String(*v.OrganizationId)
3085	}
3086
3087	return nil
3088}
3089
3090func awsAwsjson11_serializeOpDocumentDeleteGroupInput(v *DeleteGroupInput, value smithyjson.Value) error {
3091	object := value.Object()
3092	defer object.Close()
3093
3094	if v.GroupId != nil {
3095		ok := object.Key("GroupId")
3096		ok.String(*v.GroupId)
3097	}
3098
3099	if v.OrganizationId != nil {
3100		ok := object.Key("OrganizationId")
3101		ok.String(*v.OrganizationId)
3102	}
3103
3104	return nil
3105}
3106
3107func awsAwsjson11_serializeOpDocumentDeleteMailboxPermissionsInput(v *DeleteMailboxPermissionsInput, value smithyjson.Value) error {
3108	object := value.Object()
3109	defer object.Close()
3110
3111	if v.EntityId != nil {
3112		ok := object.Key("EntityId")
3113		ok.String(*v.EntityId)
3114	}
3115
3116	if v.GranteeId != nil {
3117		ok := object.Key("GranteeId")
3118		ok.String(*v.GranteeId)
3119	}
3120
3121	if v.OrganizationId != nil {
3122		ok := object.Key("OrganizationId")
3123		ok.String(*v.OrganizationId)
3124	}
3125
3126	return nil
3127}
3128
3129func awsAwsjson11_serializeOpDocumentDeleteMobileDeviceAccessRuleInput(v *DeleteMobileDeviceAccessRuleInput, value smithyjson.Value) error {
3130	object := value.Object()
3131	defer object.Close()
3132
3133	if v.MobileDeviceAccessRuleId != nil {
3134		ok := object.Key("MobileDeviceAccessRuleId")
3135		ok.String(*v.MobileDeviceAccessRuleId)
3136	}
3137
3138	if v.OrganizationId != nil {
3139		ok := object.Key("OrganizationId")
3140		ok.String(*v.OrganizationId)
3141	}
3142
3143	return nil
3144}
3145
3146func awsAwsjson11_serializeOpDocumentDeleteOrganizationInput(v *DeleteOrganizationInput, value smithyjson.Value) error {
3147	object := value.Object()
3148	defer object.Close()
3149
3150	if v.ClientToken != nil {
3151		ok := object.Key("ClientToken")
3152		ok.String(*v.ClientToken)
3153	}
3154
3155	{
3156		ok := object.Key("DeleteDirectory")
3157		ok.Boolean(v.DeleteDirectory)
3158	}
3159
3160	if v.OrganizationId != nil {
3161		ok := object.Key("OrganizationId")
3162		ok.String(*v.OrganizationId)
3163	}
3164
3165	return nil
3166}
3167
3168func awsAwsjson11_serializeOpDocumentDeleteResourceInput(v *DeleteResourceInput, value smithyjson.Value) error {
3169	object := value.Object()
3170	defer object.Close()
3171
3172	if v.OrganizationId != nil {
3173		ok := object.Key("OrganizationId")
3174		ok.String(*v.OrganizationId)
3175	}
3176
3177	if v.ResourceId != nil {
3178		ok := object.Key("ResourceId")
3179		ok.String(*v.ResourceId)
3180	}
3181
3182	return nil
3183}
3184
3185func awsAwsjson11_serializeOpDocumentDeleteRetentionPolicyInput(v *DeleteRetentionPolicyInput, value smithyjson.Value) error {
3186	object := value.Object()
3187	defer object.Close()
3188
3189	if v.Id != nil {
3190		ok := object.Key("Id")
3191		ok.String(*v.Id)
3192	}
3193
3194	if v.OrganizationId != nil {
3195		ok := object.Key("OrganizationId")
3196		ok.String(*v.OrganizationId)
3197	}
3198
3199	return nil
3200}
3201
3202func awsAwsjson11_serializeOpDocumentDeleteUserInput(v *DeleteUserInput, value smithyjson.Value) error {
3203	object := value.Object()
3204	defer object.Close()
3205
3206	if v.OrganizationId != nil {
3207		ok := object.Key("OrganizationId")
3208		ok.String(*v.OrganizationId)
3209	}
3210
3211	if v.UserId != nil {
3212		ok := object.Key("UserId")
3213		ok.String(*v.UserId)
3214	}
3215
3216	return nil
3217}
3218
3219func awsAwsjson11_serializeOpDocumentDeregisterFromWorkMailInput(v *DeregisterFromWorkMailInput, value smithyjson.Value) error {
3220	object := value.Object()
3221	defer object.Close()
3222
3223	if v.EntityId != nil {
3224		ok := object.Key("EntityId")
3225		ok.String(*v.EntityId)
3226	}
3227
3228	if v.OrganizationId != nil {
3229		ok := object.Key("OrganizationId")
3230		ok.String(*v.OrganizationId)
3231	}
3232
3233	return nil
3234}
3235
3236func awsAwsjson11_serializeOpDocumentDescribeGroupInput(v *DescribeGroupInput, value smithyjson.Value) error {
3237	object := value.Object()
3238	defer object.Close()
3239
3240	if v.GroupId != nil {
3241		ok := object.Key("GroupId")
3242		ok.String(*v.GroupId)
3243	}
3244
3245	if v.OrganizationId != nil {
3246		ok := object.Key("OrganizationId")
3247		ok.String(*v.OrganizationId)
3248	}
3249
3250	return nil
3251}
3252
3253func awsAwsjson11_serializeOpDocumentDescribeMailboxExportJobInput(v *DescribeMailboxExportJobInput, value smithyjson.Value) error {
3254	object := value.Object()
3255	defer object.Close()
3256
3257	if v.JobId != nil {
3258		ok := object.Key("JobId")
3259		ok.String(*v.JobId)
3260	}
3261
3262	if v.OrganizationId != nil {
3263		ok := object.Key("OrganizationId")
3264		ok.String(*v.OrganizationId)
3265	}
3266
3267	return nil
3268}
3269
3270func awsAwsjson11_serializeOpDocumentDescribeOrganizationInput(v *DescribeOrganizationInput, value smithyjson.Value) error {
3271	object := value.Object()
3272	defer object.Close()
3273
3274	if v.OrganizationId != nil {
3275		ok := object.Key("OrganizationId")
3276		ok.String(*v.OrganizationId)
3277	}
3278
3279	return nil
3280}
3281
3282func awsAwsjson11_serializeOpDocumentDescribeResourceInput(v *DescribeResourceInput, value smithyjson.Value) error {
3283	object := value.Object()
3284	defer object.Close()
3285
3286	if v.OrganizationId != nil {
3287		ok := object.Key("OrganizationId")
3288		ok.String(*v.OrganizationId)
3289	}
3290
3291	if v.ResourceId != nil {
3292		ok := object.Key("ResourceId")
3293		ok.String(*v.ResourceId)
3294	}
3295
3296	return nil
3297}
3298
3299func awsAwsjson11_serializeOpDocumentDescribeUserInput(v *DescribeUserInput, value smithyjson.Value) error {
3300	object := value.Object()
3301	defer object.Close()
3302
3303	if v.OrganizationId != nil {
3304		ok := object.Key("OrganizationId")
3305		ok.String(*v.OrganizationId)
3306	}
3307
3308	if v.UserId != nil {
3309		ok := object.Key("UserId")
3310		ok.String(*v.UserId)
3311	}
3312
3313	return nil
3314}
3315
3316func awsAwsjson11_serializeOpDocumentDisassociateDelegateFromResourceInput(v *DisassociateDelegateFromResourceInput, value smithyjson.Value) error {
3317	object := value.Object()
3318	defer object.Close()
3319
3320	if v.EntityId != nil {
3321		ok := object.Key("EntityId")
3322		ok.String(*v.EntityId)
3323	}
3324
3325	if v.OrganizationId != nil {
3326		ok := object.Key("OrganizationId")
3327		ok.String(*v.OrganizationId)
3328	}
3329
3330	if v.ResourceId != nil {
3331		ok := object.Key("ResourceId")
3332		ok.String(*v.ResourceId)
3333	}
3334
3335	return nil
3336}
3337
3338func awsAwsjson11_serializeOpDocumentDisassociateMemberFromGroupInput(v *DisassociateMemberFromGroupInput, value smithyjson.Value) error {
3339	object := value.Object()
3340	defer object.Close()
3341
3342	if v.GroupId != nil {
3343		ok := object.Key("GroupId")
3344		ok.String(*v.GroupId)
3345	}
3346
3347	if v.MemberId != nil {
3348		ok := object.Key("MemberId")
3349		ok.String(*v.MemberId)
3350	}
3351
3352	if v.OrganizationId != nil {
3353		ok := object.Key("OrganizationId")
3354		ok.String(*v.OrganizationId)
3355	}
3356
3357	return nil
3358}
3359
3360func awsAwsjson11_serializeOpDocumentGetAccessControlEffectInput(v *GetAccessControlEffectInput, value smithyjson.Value) error {
3361	object := value.Object()
3362	defer object.Close()
3363
3364	if v.Action != nil {
3365		ok := object.Key("Action")
3366		ok.String(*v.Action)
3367	}
3368
3369	if v.IpAddress != nil {
3370		ok := object.Key("IpAddress")
3371		ok.String(*v.IpAddress)
3372	}
3373
3374	if v.OrganizationId != nil {
3375		ok := object.Key("OrganizationId")
3376		ok.String(*v.OrganizationId)
3377	}
3378
3379	if v.UserId != nil {
3380		ok := object.Key("UserId")
3381		ok.String(*v.UserId)
3382	}
3383
3384	return nil
3385}
3386
3387func awsAwsjson11_serializeOpDocumentGetDefaultRetentionPolicyInput(v *GetDefaultRetentionPolicyInput, value smithyjson.Value) error {
3388	object := value.Object()
3389	defer object.Close()
3390
3391	if v.OrganizationId != nil {
3392		ok := object.Key("OrganizationId")
3393		ok.String(*v.OrganizationId)
3394	}
3395
3396	return nil
3397}
3398
3399func awsAwsjson11_serializeOpDocumentGetMailboxDetailsInput(v *GetMailboxDetailsInput, value smithyjson.Value) error {
3400	object := value.Object()
3401	defer object.Close()
3402
3403	if v.OrganizationId != nil {
3404		ok := object.Key("OrganizationId")
3405		ok.String(*v.OrganizationId)
3406	}
3407
3408	if v.UserId != nil {
3409		ok := object.Key("UserId")
3410		ok.String(*v.UserId)
3411	}
3412
3413	return nil
3414}
3415
3416func awsAwsjson11_serializeOpDocumentGetMobileDeviceAccessEffectInput(v *GetMobileDeviceAccessEffectInput, value smithyjson.Value) error {
3417	object := value.Object()
3418	defer object.Close()
3419
3420	if v.DeviceModel != nil {
3421		ok := object.Key("DeviceModel")
3422		ok.String(*v.DeviceModel)
3423	}
3424
3425	if v.DeviceOperatingSystem != nil {
3426		ok := object.Key("DeviceOperatingSystem")
3427		ok.String(*v.DeviceOperatingSystem)
3428	}
3429
3430	if v.DeviceType != nil {
3431		ok := object.Key("DeviceType")
3432		ok.String(*v.DeviceType)
3433	}
3434
3435	if v.DeviceUserAgent != nil {
3436		ok := object.Key("DeviceUserAgent")
3437		ok.String(*v.DeviceUserAgent)
3438	}
3439
3440	if v.OrganizationId != nil {
3441		ok := object.Key("OrganizationId")
3442		ok.String(*v.OrganizationId)
3443	}
3444
3445	return nil
3446}
3447
3448func awsAwsjson11_serializeOpDocumentListAccessControlRulesInput(v *ListAccessControlRulesInput, value smithyjson.Value) error {
3449	object := value.Object()
3450	defer object.Close()
3451
3452	if v.OrganizationId != nil {
3453		ok := object.Key("OrganizationId")
3454		ok.String(*v.OrganizationId)
3455	}
3456
3457	return nil
3458}
3459
3460func awsAwsjson11_serializeOpDocumentListAliasesInput(v *ListAliasesInput, value smithyjson.Value) error {
3461	object := value.Object()
3462	defer object.Close()
3463
3464	if v.EntityId != nil {
3465		ok := object.Key("EntityId")
3466		ok.String(*v.EntityId)
3467	}
3468
3469	if v.MaxResults != nil {
3470		ok := object.Key("MaxResults")
3471		ok.Integer(*v.MaxResults)
3472	}
3473
3474	if v.NextToken != nil {
3475		ok := object.Key("NextToken")
3476		ok.String(*v.NextToken)
3477	}
3478
3479	if v.OrganizationId != nil {
3480		ok := object.Key("OrganizationId")
3481		ok.String(*v.OrganizationId)
3482	}
3483
3484	return nil
3485}
3486
3487func awsAwsjson11_serializeOpDocumentListGroupMembersInput(v *ListGroupMembersInput, value smithyjson.Value) error {
3488	object := value.Object()
3489	defer object.Close()
3490
3491	if v.GroupId != nil {
3492		ok := object.Key("GroupId")
3493		ok.String(*v.GroupId)
3494	}
3495
3496	if v.MaxResults != nil {
3497		ok := object.Key("MaxResults")
3498		ok.Integer(*v.MaxResults)
3499	}
3500
3501	if v.NextToken != nil {
3502		ok := object.Key("NextToken")
3503		ok.String(*v.NextToken)
3504	}
3505
3506	if v.OrganizationId != nil {
3507		ok := object.Key("OrganizationId")
3508		ok.String(*v.OrganizationId)
3509	}
3510
3511	return nil
3512}
3513
3514func awsAwsjson11_serializeOpDocumentListGroupsInput(v *ListGroupsInput, value smithyjson.Value) error {
3515	object := value.Object()
3516	defer object.Close()
3517
3518	if v.MaxResults != nil {
3519		ok := object.Key("MaxResults")
3520		ok.Integer(*v.MaxResults)
3521	}
3522
3523	if v.NextToken != nil {
3524		ok := object.Key("NextToken")
3525		ok.String(*v.NextToken)
3526	}
3527
3528	if v.OrganizationId != nil {
3529		ok := object.Key("OrganizationId")
3530		ok.String(*v.OrganizationId)
3531	}
3532
3533	return nil
3534}
3535
3536func awsAwsjson11_serializeOpDocumentListMailboxExportJobsInput(v *ListMailboxExportJobsInput, value smithyjson.Value) error {
3537	object := value.Object()
3538	defer object.Close()
3539
3540	if v.MaxResults != nil {
3541		ok := object.Key("MaxResults")
3542		ok.Integer(*v.MaxResults)
3543	}
3544
3545	if v.NextToken != nil {
3546		ok := object.Key("NextToken")
3547		ok.String(*v.NextToken)
3548	}
3549
3550	if v.OrganizationId != nil {
3551		ok := object.Key("OrganizationId")
3552		ok.String(*v.OrganizationId)
3553	}
3554
3555	return nil
3556}
3557
3558func awsAwsjson11_serializeOpDocumentListMailboxPermissionsInput(v *ListMailboxPermissionsInput, value smithyjson.Value) error {
3559	object := value.Object()
3560	defer object.Close()
3561
3562	if v.EntityId != nil {
3563		ok := object.Key("EntityId")
3564		ok.String(*v.EntityId)
3565	}
3566
3567	if v.MaxResults != nil {
3568		ok := object.Key("MaxResults")
3569		ok.Integer(*v.MaxResults)
3570	}
3571
3572	if v.NextToken != nil {
3573		ok := object.Key("NextToken")
3574		ok.String(*v.NextToken)
3575	}
3576
3577	if v.OrganizationId != nil {
3578		ok := object.Key("OrganizationId")
3579		ok.String(*v.OrganizationId)
3580	}
3581
3582	return nil
3583}
3584
3585func awsAwsjson11_serializeOpDocumentListMobileDeviceAccessRulesInput(v *ListMobileDeviceAccessRulesInput, value smithyjson.Value) error {
3586	object := value.Object()
3587	defer object.Close()
3588
3589	if v.OrganizationId != nil {
3590		ok := object.Key("OrganizationId")
3591		ok.String(*v.OrganizationId)
3592	}
3593
3594	return nil
3595}
3596
3597func awsAwsjson11_serializeOpDocumentListOrganizationsInput(v *ListOrganizationsInput, value smithyjson.Value) error {
3598	object := value.Object()
3599	defer object.Close()
3600
3601	if v.MaxResults != nil {
3602		ok := object.Key("MaxResults")
3603		ok.Integer(*v.MaxResults)
3604	}
3605
3606	if v.NextToken != nil {
3607		ok := object.Key("NextToken")
3608		ok.String(*v.NextToken)
3609	}
3610
3611	return nil
3612}
3613
3614func awsAwsjson11_serializeOpDocumentListResourceDelegatesInput(v *ListResourceDelegatesInput, value smithyjson.Value) error {
3615	object := value.Object()
3616	defer object.Close()
3617
3618	if v.MaxResults != nil {
3619		ok := object.Key("MaxResults")
3620		ok.Integer(*v.MaxResults)
3621	}
3622
3623	if v.NextToken != nil {
3624		ok := object.Key("NextToken")
3625		ok.String(*v.NextToken)
3626	}
3627
3628	if v.OrganizationId != nil {
3629		ok := object.Key("OrganizationId")
3630		ok.String(*v.OrganizationId)
3631	}
3632
3633	if v.ResourceId != nil {
3634		ok := object.Key("ResourceId")
3635		ok.String(*v.ResourceId)
3636	}
3637
3638	return nil
3639}
3640
3641func awsAwsjson11_serializeOpDocumentListResourcesInput(v *ListResourcesInput, value smithyjson.Value) error {
3642	object := value.Object()
3643	defer object.Close()
3644
3645	if v.MaxResults != nil {
3646		ok := object.Key("MaxResults")
3647		ok.Integer(*v.MaxResults)
3648	}
3649
3650	if v.NextToken != nil {
3651		ok := object.Key("NextToken")
3652		ok.String(*v.NextToken)
3653	}
3654
3655	if v.OrganizationId != nil {
3656		ok := object.Key("OrganizationId")
3657		ok.String(*v.OrganizationId)
3658	}
3659
3660	return nil
3661}
3662
3663func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
3664	object := value.Object()
3665	defer object.Close()
3666
3667	if v.ResourceARN != nil {
3668		ok := object.Key("ResourceARN")
3669		ok.String(*v.ResourceARN)
3670	}
3671
3672	return nil
3673}
3674
3675func awsAwsjson11_serializeOpDocumentListUsersInput(v *ListUsersInput, value smithyjson.Value) error {
3676	object := value.Object()
3677	defer object.Close()
3678
3679	if v.MaxResults != nil {
3680		ok := object.Key("MaxResults")
3681		ok.Integer(*v.MaxResults)
3682	}
3683
3684	if v.NextToken != nil {
3685		ok := object.Key("NextToken")
3686		ok.String(*v.NextToken)
3687	}
3688
3689	if v.OrganizationId != nil {
3690		ok := object.Key("OrganizationId")
3691		ok.String(*v.OrganizationId)
3692	}
3693
3694	return nil
3695}
3696
3697func awsAwsjson11_serializeOpDocumentPutAccessControlRuleInput(v *PutAccessControlRuleInput, value smithyjson.Value) error {
3698	object := value.Object()
3699	defer object.Close()
3700
3701	if v.Actions != nil {
3702		ok := object.Key("Actions")
3703		if err := awsAwsjson11_serializeDocumentActionsList(v.Actions, ok); err != nil {
3704			return err
3705		}
3706	}
3707
3708	if v.Description != nil {
3709		ok := object.Key("Description")
3710		ok.String(*v.Description)
3711	}
3712
3713	if len(v.Effect) > 0 {
3714		ok := object.Key("Effect")
3715		ok.String(string(v.Effect))
3716	}
3717
3718	if v.IpRanges != nil {
3719		ok := object.Key("IpRanges")
3720		if err := awsAwsjson11_serializeDocumentIpRangeList(v.IpRanges, ok); err != nil {
3721			return err
3722		}
3723	}
3724
3725	if v.Name != nil {
3726		ok := object.Key("Name")
3727		ok.String(*v.Name)
3728	}
3729
3730	if v.NotActions != nil {
3731		ok := object.Key("NotActions")
3732		if err := awsAwsjson11_serializeDocumentActionsList(v.NotActions, ok); err != nil {
3733			return err
3734		}
3735	}
3736
3737	if v.NotIpRanges != nil {
3738		ok := object.Key("NotIpRanges")
3739		if err := awsAwsjson11_serializeDocumentIpRangeList(v.NotIpRanges, ok); err != nil {
3740			return err
3741		}
3742	}
3743
3744	if v.NotUserIds != nil {
3745		ok := object.Key("NotUserIds")
3746		if err := awsAwsjson11_serializeDocumentUserIdList(v.NotUserIds, ok); err != nil {
3747			return err
3748		}
3749	}
3750
3751	if v.OrganizationId != nil {
3752		ok := object.Key("OrganizationId")
3753		ok.String(*v.OrganizationId)
3754	}
3755
3756	if v.UserIds != nil {
3757		ok := object.Key("UserIds")
3758		if err := awsAwsjson11_serializeDocumentUserIdList(v.UserIds, ok); err != nil {
3759			return err
3760		}
3761	}
3762
3763	return nil
3764}
3765
3766func awsAwsjson11_serializeOpDocumentPutMailboxPermissionsInput(v *PutMailboxPermissionsInput, value smithyjson.Value) error {
3767	object := value.Object()
3768	defer object.Close()
3769
3770	if v.EntityId != nil {
3771		ok := object.Key("EntityId")
3772		ok.String(*v.EntityId)
3773	}
3774
3775	if v.GranteeId != nil {
3776		ok := object.Key("GranteeId")
3777		ok.String(*v.GranteeId)
3778	}
3779
3780	if v.OrganizationId != nil {
3781		ok := object.Key("OrganizationId")
3782		ok.String(*v.OrganizationId)
3783	}
3784
3785	if v.PermissionValues != nil {
3786		ok := object.Key("PermissionValues")
3787		if err := awsAwsjson11_serializeDocumentPermissionValues(v.PermissionValues, ok); err != nil {
3788			return err
3789		}
3790	}
3791
3792	return nil
3793}
3794
3795func awsAwsjson11_serializeOpDocumentPutRetentionPolicyInput(v *PutRetentionPolicyInput, value smithyjson.Value) error {
3796	object := value.Object()
3797	defer object.Close()
3798
3799	if v.Description != nil {
3800		ok := object.Key("Description")
3801		ok.String(*v.Description)
3802	}
3803
3804	if v.FolderConfigurations != nil {
3805		ok := object.Key("FolderConfigurations")
3806		if err := awsAwsjson11_serializeDocumentFolderConfigurations(v.FolderConfigurations, ok); err != nil {
3807			return err
3808		}
3809	}
3810
3811	if v.Id != nil {
3812		ok := object.Key("Id")
3813		ok.String(*v.Id)
3814	}
3815
3816	if v.Name != nil {
3817		ok := object.Key("Name")
3818		ok.String(*v.Name)
3819	}
3820
3821	if v.OrganizationId != nil {
3822		ok := object.Key("OrganizationId")
3823		ok.String(*v.OrganizationId)
3824	}
3825
3826	return nil
3827}
3828
3829func awsAwsjson11_serializeOpDocumentRegisterToWorkMailInput(v *RegisterToWorkMailInput, value smithyjson.Value) error {
3830	object := value.Object()
3831	defer object.Close()
3832
3833	if v.Email != nil {
3834		ok := object.Key("Email")
3835		ok.String(*v.Email)
3836	}
3837
3838	if v.EntityId != nil {
3839		ok := object.Key("EntityId")
3840		ok.String(*v.EntityId)
3841	}
3842
3843	if v.OrganizationId != nil {
3844		ok := object.Key("OrganizationId")
3845		ok.String(*v.OrganizationId)
3846	}
3847
3848	return nil
3849}
3850
3851func awsAwsjson11_serializeOpDocumentResetPasswordInput(v *ResetPasswordInput, value smithyjson.Value) error {
3852	object := value.Object()
3853	defer object.Close()
3854
3855	if v.OrganizationId != nil {
3856		ok := object.Key("OrganizationId")
3857		ok.String(*v.OrganizationId)
3858	}
3859
3860	if v.Password != nil {
3861		ok := object.Key("Password")
3862		ok.String(*v.Password)
3863	}
3864
3865	if v.UserId != nil {
3866		ok := object.Key("UserId")
3867		ok.String(*v.UserId)
3868	}
3869
3870	return nil
3871}
3872
3873func awsAwsjson11_serializeOpDocumentStartMailboxExportJobInput(v *StartMailboxExportJobInput, value smithyjson.Value) error {
3874	object := value.Object()
3875	defer object.Close()
3876
3877	if v.ClientToken != nil {
3878		ok := object.Key("ClientToken")
3879		ok.String(*v.ClientToken)
3880	}
3881
3882	if v.Description != nil {
3883		ok := object.Key("Description")
3884		ok.String(*v.Description)
3885	}
3886
3887	if v.EntityId != nil {
3888		ok := object.Key("EntityId")
3889		ok.String(*v.EntityId)
3890	}
3891
3892	if v.KmsKeyArn != nil {
3893		ok := object.Key("KmsKeyArn")
3894		ok.String(*v.KmsKeyArn)
3895	}
3896
3897	if v.OrganizationId != nil {
3898		ok := object.Key("OrganizationId")
3899		ok.String(*v.OrganizationId)
3900	}
3901
3902	if v.RoleArn != nil {
3903		ok := object.Key("RoleArn")
3904		ok.String(*v.RoleArn)
3905	}
3906
3907	if v.S3BucketName != nil {
3908		ok := object.Key("S3BucketName")
3909		ok.String(*v.S3BucketName)
3910	}
3911
3912	if v.S3Prefix != nil {
3913		ok := object.Key("S3Prefix")
3914		ok.String(*v.S3Prefix)
3915	}
3916
3917	return nil
3918}
3919
3920func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
3921	object := value.Object()
3922	defer object.Close()
3923
3924	if v.ResourceARN != nil {
3925		ok := object.Key("ResourceARN")
3926		ok.String(*v.ResourceARN)
3927	}
3928
3929	if v.Tags != nil {
3930		ok := object.Key("Tags")
3931		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3932			return err
3933		}
3934	}
3935
3936	return nil
3937}
3938
3939func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
3940	object := value.Object()
3941	defer object.Close()
3942
3943	if v.ResourceARN != nil {
3944		ok := object.Key("ResourceARN")
3945		ok.String(*v.ResourceARN)
3946	}
3947
3948	if v.TagKeys != nil {
3949		ok := object.Key("TagKeys")
3950		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
3951			return err
3952		}
3953	}
3954
3955	return nil
3956}
3957
3958func awsAwsjson11_serializeOpDocumentUpdateMailboxQuotaInput(v *UpdateMailboxQuotaInput, value smithyjson.Value) error {
3959	object := value.Object()
3960	defer object.Close()
3961
3962	if v.MailboxQuota != nil {
3963		ok := object.Key("MailboxQuota")
3964		ok.Integer(*v.MailboxQuota)
3965	}
3966
3967	if v.OrganizationId != nil {
3968		ok := object.Key("OrganizationId")
3969		ok.String(*v.OrganizationId)
3970	}
3971
3972	if v.UserId != nil {
3973		ok := object.Key("UserId")
3974		ok.String(*v.UserId)
3975	}
3976
3977	return nil
3978}
3979
3980func awsAwsjson11_serializeOpDocumentUpdateMobileDeviceAccessRuleInput(v *UpdateMobileDeviceAccessRuleInput, value smithyjson.Value) error {
3981	object := value.Object()
3982	defer object.Close()
3983
3984	if v.Description != nil {
3985		ok := object.Key("Description")
3986		ok.String(*v.Description)
3987	}
3988
3989	if v.DeviceModels != nil {
3990		ok := object.Key("DeviceModels")
3991		if err := awsAwsjson11_serializeDocumentDeviceModelList(v.DeviceModels, ok); err != nil {
3992			return err
3993		}
3994	}
3995
3996	if v.DeviceOperatingSystems != nil {
3997		ok := object.Key("DeviceOperatingSystems")
3998		if err := awsAwsjson11_serializeDocumentDeviceOperatingSystemList(v.DeviceOperatingSystems, ok); err != nil {
3999			return err
4000		}
4001	}
4002
4003	if v.DeviceTypes != nil {
4004		ok := object.Key("DeviceTypes")
4005		if err := awsAwsjson11_serializeDocumentDeviceTypeList(v.DeviceTypes, ok); err != nil {
4006			return err
4007		}
4008	}
4009
4010	if v.DeviceUserAgents != nil {
4011		ok := object.Key("DeviceUserAgents")
4012		if err := awsAwsjson11_serializeDocumentDeviceUserAgentList(v.DeviceUserAgents, ok); err != nil {
4013			return err
4014		}
4015	}
4016
4017	if len(v.Effect) > 0 {
4018		ok := object.Key("Effect")
4019		ok.String(string(v.Effect))
4020	}
4021
4022	if v.MobileDeviceAccessRuleId != nil {
4023		ok := object.Key("MobileDeviceAccessRuleId")
4024		ok.String(*v.MobileDeviceAccessRuleId)
4025	}
4026
4027	if v.Name != nil {
4028		ok := object.Key("Name")
4029		ok.String(*v.Name)
4030	}
4031
4032	if v.NotDeviceModels != nil {
4033		ok := object.Key("NotDeviceModels")
4034		if err := awsAwsjson11_serializeDocumentDeviceModelList(v.NotDeviceModels, ok); err != nil {
4035			return err
4036		}
4037	}
4038
4039	if v.NotDeviceOperatingSystems != nil {
4040		ok := object.Key("NotDeviceOperatingSystems")
4041		if err := awsAwsjson11_serializeDocumentDeviceOperatingSystemList(v.NotDeviceOperatingSystems, ok); err != nil {
4042			return err
4043		}
4044	}
4045
4046	if v.NotDeviceTypes != nil {
4047		ok := object.Key("NotDeviceTypes")
4048		if err := awsAwsjson11_serializeDocumentDeviceTypeList(v.NotDeviceTypes, ok); err != nil {
4049			return err
4050		}
4051	}
4052
4053	if v.NotDeviceUserAgents != nil {
4054		ok := object.Key("NotDeviceUserAgents")
4055		if err := awsAwsjson11_serializeDocumentDeviceUserAgentList(v.NotDeviceUserAgents, ok); err != nil {
4056			return err
4057		}
4058	}
4059
4060	if v.OrganizationId != nil {
4061		ok := object.Key("OrganizationId")
4062		ok.String(*v.OrganizationId)
4063	}
4064
4065	return nil
4066}
4067
4068func awsAwsjson11_serializeOpDocumentUpdatePrimaryEmailAddressInput(v *UpdatePrimaryEmailAddressInput, value smithyjson.Value) error {
4069	object := value.Object()
4070	defer object.Close()
4071
4072	if v.Email != nil {
4073		ok := object.Key("Email")
4074		ok.String(*v.Email)
4075	}
4076
4077	if v.EntityId != nil {
4078		ok := object.Key("EntityId")
4079		ok.String(*v.EntityId)
4080	}
4081
4082	if v.OrganizationId != nil {
4083		ok := object.Key("OrganizationId")
4084		ok.String(*v.OrganizationId)
4085	}
4086
4087	return nil
4088}
4089
4090func awsAwsjson11_serializeOpDocumentUpdateResourceInput(v *UpdateResourceInput, value smithyjson.Value) error {
4091	object := value.Object()
4092	defer object.Close()
4093
4094	if v.BookingOptions != nil {
4095		ok := object.Key("BookingOptions")
4096		if err := awsAwsjson11_serializeDocumentBookingOptions(v.BookingOptions, ok); err != nil {
4097			return err
4098		}
4099	}
4100
4101	if v.Name != nil {
4102		ok := object.Key("Name")
4103		ok.String(*v.Name)
4104	}
4105
4106	if v.OrganizationId != nil {
4107		ok := object.Key("OrganizationId")
4108		ok.String(*v.OrganizationId)
4109	}
4110
4111	if v.ResourceId != nil {
4112		ok := object.Key("ResourceId")
4113		ok.String(*v.ResourceId)
4114	}
4115
4116	return nil
4117}
4118