1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package directoryservice
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/directoryservice/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_serializeOpAcceptSharedDirectory struct {
18}
19
20func (*awsAwsjson11_serializeOpAcceptSharedDirectory) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpAcceptSharedDirectory) 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.(*AcceptSharedDirectoryInput)
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("DirectoryService_20150416.AcceptSharedDirectory")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentAcceptSharedDirectoryInput(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_serializeOpAddIpRoutes struct {
65}
66
67func (*awsAwsjson11_serializeOpAddIpRoutes) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpAddIpRoutes) 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.(*AddIpRoutesInput)
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("DirectoryService_20150416.AddIpRoutes")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentAddIpRoutesInput(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_serializeOpAddRegion struct {
112}
113
114func (*awsAwsjson11_serializeOpAddRegion) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpAddRegion) 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.(*AddRegionInput)
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("DirectoryService_20150416.AddRegion")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentAddRegionInput(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_serializeOpAddTagsToResource struct {
159}
160
161func (*awsAwsjson11_serializeOpAddTagsToResource) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpAddTagsToResource) 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.(*AddTagsToResourceInput)
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("DirectoryService_20150416.AddTagsToResource")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(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_serializeOpCancelSchemaExtension struct {
206}
207
208func (*awsAwsjson11_serializeOpCancelSchemaExtension) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCancelSchemaExtension) 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.(*CancelSchemaExtensionInput)
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("DirectoryService_20150416.CancelSchemaExtension")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCancelSchemaExtensionInput(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_serializeOpConnectDirectory struct {
253}
254
255func (*awsAwsjson11_serializeOpConnectDirectory) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpConnectDirectory) 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.(*ConnectDirectoryInput)
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("DirectoryService_20150416.ConnectDirectory")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentConnectDirectoryInput(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_serializeOpCreateAlias struct {
300}
301
302func (*awsAwsjson11_serializeOpCreateAlias) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpCreateAlias) 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.(*CreateAliasInput)
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("DirectoryService_20150416.CreateAlias")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentCreateAliasInput(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_serializeOpCreateComputer struct {
347}
348
349func (*awsAwsjson11_serializeOpCreateComputer) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpCreateComputer) 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.(*CreateComputerInput)
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("DirectoryService_20150416.CreateComputer")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentCreateComputerInput(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_serializeOpCreateConditionalForwarder struct {
394}
395
396func (*awsAwsjson11_serializeOpCreateConditionalForwarder) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpCreateConditionalForwarder) 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.(*CreateConditionalForwarderInput)
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("DirectoryService_20150416.CreateConditionalForwarder")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentCreateConditionalForwarderInput(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_serializeOpCreateDirectory struct {
441}
442
443func (*awsAwsjson11_serializeOpCreateDirectory) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpCreateDirectory) 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.(*CreateDirectoryInput)
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("DirectoryService_20150416.CreateDirectory")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentCreateDirectoryInput(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_serializeOpCreateLogSubscription struct {
488}
489
490func (*awsAwsjson11_serializeOpCreateLogSubscription) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpCreateLogSubscription) 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.(*CreateLogSubscriptionInput)
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("DirectoryService_20150416.CreateLogSubscription")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentCreateLogSubscriptionInput(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_serializeOpCreateMicrosoftAD struct {
535}
536
537func (*awsAwsjson11_serializeOpCreateMicrosoftAD) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpCreateMicrosoftAD) 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.(*CreateMicrosoftADInput)
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("DirectoryService_20150416.CreateMicrosoftAD")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentCreateMicrosoftADInput(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_serializeOpCreateSnapshot struct {
582}
583
584func (*awsAwsjson11_serializeOpCreateSnapshot) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpCreateSnapshot) 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.(*CreateSnapshotInput)
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("DirectoryService_20150416.CreateSnapshot")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentCreateSnapshotInput(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_serializeOpCreateTrust struct {
629}
630
631func (*awsAwsjson11_serializeOpCreateTrust) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpCreateTrust) 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.(*CreateTrustInput)
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("DirectoryService_20150416.CreateTrust")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentCreateTrustInput(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_serializeOpDeleteConditionalForwarder struct {
676}
677
678func (*awsAwsjson11_serializeOpDeleteConditionalForwarder) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDeleteConditionalForwarder) 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.(*DeleteConditionalForwarderInput)
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("DirectoryService_20150416.DeleteConditionalForwarder")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDeleteConditionalForwarderInput(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_serializeOpDeleteDirectory struct {
723}
724
725func (*awsAwsjson11_serializeOpDeleteDirectory) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDeleteDirectory) 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.(*DeleteDirectoryInput)
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("DirectoryService_20150416.DeleteDirectory")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDeleteDirectoryInput(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_serializeOpDeleteLogSubscription struct {
770}
771
772func (*awsAwsjson11_serializeOpDeleteLogSubscription) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDeleteLogSubscription) 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.(*DeleteLogSubscriptionInput)
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("DirectoryService_20150416.DeleteLogSubscription")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDeleteLogSubscriptionInput(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_serializeOpDeleteSnapshot struct {
817}
818
819func (*awsAwsjson11_serializeOpDeleteSnapshot) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDeleteSnapshot) 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.(*DeleteSnapshotInput)
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("DirectoryService_20150416.DeleteSnapshot")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(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_serializeOpDeleteTrust struct {
864}
865
866func (*awsAwsjson11_serializeOpDeleteTrust) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDeleteTrust) 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.(*DeleteTrustInput)
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("DirectoryService_20150416.DeleteTrust")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDeleteTrustInput(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_serializeOpDeregisterCertificate struct {
911}
912
913func (*awsAwsjson11_serializeOpDeregisterCertificate) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDeregisterCertificate) 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.(*DeregisterCertificateInput)
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("DirectoryService_20150416.DeregisterCertificate")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDeregisterCertificateInput(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_serializeOpDeregisterEventTopic struct {
958}
959
960func (*awsAwsjson11_serializeOpDeregisterEventTopic) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDeregisterEventTopic) 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.(*DeregisterEventTopicInput)
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("DirectoryService_20150416.DeregisterEventTopic")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDeregisterEventTopicInput(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_serializeOpDescribeCertificate struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpDescribeCertificate) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpDescribeCertificate) 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.(*DescribeCertificateInput)
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("DirectoryService_20150416.DescribeCertificate")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentDescribeCertificateInput(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_serializeOpDescribeConditionalForwarders struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpDescribeConditionalForwarders) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpDescribeConditionalForwarders) 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.(*DescribeConditionalForwardersInput)
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("DirectoryService_20150416.DescribeConditionalForwarders")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(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_serializeOpDescribeDirectories struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpDescribeDirectories) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpDescribeDirectories) 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.(*DescribeDirectoriesInput)
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("DirectoryService_20150416.DescribeDirectories")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(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_serializeOpDescribeDomainControllers struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpDescribeDomainControllers) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpDescribeDomainControllers) 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.(*DescribeDomainControllersInput)
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("DirectoryService_20150416.DescribeDomainControllers")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(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_serializeOpDescribeEventTopics struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpDescribeEventTopics) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpDescribeEventTopics) 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.(*DescribeEventTopicsInput)
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("DirectoryService_20150416.DescribeEventTopics")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(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_serializeOpDescribeLDAPSSettings struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpDescribeLDAPSSettings) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpDescribeLDAPSSettings) 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.(*DescribeLDAPSSettingsInput)
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("DirectoryService_20150416.DescribeLDAPSSettings")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(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_serializeOpDescribeRegions struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpDescribeRegions) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpDescribeRegions) 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.(*DescribeRegionsInput)
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("DirectoryService_20150416.DescribeRegions")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentDescribeRegionsInput(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_serializeOpDescribeSharedDirectories struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpDescribeSharedDirectories) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpDescribeSharedDirectories) 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.(*DescribeSharedDirectoriesInput)
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("DirectoryService_20150416.DescribeSharedDirectories")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(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_serializeOpDescribeSnapshots struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpDescribeSnapshots) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpDescribeSnapshots) 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.(*DescribeSnapshotsInput)
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("DirectoryService_20150416.DescribeSnapshots")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(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_serializeOpDescribeTrusts struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpDescribeTrusts) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpDescribeTrusts) 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.(*DescribeTrustsInput)
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("DirectoryService_20150416.DescribeTrusts")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentDescribeTrustsInput(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_serializeOpDisableClientAuthentication struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpDisableClientAuthentication) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpDisableClientAuthentication) 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.(*DisableClientAuthenticationInput)
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("DirectoryService_20150416.DisableClientAuthentication")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(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_serializeOpDisableLDAPS struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpDisableLDAPS) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpDisableLDAPS) 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.(*DisableLDAPSInput)
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("DirectoryService_20150416.DisableLDAPS")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentDisableLDAPSInput(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_serializeOpDisableRadius struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpDisableRadius) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpDisableRadius) 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.(*DisableRadiusInput)
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("DirectoryService_20150416.DisableRadius")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentDisableRadiusInput(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_serializeOpDisableSso struct {
1616}
1617
1618func (*awsAwsjson11_serializeOpDisableSso) ID() string {
1619	return "OperationSerializer"
1620}
1621
1622func (m *awsAwsjson11_serializeOpDisableSso) 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.(*DisableSsoInput)
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("DirectoryService_20150416.DisableSso")
1644
1645	jsonEncoder := smithyjson.NewEncoder()
1646	if err := awsAwsjson11_serializeOpDocumentDisableSsoInput(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_serializeOpEnableClientAuthentication struct {
1663}
1664
1665func (*awsAwsjson11_serializeOpEnableClientAuthentication) ID() string {
1666	return "OperationSerializer"
1667}
1668
1669func (m *awsAwsjson11_serializeOpEnableClientAuthentication) 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.(*EnableClientAuthenticationInput)
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("DirectoryService_20150416.EnableClientAuthentication")
1691
1692	jsonEncoder := smithyjson.NewEncoder()
1693	if err := awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(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_serializeOpEnableLDAPS struct {
1710}
1711
1712func (*awsAwsjson11_serializeOpEnableLDAPS) ID() string {
1713	return "OperationSerializer"
1714}
1715
1716func (m *awsAwsjson11_serializeOpEnableLDAPS) 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.(*EnableLDAPSInput)
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("DirectoryService_20150416.EnableLDAPS")
1738
1739	jsonEncoder := smithyjson.NewEncoder()
1740	if err := awsAwsjson11_serializeOpDocumentEnableLDAPSInput(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_serializeOpEnableRadius struct {
1757}
1758
1759func (*awsAwsjson11_serializeOpEnableRadius) ID() string {
1760	return "OperationSerializer"
1761}
1762
1763func (m *awsAwsjson11_serializeOpEnableRadius) 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.(*EnableRadiusInput)
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("DirectoryService_20150416.EnableRadius")
1785
1786	jsonEncoder := smithyjson.NewEncoder()
1787	if err := awsAwsjson11_serializeOpDocumentEnableRadiusInput(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_serializeOpEnableSso struct {
1804}
1805
1806func (*awsAwsjson11_serializeOpEnableSso) ID() string {
1807	return "OperationSerializer"
1808}
1809
1810func (m *awsAwsjson11_serializeOpEnableSso) 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.(*EnableSsoInput)
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("DirectoryService_20150416.EnableSso")
1832
1833	jsonEncoder := smithyjson.NewEncoder()
1834	if err := awsAwsjson11_serializeOpDocumentEnableSsoInput(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_serializeOpGetDirectoryLimits struct {
1851}
1852
1853func (*awsAwsjson11_serializeOpGetDirectoryLimits) ID() string {
1854	return "OperationSerializer"
1855}
1856
1857func (m *awsAwsjson11_serializeOpGetDirectoryLimits) 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.(*GetDirectoryLimitsInput)
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("DirectoryService_20150416.GetDirectoryLimits")
1879
1880	jsonEncoder := smithyjson.NewEncoder()
1881	if err := awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(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_serializeOpGetSnapshotLimits struct {
1898}
1899
1900func (*awsAwsjson11_serializeOpGetSnapshotLimits) ID() string {
1901	return "OperationSerializer"
1902}
1903
1904func (m *awsAwsjson11_serializeOpGetSnapshotLimits) 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.(*GetSnapshotLimitsInput)
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("DirectoryService_20150416.GetSnapshotLimits")
1926
1927	jsonEncoder := smithyjson.NewEncoder()
1928	if err := awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(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_serializeOpListCertificates struct {
1945}
1946
1947func (*awsAwsjson11_serializeOpListCertificates) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsAwsjson11_serializeOpListCertificates) 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.(*ListCertificatesInput)
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("DirectoryService_20150416.ListCertificates")
1973
1974	jsonEncoder := smithyjson.NewEncoder()
1975	if err := awsAwsjson11_serializeOpDocumentListCertificatesInput(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_serializeOpListIpRoutes struct {
1992}
1993
1994func (*awsAwsjson11_serializeOpListIpRoutes) ID() string {
1995	return "OperationSerializer"
1996}
1997
1998func (m *awsAwsjson11_serializeOpListIpRoutes) 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.(*ListIpRoutesInput)
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("DirectoryService_20150416.ListIpRoutes")
2020
2021	jsonEncoder := smithyjson.NewEncoder()
2022	if err := awsAwsjson11_serializeOpDocumentListIpRoutesInput(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_serializeOpListLogSubscriptions struct {
2039}
2040
2041func (*awsAwsjson11_serializeOpListLogSubscriptions) ID() string {
2042	return "OperationSerializer"
2043}
2044
2045func (m *awsAwsjson11_serializeOpListLogSubscriptions) 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.(*ListLogSubscriptionsInput)
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("DirectoryService_20150416.ListLogSubscriptions")
2067
2068	jsonEncoder := smithyjson.NewEncoder()
2069	if err := awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(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_serializeOpListSchemaExtensions struct {
2086}
2087
2088func (*awsAwsjson11_serializeOpListSchemaExtensions) ID() string {
2089	return "OperationSerializer"
2090}
2091
2092func (m *awsAwsjson11_serializeOpListSchemaExtensions) 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.(*ListSchemaExtensionsInput)
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("DirectoryService_20150416.ListSchemaExtensions")
2114
2115	jsonEncoder := smithyjson.NewEncoder()
2116	if err := awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(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_serializeOpListTagsForResource struct {
2133}
2134
2135func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
2136	return "OperationSerializer"
2137}
2138
2139func (m *awsAwsjson11_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput)
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("DirectoryService_20150416.ListTagsForResource")
2161
2162	jsonEncoder := smithyjson.NewEncoder()
2163	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(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_serializeOpRegisterCertificate struct {
2180}
2181
2182func (*awsAwsjson11_serializeOpRegisterCertificate) ID() string {
2183	return "OperationSerializer"
2184}
2185
2186func (m *awsAwsjson11_serializeOpRegisterCertificate) 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.(*RegisterCertificateInput)
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("DirectoryService_20150416.RegisterCertificate")
2208
2209	jsonEncoder := smithyjson.NewEncoder()
2210	if err := awsAwsjson11_serializeOpDocumentRegisterCertificateInput(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_serializeOpRegisterEventTopic struct {
2227}
2228
2229func (*awsAwsjson11_serializeOpRegisterEventTopic) ID() string {
2230	return "OperationSerializer"
2231}
2232
2233func (m *awsAwsjson11_serializeOpRegisterEventTopic) 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.(*RegisterEventTopicInput)
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("DirectoryService_20150416.RegisterEventTopic")
2255
2256	jsonEncoder := smithyjson.NewEncoder()
2257	if err := awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(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_serializeOpRejectSharedDirectory struct {
2274}
2275
2276func (*awsAwsjson11_serializeOpRejectSharedDirectory) ID() string {
2277	return "OperationSerializer"
2278}
2279
2280func (m *awsAwsjson11_serializeOpRejectSharedDirectory) 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.(*RejectSharedDirectoryInput)
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("DirectoryService_20150416.RejectSharedDirectory")
2302
2303	jsonEncoder := smithyjson.NewEncoder()
2304	if err := awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(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_serializeOpRemoveIpRoutes struct {
2321}
2322
2323func (*awsAwsjson11_serializeOpRemoveIpRoutes) ID() string {
2324	return "OperationSerializer"
2325}
2326
2327func (m *awsAwsjson11_serializeOpRemoveIpRoutes) 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.(*RemoveIpRoutesInput)
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("DirectoryService_20150416.RemoveIpRoutes")
2349
2350	jsonEncoder := smithyjson.NewEncoder()
2351	if err := awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(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_serializeOpRemoveRegion struct {
2368}
2369
2370func (*awsAwsjson11_serializeOpRemoveRegion) ID() string {
2371	return "OperationSerializer"
2372}
2373
2374func (m *awsAwsjson11_serializeOpRemoveRegion) 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.(*RemoveRegionInput)
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("DirectoryService_20150416.RemoveRegion")
2396
2397	jsonEncoder := smithyjson.NewEncoder()
2398	if err := awsAwsjson11_serializeOpDocumentRemoveRegionInput(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_serializeOpRemoveTagsFromResource struct {
2415}
2416
2417func (*awsAwsjson11_serializeOpRemoveTagsFromResource) ID() string {
2418	return "OperationSerializer"
2419}
2420
2421func (m *awsAwsjson11_serializeOpRemoveTagsFromResource) 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.(*RemoveTagsFromResourceInput)
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("DirectoryService_20150416.RemoveTagsFromResource")
2443
2444	jsonEncoder := smithyjson.NewEncoder()
2445	if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(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_serializeOpResetUserPassword struct {
2462}
2463
2464func (*awsAwsjson11_serializeOpResetUserPassword) ID() string {
2465	return "OperationSerializer"
2466}
2467
2468func (m *awsAwsjson11_serializeOpResetUserPassword) 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.(*ResetUserPasswordInput)
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("DirectoryService_20150416.ResetUserPassword")
2490
2491	jsonEncoder := smithyjson.NewEncoder()
2492	if err := awsAwsjson11_serializeOpDocumentResetUserPasswordInput(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_serializeOpRestoreFromSnapshot struct {
2509}
2510
2511func (*awsAwsjson11_serializeOpRestoreFromSnapshot) ID() string {
2512	return "OperationSerializer"
2513}
2514
2515func (m *awsAwsjson11_serializeOpRestoreFromSnapshot) 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.(*RestoreFromSnapshotInput)
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("DirectoryService_20150416.RestoreFromSnapshot")
2537
2538	jsonEncoder := smithyjson.NewEncoder()
2539	if err := awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(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}
2554
2555type awsAwsjson11_serializeOpShareDirectory struct {
2556}
2557
2558func (*awsAwsjson11_serializeOpShareDirectory) ID() string {
2559	return "OperationSerializer"
2560}
2561
2562func (m *awsAwsjson11_serializeOpShareDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2563	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2564) {
2565	request, ok := in.Request.(*smithyhttp.Request)
2566	if !ok {
2567		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2568	}
2569
2570	input, ok := in.Parameters.(*ShareDirectoryInput)
2571	_ = input
2572	if !ok {
2573		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2574	}
2575
2576	request.Request.URL.Path = "/"
2577	request.Request.Method = "POST"
2578	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2579	if err != nil {
2580		return out, metadata, &smithy.SerializationError{Err: err}
2581	}
2582	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2583	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ShareDirectory")
2584
2585	jsonEncoder := smithyjson.NewEncoder()
2586	if err := awsAwsjson11_serializeOpDocumentShareDirectoryInput(input, jsonEncoder.Value); err != nil {
2587		return out, metadata, &smithy.SerializationError{Err: err}
2588	}
2589
2590	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2591		return out, metadata, &smithy.SerializationError{Err: err}
2592	}
2593
2594	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2595		return out, metadata, &smithy.SerializationError{Err: err}
2596	}
2597	in.Request = request
2598
2599	return next.HandleSerialize(ctx, in)
2600}
2601
2602type awsAwsjson11_serializeOpStartSchemaExtension struct {
2603}
2604
2605func (*awsAwsjson11_serializeOpStartSchemaExtension) ID() string {
2606	return "OperationSerializer"
2607}
2608
2609func (m *awsAwsjson11_serializeOpStartSchemaExtension) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2610	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2611) {
2612	request, ok := in.Request.(*smithyhttp.Request)
2613	if !ok {
2614		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2615	}
2616
2617	input, ok := in.Parameters.(*StartSchemaExtensionInput)
2618	_ = input
2619	if !ok {
2620		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2621	}
2622
2623	request.Request.URL.Path = "/"
2624	request.Request.Method = "POST"
2625	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2626	if err != nil {
2627		return out, metadata, &smithy.SerializationError{Err: err}
2628	}
2629	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2630	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.StartSchemaExtension")
2631
2632	jsonEncoder := smithyjson.NewEncoder()
2633	if err := awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(input, jsonEncoder.Value); err != nil {
2634		return out, metadata, &smithy.SerializationError{Err: err}
2635	}
2636
2637	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2638		return out, metadata, &smithy.SerializationError{Err: err}
2639	}
2640
2641	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2642		return out, metadata, &smithy.SerializationError{Err: err}
2643	}
2644	in.Request = request
2645
2646	return next.HandleSerialize(ctx, in)
2647}
2648
2649type awsAwsjson11_serializeOpUnshareDirectory struct {
2650}
2651
2652func (*awsAwsjson11_serializeOpUnshareDirectory) ID() string {
2653	return "OperationSerializer"
2654}
2655
2656func (m *awsAwsjson11_serializeOpUnshareDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2657	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2658) {
2659	request, ok := in.Request.(*smithyhttp.Request)
2660	if !ok {
2661		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2662	}
2663
2664	input, ok := in.Parameters.(*UnshareDirectoryInput)
2665	_ = input
2666	if !ok {
2667		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2668	}
2669
2670	request.Request.URL.Path = "/"
2671	request.Request.Method = "POST"
2672	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2673	if err != nil {
2674		return out, metadata, &smithy.SerializationError{Err: err}
2675	}
2676	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2677	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UnshareDirectory")
2678
2679	jsonEncoder := smithyjson.NewEncoder()
2680	if err := awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(input, jsonEncoder.Value); err != nil {
2681		return out, metadata, &smithy.SerializationError{Err: err}
2682	}
2683
2684	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2685		return out, metadata, &smithy.SerializationError{Err: err}
2686	}
2687
2688	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2689		return out, metadata, &smithy.SerializationError{Err: err}
2690	}
2691	in.Request = request
2692
2693	return next.HandleSerialize(ctx, in)
2694}
2695
2696type awsAwsjson11_serializeOpUpdateConditionalForwarder struct {
2697}
2698
2699func (*awsAwsjson11_serializeOpUpdateConditionalForwarder) ID() string {
2700	return "OperationSerializer"
2701}
2702
2703func (m *awsAwsjson11_serializeOpUpdateConditionalForwarder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2704	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2705) {
2706	request, ok := in.Request.(*smithyhttp.Request)
2707	if !ok {
2708		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2709	}
2710
2711	input, ok := in.Parameters.(*UpdateConditionalForwarderInput)
2712	_ = input
2713	if !ok {
2714		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2715	}
2716
2717	request.Request.URL.Path = "/"
2718	request.Request.Method = "POST"
2719	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2720	if err != nil {
2721		return out, metadata, &smithy.SerializationError{Err: err}
2722	}
2723	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2724	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateConditionalForwarder")
2725
2726	jsonEncoder := smithyjson.NewEncoder()
2727	if err := awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(input, jsonEncoder.Value); err != nil {
2728		return out, metadata, &smithy.SerializationError{Err: err}
2729	}
2730
2731	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2732		return out, metadata, &smithy.SerializationError{Err: err}
2733	}
2734
2735	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2736		return out, metadata, &smithy.SerializationError{Err: err}
2737	}
2738	in.Request = request
2739
2740	return next.HandleSerialize(ctx, in)
2741}
2742
2743type awsAwsjson11_serializeOpUpdateNumberOfDomainControllers struct {
2744}
2745
2746func (*awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) ID() string {
2747	return "OperationSerializer"
2748}
2749
2750func (m *awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2751	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2752) {
2753	request, ok := in.Request.(*smithyhttp.Request)
2754	if !ok {
2755		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2756	}
2757
2758	input, ok := in.Parameters.(*UpdateNumberOfDomainControllersInput)
2759	_ = input
2760	if !ok {
2761		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2762	}
2763
2764	request.Request.URL.Path = "/"
2765	request.Request.Method = "POST"
2766	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2767	if err != nil {
2768		return out, metadata, &smithy.SerializationError{Err: err}
2769	}
2770	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2771	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateNumberOfDomainControllers")
2772
2773	jsonEncoder := smithyjson.NewEncoder()
2774	if err := awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(input, jsonEncoder.Value); err != nil {
2775		return out, metadata, &smithy.SerializationError{Err: err}
2776	}
2777
2778	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2779		return out, metadata, &smithy.SerializationError{Err: err}
2780	}
2781
2782	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2783		return out, metadata, &smithy.SerializationError{Err: err}
2784	}
2785	in.Request = request
2786
2787	return next.HandleSerialize(ctx, in)
2788}
2789
2790type awsAwsjson11_serializeOpUpdateRadius struct {
2791}
2792
2793func (*awsAwsjson11_serializeOpUpdateRadius) ID() string {
2794	return "OperationSerializer"
2795}
2796
2797func (m *awsAwsjson11_serializeOpUpdateRadius) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2798	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2799) {
2800	request, ok := in.Request.(*smithyhttp.Request)
2801	if !ok {
2802		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2803	}
2804
2805	input, ok := in.Parameters.(*UpdateRadiusInput)
2806	_ = input
2807	if !ok {
2808		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2809	}
2810
2811	request.Request.URL.Path = "/"
2812	request.Request.Method = "POST"
2813	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2814	if err != nil {
2815		return out, metadata, &smithy.SerializationError{Err: err}
2816	}
2817	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2818	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateRadius")
2819
2820	jsonEncoder := smithyjson.NewEncoder()
2821	if err := awsAwsjson11_serializeOpDocumentUpdateRadiusInput(input, jsonEncoder.Value); err != nil {
2822		return out, metadata, &smithy.SerializationError{Err: err}
2823	}
2824
2825	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2826		return out, metadata, &smithy.SerializationError{Err: err}
2827	}
2828
2829	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2830		return out, metadata, &smithy.SerializationError{Err: err}
2831	}
2832	in.Request = request
2833
2834	return next.HandleSerialize(ctx, in)
2835}
2836
2837type awsAwsjson11_serializeOpUpdateTrust struct {
2838}
2839
2840func (*awsAwsjson11_serializeOpUpdateTrust) ID() string {
2841	return "OperationSerializer"
2842}
2843
2844func (m *awsAwsjson11_serializeOpUpdateTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2845	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2846) {
2847	request, ok := in.Request.(*smithyhttp.Request)
2848	if !ok {
2849		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2850	}
2851
2852	input, ok := in.Parameters.(*UpdateTrustInput)
2853	_ = input
2854	if !ok {
2855		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2856	}
2857
2858	request.Request.URL.Path = "/"
2859	request.Request.Method = "POST"
2860	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2861	if err != nil {
2862		return out, metadata, &smithy.SerializationError{Err: err}
2863	}
2864	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2865	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateTrust")
2866
2867	jsonEncoder := smithyjson.NewEncoder()
2868	if err := awsAwsjson11_serializeOpDocumentUpdateTrustInput(input, jsonEncoder.Value); err != nil {
2869		return out, metadata, &smithy.SerializationError{Err: err}
2870	}
2871
2872	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2873		return out, metadata, &smithy.SerializationError{Err: err}
2874	}
2875
2876	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2877		return out, metadata, &smithy.SerializationError{Err: err}
2878	}
2879	in.Request = request
2880
2881	return next.HandleSerialize(ctx, in)
2882}
2883
2884type awsAwsjson11_serializeOpVerifyTrust struct {
2885}
2886
2887func (*awsAwsjson11_serializeOpVerifyTrust) ID() string {
2888	return "OperationSerializer"
2889}
2890
2891func (m *awsAwsjson11_serializeOpVerifyTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2892	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2893) {
2894	request, ok := in.Request.(*smithyhttp.Request)
2895	if !ok {
2896		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2897	}
2898
2899	input, ok := in.Parameters.(*VerifyTrustInput)
2900	_ = input
2901	if !ok {
2902		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2903	}
2904
2905	request.Request.URL.Path = "/"
2906	request.Request.Method = "POST"
2907	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2908	if err != nil {
2909		return out, metadata, &smithy.SerializationError{Err: err}
2910	}
2911	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2912	httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.VerifyTrust")
2913
2914	jsonEncoder := smithyjson.NewEncoder()
2915	if err := awsAwsjson11_serializeOpDocumentVerifyTrustInput(input, jsonEncoder.Value); err != nil {
2916		return out, metadata, &smithy.SerializationError{Err: err}
2917	}
2918
2919	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2920		return out, metadata, &smithy.SerializationError{Err: err}
2921	}
2922
2923	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2924		return out, metadata, &smithy.SerializationError{Err: err}
2925	}
2926	in.Request = request
2927
2928	return next.HandleSerialize(ctx, in)
2929}
2930func awsAwsjson11_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error {
2931	object := value.Object()
2932	defer object.Close()
2933
2934	if v.Name != nil {
2935		ok := object.Key("Name")
2936		ok.String(*v.Name)
2937	}
2938
2939	if v.Value != nil {
2940		ok := object.Key("Value")
2941		ok.String(*v.Value)
2942	}
2943
2944	return nil
2945}
2946
2947func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error {
2948	array := value.Array()
2949	defer array.Close()
2950
2951	for i := range v {
2952		av := array.Value()
2953		if err := awsAwsjson11_serializeDocumentAttribute(&v[i], av); err != nil {
2954			return err
2955		}
2956	}
2957	return nil
2958}
2959
2960func awsAwsjson11_serializeDocumentCidrIps(v []string, value smithyjson.Value) error {
2961	array := value.Array()
2962	defer array.Close()
2963
2964	for i := range v {
2965		av := array.Value()
2966		av.String(v[i])
2967	}
2968	return nil
2969}
2970
2971func awsAwsjson11_serializeDocumentClientCertAuthSettings(v *types.ClientCertAuthSettings, value smithyjson.Value) error {
2972	object := value.Object()
2973	defer object.Close()
2974
2975	if v.OCSPUrl != nil {
2976		ok := object.Key("OCSPUrl")
2977		ok.String(*v.OCSPUrl)
2978	}
2979
2980	return nil
2981}
2982
2983func awsAwsjson11_serializeDocumentDirectoryConnectSettings(v *types.DirectoryConnectSettings, value smithyjson.Value) error {
2984	object := value.Object()
2985	defer object.Close()
2986
2987	if v.CustomerDnsIps != nil {
2988		ok := object.Key("CustomerDnsIps")
2989		if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.CustomerDnsIps, ok); err != nil {
2990			return err
2991		}
2992	}
2993
2994	if v.CustomerUserName != nil {
2995		ok := object.Key("CustomerUserName")
2996		ok.String(*v.CustomerUserName)
2997	}
2998
2999	if v.SubnetIds != nil {
3000		ok := object.Key("SubnetIds")
3001		if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil {
3002			return err
3003		}
3004	}
3005
3006	if v.VpcId != nil {
3007		ok := object.Key("VpcId")
3008		ok.String(*v.VpcId)
3009	}
3010
3011	return nil
3012}
3013
3014func awsAwsjson11_serializeDocumentDirectoryIds(v []string, value smithyjson.Value) error {
3015	array := value.Array()
3016	defer array.Close()
3017
3018	for i := range v {
3019		av := array.Value()
3020		av.String(v[i])
3021	}
3022	return nil
3023}
3024
3025func awsAwsjson11_serializeDocumentDirectoryVpcSettings(v *types.DirectoryVpcSettings, value smithyjson.Value) error {
3026	object := value.Object()
3027	defer object.Close()
3028
3029	if v.SubnetIds != nil {
3030		ok := object.Key("SubnetIds")
3031		if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil {
3032			return err
3033		}
3034	}
3035
3036	if v.VpcId != nil {
3037		ok := object.Key("VpcId")
3038		ok.String(*v.VpcId)
3039	}
3040
3041	return nil
3042}
3043
3044func awsAwsjson11_serializeDocumentDnsIpAddrs(v []string, value smithyjson.Value) error {
3045	array := value.Array()
3046	defer array.Close()
3047
3048	for i := range v {
3049		av := array.Value()
3050		av.String(v[i])
3051	}
3052	return nil
3053}
3054
3055func awsAwsjson11_serializeDocumentDomainControllerIds(v []string, value smithyjson.Value) error {
3056	array := value.Array()
3057	defer array.Close()
3058
3059	for i := range v {
3060		av := array.Value()
3061		av.String(v[i])
3062	}
3063	return nil
3064}
3065
3066func awsAwsjson11_serializeDocumentIpRoute(v *types.IpRoute, value smithyjson.Value) error {
3067	object := value.Object()
3068	defer object.Close()
3069
3070	if v.CidrIp != nil {
3071		ok := object.Key("CidrIp")
3072		ok.String(*v.CidrIp)
3073	}
3074
3075	if v.Description != nil {
3076		ok := object.Key("Description")
3077		ok.String(*v.Description)
3078	}
3079
3080	return nil
3081}
3082
3083func awsAwsjson11_serializeDocumentIpRoutes(v []types.IpRoute, value smithyjson.Value) error {
3084	array := value.Array()
3085	defer array.Close()
3086
3087	for i := range v {
3088		av := array.Value()
3089		if err := awsAwsjson11_serializeDocumentIpRoute(&v[i], av); err != nil {
3090			return err
3091		}
3092	}
3093	return nil
3094}
3095
3096func awsAwsjson11_serializeDocumentRadiusSettings(v *types.RadiusSettings, value smithyjson.Value) error {
3097	object := value.Object()
3098	defer object.Close()
3099
3100	if len(v.AuthenticationProtocol) > 0 {
3101		ok := object.Key("AuthenticationProtocol")
3102		ok.String(string(v.AuthenticationProtocol))
3103	}
3104
3105	if v.DisplayLabel != nil {
3106		ok := object.Key("DisplayLabel")
3107		ok.String(*v.DisplayLabel)
3108	}
3109
3110	if v.RadiusPort != 0 {
3111		ok := object.Key("RadiusPort")
3112		ok.Integer(v.RadiusPort)
3113	}
3114
3115	if v.RadiusRetries != 0 {
3116		ok := object.Key("RadiusRetries")
3117		ok.Integer(v.RadiusRetries)
3118	}
3119
3120	if v.RadiusServers != nil {
3121		ok := object.Key("RadiusServers")
3122		if err := awsAwsjson11_serializeDocumentServers(v.RadiusServers, ok); err != nil {
3123			return err
3124		}
3125	}
3126
3127	if v.RadiusTimeout != 0 {
3128		ok := object.Key("RadiusTimeout")
3129		ok.Integer(v.RadiusTimeout)
3130	}
3131
3132	if v.SharedSecret != nil {
3133		ok := object.Key("SharedSecret")
3134		ok.String(*v.SharedSecret)
3135	}
3136
3137	if v.UseSameUsername {
3138		ok := object.Key("UseSameUsername")
3139		ok.Boolean(v.UseSameUsername)
3140	}
3141
3142	return nil
3143}
3144
3145func awsAwsjson11_serializeDocumentRemoteDomainNames(v []string, value smithyjson.Value) error {
3146	array := value.Array()
3147	defer array.Close()
3148
3149	for i := range v {
3150		av := array.Value()
3151		av.String(v[i])
3152	}
3153	return nil
3154}
3155
3156func awsAwsjson11_serializeDocumentServers(v []string, value smithyjson.Value) error {
3157	array := value.Array()
3158	defer array.Close()
3159
3160	for i := range v {
3161		av := array.Value()
3162		av.String(v[i])
3163	}
3164	return nil
3165}
3166
3167func awsAwsjson11_serializeDocumentShareTarget(v *types.ShareTarget, value smithyjson.Value) error {
3168	object := value.Object()
3169	defer object.Close()
3170
3171	if v.Id != nil {
3172		ok := object.Key("Id")
3173		ok.String(*v.Id)
3174	}
3175
3176	if len(v.Type) > 0 {
3177		ok := object.Key("Type")
3178		ok.String(string(v.Type))
3179	}
3180
3181	return nil
3182}
3183
3184func awsAwsjson11_serializeDocumentSnapshotIds(v []string, value smithyjson.Value) error {
3185	array := value.Array()
3186	defer array.Close()
3187
3188	for i := range v {
3189		av := array.Value()
3190		av.String(v[i])
3191	}
3192	return nil
3193}
3194
3195func awsAwsjson11_serializeDocumentSubnetIds(v []string, value smithyjson.Value) error {
3196	array := value.Array()
3197	defer array.Close()
3198
3199	for i := range v {
3200		av := array.Value()
3201		av.String(v[i])
3202	}
3203	return nil
3204}
3205
3206func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
3207	object := value.Object()
3208	defer object.Close()
3209
3210	if v.Key != nil {
3211		ok := object.Key("Key")
3212		ok.String(*v.Key)
3213	}
3214
3215	if v.Value != nil {
3216		ok := object.Key("Value")
3217		ok.String(*v.Value)
3218	}
3219
3220	return nil
3221}
3222
3223func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
3224	array := value.Array()
3225	defer array.Close()
3226
3227	for i := range v {
3228		av := array.Value()
3229		av.String(v[i])
3230	}
3231	return nil
3232}
3233
3234func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
3235	array := value.Array()
3236	defer array.Close()
3237
3238	for i := range v {
3239		av := array.Value()
3240		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
3241			return err
3242		}
3243	}
3244	return nil
3245}
3246
3247func awsAwsjson11_serializeDocumentTopicNames(v []string, value smithyjson.Value) error {
3248	array := value.Array()
3249	defer array.Close()
3250
3251	for i := range v {
3252		av := array.Value()
3253		av.String(v[i])
3254	}
3255	return nil
3256}
3257
3258func awsAwsjson11_serializeDocumentTrustIds(v []string, value smithyjson.Value) error {
3259	array := value.Array()
3260	defer array.Close()
3261
3262	for i := range v {
3263		av := array.Value()
3264		av.String(v[i])
3265	}
3266	return nil
3267}
3268
3269func awsAwsjson11_serializeDocumentUnshareTarget(v *types.UnshareTarget, value smithyjson.Value) error {
3270	object := value.Object()
3271	defer object.Close()
3272
3273	if v.Id != nil {
3274		ok := object.Key("Id")
3275		ok.String(*v.Id)
3276	}
3277
3278	if len(v.Type) > 0 {
3279		ok := object.Key("Type")
3280		ok.String(string(v.Type))
3281	}
3282
3283	return nil
3284}
3285
3286func awsAwsjson11_serializeOpDocumentAcceptSharedDirectoryInput(v *AcceptSharedDirectoryInput, value smithyjson.Value) error {
3287	object := value.Object()
3288	defer object.Close()
3289
3290	if v.SharedDirectoryId != nil {
3291		ok := object.Key("SharedDirectoryId")
3292		ok.String(*v.SharedDirectoryId)
3293	}
3294
3295	return nil
3296}
3297
3298func awsAwsjson11_serializeOpDocumentAddIpRoutesInput(v *AddIpRoutesInput, value smithyjson.Value) error {
3299	object := value.Object()
3300	defer object.Close()
3301
3302	if v.DirectoryId != nil {
3303		ok := object.Key("DirectoryId")
3304		ok.String(*v.DirectoryId)
3305	}
3306
3307	if v.IpRoutes != nil {
3308		ok := object.Key("IpRoutes")
3309		if err := awsAwsjson11_serializeDocumentIpRoutes(v.IpRoutes, ok); err != nil {
3310			return err
3311		}
3312	}
3313
3314	if v.UpdateSecurityGroupForDirectoryControllers {
3315		ok := object.Key("UpdateSecurityGroupForDirectoryControllers")
3316		ok.Boolean(v.UpdateSecurityGroupForDirectoryControllers)
3317	}
3318
3319	return nil
3320}
3321
3322func awsAwsjson11_serializeOpDocumentAddRegionInput(v *AddRegionInput, value smithyjson.Value) error {
3323	object := value.Object()
3324	defer object.Close()
3325
3326	if v.DirectoryId != nil {
3327		ok := object.Key("DirectoryId")
3328		ok.String(*v.DirectoryId)
3329	}
3330
3331	if v.RegionName != nil {
3332		ok := object.Key("RegionName")
3333		ok.String(*v.RegionName)
3334	}
3335
3336	if v.VPCSettings != nil {
3337		ok := object.Key("VPCSettings")
3338		if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VPCSettings, ok); err != nil {
3339			return err
3340		}
3341	}
3342
3343	return nil
3344}
3345
3346func awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value smithyjson.Value) error {
3347	object := value.Object()
3348	defer object.Close()
3349
3350	if v.ResourceId != nil {
3351		ok := object.Key("ResourceId")
3352		ok.String(*v.ResourceId)
3353	}
3354
3355	if v.Tags != nil {
3356		ok := object.Key("Tags")
3357		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
3358			return err
3359		}
3360	}
3361
3362	return nil
3363}
3364
3365func awsAwsjson11_serializeOpDocumentCancelSchemaExtensionInput(v *CancelSchemaExtensionInput, value smithyjson.Value) error {
3366	object := value.Object()
3367	defer object.Close()
3368
3369	if v.DirectoryId != nil {
3370		ok := object.Key("DirectoryId")
3371		ok.String(*v.DirectoryId)
3372	}
3373
3374	if v.SchemaExtensionId != nil {
3375		ok := object.Key("SchemaExtensionId")
3376		ok.String(*v.SchemaExtensionId)
3377	}
3378
3379	return nil
3380}
3381
3382func awsAwsjson11_serializeOpDocumentConnectDirectoryInput(v *ConnectDirectoryInput, value smithyjson.Value) error {
3383	object := value.Object()
3384	defer object.Close()
3385
3386	if v.ConnectSettings != nil {
3387		ok := object.Key("ConnectSettings")
3388		if err := awsAwsjson11_serializeDocumentDirectoryConnectSettings(v.ConnectSettings, ok); err != nil {
3389			return err
3390		}
3391	}
3392
3393	if v.Description != nil {
3394		ok := object.Key("Description")
3395		ok.String(*v.Description)
3396	}
3397
3398	if v.Name != nil {
3399		ok := object.Key("Name")
3400		ok.String(*v.Name)
3401	}
3402
3403	if v.Password != nil {
3404		ok := object.Key("Password")
3405		ok.String(*v.Password)
3406	}
3407
3408	if v.ShortName != nil {
3409		ok := object.Key("ShortName")
3410		ok.String(*v.ShortName)
3411	}
3412
3413	if len(v.Size) > 0 {
3414		ok := object.Key("Size")
3415		ok.String(string(v.Size))
3416	}
3417
3418	if v.Tags != nil {
3419		ok := object.Key("Tags")
3420		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
3421			return err
3422		}
3423	}
3424
3425	return nil
3426}
3427
3428func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error {
3429	object := value.Object()
3430	defer object.Close()
3431
3432	if v.Alias != nil {
3433		ok := object.Key("Alias")
3434		ok.String(*v.Alias)
3435	}
3436
3437	if v.DirectoryId != nil {
3438		ok := object.Key("DirectoryId")
3439		ok.String(*v.DirectoryId)
3440	}
3441
3442	return nil
3443}
3444
3445func awsAwsjson11_serializeOpDocumentCreateComputerInput(v *CreateComputerInput, value smithyjson.Value) error {
3446	object := value.Object()
3447	defer object.Close()
3448
3449	if v.ComputerAttributes != nil {
3450		ok := object.Key("ComputerAttributes")
3451		if err := awsAwsjson11_serializeDocumentAttributes(v.ComputerAttributes, ok); err != nil {
3452			return err
3453		}
3454	}
3455
3456	if v.ComputerName != nil {
3457		ok := object.Key("ComputerName")
3458		ok.String(*v.ComputerName)
3459	}
3460
3461	if v.DirectoryId != nil {
3462		ok := object.Key("DirectoryId")
3463		ok.String(*v.DirectoryId)
3464	}
3465
3466	if v.OrganizationalUnitDistinguishedName != nil {
3467		ok := object.Key("OrganizationalUnitDistinguishedName")
3468		ok.String(*v.OrganizationalUnitDistinguishedName)
3469	}
3470
3471	if v.Password != nil {
3472		ok := object.Key("Password")
3473		ok.String(*v.Password)
3474	}
3475
3476	return nil
3477}
3478
3479func awsAwsjson11_serializeOpDocumentCreateConditionalForwarderInput(v *CreateConditionalForwarderInput, value smithyjson.Value) error {
3480	object := value.Object()
3481	defer object.Close()
3482
3483	if v.DirectoryId != nil {
3484		ok := object.Key("DirectoryId")
3485		ok.String(*v.DirectoryId)
3486	}
3487
3488	if v.DnsIpAddrs != nil {
3489		ok := object.Key("DnsIpAddrs")
3490		if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil {
3491			return err
3492		}
3493	}
3494
3495	if v.RemoteDomainName != nil {
3496		ok := object.Key("RemoteDomainName")
3497		ok.String(*v.RemoteDomainName)
3498	}
3499
3500	return nil
3501}
3502
3503func awsAwsjson11_serializeOpDocumentCreateDirectoryInput(v *CreateDirectoryInput, value smithyjson.Value) error {
3504	object := value.Object()
3505	defer object.Close()
3506
3507	if v.Description != nil {
3508		ok := object.Key("Description")
3509		ok.String(*v.Description)
3510	}
3511
3512	if v.Name != nil {
3513		ok := object.Key("Name")
3514		ok.String(*v.Name)
3515	}
3516
3517	if v.Password != nil {
3518		ok := object.Key("Password")
3519		ok.String(*v.Password)
3520	}
3521
3522	if v.ShortName != nil {
3523		ok := object.Key("ShortName")
3524		ok.String(*v.ShortName)
3525	}
3526
3527	if len(v.Size) > 0 {
3528		ok := object.Key("Size")
3529		ok.String(string(v.Size))
3530	}
3531
3532	if v.Tags != nil {
3533		ok := object.Key("Tags")
3534		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
3535			return err
3536		}
3537	}
3538
3539	if v.VpcSettings != nil {
3540		ok := object.Key("VpcSettings")
3541		if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil {
3542			return err
3543		}
3544	}
3545
3546	return nil
3547}
3548
3549func awsAwsjson11_serializeOpDocumentCreateLogSubscriptionInput(v *CreateLogSubscriptionInput, value smithyjson.Value) error {
3550	object := value.Object()
3551	defer object.Close()
3552
3553	if v.DirectoryId != nil {
3554		ok := object.Key("DirectoryId")
3555		ok.String(*v.DirectoryId)
3556	}
3557
3558	if v.LogGroupName != nil {
3559		ok := object.Key("LogGroupName")
3560		ok.String(*v.LogGroupName)
3561	}
3562
3563	return nil
3564}
3565
3566func awsAwsjson11_serializeOpDocumentCreateMicrosoftADInput(v *CreateMicrosoftADInput, value smithyjson.Value) error {
3567	object := value.Object()
3568	defer object.Close()
3569
3570	if v.Description != nil {
3571		ok := object.Key("Description")
3572		ok.String(*v.Description)
3573	}
3574
3575	if len(v.Edition) > 0 {
3576		ok := object.Key("Edition")
3577		ok.String(string(v.Edition))
3578	}
3579
3580	if v.Name != nil {
3581		ok := object.Key("Name")
3582		ok.String(*v.Name)
3583	}
3584
3585	if v.Password != nil {
3586		ok := object.Key("Password")
3587		ok.String(*v.Password)
3588	}
3589
3590	if v.ShortName != nil {
3591		ok := object.Key("ShortName")
3592		ok.String(*v.ShortName)
3593	}
3594
3595	if v.Tags != nil {
3596		ok := object.Key("Tags")
3597		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
3598			return err
3599		}
3600	}
3601
3602	if v.VpcSettings != nil {
3603		ok := object.Key("VpcSettings")
3604		if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil {
3605			return err
3606		}
3607	}
3608
3609	return nil
3610}
3611
3612func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error {
3613	object := value.Object()
3614	defer object.Close()
3615
3616	if v.DirectoryId != nil {
3617		ok := object.Key("DirectoryId")
3618		ok.String(*v.DirectoryId)
3619	}
3620
3621	if v.Name != nil {
3622		ok := object.Key("Name")
3623		ok.String(*v.Name)
3624	}
3625
3626	return nil
3627}
3628
3629func awsAwsjson11_serializeOpDocumentCreateTrustInput(v *CreateTrustInput, value smithyjson.Value) error {
3630	object := value.Object()
3631	defer object.Close()
3632
3633	if v.ConditionalForwarderIpAddrs != nil {
3634		ok := object.Key("ConditionalForwarderIpAddrs")
3635		if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.ConditionalForwarderIpAddrs, ok); err != nil {
3636			return err
3637		}
3638	}
3639
3640	if v.DirectoryId != nil {
3641		ok := object.Key("DirectoryId")
3642		ok.String(*v.DirectoryId)
3643	}
3644
3645	if v.RemoteDomainName != nil {
3646		ok := object.Key("RemoteDomainName")
3647		ok.String(*v.RemoteDomainName)
3648	}
3649
3650	if len(v.SelectiveAuth) > 0 {
3651		ok := object.Key("SelectiveAuth")
3652		ok.String(string(v.SelectiveAuth))
3653	}
3654
3655	if len(v.TrustDirection) > 0 {
3656		ok := object.Key("TrustDirection")
3657		ok.String(string(v.TrustDirection))
3658	}
3659
3660	if v.TrustPassword != nil {
3661		ok := object.Key("TrustPassword")
3662		ok.String(*v.TrustPassword)
3663	}
3664
3665	if len(v.TrustType) > 0 {
3666		ok := object.Key("TrustType")
3667		ok.String(string(v.TrustType))
3668	}
3669
3670	return nil
3671}
3672
3673func awsAwsjson11_serializeOpDocumentDeleteConditionalForwarderInput(v *DeleteConditionalForwarderInput, value smithyjson.Value) error {
3674	object := value.Object()
3675	defer object.Close()
3676
3677	if v.DirectoryId != nil {
3678		ok := object.Key("DirectoryId")
3679		ok.String(*v.DirectoryId)
3680	}
3681
3682	if v.RemoteDomainName != nil {
3683		ok := object.Key("RemoteDomainName")
3684		ok.String(*v.RemoteDomainName)
3685	}
3686
3687	return nil
3688}
3689
3690func awsAwsjson11_serializeOpDocumentDeleteDirectoryInput(v *DeleteDirectoryInput, value smithyjson.Value) error {
3691	object := value.Object()
3692	defer object.Close()
3693
3694	if v.DirectoryId != nil {
3695		ok := object.Key("DirectoryId")
3696		ok.String(*v.DirectoryId)
3697	}
3698
3699	return nil
3700}
3701
3702func awsAwsjson11_serializeOpDocumentDeleteLogSubscriptionInput(v *DeleteLogSubscriptionInput, value smithyjson.Value) error {
3703	object := value.Object()
3704	defer object.Close()
3705
3706	if v.DirectoryId != nil {
3707		ok := object.Key("DirectoryId")
3708		ok.String(*v.DirectoryId)
3709	}
3710
3711	return nil
3712}
3713
3714func awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(v *DeleteSnapshotInput, value smithyjson.Value) error {
3715	object := value.Object()
3716	defer object.Close()
3717
3718	if v.SnapshotId != nil {
3719		ok := object.Key("SnapshotId")
3720		ok.String(*v.SnapshotId)
3721	}
3722
3723	return nil
3724}
3725
3726func awsAwsjson11_serializeOpDocumentDeleteTrustInput(v *DeleteTrustInput, value smithyjson.Value) error {
3727	object := value.Object()
3728	defer object.Close()
3729
3730	if v.DeleteAssociatedConditionalForwarder {
3731		ok := object.Key("DeleteAssociatedConditionalForwarder")
3732		ok.Boolean(v.DeleteAssociatedConditionalForwarder)
3733	}
3734
3735	if v.TrustId != nil {
3736		ok := object.Key("TrustId")
3737		ok.String(*v.TrustId)
3738	}
3739
3740	return nil
3741}
3742
3743func awsAwsjson11_serializeOpDocumentDeregisterCertificateInput(v *DeregisterCertificateInput, value smithyjson.Value) error {
3744	object := value.Object()
3745	defer object.Close()
3746
3747	if v.CertificateId != nil {
3748		ok := object.Key("CertificateId")
3749		ok.String(*v.CertificateId)
3750	}
3751
3752	if v.DirectoryId != nil {
3753		ok := object.Key("DirectoryId")
3754		ok.String(*v.DirectoryId)
3755	}
3756
3757	return nil
3758}
3759
3760func awsAwsjson11_serializeOpDocumentDeregisterEventTopicInput(v *DeregisterEventTopicInput, value smithyjson.Value) error {
3761	object := value.Object()
3762	defer object.Close()
3763
3764	if v.DirectoryId != nil {
3765		ok := object.Key("DirectoryId")
3766		ok.String(*v.DirectoryId)
3767	}
3768
3769	if v.TopicName != nil {
3770		ok := object.Key("TopicName")
3771		ok.String(*v.TopicName)
3772	}
3773
3774	return nil
3775}
3776
3777func awsAwsjson11_serializeOpDocumentDescribeCertificateInput(v *DescribeCertificateInput, value smithyjson.Value) error {
3778	object := value.Object()
3779	defer object.Close()
3780
3781	if v.CertificateId != nil {
3782		ok := object.Key("CertificateId")
3783		ok.String(*v.CertificateId)
3784	}
3785
3786	if v.DirectoryId != nil {
3787		ok := object.Key("DirectoryId")
3788		ok.String(*v.DirectoryId)
3789	}
3790
3791	return nil
3792}
3793
3794func awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(v *DescribeConditionalForwardersInput, value smithyjson.Value) error {
3795	object := value.Object()
3796	defer object.Close()
3797
3798	if v.DirectoryId != nil {
3799		ok := object.Key("DirectoryId")
3800		ok.String(*v.DirectoryId)
3801	}
3802
3803	if v.RemoteDomainNames != nil {
3804		ok := object.Key("RemoteDomainNames")
3805		if err := awsAwsjson11_serializeDocumentRemoteDomainNames(v.RemoteDomainNames, ok); err != nil {
3806			return err
3807		}
3808	}
3809
3810	return nil
3811}
3812
3813func awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(v *DescribeDirectoriesInput, value smithyjson.Value) error {
3814	object := value.Object()
3815	defer object.Close()
3816
3817	if v.DirectoryIds != nil {
3818		ok := object.Key("DirectoryIds")
3819		if err := awsAwsjson11_serializeDocumentDirectoryIds(v.DirectoryIds, ok); err != nil {
3820			return err
3821		}
3822	}
3823
3824	if v.Limit != nil {
3825		ok := object.Key("Limit")
3826		ok.Integer(*v.Limit)
3827	}
3828
3829	if v.NextToken != nil {
3830		ok := object.Key("NextToken")
3831		ok.String(*v.NextToken)
3832	}
3833
3834	return nil
3835}
3836
3837func awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(v *DescribeDomainControllersInput, value smithyjson.Value) error {
3838	object := value.Object()
3839	defer object.Close()
3840
3841	if v.DirectoryId != nil {
3842		ok := object.Key("DirectoryId")
3843		ok.String(*v.DirectoryId)
3844	}
3845
3846	if v.DomainControllerIds != nil {
3847		ok := object.Key("DomainControllerIds")
3848		if err := awsAwsjson11_serializeDocumentDomainControllerIds(v.DomainControllerIds, ok); err != nil {
3849			return err
3850		}
3851	}
3852
3853	if v.Limit != nil {
3854		ok := object.Key("Limit")
3855		ok.Integer(*v.Limit)
3856	}
3857
3858	if v.NextToken != nil {
3859		ok := object.Key("NextToken")
3860		ok.String(*v.NextToken)
3861	}
3862
3863	return nil
3864}
3865
3866func awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(v *DescribeEventTopicsInput, value smithyjson.Value) error {
3867	object := value.Object()
3868	defer object.Close()
3869
3870	if v.DirectoryId != nil {
3871		ok := object.Key("DirectoryId")
3872		ok.String(*v.DirectoryId)
3873	}
3874
3875	if v.TopicNames != nil {
3876		ok := object.Key("TopicNames")
3877		if err := awsAwsjson11_serializeDocumentTopicNames(v.TopicNames, ok); err != nil {
3878			return err
3879		}
3880	}
3881
3882	return nil
3883}
3884
3885func awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(v *DescribeLDAPSSettingsInput, value smithyjson.Value) error {
3886	object := value.Object()
3887	defer object.Close()
3888
3889	if v.DirectoryId != nil {
3890		ok := object.Key("DirectoryId")
3891		ok.String(*v.DirectoryId)
3892	}
3893
3894	if v.Limit != nil {
3895		ok := object.Key("Limit")
3896		ok.Integer(*v.Limit)
3897	}
3898
3899	if v.NextToken != nil {
3900		ok := object.Key("NextToken")
3901		ok.String(*v.NextToken)
3902	}
3903
3904	if len(v.Type) > 0 {
3905		ok := object.Key("Type")
3906		ok.String(string(v.Type))
3907	}
3908
3909	return nil
3910}
3911
3912func awsAwsjson11_serializeOpDocumentDescribeRegionsInput(v *DescribeRegionsInput, value smithyjson.Value) error {
3913	object := value.Object()
3914	defer object.Close()
3915
3916	if v.DirectoryId != nil {
3917		ok := object.Key("DirectoryId")
3918		ok.String(*v.DirectoryId)
3919	}
3920
3921	if v.NextToken != nil {
3922		ok := object.Key("NextToken")
3923		ok.String(*v.NextToken)
3924	}
3925
3926	if v.RegionName != nil {
3927		ok := object.Key("RegionName")
3928		ok.String(*v.RegionName)
3929	}
3930
3931	return nil
3932}
3933
3934func awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(v *DescribeSharedDirectoriesInput, value smithyjson.Value) error {
3935	object := value.Object()
3936	defer object.Close()
3937
3938	if v.Limit != nil {
3939		ok := object.Key("Limit")
3940		ok.Integer(*v.Limit)
3941	}
3942
3943	if v.NextToken != nil {
3944		ok := object.Key("NextToken")
3945		ok.String(*v.NextToken)
3946	}
3947
3948	if v.OwnerDirectoryId != nil {
3949		ok := object.Key("OwnerDirectoryId")
3950		ok.String(*v.OwnerDirectoryId)
3951	}
3952
3953	if v.SharedDirectoryIds != nil {
3954		ok := object.Key("SharedDirectoryIds")
3955		if err := awsAwsjson11_serializeDocumentDirectoryIds(v.SharedDirectoryIds, ok); err != nil {
3956			return err
3957		}
3958	}
3959
3960	return nil
3961}
3962
3963func awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(v *DescribeSnapshotsInput, value smithyjson.Value) error {
3964	object := value.Object()
3965	defer object.Close()
3966
3967	if v.DirectoryId != nil {
3968		ok := object.Key("DirectoryId")
3969		ok.String(*v.DirectoryId)
3970	}
3971
3972	if v.Limit != nil {
3973		ok := object.Key("Limit")
3974		ok.Integer(*v.Limit)
3975	}
3976
3977	if v.NextToken != nil {
3978		ok := object.Key("NextToken")
3979		ok.String(*v.NextToken)
3980	}
3981
3982	if v.SnapshotIds != nil {
3983		ok := object.Key("SnapshotIds")
3984		if err := awsAwsjson11_serializeDocumentSnapshotIds(v.SnapshotIds, ok); err != nil {
3985			return err
3986		}
3987	}
3988
3989	return nil
3990}
3991
3992func awsAwsjson11_serializeOpDocumentDescribeTrustsInput(v *DescribeTrustsInput, value smithyjson.Value) error {
3993	object := value.Object()
3994	defer object.Close()
3995
3996	if v.DirectoryId != nil {
3997		ok := object.Key("DirectoryId")
3998		ok.String(*v.DirectoryId)
3999	}
4000
4001	if v.Limit != nil {
4002		ok := object.Key("Limit")
4003		ok.Integer(*v.Limit)
4004	}
4005
4006	if v.NextToken != nil {
4007		ok := object.Key("NextToken")
4008		ok.String(*v.NextToken)
4009	}
4010
4011	if v.TrustIds != nil {
4012		ok := object.Key("TrustIds")
4013		if err := awsAwsjson11_serializeDocumentTrustIds(v.TrustIds, ok); err != nil {
4014			return err
4015		}
4016	}
4017
4018	return nil
4019}
4020
4021func awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(v *DisableClientAuthenticationInput, value smithyjson.Value) error {
4022	object := value.Object()
4023	defer object.Close()
4024
4025	if v.DirectoryId != nil {
4026		ok := object.Key("DirectoryId")
4027		ok.String(*v.DirectoryId)
4028	}
4029
4030	if len(v.Type) > 0 {
4031		ok := object.Key("Type")
4032		ok.String(string(v.Type))
4033	}
4034
4035	return nil
4036}
4037
4038func awsAwsjson11_serializeOpDocumentDisableLDAPSInput(v *DisableLDAPSInput, value smithyjson.Value) error {
4039	object := value.Object()
4040	defer object.Close()
4041
4042	if v.DirectoryId != nil {
4043		ok := object.Key("DirectoryId")
4044		ok.String(*v.DirectoryId)
4045	}
4046
4047	if len(v.Type) > 0 {
4048		ok := object.Key("Type")
4049		ok.String(string(v.Type))
4050	}
4051
4052	return nil
4053}
4054
4055func awsAwsjson11_serializeOpDocumentDisableRadiusInput(v *DisableRadiusInput, value smithyjson.Value) error {
4056	object := value.Object()
4057	defer object.Close()
4058
4059	if v.DirectoryId != nil {
4060		ok := object.Key("DirectoryId")
4061		ok.String(*v.DirectoryId)
4062	}
4063
4064	return nil
4065}
4066
4067func awsAwsjson11_serializeOpDocumentDisableSsoInput(v *DisableSsoInput, value smithyjson.Value) error {
4068	object := value.Object()
4069	defer object.Close()
4070
4071	if v.DirectoryId != nil {
4072		ok := object.Key("DirectoryId")
4073		ok.String(*v.DirectoryId)
4074	}
4075
4076	if v.Password != nil {
4077		ok := object.Key("Password")
4078		ok.String(*v.Password)
4079	}
4080
4081	if v.UserName != nil {
4082		ok := object.Key("UserName")
4083		ok.String(*v.UserName)
4084	}
4085
4086	return nil
4087}
4088
4089func awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(v *EnableClientAuthenticationInput, value smithyjson.Value) error {
4090	object := value.Object()
4091	defer object.Close()
4092
4093	if v.DirectoryId != nil {
4094		ok := object.Key("DirectoryId")
4095		ok.String(*v.DirectoryId)
4096	}
4097
4098	if len(v.Type) > 0 {
4099		ok := object.Key("Type")
4100		ok.String(string(v.Type))
4101	}
4102
4103	return nil
4104}
4105
4106func awsAwsjson11_serializeOpDocumentEnableLDAPSInput(v *EnableLDAPSInput, value smithyjson.Value) error {
4107	object := value.Object()
4108	defer object.Close()
4109
4110	if v.DirectoryId != nil {
4111		ok := object.Key("DirectoryId")
4112		ok.String(*v.DirectoryId)
4113	}
4114
4115	if len(v.Type) > 0 {
4116		ok := object.Key("Type")
4117		ok.String(string(v.Type))
4118	}
4119
4120	return nil
4121}
4122
4123func awsAwsjson11_serializeOpDocumentEnableRadiusInput(v *EnableRadiusInput, value smithyjson.Value) error {
4124	object := value.Object()
4125	defer object.Close()
4126
4127	if v.DirectoryId != nil {
4128		ok := object.Key("DirectoryId")
4129		ok.String(*v.DirectoryId)
4130	}
4131
4132	if v.RadiusSettings != nil {
4133		ok := object.Key("RadiusSettings")
4134		if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil {
4135			return err
4136		}
4137	}
4138
4139	return nil
4140}
4141
4142func awsAwsjson11_serializeOpDocumentEnableSsoInput(v *EnableSsoInput, value smithyjson.Value) error {
4143	object := value.Object()
4144	defer object.Close()
4145
4146	if v.DirectoryId != nil {
4147		ok := object.Key("DirectoryId")
4148		ok.String(*v.DirectoryId)
4149	}
4150
4151	if v.Password != nil {
4152		ok := object.Key("Password")
4153		ok.String(*v.Password)
4154	}
4155
4156	if v.UserName != nil {
4157		ok := object.Key("UserName")
4158		ok.String(*v.UserName)
4159	}
4160
4161	return nil
4162}
4163
4164func awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(v *GetDirectoryLimitsInput, value smithyjson.Value) error {
4165	object := value.Object()
4166	defer object.Close()
4167
4168	return nil
4169}
4170
4171func awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(v *GetSnapshotLimitsInput, value smithyjson.Value) error {
4172	object := value.Object()
4173	defer object.Close()
4174
4175	if v.DirectoryId != nil {
4176		ok := object.Key("DirectoryId")
4177		ok.String(*v.DirectoryId)
4178	}
4179
4180	return nil
4181}
4182
4183func awsAwsjson11_serializeOpDocumentListCertificatesInput(v *ListCertificatesInput, value smithyjson.Value) error {
4184	object := value.Object()
4185	defer object.Close()
4186
4187	if v.DirectoryId != nil {
4188		ok := object.Key("DirectoryId")
4189		ok.String(*v.DirectoryId)
4190	}
4191
4192	if v.Limit != nil {
4193		ok := object.Key("Limit")
4194		ok.Integer(*v.Limit)
4195	}
4196
4197	if v.NextToken != nil {
4198		ok := object.Key("NextToken")
4199		ok.String(*v.NextToken)
4200	}
4201
4202	return nil
4203}
4204
4205func awsAwsjson11_serializeOpDocumentListIpRoutesInput(v *ListIpRoutesInput, value smithyjson.Value) error {
4206	object := value.Object()
4207	defer object.Close()
4208
4209	if v.DirectoryId != nil {
4210		ok := object.Key("DirectoryId")
4211		ok.String(*v.DirectoryId)
4212	}
4213
4214	if v.Limit != nil {
4215		ok := object.Key("Limit")
4216		ok.Integer(*v.Limit)
4217	}
4218
4219	if v.NextToken != nil {
4220		ok := object.Key("NextToken")
4221		ok.String(*v.NextToken)
4222	}
4223
4224	return nil
4225}
4226
4227func awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(v *ListLogSubscriptionsInput, value smithyjson.Value) error {
4228	object := value.Object()
4229	defer object.Close()
4230
4231	if v.DirectoryId != nil {
4232		ok := object.Key("DirectoryId")
4233		ok.String(*v.DirectoryId)
4234	}
4235
4236	if v.Limit != nil {
4237		ok := object.Key("Limit")
4238		ok.Integer(*v.Limit)
4239	}
4240
4241	if v.NextToken != nil {
4242		ok := object.Key("NextToken")
4243		ok.String(*v.NextToken)
4244	}
4245
4246	return nil
4247}
4248
4249func awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(v *ListSchemaExtensionsInput, value smithyjson.Value) error {
4250	object := value.Object()
4251	defer object.Close()
4252
4253	if v.DirectoryId != nil {
4254		ok := object.Key("DirectoryId")
4255		ok.String(*v.DirectoryId)
4256	}
4257
4258	if v.Limit != nil {
4259		ok := object.Key("Limit")
4260		ok.Integer(*v.Limit)
4261	}
4262
4263	if v.NextToken != nil {
4264		ok := object.Key("NextToken")
4265		ok.String(*v.NextToken)
4266	}
4267
4268	return nil
4269}
4270
4271func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
4272	object := value.Object()
4273	defer object.Close()
4274
4275	if v.Limit != nil {
4276		ok := object.Key("Limit")
4277		ok.Integer(*v.Limit)
4278	}
4279
4280	if v.NextToken != nil {
4281		ok := object.Key("NextToken")
4282		ok.String(*v.NextToken)
4283	}
4284
4285	if v.ResourceId != nil {
4286		ok := object.Key("ResourceId")
4287		ok.String(*v.ResourceId)
4288	}
4289
4290	return nil
4291}
4292
4293func awsAwsjson11_serializeOpDocumentRegisterCertificateInput(v *RegisterCertificateInput, value smithyjson.Value) error {
4294	object := value.Object()
4295	defer object.Close()
4296
4297	if v.CertificateData != nil {
4298		ok := object.Key("CertificateData")
4299		ok.String(*v.CertificateData)
4300	}
4301
4302	if v.ClientCertAuthSettings != nil {
4303		ok := object.Key("ClientCertAuthSettings")
4304		if err := awsAwsjson11_serializeDocumentClientCertAuthSettings(v.ClientCertAuthSettings, ok); err != nil {
4305			return err
4306		}
4307	}
4308
4309	if v.DirectoryId != nil {
4310		ok := object.Key("DirectoryId")
4311		ok.String(*v.DirectoryId)
4312	}
4313
4314	if len(v.Type) > 0 {
4315		ok := object.Key("Type")
4316		ok.String(string(v.Type))
4317	}
4318
4319	return nil
4320}
4321
4322func awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(v *RegisterEventTopicInput, value smithyjson.Value) error {
4323	object := value.Object()
4324	defer object.Close()
4325
4326	if v.DirectoryId != nil {
4327		ok := object.Key("DirectoryId")
4328		ok.String(*v.DirectoryId)
4329	}
4330
4331	if v.TopicName != nil {
4332		ok := object.Key("TopicName")
4333		ok.String(*v.TopicName)
4334	}
4335
4336	return nil
4337}
4338
4339func awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(v *RejectSharedDirectoryInput, value smithyjson.Value) error {
4340	object := value.Object()
4341	defer object.Close()
4342
4343	if v.SharedDirectoryId != nil {
4344		ok := object.Key("SharedDirectoryId")
4345		ok.String(*v.SharedDirectoryId)
4346	}
4347
4348	return nil
4349}
4350
4351func awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(v *RemoveIpRoutesInput, value smithyjson.Value) error {
4352	object := value.Object()
4353	defer object.Close()
4354
4355	if v.CidrIps != nil {
4356		ok := object.Key("CidrIps")
4357		if err := awsAwsjson11_serializeDocumentCidrIps(v.CidrIps, ok); err != nil {
4358			return err
4359		}
4360	}
4361
4362	if v.DirectoryId != nil {
4363		ok := object.Key("DirectoryId")
4364		ok.String(*v.DirectoryId)
4365	}
4366
4367	return nil
4368}
4369
4370func awsAwsjson11_serializeOpDocumentRemoveRegionInput(v *RemoveRegionInput, value smithyjson.Value) error {
4371	object := value.Object()
4372	defer object.Close()
4373
4374	if v.DirectoryId != nil {
4375		ok := object.Key("DirectoryId")
4376		ok.String(*v.DirectoryId)
4377	}
4378
4379	return nil
4380}
4381
4382func awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value smithyjson.Value) error {
4383	object := value.Object()
4384	defer object.Close()
4385
4386	if v.ResourceId != nil {
4387		ok := object.Key("ResourceId")
4388		ok.String(*v.ResourceId)
4389	}
4390
4391	if v.TagKeys != nil {
4392		ok := object.Key("TagKeys")
4393		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
4394			return err
4395		}
4396	}
4397
4398	return nil
4399}
4400
4401func awsAwsjson11_serializeOpDocumentResetUserPasswordInput(v *ResetUserPasswordInput, value smithyjson.Value) error {
4402	object := value.Object()
4403	defer object.Close()
4404
4405	if v.DirectoryId != nil {
4406		ok := object.Key("DirectoryId")
4407		ok.String(*v.DirectoryId)
4408	}
4409
4410	if v.NewPassword != nil {
4411		ok := object.Key("NewPassword")
4412		ok.String(*v.NewPassword)
4413	}
4414
4415	if v.UserName != nil {
4416		ok := object.Key("UserName")
4417		ok.String(*v.UserName)
4418	}
4419
4420	return nil
4421}
4422
4423func awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(v *RestoreFromSnapshotInput, value smithyjson.Value) error {
4424	object := value.Object()
4425	defer object.Close()
4426
4427	if v.SnapshotId != nil {
4428		ok := object.Key("SnapshotId")
4429		ok.String(*v.SnapshotId)
4430	}
4431
4432	return nil
4433}
4434
4435func awsAwsjson11_serializeOpDocumentShareDirectoryInput(v *ShareDirectoryInput, value smithyjson.Value) error {
4436	object := value.Object()
4437	defer object.Close()
4438
4439	if v.DirectoryId != nil {
4440		ok := object.Key("DirectoryId")
4441		ok.String(*v.DirectoryId)
4442	}
4443
4444	if len(v.ShareMethod) > 0 {
4445		ok := object.Key("ShareMethod")
4446		ok.String(string(v.ShareMethod))
4447	}
4448
4449	if v.ShareNotes != nil {
4450		ok := object.Key("ShareNotes")
4451		ok.String(*v.ShareNotes)
4452	}
4453
4454	if v.ShareTarget != nil {
4455		ok := object.Key("ShareTarget")
4456		if err := awsAwsjson11_serializeDocumentShareTarget(v.ShareTarget, ok); err != nil {
4457			return err
4458		}
4459	}
4460
4461	return nil
4462}
4463
4464func awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(v *StartSchemaExtensionInput, value smithyjson.Value) error {
4465	object := value.Object()
4466	defer object.Close()
4467
4468	{
4469		ok := object.Key("CreateSnapshotBeforeSchemaExtension")
4470		ok.Boolean(v.CreateSnapshotBeforeSchemaExtension)
4471	}
4472
4473	if v.Description != nil {
4474		ok := object.Key("Description")
4475		ok.String(*v.Description)
4476	}
4477
4478	if v.DirectoryId != nil {
4479		ok := object.Key("DirectoryId")
4480		ok.String(*v.DirectoryId)
4481	}
4482
4483	if v.LdifContent != nil {
4484		ok := object.Key("LdifContent")
4485		ok.String(*v.LdifContent)
4486	}
4487
4488	return nil
4489}
4490
4491func awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(v *UnshareDirectoryInput, value smithyjson.Value) error {
4492	object := value.Object()
4493	defer object.Close()
4494
4495	if v.DirectoryId != nil {
4496		ok := object.Key("DirectoryId")
4497		ok.String(*v.DirectoryId)
4498	}
4499
4500	if v.UnshareTarget != nil {
4501		ok := object.Key("UnshareTarget")
4502		if err := awsAwsjson11_serializeDocumentUnshareTarget(v.UnshareTarget, ok); err != nil {
4503			return err
4504		}
4505	}
4506
4507	return nil
4508}
4509
4510func awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(v *UpdateConditionalForwarderInput, value smithyjson.Value) error {
4511	object := value.Object()
4512	defer object.Close()
4513
4514	if v.DirectoryId != nil {
4515		ok := object.Key("DirectoryId")
4516		ok.String(*v.DirectoryId)
4517	}
4518
4519	if v.DnsIpAddrs != nil {
4520		ok := object.Key("DnsIpAddrs")
4521		if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil {
4522			return err
4523		}
4524	}
4525
4526	if v.RemoteDomainName != nil {
4527		ok := object.Key("RemoteDomainName")
4528		ok.String(*v.RemoteDomainName)
4529	}
4530
4531	return nil
4532}
4533
4534func awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(v *UpdateNumberOfDomainControllersInput, value smithyjson.Value) error {
4535	object := value.Object()
4536	defer object.Close()
4537
4538	{
4539		ok := object.Key("DesiredNumber")
4540		ok.Integer(v.DesiredNumber)
4541	}
4542
4543	if v.DirectoryId != nil {
4544		ok := object.Key("DirectoryId")
4545		ok.String(*v.DirectoryId)
4546	}
4547
4548	return nil
4549}
4550
4551func awsAwsjson11_serializeOpDocumentUpdateRadiusInput(v *UpdateRadiusInput, value smithyjson.Value) error {
4552	object := value.Object()
4553	defer object.Close()
4554
4555	if v.DirectoryId != nil {
4556		ok := object.Key("DirectoryId")
4557		ok.String(*v.DirectoryId)
4558	}
4559
4560	if v.RadiusSettings != nil {
4561		ok := object.Key("RadiusSettings")
4562		if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil {
4563			return err
4564		}
4565	}
4566
4567	return nil
4568}
4569
4570func awsAwsjson11_serializeOpDocumentUpdateTrustInput(v *UpdateTrustInput, value smithyjson.Value) error {
4571	object := value.Object()
4572	defer object.Close()
4573
4574	if len(v.SelectiveAuth) > 0 {
4575		ok := object.Key("SelectiveAuth")
4576		ok.String(string(v.SelectiveAuth))
4577	}
4578
4579	if v.TrustId != nil {
4580		ok := object.Key("TrustId")
4581		ok.String(*v.TrustId)
4582	}
4583
4584	return nil
4585}
4586
4587func awsAwsjson11_serializeOpDocumentVerifyTrustInput(v *VerifyTrustInput, value smithyjson.Value) error {
4588	object := value.Object()
4589	defer object.Close()
4590
4591	if v.TrustId != nil {
4592		ok := object.Key("TrustId")
4593		ok.String(*v.TrustId)
4594	}
4595
4596	return nil
4597}
4598