1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package fsx
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/fsx/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_serializeOpAssociateFileSystemAliases struct {
18}
19
20func (*awsAwsjson11_serializeOpAssociateFileSystemAliases) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpAssociateFileSystemAliases) 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.(*AssociateFileSystemAliasesInput)
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("AWSSimbaAPIService_v20180301.AssociateFileSystemAliases")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentAssociateFileSystemAliasesInput(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_serializeOpCancelDataRepositoryTask struct {
65}
66
67func (*awsAwsjson11_serializeOpCancelDataRepositoryTask) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpCancelDataRepositoryTask) 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.(*CancelDataRepositoryTaskInput)
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("AWSSimbaAPIService_v20180301.CancelDataRepositoryTask")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentCancelDataRepositoryTaskInput(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_serializeOpCopyBackup struct {
112}
113
114func (*awsAwsjson11_serializeOpCopyBackup) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpCopyBackup) 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.(*CopyBackupInput)
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("AWSSimbaAPIService_v20180301.CopyBackup")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentCopyBackupInput(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_serializeOpCreateBackup struct {
159}
160
161func (*awsAwsjson11_serializeOpCreateBackup) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCreateBackup) 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.(*CreateBackupInput)
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("AWSSimbaAPIService_v20180301.CreateBackup")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCreateBackupInput(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_serializeOpCreateDataRepositoryTask struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateDataRepositoryTask) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateDataRepositoryTask) 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.(*CreateDataRepositoryTaskInput)
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("AWSSimbaAPIService_v20180301.CreateDataRepositoryTask")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateDataRepositoryTaskInput(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_serializeOpCreateFileSystem struct {
253}
254
255func (*awsAwsjson11_serializeOpCreateFileSystem) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpCreateFileSystem) 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.(*CreateFileSystemInput)
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("AWSSimbaAPIService_v20180301.CreateFileSystem")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentCreateFileSystemInput(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_serializeOpCreateFileSystemFromBackup struct {
300}
301
302func (*awsAwsjson11_serializeOpCreateFileSystemFromBackup) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpCreateFileSystemFromBackup) 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.(*CreateFileSystemFromBackupInput)
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("AWSSimbaAPIService_v20180301.CreateFileSystemFromBackup")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentCreateFileSystemFromBackupInput(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_serializeOpCreateStorageVirtualMachine struct {
347}
348
349func (*awsAwsjson11_serializeOpCreateStorageVirtualMachine) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpCreateStorageVirtualMachine) 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.(*CreateStorageVirtualMachineInput)
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("AWSSimbaAPIService_v20180301.CreateStorageVirtualMachine")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentCreateStorageVirtualMachineInput(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_serializeOpCreateVolume struct {
394}
395
396func (*awsAwsjson11_serializeOpCreateVolume) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpCreateVolume) 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.(*CreateVolumeInput)
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("AWSSimbaAPIService_v20180301.CreateVolume")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentCreateVolumeInput(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_serializeOpCreateVolumeFromBackup struct {
441}
442
443func (*awsAwsjson11_serializeOpCreateVolumeFromBackup) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpCreateVolumeFromBackup) 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.(*CreateVolumeFromBackupInput)
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("AWSSimbaAPIService_v20180301.CreateVolumeFromBackup")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentCreateVolumeFromBackupInput(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_serializeOpDeleteBackup struct {
488}
489
490func (*awsAwsjson11_serializeOpDeleteBackup) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDeleteBackup) 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.(*DeleteBackupInput)
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("AWSSimbaAPIService_v20180301.DeleteBackup")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDeleteBackupInput(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_serializeOpDeleteFileSystem struct {
535}
536
537func (*awsAwsjson11_serializeOpDeleteFileSystem) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDeleteFileSystem) 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.(*DeleteFileSystemInput)
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("AWSSimbaAPIService_v20180301.DeleteFileSystem")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDeleteFileSystemInput(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_serializeOpDeleteStorageVirtualMachine struct {
582}
583
584func (*awsAwsjson11_serializeOpDeleteStorageVirtualMachine) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDeleteStorageVirtualMachine) 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.(*DeleteStorageVirtualMachineInput)
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("AWSSimbaAPIService_v20180301.DeleteStorageVirtualMachine")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDeleteStorageVirtualMachineInput(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_serializeOpDeleteVolume struct {
629}
630
631func (*awsAwsjson11_serializeOpDeleteVolume) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpDeleteVolume) 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.(*DeleteVolumeInput)
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("AWSSimbaAPIService_v20180301.DeleteVolume")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentDeleteVolumeInput(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_serializeOpDescribeBackups struct {
676}
677
678func (*awsAwsjson11_serializeOpDescribeBackups) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDescribeBackups) 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.(*DescribeBackupsInput)
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("AWSSimbaAPIService_v20180301.DescribeBackups")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDescribeBackupsInput(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_serializeOpDescribeDataRepositoryTasks struct {
723}
724
725func (*awsAwsjson11_serializeOpDescribeDataRepositoryTasks) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDescribeDataRepositoryTasks) 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.(*DescribeDataRepositoryTasksInput)
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("AWSSimbaAPIService_v20180301.DescribeDataRepositoryTasks")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDescribeDataRepositoryTasksInput(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_serializeOpDescribeFileSystemAliases struct {
770}
771
772func (*awsAwsjson11_serializeOpDescribeFileSystemAliases) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDescribeFileSystemAliases) 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.(*DescribeFileSystemAliasesInput)
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("AWSSimbaAPIService_v20180301.DescribeFileSystemAliases")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDescribeFileSystemAliasesInput(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_serializeOpDescribeFileSystems struct {
817}
818
819func (*awsAwsjson11_serializeOpDescribeFileSystems) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDescribeFileSystems) 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.(*DescribeFileSystemsInput)
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("AWSSimbaAPIService_v20180301.DescribeFileSystems")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDescribeFileSystemsInput(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_serializeOpDescribeStorageVirtualMachines struct {
864}
865
866func (*awsAwsjson11_serializeOpDescribeStorageVirtualMachines) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDescribeStorageVirtualMachines) 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.(*DescribeStorageVirtualMachinesInput)
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("AWSSimbaAPIService_v20180301.DescribeStorageVirtualMachines")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDescribeStorageVirtualMachinesInput(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_serializeOpDescribeVolumes struct {
911}
912
913func (*awsAwsjson11_serializeOpDescribeVolumes) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDescribeVolumes) 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.(*DescribeVolumesInput)
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("AWSSimbaAPIService_v20180301.DescribeVolumes")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDescribeVolumesInput(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_serializeOpDisassociateFileSystemAliases struct {
958}
959
960func (*awsAwsjson11_serializeOpDisassociateFileSystemAliases) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDisassociateFileSystemAliases) 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.(*DisassociateFileSystemAliasesInput)
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("AWSSimbaAPIService_v20180301.DisassociateFileSystemAliases")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDisassociateFileSystemAliasesInput(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_serializeOpListTagsForResource struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput)
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("AWSSimbaAPIService_v20180301.ListTagsForResource")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(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_serializeOpTagResource struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpTagResource) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpTagResource) 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.(*TagResourceInput)
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("AWSSimbaAPIService_v20180301.TagResource")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(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_serializeOpUntagResource struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpUntagResource) 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.(*UntagResourceInput)
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("AWSSimbaAPIService_v20180301.UntagResource")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(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_serializeOpUpdateFileSystem struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpUpdateFileSystem) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpUpdateFileSystem) 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.(*UpdateFileSystemInput)
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("AWSSimbaAPIService_v20180301.UpdateFileSystem")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentUpdateFileSystemInput(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_serializeOpUpdateStorageVirtualMachine struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpUpdateStorageVirtualMachine) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpUpdateStorageVirtualMachine) 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.(*UpdateStorageVirtualMachineInput)
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("AWSSimbaAPIService_v20180301.UpdateStorageVirtualMachine")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentUpdateStorageVirtualMachineInput(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_serializeOpUpdateVolume struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpUpdateVolume) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpUpdateVolume) 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.(*UpdateVolumeInput)
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("AWSSimbaAPIService_v20180301.UpdateVolume")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentUpdateVolumeInput(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}
1285func awsAwsjson11_serializeDocumentAlternateDNSNames(v []string, value smithyjson.Value) error {
1286	array := value.Array()
1287	defer array.Close()
1288
1289	for i := range v {
1290		av := array.Value()
1291		av.String(v[i])
1292	}
1293	return nil
1294}
1295
1296func awsAwsjson11_serializeDocumentBackupIds(v []string, value smithyjson.Value) error {
1297	array := value.Array()
1298	defer array.Close()
1299
1300	for i := range v {
1301		av := array.Value()
1302		av.String(v[i])
1303	}
1304	return nil
1305}
1306
1307func awsAwsjson11_serializeDocumentCompletionReport(v *types.CompletionReport, value smithyjson.Value) error {
1308	object := value.Object()
1309	defer object.Close()
1310
1311	if v.Enabled != nil {
1312		ok := object.Key("Enabled")
1313		ok.Boolean(*v.Enabled)
1314	}
1315
1316	if len(v.Format) > 0 {
1317		ok := object.Key("Format")
1318		ok.String(string(v.Format))
1319	}
1320
1321	if v.Path != nil {
1322		ok := object.Key("Path")
1323		ok.String(*v.Path)
1324	}
1325
1326	if len(v.Scope) > 0 {
1327		ok := object.Key("Scope")
1328		ok.String(string(v.Scope))
1329	}
1330
1331	return nil
1332}
1333
1334func awsAwsjson11_serializeDocumentCreateFileSystemLustreConfiguration(v *types.CreateFileSystemLustreConfiguration, value smithyjson.Value) error {
1335	object := value.Object()
1336	defer object.Close()
1337
1338	if len(v.AutoImportPolicy) > 0 {
1339		ok := object.Key("AutoImportPolicy")
1340		ok.String(string(v.AutoImportPolicy))
1341	}
1342
1343	if v.AutomaticBackupRetentionDays != nil {
1344		ok := object.Key("AutomaticBackupRetentionDays")
1345		ok.Integer(*v.AutomaticBackupRetentionDays)
1346	}
1347
1348	if v.CopyTagsToBackups != nil {
1349		ok := object.Key("CopyTagsToBackups")
1350		ok.Boolean(*v.CopyTagsToBackups)
1351	}
1352
1353	if v.DailyAutomaticBackupStartTime != nil {
1354		ok := object.Key("DailyAutomaticBackupStartTime")
1355		ok.String(*v.DailyAutomaticBackupStartTime)
1356	}
1357
1358	if len(v.DataCompressionType) > 0 {
1359		ok := object.Key("DataCompressionType")
1360		ok.String(string(v.DataCompressionType))
1361	}
1362
1363	if len(v.DeploymentType) > 0 {
1364		ok := object.Key("DeploymentType")
1365		ok.String(string(v.DeploymentType))
1366	}
1367
1368	if len(v.DriveCacheType) > 0 {
1369		ok := object.Key("DriveCacheType")
1370		ok.String(string(v.DriveCacheType))
1371	}
1372
1373	if v.ExportPath != nil {
1374		ok := object.Key("ExportPath")
1375		ok.String(*v.ExportPath)
1376	}
1377
1378	if v.ImportedFileChunkSize != nil {
1379		ok := object.Key("ImportedFileChunkSize")
1380		ok.Integer(*v.ImportedFileChunkSize)
1381	}
1382
1383	if v.ImportPath != nil {
1384		ok := object.Key("ImportPath")
1385		ok.String(*v.ImportPath)
1386	}
1387
1388	if v.PerUnitStorageThroughput != nil {
1389		ok := object.Key("PerUnitStorageThroughput")
1390		ok.Integer(*v.PerUnitStorageThroughput)
1391	}
1392
1393	if v.WeeklyMaintenanceStartTime != nil {
1394		ok := object.Key("WeeklyMaintenanceStartTime")
1395		ok.String(*v.WeeklyMaintenanceStartTime)
1396	}
1397
1398	return nil
1399}
1400
1401func awsAwsjson11_serializeDocumentCreateFileSystemOntapConfiguration(v *types.CreateFileSystemOntapConfiguration, value smithyjson.Value) error {
1402	object := value.Object()
1403	defer object.Close()
1404
1405	if v.AutomaticBackupRetentionDays != nil {
1406		ok := object.Key("AutomaticBackupRetentionDays")
1407		ok.Integer(*v.AutomaticBackupRetentionDays)
1408	}
1409
1410	if v.DailyAutomaticBackupStartTime != nil {
1411		ok := object.Key("DailyAutomaticBackupStartTime")
1412		ok.String(*v.DailyAutomaticBackupStartTime)
1413	}
1414
1415	if len(v.DeploymentType) > 0 {
1416		ok := object.Key("DeploymentType")
1417		ok.String(string(v.DeploymentType))
1418	}
1419
1420	if v.DiskIopsConfiguration != nil {
1421		ok := object.Key("DiskIopsConfiguration")
1422		if err := awsAwsjson11_serializeDocumentDiskIopsConfiguration(v.DiskIopsConfiguration, ok); err != nil {
1423			return err
1424		}
1425	}
1426
1427	if v.EndpointIpAddressRange != nil {
1428		ok := object.Key("EndpointIpAddressRange")
1429		ok.String(*v.EndpointIpAddressRange)
1430	}
1431
1432	if v.FsxAdminPassword != nil {
1433		ok := object.Key("FsxAdminPassword")
1434		ok.String(*v.FsxAdminPassword)
1435	}
1436
1437	if v.PreferredSubnetId != nil {
1438		ok := object.Key("PreferredSubnetId")
1439		ok.String(*v.PreferredSubnetId)
1440	}
1441
1442	if v.RouteTableIds != nil {
1443		ok := object.Key("RouteTableIds")
1444		if err := awsAwsjson11_serializeDocumentRouteTableIds(v.RouteTableIds, ok); err != nil {
1445			return err
1446		}
1447	}
1448
1449	if v.ThroughputCapacity != nil {
1450		ok := object.Key("ThroughputCapacity")
1451		ok.Integer(*v.ThroughputCapacity)
1452	}
1453
1454	if v.WeeklyMaintenanceStartTime != nil {
1455		ok := object.Key("WeeklyMaintenanceStartTime")
1456		ok.String(*v.WeeklyMaintenanceStartTime)
1457	}
1458
1459	return nil
1460}
1461
1462func awsAwsjson11_serializeDocumentCreateFileSystemWindowsConfiguration(v *types.CreateFileSystemWindowsConfiguration, value smithyjson.Value) error {
1463	object := value.Object()
1464	defer object.Close()
1465
1466	if v.ActiveDirectoryId != nil {
1467		ok := object.Key("ActiveDirectoryId")
1468		ok.String(*v.ActiveDirectoryId)
1469	}
1470
1471	if v.Aliases != nil {
1472		ok := object.Key("Aliases")
1473		if err := awsAwsjson11_serializeDocumentAlternateDNSNames(v.Aliases, ok); err != nil {
1474			return err
1475		}
1476	}
1477
1478	if v.AuditLogConfiguration != nil {
1479		ok := object.Key("AuditLogConfiguration")
1480		if err := awsAwsjson11_serializeDocumentWindowsAuditLogCreateConfiguration(v.AuditLogConfiguration, ok); err != nil {
1481			return err
1482		}
1483	}
1484
1485	if v.AutomaticBackupRetentionDays != nil {
1486		ok := object.Key("AutomaticBackupRetentionDays")
1487		ok.Integer(*v.AutomaticBackupRetentionDays)
1488	}
1489
1490	if v.CopyTagsToBackups != nil {
1491		ok := object.Key("CopyTagsToBackups")
1492		ok.Boolean(*v.CopyTagsToBackups)
1493	}
1494
1495	if v.DailyAutomaticBackupStartTime != nil {
1496		ok := object.Key("DailyAutomaticBackupStartTime")
1497		ok.String(*v.DailyAutomaticBackupStartTime)
1498	}
1499
1500	if len(v.DeploymentType) > 0 {
1501		ok := object.Key("DeploymentType")
1502		ok.String(string(v.DeploymentType))
1503	}
1504
1505	if v.PreferredSubnetId != nil {
1506		ok := object.Key("PreferredSubnetId")
1507		ok.String(*v.PreferredSubnetId)
1508	}
1509
1510	if v.SelfManagedActiveDirectoryConfiguration != nil {
1511		ok := object.Key("SelfManagedActiveDirectoryConfiguration")
1512		if err := awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfiguration(v.SelfManagedActiveDirectoryConfiguration, ok); err != nil {
1513			return err
1514		}
1515	}
1516
1517	if v.ThroughputCapacity != nil {
1518		ok := object.Key("ThroughputCapacity")
1519		ok.Integer(*v.ThroughputCapacity)
1520	}
1521
1522	if v.WeeklyMaintenanceStartTime != nil {
1523		ok := object.Key("WeeklyMaintenanceStartTime")
1524		ok.String(*v.WeeklyMaintenanceStartTime)
1525	}
1526
1527	return nil
1528}
1529
1530func awsAwsjson11_serializeDocumentCreateOntapVolumeConfiguration(v *types.CreateOntapVolumeConfiguration, value smithyjson.Value) error {
1531	object := value.Object()
1532	defer object.Close()
1533
1534	if v.JunctionPath != nil {
1535		ok := object.Key("JunctionPath")
1536		ok.String(*v.JunctionPath)
1537	}
1538
1539	if len(v.SecurityStyle) > 0 {
1540		ok := object.Key("SecurityStyle")
1541		ok.String(string(v.SecurityStyle))
1542	}
1543
1544	if v.SizeInMegabytes != nil {
1545		ok := object.Key("SizeInMegabytes")
1546		ok.Integer(*v.SizeInMegabytes)
1547	}
1548
1549	if v.StorageEfficiencyEnabled != nil {
1550		ok := object.Key("StorageEfficiencyEnabled")
1551		ok.Boolean(*v.StorageEfficiencyEnabled)
1552	}
1553
1554	if v.StorageVirtualMachineId != nil {
1555		ok := object.Key("StorageVirtualMachineId")
1556		ok.String(*v.StorageVirtualMachineId)
1557	}
1558
1559	if v.TieringPolicy != nil {
1560		ok := object.Key("TieringPolicy")
1561		if err := awsAwsjson11_serializeDocumentTieringPolicy(v.TieringPolicy, ok); err != nil {
1562			return err
1563		}
1564	}
1565
1566	return nil
1567}
1568
1569func awsAwsjson11_serializeDocumentCreateSvmActiveDirectoryConfiguration(v *types.CreateSvmActiveDirectoryConfiguration, value smithyjson.Value) error {
1570	object := value.Object()
1571	defer object.Close()
1572
1573	if v.NetBiosName != nil {
1574		ok := object.Key("NetBiosName")
1575		ok.String(*v.NetBiosName)
1576	}
1577
1578	if v.SelfManagedActiveDirectoryConfiguration != nil {
1579		ok := object.Key("SelfManagedActiveDirectoryConfiguration")
1580		if err := awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfiguration(v.SelfManagedActiveDirectoryConfiguration, ok); err != nil {
1581			return err
1582		}
1583	}
1584
1585	return nil
1586}
1587
1588func awsAwsjson11_serializeDocumentDataRepositoryTaskFilter(v *types.DataRepositoryTaskFilter, value smithyjson.Value) error {
1589	object := value.Object()
1590	defer object.Close()
1591
1592	if len(v.Name) > 0 {
1593		ok := object.Key("Name")
1594		ok.String(string(v.Name))
1595	}
1596
1597	if v.Values != nil {
1598		ok := object.Key("Values")
1599		if err := awsAwsjson11_serializeDocumentDataRepositoryTaskFilterValues(v.Values, ok); err != nil {
1600			return err
1601		}
1602	}
1603
1604	return nil
1605}
1606
1607func awsAwsjson11_serializeDocumentDataRepositoryTaskFilters(v []types.DataRepositoryTaskFilter, value smithyjson.Value) error {
1608	array := value.Array()
1609	defer array.Close()
1610
1611	for i := range v {
1612		av := array.Value()
1613		if err := awsAwsjson11_serializeDocumentDataRepositoryTaskFilter(&v[i], av); err != nil {
1614			return err
1615		}
1616	}
1617	return nil
1618}
1619
1620func awsAwsjson11_serializeDocumentDataRepositoryTaskFilterValues(v []string, value smithyjson.Value) error {
1621	array := value.Array()
1622	defer array.Close()
1623
1624	for i := range v {
1625		av := array.Value()
1626		av.String(v[i])
1627	}
1628	return nil
1629}
1630
1631func awsAwsjson11_serializeDocumentDataRepositoryTaskPaths(v []string, value smithyjson.Value) error {
1632	array := value.Array()
1633	defer array.Close()
1634
1635	for i := range v {
1636		av := array.Value()
1637		av.String(v[i])
1638	}
1639	return nil
1640}
1641
1642func awsAwsjson11_serializeDocumentDeleteFileSystemLustreConfiguration(v *types.DeleteFileSystemLustreConfiguration, value smithyjson.Value) error {
1643	object := value.Object()
1644	defer object.Close()
1645
1646	if v.FinalBackupTags != nil {
1647		ok := object.Key("FinalBackupTags")
1648		if err := awsAwsjson11_serializeDocumentTags(v.FinalBackupTags, ok); err != nil {
1649			return err
1650		}
1651	}
1652
1653	if v.SkipFinalBackup != nil {
1654		ok := object.Key("SkipFinalBackup")
1655		ok.Boolean(*v.SkipFinalBackup)
1656	}
1657
1658	return nil
1659}
1660
1661func awsAwsjson11_serializeDocumentDeleteFileSystemWindowsConfiguration(v *types.DeleteFileSystemWindowsConfiguration, value smithyjson.Value) error {
1662	object := value.Object()
1663	defer object.Close()
1664
1665	if v.FinalBackupTags != nil {
1666		ok := object.Key("FinalBackupTags")
1667		if err := awsAwsjson11_serializeDocumentTags(v.FinalBackupTags, ok); err != nil {
1668			return err
1669		}
1670	}
1671
1672	if v.SkipFinalBackup != nil {
1673		ok := object.Key("SkipFinalBackup")
1674		ok.Boolean(*v.SkipFinalBackup)
1675	}
1676
1677	return nil
1678}
1679
1680func awsAwsjson11_serializeDocumentDeleteVolumeOntapConfiguration(v *types.DeleteVolumeOntapConfiguration, value smithyjson.Value) error {
1681	object := value.Object()
1682	defer object.Close()
1683
1684	if v.FinalBackupTags != nil {
1685		ok := object.Key("FinalBackupTags")
1686		if err := awsAwsjson11_serializeDocumentTags(v.FinalBackupTags, ok); err != nil {
1687			return err
1688		}
1689	}
1690
1691	if v.SkipFinalBackup != nil {
1692		ok := object.Key("SkipFinalBackup")
1693		ok.Boolean(*v.SkipFinalBackup)
1694	}
1695
1696	return nil
1697}
1698
1699func awsAwsjson11_serializeDocumentDiskIopsConfiguration(v *types.DiskIopsConfiguration, value smithyjson.Value) error {
1700	object := value.Object()
1701	defer object.Close()
1702
1703	if v.Iops != nil {
1704		ok := object.Key("Iops")
1705		ok.Long(*v.Iops)
1706	}
1707
1708	if len(v.Mode) > 0 {
1709		ok := object.Key("Mode")
1710		ok.String(string(v.Mode))
1711	}
1712
1713	return nil
1714}
1715
1716func awsAwsjson11_serializeDocumentDnsIps(v []string, value smithyjson.Value) error {
1717	array := value.Array()
1718	defer array.Close()
1719
1720	for i := range v {
1721		av := array.Value()
1722		av.String(v[i])
1723	}
1724	return nil
1725}
1726
1727func awsAwsjson11_serializeDocumentFileSystemIds(v []string, value smithyjson.Value) error {
1728	array := value.Array()
1729	defer array.Close()
1730
1731	for i := range v {
1732		av := array.Value()
1733		av.String(v[i])
1734	}
1735	return nil
1736}
1737
1738func awsAwsjson11_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
1739	object := value.Object()
1740	defer object.Close()
1741
1742	if len(v.Name) > 0 {
1743		ok := object.Key("Name")
1744		ok.String(string(v.Name))
1745	}
1746
1747	if v.Values != nil {
1748		ok := object.Key("Values")
1749		if err := awsAwsjson11_serializeDocumentFilterValues(v.Values, ok); err != nil {
1750			return err
1751		}
1752	}
1753
1754	return nil
1755}
1756
1757func awsAwsjson11_serializeDocumentFilters(v []types.Filter, value smithyjson.Value) error {
1758	array := value.Array()
1759	defer array.Close()
1760
1761	for i := range v {
1762		av := array.Value()
1763		if err := awsAwsjson11_serializeDocumentFilter(&v[i], av); err != nil {
1764			return err
1765		}
1766	}
1767	return nil
1768}
1769
1770func awsAwsjson11_serializeDocumentFilterValues(v []string, value smithyjson.Value) error {
1771	array := value.Array()
1772	defer array.Close()
1773
1774	for i := range v {
1775		av := array.Value()
1776		av.String(v[i])
1777	}
1778	return nil
1779}
1780
1781func awsAwsjson11_serializeDocumentRouteTableIds(v []string, value smithyjson.Value) error {
1782	array := value.Array()
1783	defer array.Close()
1784
1785	for i := range v {
1786		av := array.Value()
1787		av.String(v[i])
1788	}
1789	return nil
1790}
1791
1792func awsAwsjson11_serializeDocumentSecurityGroupIds(v []string, value smithyjson.Value) error {
1793	array := value.Array()
1794	defer array.Close()
1795
1796	for i := range v {
1797		av := array.Value()
1798		av.String(v[i])
1799	}
1800	return nil
1801}
1802
1803func awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfiguration(v *types.SelfManagedActiveDirectoryConfiguration, value smithyjson.Value) error {
1804	object := value.Object()
1805	defer object.Close()
1806
1807	if v.DnsIps != nil {
1808		ok := object.Key("DnsIps")
1809		if err := awsAwsjson11_serializeDocumentDnsIps(v.DnsIps, ok); err != nil {
1810			return err
1811		}
1812	}
1813
1814	if v.DomainName != nil {
1815		ok := object.Key("DomainName")
1816		ok.String(*v.DomainName)
1817	}
1818
1819	if v.FileSystemAdministratorsGroup != nil {
1820		ok := object.Key("FileSystemAdministratorsGroup")
1821		ok.String(*v.FileSystemAdministratorsGroup)
1822	}
1823
1824	if v.OrganizationalUnitDistinguishedName != nil {
1825		ok := object.Key("OrganizationalUnitDistinguishedName")
1826		ok.String(*v.OrganizationalUnitDistinguishedName)
1827	}
1828
1829	if v.Password != nil {
1830		ok := object.Key("Password")
1831		ok.String(*v.Password)
1832	}
1833
1834	if v.UserName != nil {
1835		ok := object.Key("UserName")
1836		ok.String(*v.UserName)
1837	}
1838
1839	return nil
1840}
1841
1842func awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfigurationUpdates(v *types.SelfManagedActiveDirectoryConfigurationUpdates, value smithyjson.Value) error {
1843	object := value.Object()
1844	defer object.Close()
1845
1846	if v.DnsIps != nil {
1847		ok := object.Key("DnsIps")
1848		if err := awsAwsjson11_serializeDocumentDnsIps(v.DnsIps, ok); err != nil {
1849			return err
1850		}
1851	}
1852
1853	if v.Password != nil {
1854		ok := object.Key("Password")
1855		ok.String(*v.Password)
1856	}
1857
1858	if v.UserName != nil {
1859		ok := object.Key("UserName")
1860		ok.String(*v.UserName)
1861	}
1862
1863	return nil
1864}
1865
1866func awsAwsjson11_serializeDocumentStorageVirtualMachineFilter(v *types.StorageVirtualMachineFilter, value smithyjson.Value) error {
1867	object := value.Object()
1868	defer object.Close()
1869
1870	if len(v.Name) > 0 {
1871		ok := object.Key("Name")
1872		ok.String(string(v.Name))
1873	}
1874
1875	if v.Values != nil {
1876		ok := object.Key("Values")
1877		if err := awsAwsjson11_serializeDocumentStorageVirtualMachineFilterValues(v.Values, ok); err != nil {
1878			return err
1879		}
1880	}
1881
1882	return nil
1883}
1884
1885func awsAwsjson11_serializeDocumentStorageVirtualMachineFilters(v []types.StorageVirtualMachineFilter, value smithyjson.Value) error {
1886	array := value.Array()
1887	defer array.Close()
1888
1889	for i := range v {
1890		av := array.Value()
1891		if err := awsAwsjson11_serializeDocumentStorageVirtualMachineFilter(&v[i], av); err != nil {
1892			return err
1893		}
1894	}
1895	return nil
1896}
1897
1898func awsAwsjson11_serializeDocumentStorageVirtualMachineFilterValues(v []string, value smithyjson.Value) error {
1899	array := value.Array()
1900	defer array.Close()
1901
1902	for i := range v {
1903		av := array.Value()
1904		av.String(v[i])
1905	}
1906	return nil
1907}
1908
1909func awsAwsjson11_serializeDocumentStorageVirtualMachineIds(v []string, value smithyjson.Value) error {
1910	array := value.Array()
1911	defer array.Close()
1912
1913	for i := range v {
1914		av := array.Value()
1915		av.String(v[i])
1916	}
1917	return nil
1918}
1919
1920func awsAwsjson11_serializeDocumentSubnetIds(v []string, value smithyjson.Value) error {
1921	array := value.Array()
1922	defer array.Close()
1923
1924	for i := range v {
1925		av := array.Value()
1926		av.String(v[i])
1927	}
1928	return nil
1929}
1930
1931func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
1932	object := value.Object()
1933	defer object.Close()
1934
1935	if v.Key != nil {
1936		ok := object.Key("Key")
1937		ok.String(*v.Key)
1938	}
1939
1940	if v.Value != nil {
1941		ok := object.Key("Value")
1942		ok.String(*v.Value)
1943	}
1944
1945	return nil
1946}
1947
1948func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
1949	array := value.Array()
1950	defer array.Close()
1951
1952	for i := range v {
1953		av := array.Value()
1954		av.String(v[i])
1955	}
1956	return nil
1957}
1958
1959func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
1960	array := value.Array()
1961	defer array.Close()
1962
1963	for i := range v {
1964		av := array.Value()
1965		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
1966			return err
1967		}
1968	}
1969	return nil
1970}
1971
1972func awsAwsjson11_serializeDocumentTaskIds(v []string, value smithyjson.Value) error {
1973	array := value.Array()
1974	defer array.Close()
1975
1976	for i := range v {
1977		av := array.Value()
1978		av.String(v[i])
1979	}
1980	return nil
1981}
1982
1983func awsAwsjson11_serializeDocumentTieringPolicy(v *types.TieringPolicy, value smithyjson.Value) error {
1984	object := value.Object()
1985	defer object.Close()
1986
1987	if v.CoolingPeriod != nil {
1988		ok := object.Key("CoolingPeriod")
1989		ok.Integer(*v.CoolingPeriod)
1990	}
1991
1992	if len(v.Name) > 0 {
1993		ok := object.Key("Name")
1994		ok.String(string(v.Name))
1995	}
1996
1997	return nil
1998}
1999
2000func awsAwsjson11_serializeDocumentUpdateFileSystemLustreConfiguration(v *types.UpdateFileSystemLustreConfiguration, value smithyjson.Value) error {
2001	object := value.Object()
2002	defer object.Close()
2003
2004	if len(v.AutoImportPolicy) > 0 {
2005		ok := object.Key("AutoImportPolicy")
2006		ok.String(string(v.AutoImportPolicy))
2007	}
2008
2009	if v.AutomaticBackupRetentionDays != nil {
2010		ok := object.Key("AutomaticBackupRetentionDays")
2011		ok.Integer(*v.AutomaticBackupRetentionDays)
2012	}
2013
2014	if v.DailyAutomaticBackupStartTime != nil {
2015		ok := object.Key("DailyAutomaticBackupStartTime")
2016		ok.String(*v.DailyAutomaticBackupStartTime)
2017	}
2018
2019	if len(v.DataCompressionType) > 0 {
2020		ok := object.Key("DataCompressionType")
2021		ok.String(string(v.DataCompressionType))
2022	}
2023
2024	if v.WeeklyMaintenanceStartTime != nil {
2025		ok := object.Key("WeeklyMaintenanceStartTime")
2026		ok.String(*v.WeeklyMaintenanceStartTime)
2027	}
2028
2029	return nil
2030}
2031
2032func awsAwsjson11_serializeDocumentUpdateFileSystemOntapConfiguration(v *types.UpdateFileSystemOntapConfiguration, value smithyjson.Value) error {
2033	object := value.Object()
2034	defer object.Close()
2035
2036	if v.AutomaticBackupRetentionDays != nil {
2037		ok := object.Key("AutomaticBackupRetentionDays")
2038		ok.Integer(*v.AutomaticBackupRetentionDays)
2039	}
2040
2041	if v.DailyAutomaticBackupStartTime != nil {
2042		ok := object.Key("DailyAutomaticBackupStartTime")
2043		ok.String(*v.DailyAutomaticBackupStartTime)
2044	}
2045
2046	if v.FsxAdminPassword != nil {
2047		ok := object.Key("FsxAdminPassword")
2048		ok.String(*v.FsxAdminPassword)
2049	}
2050
2051	if v.WeeklyMaintenanceStartTime != nil {
2052		ok := object.Key("WeeklyMaintenanceStartTime")
2053		ok.String(*v.WeeklyMaintenanceStartTime)
2054	}
2055
2056	return nil
2057}
2058
2059func awsAwsjson11_serializeDocumentUpdateFileSystemWindowsConfiguration(v *types.UpdateFileSystemWindowsConfiguration, value smithyjson.Value) error {
2060	object := value.Object()
2061	defer object.Close()
2062
2063	if v.AuditLogConfiguration != nil {
2064		ok := object.Key("AuditLogConfiguration")
2065		if err := awsAwsjson11_serializeDocumentWindowsAuditLogCreateConfiguration(v.AuditLogConfiguration, ok); err != nil {
2066			return err
2067		}
2068	}
2069
2070	if v.AutomaticBackupRetentionDays != nil {
2071		ok := object.Key("AutomaticBackupRetentionDays")
2072		ok.Integer(*v.AutomaticBackupRetentionDays)
2073	}
2074
2075	if v.DailyAutomaticBackupStartTime != nil {
2076		ok := object.Key("DailyAutomaticBackupStartTime")
2077		ok.String(*v.DailyAutomaticBackupStartTime)
2078	}
2079
2080	if v.SelfManagedActiveDirectoryConfiguration != nil {
2081		ok := object.Key("SelfManagedActiveDirectoryConfiguration")
2082		if err := awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfigurationUpdates(v.SelfManagedActiveDirectoryConfiguration, ok); err != nil {
2083			return err
2084		}
2085	}
2086
2087	if v.ThroughputCapacity != nil {
2088		ok := object.Key("ThroughputCapacity")
2089		ok.Integer(*v.ThroughputCapacity)
2090	}
2091
2092	if v.WeeklyMaintenanceStartTime != nil {
2093		ok := object.Key("WeeklyMaintenanceStartTime")
2094		ok.String(*v.WeeklyMaintenanceStartTime)
2095	}
2096
2097	return nil
2098}
2099
2100func awsAwsjson11_serializeDocumentUpdateOntapVolumeConfiguration(v *types.UpdateOntapVolumeConfiguration, value smithyjson.Value) error {
2101	object := value.Object()
2102	defer object.Close()
2103
2104	if v.JunctionPath != nil {
2105		ok := object.Key("JunctionPath")
2106		ok.String(*v.JunctionPath)
2107	}
2108
2109	if len(v.SecurityStyle) > 0 {
2110		ok := object.Key("SecurityStyle")
2111		ok.String(string(v.SecurityStyle))
2112	}
2113
2114	if v.SizeInMegabytes != nil {
2115		ok := object.Key("SizeInMegabytes")
2116		ok.Integer(*v.SizeInMegabytes)
2117	}
2118
2119	if v.StorageEfficiencyEnabled != nil {
2120		ok := object.Key("StorageEfficiencyEnabled")
2121		ok.Boolean(*v.StorageEfficiencyEnabled)
2122	}
2123
2124	if v.TieringPolicy != nil {
2125		ok := object.Key("TieringPolicy")
2126		if err := awsAwsjson11_serializeDocumentTieringPolicy(v.TieringPolicy, ok); err != nil {
2127			return err
2128		}
2129	}
2130
2131	return nil
2132}
2133
2134func awsAwsjson11_serializeDocumentUpdateSvmActiveDirectoryConfiguration(v *types.UpdateSvmActiveDirectoryConfiguration, value smithyjson.Value) error {
2135	object := value.Object()
2136	defer object.Close()
2137
2138	if v.SelfManagedActiveDirectoryConfiguration != nil {
2139		ok := object.Key("SelfManagedActiveDirectoryConfiguration")
2140		if err := awsAwsjson11_serializeDocumentSelfManagedActiveDirectoryConfigurationUpdates(v.SelfManagedActiveDirectoryConfiguration, ok); err != nil {
2141			return err
2142		}
2143	}
2144
2145	return nil
2146}
2147
2148func awsAwsjson11_serializeDocumentVolumeFilter(v *types.VolumeFilter, value smithyjson.Value) error {
2149	object := value.Object()
2150	defer object.Close()
2151
2152	if len(v.Name) > 0 {
2153		ok := object.Key("Name")
2154		ok.String(string(v.Name))
2155	}
2156
2157	if v.Values != nil {
2158		ok := object.Key("Values")
2159		if err := awsAwsjson11_serializeDocumentVolumeFilterValues(v.Values, ok); err != nil {
2160			return err
2161		}
2162	}
2163
2164	return nil
2165}
2166
2167func awsAwsjson11_serializeDocumentVolumeFilters(v []types.VolumeFilter, value smithyjson.Value) error {
2168	array := value.Array()
2169	defer array.Close()
2170
2171	for i := range v {
2172		av := array.Value()
2173		if err := awsAwsjson11_serializeDocumentVolumeFilter(&v[i], av); err != nil {
2174			return err
2175		}
2176	}
2177	return nil
2178}
2179
2180func awsAwsjson11_serializeDocumentVolumeFilterValues(v []string, value smithyjson.Value) error {
2181	array := value.Array()
2182	defer array.Close()
2183
2184	for i := range v {
2185		av := array.Value()
2186		av.String(v[i])
2187	}
2188	return nil
2189}
2190
2191func awsAwsjson11_serializeDocumentVolumeIds(v []string, value smithyjson.Value) error {
2192	array := value.Array()
2193	defer array.Close()
2194
2195	for i := range v {
2196		av := array.Value()
2197		av.String(v[i])
2198	}
2199	return nil
2200}
2201
2202func awsAwsjson11_serializeDocumentWindowsAuditLogCreateConfiguration(v *types.WindowsAuditLogCreateConfiguration, value smithyjson.Value) error {
2203	object := value.Object()
2204	defer object.Close()
2205
2206	if v.AuditLogDestination != nil {
2207		ok := object.Key("AuditLogDestination")
2208		ok.String(*v.AuditLogDestination)
2209	}
2210
2211	if len(v.FileAccessAuditLogLevel) > 0 {
2212		ok := object.Key("FileAccessAuditLogLevel")
2213		ok.String(string(v.FileAccessAuditLogLevel))
2214	}
2215
2216	if len(v.FileShareAccessAuditLogLevel) > 0 {
2217		ok := object.Key("FileShareAccessAuditLogLevel")
2218		ok.String(string(v.FileShareAccessAuditLogLevel))
2219	}
2220
2221	return nil
2222}
2223
2224func awsAwsjson11_serializeOpDocumentAssociateFileSystemAliasesInput(v *AssociateFileSystemAliasesInput, value smithyjson.Value) error {
2225	object := value.Object()
2226	defer object.Close()
2227
2228	if v.Aliases != nil {
2229		ok := object.Key("Aliases")
2230		if err := awsAwsjson11_serializeDocumentAlternateDNSNames(v.Aliases, ok); err != nil {
2231			return err
2232		}
2233	}
2234
2235	if v.ClientRequestToken != nil {
2236		ok := object.Key("ClientRequestToken")
2237		ok.String(*v.ClientRequestToken)
2238	}
2239
2240	if v.FileSystemId != nil {
2241		ok := object.Key("FileSystemId")
2242		ok.String(*v.FileSystemId)
2243	}
2244
2245	return nil
2246}
2247
2248func awsAwsjson11_serializeOpDocumentCancelDataRepositoryTaskInput(v *CancelDataRepositoryTaskInput, value smithyjson.Value) error {
2249	object := value.Object()
2250	defer object.Close()
2251
2252	if v.TaskId != nil {
2253		ok := object.Key("TaskId")
2254		ok.String(*v.TaskId)
2255	}
2256
2257	return nil
2258}
2259
2260func awsAwsjson11_serializeOpDocumentCopyBackupInput(v *CopyBackupInput, value smithyjson.Value) error {
2261	object := value.Object()
2262	defer object.Close()
2263
2264	if v.ClientRequestToken != nil {
2265		ok := object.Key("ClientRequestToken")
2266		ok.String(*v.ClientRequestToken)
2267	}
2268
2269	if v.CopyTags != nil {
2270		ok := object.Key("CopyTags")
2271		ok.Boolean(*v.CopyTags)
2272	}
2273
2274	if v.KmsKeyId != nil {
2275		ok := object.Key("KmsKeyId")
2276		ok.String(*v.KmsKeyId)
2277	}
2278
2279	if v.SourceBackupId != nil {
2280		ok := object.Key("SourceBackupId")
2281		ok.String(*v.SourceBackupId)
2282	}
2283
2284	if v.SourceRegion != nil {
2285		ok := object.Key("SourceRegion")
2286		ok.String(*v.SourceRegion)
2287	}
2288
2289	if v.Tags != nil {
2290		ok := object.Key("Tags")
2291		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2292			return err
2293		}
2294	}
2295
2296	return nil
2297}
2298
2299func awsAwsjson11_serializeOpDocumentCreateBackupInput(v *CreateBackupInput, value smithyjson.Value) error {
2300	object := value.Object()
2301	defer object.Close()
2302
2303	if v.ClientRequestToken != nil {
2304		ok := object.Key("ClientRequestToken")
2305		ok.String(*v.ClientRequestToken)
2306	}
2307
2308	if v.FileSystemId != nil {
2309		ok := object.Key("FileSystemId")
2310		ok.String(*v.FileSystemId)
2311	}
2312
2313	if v.Tags != nil {
2314		ok := object.Key("Tags")
2315		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2316			return err
2317		}
2318	}
2319
2320	if v.VolumeId != nil {
2321		ok := object.Key("VolumeId")
2322		ok.String(*v.VolumeId)
2323	}
2324
2325	return nil
2326}
2327
2328func awsAwsjson11_serializeOpDocumentCreateDataRepositoryTaskInput(v *CreateDataRepositoryTaskInput, value smithyjson.Value) error {
2329	object := value.Object()
2330	defer object.Close()
2331
2332	if v.ClientRequestToken != nil {
2333		ok := object.Key("ClientRequestToken")
2334		ok.String(*v.ClientRequestToken)
2335	}
2336
2337	if v.FileSystemId != nil {
2338		ok := object.Key("FileSystemId")
2339		ok.String(*v.FileSystemId)
2340	}
2341
2342	if v.Paths != nil {
2343		ok := object.Key("Paths")
2344		if err := awsAwsjson11_serializeDocumentDataRepositoryTaskPaths(v.Paths, ok); err != nil {
2345			return err
2346		}
2347	}
2348
2349	if v.Report != nil {
2350		ok := object.Key("Report")
2351		if err := awsAwsjson11_serializeDocumentCompletionReport(v.Report, ok); err != nil {
2352			return err
2353		}
2354	}
2355
2356	if v.Tags != nil {
2357		ok := object.Key("Tags")
2358		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2359			return err
2360		}
2361	}
2362
2363	if len(v.Type) > 0 {
2364		ok := object.Key("Type")
2365		ok.String(string(v.Type))
2366	}
2367
2368	return nil
2369}
2370
2371func awsAwsjson11_serializeOpDocumentCreateFileSystemFromBackupInput(v *CreateFileSystemFromBackupInput, value smithyjson.Value) error {
2372	object := value.Object()
2373	defer object.Close()
2374
2375	if v.BackupId != nil {
2376		ok := object.Key("BackupId")
2377		ok.String(*v.BackupId)
2378	}
2379
2380	if v.ClientRequestToken != nil {
2381		ok := object.Key("ClientRequestToken")
2382		ok.String(*v.ClientRequestToken)
2383	}
2384
2385	if v.KmsKeyId != nil {
2386		ok := object.Key("KmsKeyId")
2387		ok.String(*v.KmsKeyId)
2388	}
2389
2390	if v.LustreConfiguration != nil {
2391		ok := object.Key("LustreConfiguration")
2392		if err := awsAwsjson11_serializeDocumentCreateFileSystemLustreConfiguration(v.LustreConfiguration, ok); err != nil {
2393			return err
2394		}
2395	}
2396
2397	if v.SecurityGroupIds != nil {
2398		ok := object.Key("SecurityGroupIds")
2399		if err := awsAwsjson11_serializeDocumentSecurityGroupIds(v.SecurityGroupIds, ok); err != nil {
2400			return err
2401		}
2402	}
2403
2404	if len(v.StorageType) > 0 {
2405		ok := object.Key("StorageType")
2406		ok.String(string(v.StorageType))
2407	}
2408
2409	if v.SubnetIds != nil {
2410		ok := object.Key("SubnetIds")
2411		if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil {
2412			return err
2413		}
2414	}
2415
2416	if v.Tags != nil {
2417		ok := object.Key("Tags")
2418		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2419			return err
2420		}
2421	}
2422
2423	if v.WindowsConfiguration != nil {
2424		ok := object.Key("WindowsConfiguration")
2425		if err := awsAwsjson11_serializeDocumentCreateFileSystemWindowsConfiguration(v.WindowsConfiguration, ok); err != nil {
2426			return err
2427		}
2428	}
2429
2430	return nil
2431}
2432
2433func awsAwsjson11_serializeOpDocumentCreateFileSystemInput(v *CreateFileSystemInput, value smithyjson.Value) error {
2434	object := value.Object()
2435	defer object.Close()
2436
2437	if v.ClientRequestToken != nil {
2438		ok := object.Key("ClientRequestToken")
2439		ok.String(*v.ClientRequestToken)
2440	}
2441
2442	if len(v.FileSystemType) > 0 {
2443		ok := object.Key("FileSystemType")
2444		ok.String(string(v.FileSystemType))
2445	}
2446
2447	if v.KmsKeyId != nil {
2448		ok := object.Key("KmsKeyId")
2449		ok.String(*v.KmsKeyId)
2450	}
2451
2452	if v.LustreConfiguration != nil {
2453		ok := object.Key("LustreConfiguration")
2454		if err := awsAwsjson11_serializeDocumentCreateFileSystemLustreConfiguration(v.LustreConfiguration, ok); err != nil {
2455			return err
2456		}
2457	}
2458
2459	if v.OntapConfiguration != nil {
2460		ok := object.Key("OntapConfiguration")
2461		if err := awsAwsjson11_serializeDocumentCreateFileSystemOntapConfiguration(v.OntapConfiguration, ok); err != nil {
2462			return err
2463		}
2464	}
2465
2466	if v.SecurityGroupIds != nil {
2467		ok := object.Key("SecurityGroupIds")
2468		if err := awsAwsjson11_serializeDocumentSecurityGroupIds(v.SecurityGroupIds, ok); err != nil {
2469			return err
2470		}
2471	}
2472
2473	if v.StorageCapacity != nil {
2474		ok := object.Key("StorageCapacity")
2475		ok.Integer(*v.StorageCapacity)
2476	}
2477
2478	if len(v.StorageType) > 0 {
2479		ok := object.Key("StorageType")
2480		ok.String(string(v.StorageType))
2481	}
2482
2483	if v.SubnetIds != nil {
2484		ok := object.Key("SubnetIds")
2485		if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil {
2486			return err
2487		}
2488	}
2489
2490	if v.Tags != nil {
2491		ok := object.Key("Tags")
2492		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2493			return err
2494		}
2495	}
2496
2497	if v.WindowsConfiguration != nil {
2498		ok := object.Key("WindowsConfiguration")
2499		if err := awsAwsjson11_serializeDocumentCreateFileSystemWindowsConfiguration(v.WindowsConfiguration, ok); err != nil {
2500			return err
2501		}
2502	}
2503
2504	return nil
2505}
2506
2507func awsAwsjson11_serializeOpDocumentCreateStorageVirtualMachineInput(v *CreateStorageVirtualMachineInput, value smithyjson.Value) error {
2508	object := value.Object()
2509	defer object.Close()
2510
2511	if v.ActiveDirectoryConfiguration != nil {
2512		ok := object.Key("ActiveDirectoryConfiguration")
2513		if err := awsAwsjson11_serializeDocumentCreateSvmActiveDirectoryConfiguration(v.ActiveDirectoryConfiguration, ok); err != nil {
2514			return err
2515		}
2516	}
2517
2518	if v.ClientRequestToken != nil {
2519		ok := object.Key("ClientRequestToken")
2520		ok.String(*v.ClientRequestToken)
2521	}
2522
2523	if v.FileSystemId != nil {
2524		ok := object.Key("FileSystemId")
2525		ok.String(*v.FileSystemId)
2526	}
2527
2528	if v.Name != nil {
2529		ok := object.Key("Name")
2530		ok.String(*v.Name)
2531	}
2532
2533	if len(v.RootVolumeSecurityStyle) > 0 {
2534		ok := object.Key("RootVolumeSecurityStyle")
2535		ok.String(string(v.RootVolumeSecurityStyle))
2536	}
2537
2538	if v.SvmAdminPassword != nil {
2539		ok := object.Key("SvmAdminPassword")
2540		ok.String(*v.SvmAdminPassword)
2541	}
2542
2543	if v.Tags != nil {
2544		ok := object.Key("Tags")
2545		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2546			return err
2547		}
2548	}
2549
2550	return nil
2551}
2552
2553func awsAwsjson11_serializeOpDocumentCreateVolumeFromBackupInput(v *CreateVolumeFromBackupInput, value smithyjson.Value) error {
2554	object := value.Object()
2555	defer object.Close()
2556
2557	if v.BackupId != nil {
2558		ok := object.Key("BackupId")
2559		ok.String(*v.BackupId)
2560	}
2561
2562	if v.ClientRequestToken != nil {
2563		ok := object.Key("ClientRequestToken")
2564		ok.String(*v.ClientRequestToken)
2565	}
2566
2567	if v.Name != nil {
2568		ok := object.Key("Name")
2569		ok.String(*v.Name)
2570	}
2571
2572	if v.OntapConfiguration != nil {
2573		ok := object.Key("OntapConfiguration")
2574		if err := awsAwsjson11_serializeDocumentCreateOntapVolumeConfiguration(v.OntapConfiguration, ok); err != nil {
2575			return err
2576		}
2577	}
2578
2579	if v.Tags != nil {
2580		ok := object.Key("Tags")
2581		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2582			return err
2583		}
2584	}
2585
2586	return nil
2587}
2588
2589func awsAwsjson11_serializeOpDocumentCreateVolumeInput(v *CreateVolumeInput, value smithyjson.Value) error {
2590	object := value.Object()
2591	defer object.Close()
2592
2593	if v.ClientRequestToken != nil {
2594		ok := object.Key("ClientRequestToken")
2595		ok.String(*v.ClientRequestToken)
2596	}
2597
2598	if v.Name != nil {
2599		ok := object.Key("Name")
2600		ok.String(*v.Name)
2601	}
2602
2603	if v.OntapConfiguration != nil {
2604		ok := object.Key("OntapConfiguration")
2605		if err := awsAwsjson11_serializeDocumentCreateOntapVolumeConfiguration(v.OntapConfiguration, ok); err != nil {
2606			return err
2607		}
2608	}
2609
2610	if v.Tags != nil {
2611		ok := object.Key("Tags")
2612		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2613			return err
2614		}
2615	}
2616
2617	if len(v.VolumeType) > 0 {
2618		ok := object.Key("VolumeType")
2619		ok.String(string(v.VolumeType))
2620	}
2621
2622	return nil
2623}
2624
2625func awsAwsjson11_serializeOpDocumentDeleteBackupInput(v *DeleteBackupInput, value smithyjson.Value) error {
2626	object := value.Object()
2627	defer object.Close()
2628
2629	if v.BackupId != nil {
2630		ok := object.Key("BackupId")
2631		ok.String(*v.BackupId)
2632	}
2633
2634	if v.ClientRequestToken != nil {
2635		ok := object.Key("ClientRequestToken")
2636		ok.String(*v.ClientRequestToken)
2637	}
2638
2639	return nil
2640}
2641
2642func awsAwsjson11_serializeOpDocumentDeleteFileSystemInput(v *DeleteFileSystemInput, value smithyjson.Value) error {
2643	object := value.Object()
2644	defer object.Close()
2645
2646	if v.ClientRequestToken != nil {
2647		ok := object.Key("ClientRequestToken")
2648		ok.String(*v.ClientRequestToken)
2649	}
2650
2651	if v.FileSystemId != nil {
2652		ok := object.Key("FileSystemId")
2653		ok.String(*v.FileSystemId)
2654	}
2655
2656	if v.LustreConfiguration != nil {
2657		ok := object.Key("LustreConfiguration")
2658		if err := awsAwsjson11_serializeDocumentDeleteFileSystemLustreConfiguration(v.LustreConfiguration, ok); err != nil {
2659			return err
2660		}
2661	}
2662
2663	if v.WindowsConfiguration != nil {
2664		ok := object.Key("WindowsConfiguration")
2665		if err := awsAwsjson11_serializeDocumentDeleteFileSystemWindowsConfiguration(v.WindowsConfiguration, ok); err != nil {
2666			return err
2667		}
2668	}
2669
2670	return nil
2671}
2672
2673func awsAwsjson11_serializeOpDocumentDeleteStorageVirtualMachineInput(v *DeleteStorageVirtualMachineInput, value smithyjson.Value) error {
2674	object := value.Object()
2675	defer object.Close()
2676
2677	if v.ClientRequestToken != nil {
2678		ok := object.Key("ClientRequestToken")
2679		ok.String(*v.ClientRequestToken)
2680	}
2681
2682	if v.StorageVirtualMachineId != nil {
2683		ok := object.Key("StorageVirtualMachineId")
2684		ok.String(*v.StorageVirtualMachineId)
2685	}
2686
2687	return nil
2688}
2689
2690func awsAwsjson11_serializeOpDocumentDeleteVolumeInput(v *DeleteVolumeInput, value smithyjson.Value) error {
2691	object := value.Object()
2692	defer object.Close()
2693
2694	if v.ClientRequestToken != nil {
2695		ok := object.Key("ClientRequestToken")
2696		ok.String(*v.ClientRequestToken)
2697	}
2698
2699	if v.OntapConfiguration != nil {
2700		ok := object.Key("OntapConfiguration")
2701		if err := awsAwsjson11_serializeDocumentDeleteVolumeOntapConfiguration(v.OntapConfiguration, ok); err != nil {
2702			return err
2703		}
2704	}
2705
2706	if v.VolumeId != nil {
2707		ok := object.Key("VolumeId")
2708		ok.String(*v.VolumeId)
2709	}
2710
2711	return nil
2712}
2713
2714func awsAwsjson11_serializeOpDocumentDescribeBackupsInput(v *DescribeBackupsInput, value smithyjson.Value) error {
2715	object := value.Object()
2716	defer object.Close()
2717
2718	if v.BackupIds != nil {
2719		ok := object.Key("BackupIds")
2720		if err := awsAwsjson11_serializeDocumentBackupIds(v.BackupIds, ok); err != nil {
2721			return err
2722		}
2723	}
2724
2725	if v.Filters != nil {
2726		ok := object.Key("Filters")
2727		if err := awsAwsjson11_serializeDocumentFilters(v.Filters, ok); err != nil {
2728			return err
2729		}
2730	}
2731
2732	if v.MaxResults != nil {
2733		ok := object.Key("MaxResults")
2734		ok.Integer(*v.MaxResults)
2735	}
2736
2737	if v.NextToken != nil {
2738		ok := object.Key("NextToken")
2739		ok.String(*v.NextToken)
2740	}
2741
2742	return nil
2743}
2744
2745func awsAwsjson11_serializeOpDocumentDescribeDataRepositoryTasksInput(v *DescribeDataRepositoryTasksInput, value smithyjson.Value) error {
2746	object := value.Object()
2747	defer object.Close()
2748
2749	if v.Filters != nil {
2750		ok := object.Key("Filters")
2751		if err := awsAwsjson11_serializeDocumentDataRepositoryTaskFilters(v.Filters, ok); err != nil {
2752			return err
2753		}
2754	}
2755
2756	if v.MaxResults != nil {
2757		ok := object.Key("MaxResults")
2758		ok.Integer(*v.MaxResults)
2759	}
2760
2761	if v.NextToken != nil {
2762		ok := object.Key("NextToken")
2763		ok.String(*v.NextToken)
2764	}
2765
2766	if v.TaskIds != nil {
2767		ok := object.Key("TaskIds")
2768		if err := awsAwsjson11_serializeDocumentTaskIds(v.TaskIds, ok); err != nil {
2769			return err
2770		}
2771	}
2772
2773	return nil
2774}
2775
2776func awsAwsjson11_serializeOpDocumentDescribeFileSystemAliasesInput(v *DescribeFileSystemAliasesInput, value smithyjson.Value) error {
2777	object := value.Object()
2778	defer object.Close()
2779
2780	if v.ClientRequestToken != nil {
2781		ok := object.Key("ClientRequestToken")
2782		ok.String(*v.ClientRequestToken)
2783	}
2784
2785	if v.FileSystemId != nil {
2786		ok := object.Key("FileSystemId")
2787		ok.String(*v.FileSystemId)
2788	}
2789
2790	if v.MaxResults != nil {
2791		ok := object.Key("MaxResults")
2792		ok.Integer(*v.MaxResults)
2793	}
2794
2795	if v.NextToken != nil {
2796		ok := object.Key("NextToken")
2797		ok.String(*v.NextToken)
2798	}
2799
2800	return nil
2801}
2802
2803func awsAwsjson11_serializeOpDocumentDescribeFileSystemsInput(v *DescribeFileSystemsInput, value smithyjson.Value) error {
2804	object := value.Object()
2805	defer object.Close()
2806
2807	if v.FileSystemIds != nil {
2808		ok := object.Key("FileSystemIds")
2809		if err := awsAwsjson11_serializeDocumentFileSystemIds(v.FileSystemIds, ok); err != nil {
2810			return err
2811		}
2812	}
2813
2814	if v.MaxResults != nil {
2815		ok := object.Key("MaxResults")
2816		ok.Integer(*v.MaxResults)
2817	}
2818
2819	if v.NextToken != nil {
2820		ok := object.Key("NextToken")
2821		ok.String(*v.NextToken)
2822	}
2823
2824	return nil
2825}
2826
2827func awsAwsjson11_serializeOpDocumentDescribeStorageVirtualMachinesInput(v *DescribeStorageVirtualMachinesInput, value smithyjson.Value) error {
2828	object := value.Object()
2829	defer object.Close()
2830
2831	if v.Filters != nil {
2832		ok := object.Key("Filters")
2833		if err := awsAwsjson11_serializeDocumentStorageVirtualMachineFilters(v.Filters, ok); err != nil {
2834			return err
2835		}
2836	}
2837
2838	if v.MaxResults != nil {
2839		ok := object.Key("MaxResults")
2840		ok.Integer(*v.MaxResults)
2841	}
2842
2843	if v.NextToken != nil {
2844		ok := object.Key("NextToken")
2845		ok.String(*v.NextToken)
2846	}
2847
2848	if v.StorageVirtualMachineIds != nil {
2849		ok := object.Key("StorageVirtualMachineIds")
2850		if err := awsAwsjson11_serializeDocumentStorageVirtualMachineIds(v.StorageVirtualMachineIds, ok); err != nil {
2851			return err
2852		}
2853	}
2854
2855	return nil
2856}
2857
2858func awsAwsjson11_serializeOpDocumentDescribeVolumesInput(v *DescribeVolumesInput, value smithyjson.Value) error {
2859	object := value.Object()
2860	defer object.Close()
2861
2862	if v.Filters != nil {
2863		ok := object.Key("Filters")
2864		if err := awsAwsjson11_serializeDocumentVolumeFilters(v.Filters, ok); err != nil {
2865			return err
2866		}
2867	}
2868
2869	if v.MaxResults != nil {
2870		ok := object.Key("MaxResults")
2871		ok.Integer(*v.MaxResults)
2872	}
2873
2874	if v.NextToken != nil {
2875		ok := object.Key("NextToken")
2876		ok.String(*v.NextToken)
2877	}
2878
2879	if v.VolumeIds != nil {
2880		ok := object.Key("VolumeIds")
2881		if err := awsAwsjson11_serializeDocumentVolumeIds(v.VolumeIds, ok); err != nil {
2882			return err
2883		}
2884	}
2885
2886	return nil
2887}
2888
2889func awsAwsjson11_serializeOpDocumentDisassociateFileSystemAliasesInput(v *DisassociateFileSystemAliasesInput, value smithyjson.Value) error {
2890	object := value.Object()
2891	defer object.Close()
2892
2893	if v.Aliases != nil {
2894		ok := object.Key("Aliases")
2895		if err := awsAwsjson11_serializeDocumentAlternateDNSNames(v.Aliases, ok); err != nil {
2896			return err
2897		}
2898	}
2899
2900	if v.ClientRequestToken != nil {
2901		ok := object.Key("ClientRequestToken")
2902		ok.String(*v.ClientRequestToken)
2903	}
2904
2905	if v.FileSystemId != nil {
2906		ok := object.Key("FileSystemId")
2907		ok.String(*v.FileSystemId)
2908	}
2909
2910	return nil
2911}
2912
2913func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
2914	object := value.Object()
2915	defer object.Close()
2916
2917	if v.MaxResults != nil {
2918		ok := object.Key("MaxResults")
2919		ok.Integer(*v.MaxResults)
2920	}
2921
2922	if v.NextToken != nil {
2923		ok := object.Key("NextToken")
2924		ok.String(*v.NextToken)
2925	}
2926
2927	if v.ResourceARN != nil {
2928		ok := object.Key("ResourceARN")
2929		ok.String(*v.ResourceARN)
2930	}
2931
2932	return nil
2933}
2934
2935func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
2936	object := value.Object()
2937	defer object.Close()
2938
2939	if v.ResourceARN != nil {
2940		ok := object.Key("ResourceARN")
2941		ok.String(*v.ResourceARN)
2942	}
2943
2944	if v.Tags != nil {
2945		ok := object.Key("Tags")
2946		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
2947			return err
2948		}
2949	}
2950
2951	return nil
2952}
2953
2954func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
2955	object := value.Object()
2956	defer object.Close()
2957
2958	if v.ResourceARN != nil {
2959		ok := object.Key("ResourceARN")
2960		ok.String(*v.ResourceARN)
2961	}
2962
2963	if v.TagKeys != nil {
2964		ok := object.Key("TagKeys")
2965		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
2966			return err
2967		}
2968	}
2969
2970	return nil
2971}
2972
2973func awsAwsjson11_serializeOpDocumentUpdateFileSystemInput(v *UpdateFileSystemInput, value smithyjson.Value) error {
2974	object := value.Object()
2975	defer object.Close()
2976
2977	if v.ClientRequestToken != nil {
2978		ok := object.Key("ClientRequestToken")
2979		ok.String(*v.ClientRequestToken)
2980	}
2981
2982	if v.FileSystemId != nil {
2983		ok := object.Key("FileSystemId")
2984		ok.String(*v.FileSystemId)
2985	}
2986
2987	if v.LustreConfiguration != nil {
2988		ok := object.Key("LustreConfiguration")
2989		if err := awsAwsjson11_serializeDocumentUpdateFileSystemLustreConfiguration(v.LustreConfiguration, ok); err != nil {
2990			return err
2991		}
2992	}
2993
2994	if v.OntapConfiguration != nil {
2995		ok := object.Key("OntapConfiguration")
2996		if err := awsAwsjson11_serializeDocumentUpdateFileSystemOntapConfiguration(v.OntapConfiguration, ok); err != nil {
2997			return err
2998		}
2999	}
3000
3001	if v.StorageCapacity != nil {
3002		ok := object.Key("StorageCapacity")
3003		ok.Integer(*v.StorageCapacity)
3004	}
3005
3006	if v.WindowsConfiguration != nil {
3007		ok := object.Key("WindowsConfiguration")
3008		if err := awsAwsjson11_serializeDocumentUpdateFileSystemWindowsConfiguration(v.WindowsConfiguration, ok); err != nil {
3009			return err
3010		}
3011	}
3012
3013	return nil
3014}
3015
3016func awsAwsjson11_serializeOpDocumentUpdateStorageVirtualMachineInput(v *UpdateStorageVirtualMachineInput, value smithyjson.Value) error {
3017	object := value.Object()
3018	defer object.Close()
3019
3020	if v.ActiveDirectoryConfiguration != nil {
3021		ok := object.Key("ActiveDirectoryConfiguration")
3022		if err := awsAwsjson11_serializeDocumentUpdateSvmActiveDirectoryConfiguration(v.ActiveDirectoryConfiguration, ok); err != nil {
3023			return err
3024		}
3025	}
3026
3027	if v.ClientRequestToken != nil {
3028		ok := object.Key("ClientRequestToken")
3029		ok.String(*v.ClientRequestToken)
3030	}
3031
3032	if v.StorageVirtualMachineId != nil {
3033		ok := object.Key("StorageVirtualMachineId")
3034		ok.String(*v.StorageVirtualMachineId)
3035	}
3036
3037	if v.SvmAdminPassword != nil {
3038		ok := object.Key("SvmAdminPassword")
3039		ok.String(*v.SvmAdminPassword)
3040	}
3041
3042	return nil
3043}
3044
3045func awsAwsjson11_serializeOpDocumentUpdateVolumeInput(v *UpdateVolumeInput, value smithyjson.Value) error {
3046	object := value.Object()
3047	defer object.Close()
3048
3049	if v.ClientRequestToken != nil {
3050		ok := object.Key("ClientRequestToken")
3051		ok.String(*v.ClientRequestToken)
3052	}
3053
3054	if v.OntapConfiguration != nil {
3055		ok := object.Key("OntapConfiguration")
3056		if err := awsAwsjson11_serializeDocumentUpdateOntapVolumeConfiguration(v.OntapConfiguration, ok); err != nil {
3057			return err
3058		}
3059	}
3060
3061	if v.VolumeId != nil {
3062		ok := object.Key("VolumeId")
3063		ok.String(*v.VolumeId)
3064	}
3065
3066	return nil
3067}
3068