1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package storagegateway
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/storagegateway/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_serializeOpActivateGateway struct {
18}
19
20func (*awsAwsjson11_serializeOpActivateGateway) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpActivateGateway) 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.(*ActivateGatewayInput)
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("StorageGateway_20130630.ActivateGateway")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentActivateGatewayInput(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_serializeOpAddCache struct {
65}
66
67func (*awsAwsjson11_serializeOpAddCache) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpAddCache) 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.(*AddCacheInput)
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("StorageGateway_20130630.AddCache")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentAddCacheInput(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_serializeOpAddTagsToResource struct {
112}
113
114func (*awsAwsjson11_serializeOpAddTagsToResource) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpAddTagsToResource) 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.(*AddTagsToResourceInput)
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("StorageGateway_20130630.AddTagsToResource")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(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_serializeOpAddUploadBuffer struct {
159}
160
161func (*awsAwsjson11_serializeOpAddUploadBuffer) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpAddUploadBuffer) 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.(*AddUploadBufferInput)
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("StorageGateway_20130630.AddUploadBuffer")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentAddUploadBufferInput(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_serializeOpAddWorkingStorage struct {
206}
207
208func (*awsAwsjson11_serializeOpAddWorkingStorage) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpAddWorkingStorage) 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.(*AddWorkingStorageInput)
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("StorageGateway_20130630.AddWorkingStorage")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentAddWorkingStorageInput(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_serializeOpAssignTapePool struct {
253}
254
255func (*awsAwsjson11_serializeOpAssignTapePool) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpAssignTapePool) 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.(*AssignTapePoolInput)
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("StorageGateway_20130630.AssignTapePool")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentAssignTapePoolInput(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_serializeOpAssociateFileSystem struct {
300}
301
302func (*awsAwsjson11_serializeOpAssociateFileSystem) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpAssociateFileSystem) 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.(*AssociateFileSystemInput)
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("StorageGateway_20130630.AssociateFileSystem")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentAssociateFileSystemInput(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_serializeOpAttachVolume struct {
347}
348
349func (*awsAwsjson11_serializeOpAttachVolume) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpAttachVolume) 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.(*AttachVolumeInput)
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("StorageGateway_20130630.AttachVolume")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentAttachVolumeInput(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_serializeOpCancelArchival struct {
394}
395
396func (*awsAwsjson11_serializeOpCancelArchival) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpCancelArchival) 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.(*CancelArchivalInput)
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("StorageGateway_20130630.CancelArchival")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentCancelArchivalInput(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_serializeOpCancelRetrieval struct {
441}
442
443func (*awsAwsjson11_serializeOpCancelRetrieval) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpCancelRetrieval) 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.(*CancelRetrievalInput)
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("StorageGateway_20130630.CancelRetrieval")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentCancelRetrievalInput(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_serializeOpCreateCachediSCSIVolume struct {
488}
489
490func (*awsAwsjson11_serializeOpCreateCachediSCSIVolume) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpCreateCachediSCSIVolume) 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.(*CreateCachediSCSIVolumeInput)
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("StorageGateway_20130630.CreateCachediSCSIVolume")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentCreateCachediSCSIVolumeInput(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_serializeOpCreateNFSFileShare struct {
535}
536
537func (*awsAwsjson11_serializeOpCreateNFSFileShare) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpCreateNFSFileShare) 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.(*CreateNFSFileShareInput)
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("StorageGateway_20130630.CreateNFSFileShare")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentCreateNFSFileShareInput(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_serializeOpCreateSMBFileShare struct {
582}
583
584func (*awsAwsjson11_serializeOpCreateSMBFileShare) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpCreateSMBFileShare) 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.(*CreateSMBFileShareInput)
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("StorageGateway_20130630.CreateSMBFileShare")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentCreateSMBFileShareInput(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_serializeOpCreateSnapshot struct {
629}
630
631func (*awsAwsjson11_serializeOpCreateSnapshot) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpCreateSnapshot) 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.(*CreateSnapshotInput)
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("StorageGateway_20130630.CreateSnapshot")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentCreateSnapshotInput(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_serializeOpCreateSnapshotFromVolumeRecoveryPoint struct {
676}
677
678func (*awsAwsjson11_serializeOpCreateSnapshotFromVolumeRecoveryPoint) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpCreateSnapshotFromVolumeRecoveryPoint) 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.(*CreateSnapshotFromVolumeRecoveryPointInput)
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("StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentCreateSnapshotFromVolumeRecoveryPointInput(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_serializeOpCreateStorediSCSIVolume struct {
723}
724
725func (*awsAwsjson11_serializeOpCreateStorediSCSIVolume) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpCreateStorediSCSIVolume) 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.(*CreateStorediSCSIVolumeInput)
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("StorageGateway_20130630.CreateStorediSCSIVolume")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentCreateStorediSCSIVolumeInput(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_serializeOpCreateTapePool struct {
770}
771
772func (*awsAwsjson11_serializeOpCreateTapePool) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpCreateTapePool) 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.(*CreateTapePoolInput)
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("StorageGateway_20130630.CreateTapePool")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentCreateTapePoolInput(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_serializeOpCreateTapes struct {
817}
818
819func (*awsAwsjson11_serializeOpCreateTapes) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpCreateTapes) 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.(*CreateTapesInput)
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("StorageGateway_20130630.CreateTapes")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentCreateTapesInput(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_serializeOpCreateTapeWithBarcode struct {
864}
865
866func (*awsAwsjson11_serializeOpCreateTapeWithBarcode) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpCreateTapeWithBarcode) 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.(*CreateTapeWithBarcodeInput)
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("StorageGateway_20130630.CreateTapeWithBarcode")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentCreateTapeWithBarcodeInput(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_serializeOpDeleteAutomaticTapeCreationPolicy struct {
911}
912
913func (*awsAwsjson11_serializeOpDeleteAutomaticTapeCreationPolicy) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDeleteAutomaticTapeCreationPolicy) 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.(*DeleteAutomaticTapeCreationPolicyInput)
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("StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDeleteAutomaticTapeCreationPolicyInput(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_serializeOpDeleteBandwidthRateLimit struct {
958}
959
960func (*awsAwsjson11_serializeOpDeleteBandwidthRateLimit) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDeleteBandwidthRateLimit) 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.(*DeleteBandwidthRateLimitInput)
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("StorageGateway_20130630.DeleteBandwidthRateLimit")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDeleteBandwidthRateLimitInput(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_serializeOpDeleteChapCredentials struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpDeleteChapCredentials) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpDeleteChapCredentials) 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.(*DeleteChapCredentialsInput)
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("StorageGateway_20130630.DeleteChapCredentials")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentDeleteChapCredentialsInput(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_serializeOpDeleteFileShare struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpDeleteFileShare) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpDeleteFileShare) 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.(*DeleteFileShareInput)
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("StorageGateway_20130630.DeleteFileShare")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentDeleteFileShareInput(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_serializeOpDeleteGateway struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpDeleteGateway) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpDeleteGateway) 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.(*DeleteGatewayInput)
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("StorageGateway_20130630.DeleteGateway")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentDeleteGatewayInput(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_serializeOpDeleteSnapshotSchedule struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpDeleteSnapshotSchedule) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpDeleteSnapshotSchedule) 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.(*DeleteSnapshotScheduleInput)
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("StorageGateway_20130630.DeleteSnapshotSchedule")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentDeleteSnapshotScheduleInput(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_serializeOpDeleteTape struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpDeleteTape) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpDeleteTape) 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.(*DeleteTapeInput)
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("StorageGateway_20130630.DeleteTape")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentDeleteTapeInput(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_serializeOpDeleteTapeArchive struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpDeleteTapeArchive) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpDeleteTapeArchive) 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.(*DeleteTapeArchiveInput)
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("StorageGateway_20130630.DeleteTapeArchive")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentDeleteTapeArchiveInput(input, jsonEncoder.Value); err != nil {
1271		return out, metadata, &smithy.SerializationError{Err: err}
1272	}
1273
1274	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277
1278	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1279		return out, metadata, &smithy.SerializationError{Err: err}
1280	}
1281	in.Request = request
1282
1283	return next.HandleSerialize(ctx, in)
1284}
1285
1286type awsAwsjson11_serializeOpDeleteTapePool struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpDeleteTapePool) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpDeleteTapePool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	request, ok := in.Request.(*smithyhttp.Request)
1297	if !ok {
1298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1299	}
1300
1301	input, ok := in.Parameters.(*DeleteTapePoolInput)
1302	_ = input
1303	if !ok {
1304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1305	}
1306
1307	request.Request.URL.Path = "/"
1308	request.Request.Method = "POST"
1309	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1310	if err != nil {
1311		return out, metadata, &smithy.SerializationError{Err: err}
1312	}
1313	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1314	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DeleteTapePool")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentDeleteTapePoolInput(input, jsonEncoder.Value); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320
1321	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1322		return out, metadata, &smithy.SerializationError{Err: err}
1323	}
1324
1325	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328	in.Request = request
1329
1330	return next.HandleSerialize(ctx, in)
1331}
1332
1333type awsAwsjson11_serializeOpDeleteVolume struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpDeleteVolume) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpDeleteVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1341	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	request, ok := in.Request.(*smithyhttp.Request)
1344	if !ok {
1345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1346	}
1347
1348	input, ok := in.Parameters.(*DeleteVolumeInput)
1349	_ = input
1350	if !ok {
1351		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1352	}
1353
1354	request.Request.URL.Path = "/"
1355	request.Request.Method = "POST"
1356	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1357	if err != nil {
1358		return out, metadata, &smithy.SerializationError{Err: err}
1359	}
1360	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1361	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DeleteVolume")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentDeleteVolumeInput(input, jsonEncoder.Value); err != nil {
1365		return out, metadata, &smithy.SerializationError{Err: err}
1366	}
1367
1368	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1369		return out, metadata, &smithy.SerializationError{Err: err}
1370	}
1371
1372	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1373		return out, metadata, &smithy.SerializationError{Err: err}
1374	}
1375	in.Request = request
1376
1377	return next.HandleSerialize(ctx, in)
1378}
1379
1380type awsAwsjson11_serializeOpDescribeAvailabilityMonitorTest struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpDescribeAvailabilityMonitorTest) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpDescribeAvailabilityMonitorTest) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1388	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1389) {
1390	request, ok := in.Request.(*smithyhttp.Request)
1391	if !ok {
1392		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1393	}
1394
1395	input, ok := in.Parameters.(*DescribeAvailabilityMonitorTestInput)
1396	_ = input
1397	if !ok {
1398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1399	}
1400
1401	request.Request.URL.Path = "/"
1402	request.Request.Method = "POST"
1403	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1404	if err != nil {
1405		return out, metadata, &smithy.SerializationError{Err: err}
1406	}
1407	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1408	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeAvailabilityMonitorTest")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentDescribeAvailabilityMonitorTestInput(input, jsonEncoder.Value); err != nil {
1412		return out, metadata, &smithy.SerializationError{Err: err}
1413	}
1414
1415	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1416		return out, metadata, &smithy.SerializationError{Err: err}
1417	}
1418
1419	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1420		return out, metadata, &smithy.SerializationError{Err: err}
1421	}
1422	in.Request = request
1423
1424	return next.HandleSerialize(ctx, in)
1425}
1426
1427type awsAwsjson11_serializeOpDescribeBandwidthRateLimit struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpDescribeBandwidthRateLimit) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpDescribeBandwidthRateLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1435	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1436) {
1437	request, ok := in.Request.(*smithyhttp.Request)
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1440	}
1441
1442	input, ok := in.Parameters.(*DescribeBandwidthRateLimitInput)
1443	_ = input
1444	if !ok {
1445		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1446	}
1447
1448	request.Request.URL.Path = "/"
1449	request.Request.Method = "POST"
1450	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1451	if err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1455	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeBandwidthRateLimit")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentDescribeBandwidthRateLimitInput(input, jsonEncoder.Value); err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsjson11_serializeOpDescribeBandwidthRateLimitSchedule struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpDescribeBandwidthRateLimitSchedule) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpDescribeBandwidthRateLimitSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*DescribeBandwidthRateLimitScheduleInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1502	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentDescribeBandwidthRateLimitScheduleInput(input, jsonEncoder.Value); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1514		return out, metadata, &smithy.SerializationError{Err: err}
1515	}
1516	in.Request = request
1517
1518	return next.HandleSerialize(ctx, in)
1519}
1520
1521type awsAwsjson11_serializeOpDescribeCache struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpDescribeCache) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpDescribeCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1530) {
1531	request, ok := in.Request.(*smithyhttp.Request)
1532	if !ok {
1533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1534	}
1535
1536	input, ok := in.Parameters.(*DescribeCacheInput)
1537	_ = input
1538	if !ok {
1539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1540	}
1541
1542	request.Request.URL.Path = "/"
1543	request.Request.Method = "POST"
1544	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1549	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeCache")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentDescribeCacheInput(input, jsonEncoder.Value); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563	in.Request = request
1564
1565	return next.HandleSerialize(ctx, in)
1566}
1567
1568type awsAwsjson11_serializeOpDescribeCachediSCSIVolumes struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpDescribeCachediSCSIVolumes) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpDescribeCachediSCSIVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1576	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1577) {
1578	request, ok := in.Request.(*smithyhttp.Request)
1579	if !ok {
1580		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1581	}
1582
1583	input, ok := in.Parameters.(*DescribeCachediSCSIVolumesInput)
1584	_ = input
1585	if !ok {
1586		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1587	}
1588
1589	request.Request.URL.Path = "/"
1590	request.Request.Method = "POST"
1591	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1592	if err != nil {
1593		return out, metadata, &smithy.SerializationError{Err: err}
1594	}
1595	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1596	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeCachediSCSIVolumes")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentDescribeCachediSCSIVolumesInput(input, jsonEncoder.Value); err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606
1607	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1608		return out, metadata, &smithy.SerializationError{Err: err}
1609	}
1610	in.Request = request
1611
1612	return next.HandleSerialize(ctx, in)
1613}
1614
1615type awsAwsjson11_serializeOpDescribeChapCredentials struct {
1616}
1617
1618func (*awsAwsjson11_serializeOpDescribeChapCredentials) ID() string {
1619	return "OperationSerializer"
1620}
1621
1622func (m *awsAwsjson11_serializeOpDescribeChapCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1623	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1624) {
1625	request, ok := in.Request.(*smithyhttp.Request)
1626	if !ok {
1627		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1628	}
1629
1630	input, ok := in.Parameters.(*DescribeChapCredentialsInput)
1631	_ = input
1632	if !ok {
1633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1634	}
1635
1636	request.Request.URL.Path = "/"
1637	request.Request.Method = "POST"
1638	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1639	if err != nil {
1640		return out, metadata, &smithy.SerializationError{Err: err}
1641	}
1642	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1643	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeChapCredentials")
1644
1645	jsonEncoder := smithyjson.NewEncoder()
1646	if err := awsAwsjson11_serializeOpDocumentDescribeChapCredentialsInput(input, jsonEncoder.Value); err != nil {
1647		return out, metadata, &smithy.SerializationError{Err: err}
1648	}
1649
1650	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1651		return out, metadata, &smithy.SerializationError{Err: err}
1652	}
1653
1654	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1655		return out, metadata, &smithy.SerializationError{Err: err}
1656	}
1657	in.Request = request
1658
1659	return next.HandleSerialize(ctx, in)
1660}
1661
1662type awsAwsjson11_serializeOpDescribeFileSystemAssociations struct {
1663}
1664
1665func (*awsAwsjson11_serializeOpDescribeFileSystemAssociations) ID() string {
1666	return "OperationSerializer"
1667}
1668
1669func (m *awsAwsjson11_serializeOpDescribeFileSystemAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1670	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1671) {
1672	request, ok := in.Request.(*smithyhttp.Request)
1673	if !ok {
1674		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1675	}
1676
1677	input, ok := in.Parameters.(*DescribeFileSystemAssociationsInput)
1678	_ = input
1679	if !ok {
1680		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1681	}
1682
1683	request.Request.URL.Path = "/"
1684	request.Request.Method = "POST"
1685	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1686	if err != nil {
1687		return out, metadata, &smithy.SerializationError{Err: err}
1688	}
1689	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1690	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeFileSystemAssociations")
1691
1692	jsonEncoder := smithyjson.NewEncoder()
1693	if err := awsAwsjson11_serializeOpDocumentDescribeFileSystemAssociationsInput(input, jsonEncoder.Value); err != nil {
1694		return out, metadata, &smithy.SerializationError{Err: err}
1695	}
1696
1697	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1698		return out, metadata, &smithy.SerializationError{Err: err}
1699	}
1700
1701	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1702		return out, metadata, &smithy.SerializationError{Err: err}
1703	}
1704	in.Request = request
1705
1706	return next.HandleSerialize(ctx, in)
1707}
1708
1709type awsAwsjson11_serializeOpDescribeGatewayInformation struct {
1710}
1711
1712func (*awsAwsjson11_serializeOpDescribeGatewayInformation) ID() string {
1713	return "OperationSerializer"
1714}
1715
1716func (m *awsAwsjson11_serializeOpDescribeGatewayInformation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1717	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1718) {
1719	request, ok := in.Request.(*smithyhttp.Request)
1720	if !ok {
1721		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1722	}
1723
1724	input, ok := in.Parameters.(*DescribeGatewayInformationInput)
1725	_ = input
1726	if !ok {
1727		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1728	}
1729
1730	request.Request.URL.Path = "/"
1731	request.Request.Method = "POST"
1732	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1733	if err != nil {
1734		return out, metadata, &smithy.SerializationError{Err: err}
1735	}
1736	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1737	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeGatewayInformation")
1738
1739	jsonEncoder := smithyjson.NewEncoder()
1740	if err := awsAwsjson11_serializeOpDocumentDescribeGatewayInformationInput(input, jsonEncoder.Value); err != nil {
1741		return out, metadata, &smithy.SerializationError{Err: err}
1742	}
1743
1744	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1745		return out, metadata, &smithy.SerializationError{Err: err}
1746	}
1747
1748	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1749		return out, metadata, &smithy.SerializationError{Err: err}
1750	}
1751	in.Request = request
1752
1753	return next.HandleSerialize(ctx, in)
1754}
1755
1756type awsAwsjson11_serializeOpDescribeMaintenanceStartTime struct {
1757}
1758
1759func (*awsAwsjson11_serializeOpDescribeMaintenanceStartTime) ID() string {
1760	return "OperationSerializer"
1761}
1762
1763func (m *awsAwsjson11_serializeOpDescribeMaintenanceStartTime) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1764	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1765) {
1766	request, ok := in.Request.(*smithyhttp.Request)
1767	if !ok {
1768		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1769	}
1770
1771	input, ok := in.Parameters.(*DescribeMaintenanceStartTimeInput)
1772	_ = input
1773	if !ok {
1774		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1775	}
1776
1777	request.Request.URL.Path = "/"
1778	request.Request.Method = "POST"
1779	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1780	if err != nil {
1781		return out, metadata, &smithy.SerializationError{Err: err}
1782	}
1783	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1784	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeMaintenanceStartTime")
1785
1786	jsonEncoder := smithyjson.NewEncoder()
1787	if err := awsAwsjson11_serializeOpDocumentDescribeMaintenanceStartTimeInput(input, jsonEncoder.Value); err != nil {
1788		return out, metadata, &smithy.SerializationError{Err: err}
1789	}
1790
1791	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1792		return out, metadata, &smithy.SerializationError{Err: err}
1793	}
1794
1795	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1796		return out, metadata, &smithy.SerializationError{Err: err}
1797	}
1798	in.Request = request
1799
1800	return next.HandleSerialize(ctx, in)
1801}
1802
1803type awsAwsjson11_serializeOpDescribeNFSFileShares struct {
1804}
1805
1806func (*awsAwsjson11_serializeOpDescribeNFSFileShares) ID() string {
1807	return "OperationSerializer"
1808}
1809
1810func (m *awsAwsjson11_serializeOpDescribeNFSFileShares) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1811	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1812) {
1813	request, ok := in.Request.(*smithyhttp.Request)
1814	if !ok {
1815		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1816	}
1817
1818	input, ok := in.Parameters.(*DescribeNFSFileSharesInput)
1819	_ = input
1820	if !ok {
1821		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1822	}
1823
1824	request.Request.URL.Path = "/"
1825	request.Request.Method = "POST"
1826	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1827	if err != nil {
1828		return out, metadata, &smithy.SerializationError{Err: err}
1829	}
1830	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1831	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeNFSFileShares")
1832
1833	jsonEncoder := smithyjson.NewEncoder()
1834	if err := awsAwsjson11_serializeOpDocumentDescribeNFSFileSharesInput(input, jsonEncoder.Value); err != nil {
1835		return out, metadata, &smithy.SerializationError{Err: err}
1836	}
1837
1838	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1839		return out, metadata, &smithy.SerializationError{Err: err}
1840	}
1841
1842	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1843		return out, metadata, &smithy.SerializationError{Err: err}
1844	}
1845	in.Request = request
1846
1847	return next.HandleSerialize(ctx, in)
1848}
1849
1850type awsAwsjson11_serializeOpDescribeSMBFileShares struct {
1851}
1852
1853func (*awsAwsjson11_serializeOpDescribeSMBFileShares) ID() string {
1854	return "OperationSerializer"
1855}
1856
1857func (m *awsAwsjson11_serializeOpDescribeSMBFileShares) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1858	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1859) {
1860	request, ok := in.Request.(*smithyhttp.Request)
1861	if !ok {
1862		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1863	}
1864
1865	input, ok := in.Parameters.(*DescribeSMBFileSharesInput)
1866	_ = input
1867	if !ok {
1868		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1869	}
1870
1871	request.Request.URL.Path = "/"
1872	request.Request.Method = "POST"
1873	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1874	if err != nil {
1875		return out, metadata, &smithy.SerializationError{Err: err}
1876	}
1877	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1878	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeSMBFileShares")
1879
1880	jsonEncoder := smithyjson.NewEncoder()
1881	if err := awsAwsjson11_serializeOpDocumentDescribeSMBFileSharesInput(input, jsonEncoder.Value); err != nil {
1882		return out, metadata, &smithy.SerializationError{Err: err}
1883	}
1884
1885	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1886		return out, metadata, &smithy.SerializationError{Err: err}
1887	}
1888
1889	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1890		return out, metadata, &smithy.SerializationError{Err: err}
1891	}
1892	in.Request = request
1893
1894	return next.HandleSerialize(ctx, in)
1895}
1896
1897type awsAwsjson11_serializeOpDescribeSMBSettings struct {
1898}
1899
1900func (*awsAwsjson11_serializeOpDescribeSMBSettings) ID() string {
1901	return "OperationSerializer"
1902}
1903
1904func (m *awsAwsjson11_serializeOpDescribeSMBSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1905	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1906) {
1907	request, ok := in.Request.(*smithyhttp.Request)
1908	if !ok {
1909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1910	}
1911
1912	input, ok := in.Parameters.(*DescribeSMBSettingsInput)
1913	_ = input
1914	if !ok {
1915		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1916	}
1917
1918	request.Request.URL.Path = "/"
1919	request.Request.Method = "POST"
1920	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1921	if err != nil {
1922		return out, metadata, &smithy.SerializationError{Err: err}
1923	}
1924	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1925	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeSMBSettings")
1926
1927	jsonEncoder := smithyjson.NewEncoder()
1928	if err := awsAwsjson11_serializeOpDocumentDescribeSMBSettingsInput(input, jsonEncoder.Value); err != nil {
1929		return out, metadata, &smithy.SerializationError{Err: err}
1930	}
1931
1932	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1933		return out, metadata, &smithy.SerializationError{Err: err}
1934	}
1935
1936	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1937		return out, metadata, &smithy.SerializationError{Err: err}
1938	}
1939	in.Request = request
1940
1941	return next.HandleSerialize(ctx, in)
1942}
1943
1944type awsAwsjson11_serializeOpDescribeSnapshotSchedule struct {
1945}
1946
1947func (*awsAwsjson11_serializeOpDescribeSnapshotSchedule) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsAwsjson11_serializeOpDescribeSnapshotSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1952	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1953) {
1954	request, ok := in.Request.(*smithyhttp.Request)
1955	if !ok {
1956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1957	}
1958
1959	input, ok := in.Parameters.(*DescribeSnapshotScheduleInput)
1960	_ = input
1961	if !ok {
1962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1963	}
1964
1965	request.Request.URL.Path = "/"
1966	request.Request.Method = "POST"
1967	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1968	if err != nil {
1969		return out, metadata, &smithy.SerializationError{Err: err}
1970	}
1971	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1972	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeSnapshotSchedule")
1973
1974	jsonEncoder := smithyjson.NewEncoder()
1975	if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotScheduleInput(input, jsonEncoder.Value); err != nil {
1976		return out, metadata, &smithy.SerializationError{Err: err}
1977	}
1978
1979	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1980		return out, metadata, &smithy.SerializationError{Err: err}
1981	}
1982
1983	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1984		return out, metadata, &smithy.SerializationError{Err: err}
1985	}
1986	in.Request = request
1987
1988	return next.HandleSerialize(ctx, in)
1989}
1990
1991type awsAwsjson11_serializeOpDescribeStorediSCSIVolumes struct {
1992}
1993
1994func (*awsAwsjson11_serializeOpDescribeStorediSCSIVolumes) ID() string {
1995	return "OperationSerializer"
1996}
1997
1998func (m *awsAwsjson11_serializeOpDescribeStorediSCSIVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1999	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2000) {
2001	request, ok := in.Request.(*smithyhttp.Request)
2002	if !ok {
2003		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2004	}
2005
2006	input, ok := in.Parameters.(*DescribeStorediSCSIVolumesInput)
2007	_ = input
2008	if !ok {
2009		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2010	}
2011
2012	request.Request.URL.Path = "/"
2013	request.Request.Method = "POST"
2014	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2015	if err != nil {
2016		return out, metadata, &smithy.SerializationError{Err: err}
2017	}
2018	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2019	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeStorediSCSIVolumes")
2020
2021	jsonEncoder := smithyjson.NewEncoder()
2022	if err := awsAwsjson11_serializeOpDocumentDescribeStorediSCSIVolumesInput(input, jsonEncoder.Value); err != nil {
2023		return out, metadata, &smithy.SerializationError{Err: err}
2024	}
2025
2026	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2027		return out, metadata, &smithy.SerializationError{Err: err}
2028	}
2029
2030	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2031		return out, metadata, &smithy.SerializationError{Err: err}
2032	}
2033	in.Request = request
2034
2035	return next.HandleSerialize(ctx, in)
2036}
2037
2038type awsAwsjson11_serializeOpDescribeTapeArchives struct {
2039}
2040
2041func (*awsAwsjson11_serializeOpDescribeTapeArchives) ID() string {
2042	return "OperationSerializer"
2043}
2044
2045func (m *awsAwsjson11_serializeOpDescribeTapeArchives) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2046	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2047) {
2048	request, ok := in.Request.(*smithyhttp.Request)
2049	if !ok {
2050		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2051	}
2052
2053	input, ok := in.Parameters.(*DescribeTapeArchivesInput)
2054	_ = input
2055	if !ok {
2056		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2057	}
2058
2059	request.Request.URL.Path = "/"
2060	request.Request.Method = "POST"
2061	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2062	if err != nil {
2063		return out, metadata, &smithy.SerializationError{Err: err}
2064	}
2065	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2066	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeTapeArchives")
2067
2068	jsonEncoder := smithyjson.NewEncoder()
2069	if err := awsAwsjson11_serializeOpDocumentDescribeTapeArchivesInput(input, jsonEncoder.Value); err != nil {
2070		return out, metadata, &smithy.SerializationError{Err: err}
2071	}
2072
2073	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2074		return out, metadata, &smithy.SerializationError{Err: err}
2075	}
2076
2077	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2078		return out, metadata, &smithy.SerializationError{Err: err}
2079	}
2080	in.Request = request
2081
2082	return next.HandleSerialize(ctx, in)
2083}
2084
2085type awsAwsjson11_serializeOpDescribeTapeRecoveryPoints struct {
2086}
2087
2088func (*awsAwsjson11_serializeOpDescribeTapeRecoveryPoints) ID() string {
2089	return "OperationSerializer"
2090}
2091
2092func (m *awsAwsjson11_serializeOpDescribeTapeRecoveryPoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2093	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2094) {
2095	request, ok := in.Request.(*smithyhttp.Request)
2096	if !ok {
2097		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2098	}
2099
2100	input, ok := in.Parameters.(*DescribeTapeRecoveryPointsInput)
2101	_ = input
2102	if !ok {
2103		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2104	}
2105
2106	request.Request.URL.Path = "/"
2107	request.Request.Method = "POST"
2108	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2109	if err != nil {
2110		return out, metadata, &smithy.SerializationError{Err: err}
2111	}
2112	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2113	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeTapeRecoveryPoints")
2114
2115	jsonEncoder := smithyjson.NewEncoder()
2116	if err := awsAwsjson11_serializeOpDocumentDescribeTapeRecoveryPointsInput(input, jsonEncoder.Value); err != nil {
2117		return out, metadata, &smithy.SerializationError{Err: err}
2118	}
2119
2120	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2121		return out, metadata, &smithy.SerializationError{Err: err}
2122	}
2123
2124	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2125		return out, metadata, &smithy.SerializationError{Err: err}
2126	}
2127	in.Request = request
2128
2129	return next.HandleSerialize(ctx, in)
2130}
2131
2132type awsAwsjson11_serializeOpDescribeTapes struct {
2133}
2134
2135func (*awsAwsjson11_serializeOpDescribeTapes) ID() string {
2136	return "OperationSerializer"
2137}
2138
2139func (m *awsAwsjson11_serializeOpDescribeTapes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2140	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2141) {
2142	request, ok := in.Request.(*smithyhttp.Request)
2143	if !ok {
2144		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2145	}
2146
2147	input, ok := in.Parameters.(*DescribeTapesInput)
2148	_ = input
2149	if !ok {
2150		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2151	}
2152
2153	request.Request.URL.Path = "/"
2154	request.Request.Method = "POST"
2155	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2156	if err != nil {
2157		return out, metadata, &smithy.SerializationError{Err: err}
2158	}
2159	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2160	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeTapes")
2161
2162	jsonEncoder := smithyjson.NewEncoder()
2163	if err := awsAwsjson11_serializeOpDocumentDescribeTapesInput(input, jsonEncoder.Value); err != nil {
2164		return out, metadata, &smithy.SerializationError{Err: err}
2165	}
2166
2167	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2168		return out, metadata, &smithy.SerializationError{Err: err}
2169	}
2170
2171	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2172		return out, metadata, &smithy.SerializationError{Err: err}
2173	}
2174	in.Request = request
2175
2176	return next.HandleSerialize(ctx, in)
2177}
2178
2179type awsAwsjson11_serializeOpDescribeUploadBuffer struct {
2180}
2181
2182func (*awsAwsjson11_serializeOpDescribeUploadBuffer) ID() string {
2183	return "OperationSerializer"
2184}
2185
2186func (m *awsAwsjson11_serializeOpDescribeUploadBuffer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2187	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2188) {
2189	request, ok := in.Request.(*smithyhttp.Request)
2190	if !ok {
2191		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2192	}
2193
2194	input, ok := in.Parameters.(*DescribeUploadBufferInput)
2195	_ = input
2196	if !ok {
2197		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2198	}
2199
2200	request.Request.URL.Path = "/"
2201	request.Request.Method = "POST"
2202	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2203	if err != nil {
2204		return out, metadata, &smithy.SerializationError{Err: err}
2205	}
2206	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2207	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeUploadBuffer")
2208
2209	jsonEncoder := smithyjson.NewEncoder()
2210	if err := awsAwsjson11_serializeOpDocumentDescribeUploadBufferInput(input, jsonEncoder.Value); err != nil {
2211		return out, metadata, &smithy.SerializationError{Err: err}
2212	}
2213
2214	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2215		return out, metadata, &smithy.SerializationError{Err: err}
2216	}
2217
2218	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2219		return out, metadata, &smithy.SerializationError{Err: err}
2220	}
2221	in.Request = request
2222
2223	return next.HandleSerialize(ctx, in)
2224}
2225
2226type awsAwsjson11_serializeOpDescribeVTLDevices struct {
2227}
2228
2229func (*awsAwsjson11_serializeOpDescribeVTLDevices) ID() string {
2230	return "OperationSerializer"
2231}
2232
2233func (m *awsAwsjson11_serializeOpDescribeVTLDevices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2234	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2235) {
2236	request, ok := in.Request.(*smithyhttp.Request)
2237	if !ok {
2238		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2239	}
2240
2241	input, ok := in.Parameters.(*DescribeVTLDevicesInput)
2242	_ = input
2243	if !ok {
2244		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2245	}
2246
2247	request.Request.URL.Path = "/"
2248	request.Request.Method = "POST"
2249	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2250	if err != nil {
2251		return out, metadata, &smithy.SerializationError{Err: err}
2252	}
2253	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2254	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeVTLDevices")
2255
2256	jsonEncoder := smithyjson.NewEncoder()
2257	if err := awsAwsjson11_serializeOpDocumentDescribeVTLDevicesInput(input, jsonEncoder.Value); err != nil {
2258		return out, metadata, &smithy.SerializationError{Err: err}
2259	}
2260
2261	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2262		return out, metadata, &smithy.SerializationError{Err: err}
2263	}
2264
2265	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2266		return out, metadata, &smithy.SerializationError{Err: err}
2267	}
2268	in.Request = request
2269
2270	return next.HandleSerialize(ctx, in)
2271}
2272
2273type awsAwsjson11_serializeOpDescribeWorkingStorage struct {
2274}
2275
2276func (*awsAwsjson11_serializeOpDescribeWorkingStorage) ID() string {
2277	return "OperationSerializer"
2278}
2279
2280func (m *awsAwsjson11_serializeOpDescribeWorkingStorage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2281	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2282) {
2283	request, ok := in.Request.(*smithyhttp.Request)
2284	if !ok {
2285		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2286	}
2287
2288	input, ok := in.Parameters.(*DescribeWorkingStorageInput)
2289	_ = input
2290	if !ok {
2291		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2292	}
2293
2294	request.Request.URL.Path = "/"
2295	request.Request.Method = "POST"
2296	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2297	if err != nil {
2298		return out, metadata, &smithy.SerializationError{Err: err}
2299	}
2300	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2301	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DescribeWorkingStorage")
2302
2303	jsonEncoder := smithyjson.NewEncoder()
2304	if err := awsAwsjson11_serializeOpDocumentDescribeWorkingStorageInput(input, jsonEncoder.Value); err != nil {
2305		return out, metadata, &smithy.SerializationError{Err: err}
2306	}
2307
2308	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2309		return out, metadata, &smithy.SerializationError{Err: err}
2310	}
2311
2312	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2313		return out, metadata, &smithy.SerializationError{Err: err}
2314	}
2315	in.Request = request
2316
2317	return next.HandleSerialize(ctx, in)
2318}
2319
2320type awsAwsjson11_serializeOpDetachVolume struct {
2321}
2322
2323func (*awsAwsjson11_serializeOpDetachVolume) ID() string {
2324	return "OperationSerializer"
2325}
2326
2327func (m *awsAwsjson11_serializeOpDetachVolume) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2328	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2329) {
2330	request, ok := in.Request.(*smithyhttp.Request)
2331	if !ok {
2332		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2333	}
2334
2335	input, ok := in.Parameters.(*DetachVolumeInput)
2336	_ = input
2337	if !ok {
2338		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2339	}
2340
2341	request.Request.URL.Path = "/"
2342	request.Request.Method = "POST"
2343	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2344	if err != nil {
2345		return out, metadata, &smithy.SerializationError{Err: err}
2346	}
2347	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2348	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DetachVolume")
2349
2350	jsonEncoder := smithyjson.NewEncoder()
2351	if err := awsAwsjson11_serializeOpDocumentDetachVolumeInput(input, jsonEncoder.Value); err != nil {
2352		return out, metadata, &smithy.SerializationError{Err: err}
2353	}
2354
2355	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2356		return out, metadata, &smithy.SerializationError{Err: err}
2357	}
2358
2359	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2360		return out, metadata, &smithy.SerializationError{Err: err}
2361	}
2362	in.Request = request
2363
2364	return next.HandleSerialize(ctx, in)
2365}
2366
2367type awsAwsjson11_serializeOpDisableGateway struct {
2368}
2369
2370func (*awsAwsjson11_serializeOpDisableGateway) ID() string {
2371	return "OperationSerializer"
2372}
2373
2374func (m *awsAwsjson11_serializeOpDisableGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2375	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2376) {
2377	request, ok := in.Request.(*smithyhttp.Request)
2378	if !ok {
2379		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2380	}
2381
2382	input, ok := in.Parameters.(*DisableGatewayInput)
2383	_ = input
2384	if !ok {
2385		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2386	}
2387
2388	request.Request.URL.Path = "/"
2389	request.Request.Method = "POST"
2390	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2391	if err != nil {
2392		return out, metadata, &smithy.SerializationError{Err: err}
2393	}
2394	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2395	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DisableGateway")
2396
2397	jsonEncoder := smithyjson.NewEncoder()
2398	if err := awsAwsjson11_serializeOpDocumentDisableGatewayInput(input, jsonEncoder.Value); err != nil {
2399		return out, metadata, &smithy.SerializationError{Err: err}
2400	}
2401
2402	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2403		return out, metadata, &smithy.SerializationError{Err: err}
2404	}
2405
2406	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2407		return out, metadata, &smithy.SerializationError{Err: err}
2408	}
2409	in.Request = request
2410
2411	return next.HandleSerialize(ctx, in)
2412}
2413
2414type awsAwsjson11_serializeOpDisassociateFileSystem struct {
2415}
2416
2417func (*awsAwsjson11_serializeOpDisassociateFileSystem) ID() string {
2418	return "OperationSerializer"
2419}
2420
2421func (m *awsAwsjson11_serializeOpDisassociateFileSystem) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2422	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2423) {
2424	request, ok := in.Request.(*smithyhttp.Request)
2425	if !ok {
2426		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2427	}
2428
2429	input, ok := in.Parameters.(*DisassociateFileSystemInput)
2430	_ = input
2431	if !ok {
2432		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2433	}
2434
2435	request.Request.URL.Path = "/"
2436	request.Request.Method = "POST"
2437	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2438	if err != nil {
2439		return out, metadata, &smithy.SerializationError{Err: err}
2440	}
2441	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2442	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.DisassociateFileSystem")
2443
2444	jsonEncoder := smithyjson.NewEncoder()
2445	if err := awsAwsjson11_serializeOpDocumentDisassociateFileSystemInput(input, jsonEncoder.Value); err != nil {
2446		return out, metadata, &smithy.SerializationError{Err: err}
2447	}
2448
2449	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2450		return out, metadata, &smithy.SerializationError{Err: err}
2451	}
2452
2453	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2454		return out, metadata, &smithy.SerializationError{Err: err}
2455	}
2456	in.Request = request
2457
2458	return next.HandleSerialize(ctx, in)
2459}
2460
2461type awsAwsjson11_serializeOpJoinDomain struct {
2462}
2463
2464func (*awsAwsjson11_serializeOpJoinDomain) ID() string {
2465	return "OperationSerializer"
2466}
2467
2468func (m *awsAwsjson11_serializeOpJoinDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2469	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2470) {
2471	request, ok := in.Request.(*smithyhttp.Request)
2472	if !ok {
2473		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2474	}
2475
2476	input, ok := in.Parameters.(*JoinDomainInput)
2477	_ = input
2478	if !ok {
2479		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2480	}
2481
2482	request.Request.URL.Path = "/"
2483	request.Request.Method = "POST"
2484	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2485	if err != nil {
2486		return out, metadata, &smithy.SerializationError{Err: err}
2487	}
2488	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2489	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.JoinDomain")
2490
2491	jsonEncoder := smithyjson.NewEncoder()
2492	if err := awsAwsjson11_serializeOpDocumentJoinDomainInput(input, jsonEncoder.Value); err != nil {
2493		return out, metadata, &smithy.SerializationError{Err: err}
2494	}
2495
2496	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2497		return out, metadata, &smithy.SerializationError{Err: err}
2498	}
2499
2500	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2501		return out, metadata, &smithy.SerializationError{Err: err}
2502	}
2503	in.Request = request
2504
2505	return next.HandleSerialize(ctx, in)
2506}
2507
2508type awsAwsjson11_serializeOpListAutomaticTapeCreationPolicies struct {
2509}
2510
2511func (*awsAwsjson11_serializeOpListAutomaticTapeCreationPolicies) ID() string {
2512	return "OperationSerializer"
2513}
2514
2515func (m *awsAwsjson11_serializeOpListAutomaticTapeCreationPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2516	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2517) {
2518	request, ok := in.Request.(*smithyhttp.Request)
2519	if !ok {
2520		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2521	}
2522
2523	input, ok := in.Parameters.(*ListAutomaticTapeCreationPoliciesInput)
2524	_ = input
2525	if !ok {
2526		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2527	}
2528
2529	request.Request.URL.Path = "/"
2530	request.Request.Method = "POST"
2531	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2532	if err != nil {
2533		return out, metadata, &smithy.SerializationError{Err: err}
2534	}
2535	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2536	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListAutomaticTapeCreationPolicies")
2537
2538	jsonEncoder := smithyjson.NewEncoder()
2539	if err := awsAwsjson11_serializeOpDocumentListAutomaticTapeCreationPoliciesInput(input, jsonEncoder.Value); err != nil {
2540		return out, metadata, &smithy.SerializationError{Err: err}
2541	}
2542
2543	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2544		return out, metadata, &smithy.SerializationError{Err: err}
2545	}
2546
2547	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2548		return out, metadata, &smithy.SerializationError{Err: err}
2549	}
2550	in.Request = request
2551
2552	return next.HandleSerialize(ctx, in)
2553}
2554
2555type awsAwsjson11_serializeOpListFileShares struct {
2556}
2557
2558func (*awsAwsjson11_serializeOpListFileShares) ID() string {
2559	return "OperationSerializer"
2560}
2561
2562func (m *awsAwsjson11_serializeOpListFileShares) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2563	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2564) {
2565	request, ok := in.Request.(*smithyhttp.Request)
2566	if !ok {
2567		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2568	}
2569
2570	input, ok := in.Parameters.(*ListFileSharesInput)
2571	_ = input
2572	if !ok {
2573		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2574	}
2575
2576	request.Request.URL.Path = "/"
2577	request.Request.Method = "POST"
2578	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2579	if err != nil {
2580		return out, metadata, &smithy.SerializationError{Err: err}
2581	}
2582	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2583	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListFileShares")
2584
2585	jsonEncoder := smithyjson.NewEncoder()
2586	if err := awsAwsjson11_serializeOpDocumentListFileSharesInput(input, jsonEncoder.Value); err != nil {
2587		return out, metadata, &smithy.SerializationError{Err: err}
2588	}
2589
2590	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2591		return out, metadata, &smithy.SerializationError{Err: err}
2592	}
2593
2594	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2595		return out, metadata, &smithy.SerializationError{Err: err}
2596	}
2597	in.Request = request
2598
2599	return next.HandleSerialize(ctx, in)
2600}
2601
2602type awsAwsjson11_serializeOpListFileSystemAssociations struct {
2603}
2604
2605func (*awsAwsjson11_serializeOpListFileSystemAssociations) ID() string {
2606	return "OperationSerializer"
2607}
2608
2609func (m *awsAwsjson11_serializeOpListFileSystemAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2610	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2611) {
2612	request, ok := in.Request.(*smithyhttp.Request)
2613	if !ok {
2614		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2615	}
2616
2617	input, ok := in.Parameters.(*ListFileSystemAssociationsInput)
2618	_ = input
2619	if !ok {
2620		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2621	}
2622
2623	request.Request.URL.Path = "/"
2624	request.Request.Method = "POST"
2625	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2626	if err != nil {
2627		return out, metadata, &smithy.SerializationError{Err: err}
2628	}
2629	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2630	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListFileSystemAssociations")
2631
2632	jsonEncoder := smithyjson.NewEncoder()
2633	if err := awsAwsjson11_serializeOpDocumentListFileSystemAssociationsInput(input, jsonEncoder.Value); err != nil {
2634		return out, metadata, &smithy.SerializationError{Err: err}
2635	}
2636
2637	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2638		return out, metadata, &smithy.SerializationError{Err: err}
2639	}
2640
2641	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2642		return out, metadata, &smithy.SerializationError{Err: err}
2643	}
2644	in.Request = request
2645
2646	return next.HandleSerialize(ctx, in)
2647}
2648
2649type awsAwsjson11_serializeOpListGateways struct {
2650}
2651
2652func (*awsAwsjson11_serializeOpListGateways) ID() string {
2653	return "OperationSerializer"
2654}
2655
2656func (m *awsAwsjson11_serializeOpListGateways) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2657	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2658) {
2659	request, ok := in.Request.(*smithyhttp.Request)
2660	if !ok {
2661		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2662	}
2663
2664	input, ok := in.Parameters.(*ListGatewaysInput)
2665	_ = input
2666	if !ok {
2667		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2668	}
2669
2670	request.Request.URL.Path = "/"
2671	request.Request.Method = "POST"
2672	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2673	if err != nil {
2674		return out, metadata, &smithy.SerializationError{Err: err}
2675	}
2676	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2677	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListGateways")
2678
2679	jsonEncoder := smithyjson.NewEncoder()
2680	if err := awsAwsjson11_serializeOpDocumentListGatewaysInput(input, jsonEncoder.Value); err != nil {
2681		return out, metadata, &smithy.SerializationError{Err: err}
2682	}
2683
2684	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2685		return out, metadata, &smithy.SerializationError{Err: err}
2686	}
2687
2688	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2689		return out, metadata, &smithy.SerializationError{Err: err}
2690	}
2691	in.Request = request
2692
2693	return next.HandleSerialize(ctx, in)
2694}
2695
2696type awsAwsjson11_serializeOpListLocalDisks struct {
2697}
2698
2699func (*awsAwsjson11_serializeOpListLocalDisks) ID() string {
2700	return "OperationSerializer"
2701}
2702
2703func (m *awsAwsjson11_serializeOpListLocalDisks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2704	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2705) {
2706	request, ok := in.Request.(*smithyhttp.Request)
2707	if !ok {
2708		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2709	}
2710
2711	input, ok := in.Parameters.(*ListLocalDisksInput)
2712	_ = input
2713	if !ok {
2714		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2715	}
2716
2717	request.Request.URL.Path = "/"
2718	request.Request.Method = "POST"
2719	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2720	if err != nil {
2721		return out, metadata, &smithy.SerializationError{Err: err}
2722	}
2723	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2724	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListLocalDisks")
2725
2726	jsonEncoder := smithyjson.NewEncoder()
2727	if err := awsAwsjson11_serializeOpDocumentListLocalDisksInput(input, jsonEncoder.Value); err != nil {
2728		return out, metadata, &smithy.SerializationError{Err: err}
2729	}
2730
2731	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2732		return out, metadata, &smithy.SerializationError{Err: err}
2733	}
2734
2735	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2736		return out, metadata, &smithy.SerializationError{Err: err}
2737	}
2738	in.Request = request
2739
2740	return next.HandleSerialize(ctx, in)
2741}
2742
2743type awsAwsjson11_serializeOpListTagsForResource struct {
2744}
2745
2746func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
2747	return "OperationSerializer"
2748}
2749
2750func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2751	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2752) {
2753	request, ok := in.Request.(*smithyhttp.Request)
2754	if !ok {
2755		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2756	}
2757
2758	input, ok := in.Parameters.(*ListTagsForResourceInput)
2759	_ = input
2760	if !ok {
2761		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2762	}
2763
2764	request.Request.URL.Path = "/"
2765	request.Request.Method = "POST"
2766	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2767	if err != nil {
2768		return out, metadata, &smithy.SerializationError{Err: err}
2769	}
2770	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2771	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListTagsForResource")
2772
2773	jsonEncoder := smithyjson.NewEncoder()
2774	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
2775		return out, metadata, &smithy.SerializationError{Err: err}
2776	}
2777
2778	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2779		return out, metadata, &smithy.SerializationError{Err: err}
2780	}
2781
2782	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2783		return out, metadata, &smithy.SerializationError{Err: err}
2784	}
2785	in.Request = request
2786
2787	return next.HandleSerialize(ctx, in)
2788}
2789
2790type awsAwsjson11_serializeOpListTapePools struct {
2791}
2792
2793func (*awsAwsjson11_serializeOpListTapePools) ID() string {
2794	return "OperationSerializer"
2795}
2796
2797func (m *awsAwsjson11_serializeOpListTapePools) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2798	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2799) {
2800	request, ok := in.Request.(*smithyhttp.Request)
2801	if !ok {
2802		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2803	}
2804
2805	input, ok := in.Parameters.(*ListTapePoolsInput)
2806	_ = input
2807	if !ok {
2808		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2809	}
2810
2811	request.Request.URL.Path = "/"
2812	request.Request.Method = "POST"
2813	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2814	if err != nil {
2815		return out, metadata, &smithy.SerializationError{Err: err}
2816	}
2817	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2818	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListTapePools")
2819
2820	jsonEncoder := smithyjson.NewEncoder()
2821	if err := awsAwsjson11_serializeOpDocumentListTapePoolsInput(input, jsonEncoder.Value); err != nil {
2822		return out, metadata, &smithy.SerializationError{Err: err}
2823	}
2824
2825	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2826		return out, metadata, &smithy.SerializationError{Err: err}
2827	}
2828
2829	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2830		return out, metadata, &smithy.SerializationError{Err: err}
2831	}
2832	in.Request = request
2833
2834	return next.HandleSerialize(ctx, in)
2835}
2836
2837type awsAwsjson11_serializeOpListTapes struct {
2838}
2839
2840func (*awsAwsjson11_serializeOpListTapes) ID() string {
2841	return "OperationSerializer"
2842}
2843
2844func (m *awsAwsjson11_serializeOpListTapes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2845	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2846) {
2847	request, ok := in.Request.(*smithyhttp.Request)
2848	if !ok {
2849		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2850	}
2851
2852	input, ok := in.Parameters.(*ListTapesInput)
2853	_ = input
2854	if !ok {
2855		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2856	}
2857
2858	request.Request.URL.Path = "/"
2859	request.Request.Method = "POST"
2860	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2861	if err != nil {
2862		return out, metadata, &smithy.SerializationError{Err: err}
2863	}
2864	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2865	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListTapes")
2866
2867	jsonEncoder := smithyjson.NewEncoder()
2868	if err := awsAwsjson11_serializeOpDocumentListTapesInput(input, jsonEncoder.Value); err != nil {
2869		return out, metadata, &smithy.SerializationError{Err: err}
2870	}
2871
2872	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2873		return out, metadata, &smithy.SerializationError{Err: err}
2874	}
2875
2876	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2877		return out, metadata, &smithy.SerializationError{Err: err}
2878	}
2879	in.Request = request
2880
2881	return next.HandleSerialize(ctx, in)
2882}
2883
2884type awsAwsjson11_serializeOpListVolumeInitiators struct {
2885}
2886
2887func (*awsAwsjson11_serializeOpListVolumeInitiators) ID() string {
2888	return "OperationSerializer"
2889}
2890
2891func (m *awsAwsjson11_serializeOpListVolumeInitiators) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2892	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2893) {
2894	request, ok := in.Request.(*smithyhttp.Request)
2895	if !ok {
2896		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2897	}
2898
2899	input, ok := in.Parameters.(*ListVolumeInitiatorsInput)
2900	_ = input
2901	if !ok {
2902		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2903	}
2904
2905	request.Request.URL.Path = "/"
2906	request.Request.Method = "POST"
2907	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2908	if err != nil {
2909		return out, metadata, &smithy.SerializationError{Err: err}
2910	}
2911	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2912	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListVolumeInitiators")
2913
2914	jsonEncoder := smithyjson.NewEncoder()
2915	if err := awsAwsjson11_serializeOpDocumentListVolumeInitiatorsInput(input, jsonEncoder.Value); err != nil {
2916		return out, metadata, &smithy.SerializationError{Err: err}
2917	}
2918
2919	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2920		return out, metadata, &smithy.SerializationError{Err: err}
2921	}
2922
2923	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2924		return out, metadata, &smithy.SerializationError{Err: err}
2925	}
2926	in.Request = request
2927
2928	return next.HandleSerialize(ctx, in)
2929}
2930
2931type awsAwsjson11_serializeOpListVolumeRecoveryPoints struct {
2932}
2933
2934func (*awsAwsjson11_serializeOpListVolumeRecoveryPoints) ID() string {
2935	return "OperationSerializer"
2936}
2937
2938func (m *awsAwsjson11_serializeOpListVolumeRecoveryPoints) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2939	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2940) {
2941	request, ok := in.Request.(*smithyhttp.Request)
2942	if !ok {
2943		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2944	}
2945
2946	input, ok := in.Parameters.(*ListVolumeRecoveryPointsInput)
2947	_ = input
2948	if !ok {
2949		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2950	}
2951
2952	request.Request.URL.Path = "/"
2953	request.Request.Method = "POST"
2954	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2955	if err != nil {
2956		return out, metadata, &smithy.SerializationError{Err: err}
2957	}
2958	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2959	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListVolumeRecoveryPoints")
2960
2961	jsonEncoder := smithyjson.NewEncoder()
2962	if err := awsAwsjson11_serializeOpDocumentListVolumeRecoveryPointsInput(input, jsonEncoder.Value); err != nil {
2963		return out, metadata, &smithy.SerializationError{Err: err}
2964	}
2965
2966	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2967		return out, metadata, &smithy.SerializationError{Err: err}
2968	}
2969
2970	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2971		return out, metadata, &smithy.SerializationError{Err: err}
2972	}
2973	in.Request = request
2974
2975	return next.HandleSerialize(ctx, in)
2976}
2977
2978type awsAwsjson11_serializeOpListVolumes struct {
2979}
2980
2981func (*awsAwsjson11_serializeOpListVolumes) ID() string {
2982	return "OperationSerializer"
2983}
2984
2985func (m *awsAwsjson11_serializeOpListVolumes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2986	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2987) {
2988	request, ok := in.Request.(*smithyhttp.Request)
2989	if !ok {
2990		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2991	}
2992
2993	input, ok := in.Parameters.(*ListVolumesInput)
2994	_ = input
2995	if !ok {
2996		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2997	}
2998
2999	request.Request.URL.Path = "/"
3000	request.Request.Method = "POST"
3001	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3002	if err != nil {
3003		return out, metadata, &smithy.SerializationError{Err: err}
3004	}
3005	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3006	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ListVolumes")
3007
3008	jsonEncoder := smithyjson.NewEncoder()
3009	if err := awsAwsjson11_serializeOpDocumentListVolumesInput(input, jsonEncoder.Value); err != nil {
3010		return out, metadata, &smithy.SerializationError{Err: err}
3011	}
3012
3013	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3014		return out, metadata, &smithy.SerializationError{Err: err}
3015	}
3016
3017	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3018		return out, metadata, &smithy.SerializationError{Err: err}
3019	}
3020	in.Request = request
3021
3022	return next.HandleSerialize(ctx, in)
3023}
3024
3025type awsAwsjson11_serializeOpNotifyWhenUploaded struct {
3026}
3027
3028func (*awsAwsjson11_serializeOpNotifyWhenUploaded) ID() string {
3029	return "OperationSerializer"
3030}
3031
3032func (m *awsAwsjson11_serializeOpNotifyWhenUploaded) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3033	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3034) {
3035	request, ok := in.Request.(*smithyhttp.Request)
3036	if !ok {
3037		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3038	}
3039
3040	input, ok := in.Parameters.(*NotifyWhenUploadedInput)
3041	_ = input
3042	if !ok {
3043		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3044	}
3045
3046	request.Request.URL.Path = "/"
3047	request.Request.Method = "POST"
3048	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3049	if err != nil {
3050		return out, metadata, &smithy.SerializationError{Err: err}
3051	}
3052	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3053	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.NotifyWhenUploaded")
3054
3055	jsonEncoder := smithyjson.NewEncoder()
3056	if err := awsAwsjson11_serializeOpDocumentNotifyWhenUploadedInput(input, jsonEncoder.Value); err != nil {
3057		return out, metadata, &smithy.SerializationError{Err: err}
3058	}
3059
3060	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3061		return out, metadata, &smithy.SerializationError{Err: err}
3062	}
3063
3064	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3065		return out, metadata, &smithy.SerializationError{Err: err}
3066	}
3067	in.Request = request
3068
3069	return next.HandleSerialize(ctx, in)
3070}
3071
3072type awsAwsjson11_serializeOpRefreshCache struct {
3073}
3074
3075func (*awsAwsjson11_serializeOpRefreshCache) ID() string {
3076	return "OperationSerializer"
3077}
3078
3079func (m *awsAwsjson11_serializeOpRefreshCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3080	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3081) {
3082	request, ok := in.Request.(*smithyhttp.Request)
3083	if !ok {
3084		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3085	}
3086
3087	input, ok := in.Parameters.(*RefreshCacheInput)
3088	_ = input
3089	if !ok {
3090		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3091	}
3092
3093	request.Request.URL.Path = "/"
3094	request.Request.Method = "POST"
3095	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3096	if err != nil {
3097		return out, metadata, &smithy.SerializationError{Err: err}
3098	}
3099	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3100	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.RefreshCache")
3101
3102	jsonEncoder := smithyjson.NewEncoder()
3103	if err := awsAwsjson11_serializeOpDocumentRefreshCacheInput(input, jsonEncoder.Value); err != nil {
3104		return out, metadata, &smithy.SerializationError{Err: err}
3105	}
3106
3107	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3108		return out, metadata, &smithy.SerializationError{Err: err}
3109	}
3110
3111	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3112		return out, metadata, &smithy.SerializationError{Err: err}
3113	}
3114	in.Request = request
3115
3116	return next.HandleSerialize(ctx, in)
3117}
3118
3119type awsAwsjson11_serializeOpRemoveTagsFromResource struct {
3120}
3121
3122func (*awsAwsjson11_serializeOpRemoveTagsFromResource) ID() string {
3123	return "OperationSerializer"
3124}
3125
3126func (m *awsAwsjson11_serializeOpRemoveTagsFromResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3127	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3128) {
3129	request, ok := in.Request.(*smithyhttp.Request)
3130	if !ok {
3131		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3132	}
3133
3134	input, ok := in.Parameters.(*RemoveTagsFromResourceInput)
3135	_ = input
3136	if !ok {
3137		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3138	}
3139
3140	request.Request.URL.Path = "/"
3141	request.Request.Method = "POST"
3142	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3143	if err != nil {
3144		return out, metadata, &smithy.SerializationError{Err: err}
3145	}
3146	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3147	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.RemoveTagsFromResource")
3148
3149	jsonEncoder := smithyjson.NewEncoder()
3150	if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(input, jsonEncoder.Value); err != nil {
3151		return out, metadata, &smithy.SerializationError{Err: err}
3152	}
3153
3154	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3155		return out, metadata, &smithy.SerializationError{Err: err}
3156	}
3157
3158	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3159		return out, metadata, &smithy.SerializationError{Err: err}
3160	}
3161	in.Request = request
3162
3163	return next.HandleSerialize(ctx, in)
3164}
3165
3166type awsAwsjson11_serializeOpResetCache struct {
3167}
3168
3169func (*awsAwsjson11_serializeOpResetCache) ID() string {
3170	return "OperationSerializer"
3171}
3172
3173func (m *awsAwsjson11_serializeOpResetCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3174	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3175) {
3176	request, ok := in.Request.(*smithyhttp.Request)
3177	if !ok {
3178		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3179	}
3180
3181	input, ok := in.Parameters.(*ResetCacheInput)
3182	_ = input
3183	if !ok {
3184		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3185	}
3186
3187	request.Request.URL.Path = "/"
3188	request.Request.Method = "POST"
3189	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3190	if err != nil {
3191		return out, metadata, &smithy.SerializationError{Err: err}
3192	}
3193	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3194	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ResetCache")
3195
3196	jsonEncoder := smithyjson.NewEncoder()
3197	if err := awsAwsjson11_serializeOpDocumentResetCacheInput(input, jsonEncoder.Value); err != nil {
3198		return out, metadata, &smithy.SerializationError{Err: err}
3199	}
3200
3201	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3202		return out, metadata, &smithy.SerializationError{Err: err}
3203	}
3204
3205	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3206		return out, metadata, &smithy.SerializationError{Err: err}
3207	}
3208	in.Request = request
3209
3210	return next.HandleSerialize(ctx, in)
3211}
3212
3213type awsAwsjson11_serializeOpRetrieveTapeArchive struct {
3214}
3215
3216func (*awsAwsjson11_serializeOpRetrieveTapeArchive) ID() string {
3217	return "OperationSerializer"
3218}
3219
3220func (m *awsAwsjson11_serializeOpRetrieveTapeArchive) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3221	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3222) {
3223	request, ok := in.Request.(*smithyhttp.Request)
3224	if !ok {
3225		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3226	}
3227
3228	input, ok := in.Parameters.(*RetrieveTapeArchiveInput)
3229	_ = input
3230	if !ok {
3231		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3232	}
3233
3234	request.Request.URL.Path = "/"
3235	request.Request.Method = "POST"
3236	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3237	if err != nil {
3238		return out, metadata, &smithy.SerializationError{Err: err}
3239	}
3240	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3241	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.RetrieveTapeArchive")
3242
3243	jsonEncoder := smithyjson.NewEncoder()
3244	if err := awsAwsjson11_serializeOpDocumentRetrieveTapeArchiveInput(input, jsonEncoder.Value); err != nil {
3245		return out, metadata, &smithy.SerializationError{Err: err}
3246	}
3247
3248	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3249		return out, metadata, &smithy.SerializationError{Err: err}
3250	}
3251
3252	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3253		return out, metadata, &smithy.SerializationError{Err: err}
3254	}
3255	in.Request = request
3256
3257	return next.HandleSerialize(ctx, in)
3258}
3259
3260type awsAwsjson11_serializeOpRetrieveTapeRecoveryPoint struct {
3261}
3262
3263func (*awsAwsjson11_serializeOpRetrieveTapeRecoveryPoint) ID() string {
3264	return "OperationSerializer"
3265}
3266
3267func (m *awsAwsjson11_serializeOpRetrieveTapeRecoveryPoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3268	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3269) {
3270	request, ok := in.Request.(*smithyhttp.Request)
3271	if !ok {
3272		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3273	}
3274
3275	input, ok := in.Parameters.(*RetrieveTapeRecoveryPointInput)
3276	_ = input
3277	if !ok {
3278		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3279	}
3280
3281	request.Request.URL.Path = "/"
3282	request.Request.Method = "POST"
3283	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3284	if err != nil {
3285		return out, metadata, &smithy.SerializationError{Err: err}
3286	}
3287	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3288	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.RetrieveTapeRecoveryPoint")
3289
3290	jsonEncoder := smithyjson.NewEncoder()
3291	if err := awsAwsjson11_serializeOpDocumentRetrieveTapeRecoveryPointInput(input, jsonEncoder.Value); err != nil {
3292		return out, metadata, &smithy.SerializationError{Err: err}
3293	}
3294
3295	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3296		return out, metadata, &smithy.SerializationError{Err: err}
3297	}
3298
3299	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3300		return out, metadata, &smithy.SerializationError{Err: err}
3301	}
3302	in.Request = request
3303
3304	return next.HandleSerialize(ctx, in)
3305}
3306
3307type awsAwsjson11_serializeOpSetLocalConsolePassword struct {
3308}
3309
3310func (*awsAwsjson11_serializeOpSetLocalConsolePassword) ID() string {
3311	return "OperationSerializer"
3312}
3313
3314func (m *awsAwsjson11_serializeOpSetLocalConsolePassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3315	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3316) {
3317	request, ok := in.Request.(*smithyhttp.Request)
3318	if !ok {
3319		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3320	}
3321
3322	input, ok := in.Parameters.(*SetLocalConsolePasswordInput)
3323	_ = input
3324	if !ok {
3325		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3326	}
3327
3328	request.Request.URL.Path = "/"
3329	request.Request.Method = "POST"
3330	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3331	if err != nil {
3332		return out, metadata, &smithy.SerializationError{Err: err}
3333	}
3334	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3335	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.SetLocalConsolePassword")
3336
3337	jsonEncoder := smithyjson.NewEncoder()
3338	if err := awsAwsjson11_serializeOpDocumentSetLocalConsolePasswordInput(input, jsonEncoder.Value); err != nil {
3339		return out, metadata, &smithy.SerializationError{Err: err}
3340	}
3341
3342	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3343		return out, metadata, &smithy.SerializationError{Err: err}
3344	}
3345
3346	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3347		return out, metadata, &smithy.SerializationError{Err: err}
3348	}
3349	in.Request = request
3350
3351	return next.HandleSerialize(ctx, in)
3352}
3353
3354type awsAwsjson11_serializeOpSetSMBGuestPassword struct {
3355}
3356
3357func (*awsAwsjson11_serializeOpSetSMBGuestPassword) ID() string {
3358	return "OperationSerializer"
3359}
3360
3361func (m *awsAwsjson11_serializeOpSetSMBGuestPassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3362	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3363) {
3364	request, ok := in.Request.(*smithyhttp.Request)
3365	if !ok {
3366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3367	}
3368
3369	input, ok := in.Parameters.(*SetSMBGuestPasswordInput)
3370	_ = input
3371	if !ok {
3372		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3373	}
3374
3375	request.Request.URL.Path = "/"
3376	request.Request.Method = "POST"
3377	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3378	if err != nil {
3379		return out, metadata, &smithy.SerializationError{Err: err}
3380	}
3381	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3382	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.SetSMBGuestPassword")
3383
3384	jsonEncoder := smithyjson.NewEncoder()
3385	if err := awsAwsjson11_serializeOpDocumentSetSMBGuestPasswordInput(input, jsonEncoder.Value); err != nil {
3386		return out, metadata, &smithy.SerializationError{Err: err}
3387	}
3388
3389	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3390		return out, metadata, &smithy.SerializationError{Err: err}
3391	}
3392
3393	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3394		return out, metadata, &smithy.SerializationError{Err: err}
3395	}
3396	in.Request = request
3397
3398	return next.HandleSerialize(ctx, in)
3399}
3400
3401type awsAwsjson11_serializeOpShutdownGateway struct {
3402}
3403
3404func (*awsAwsjson11_serializeOpShutdownGateway) ID() string {
3405	return "OperationSerializer"
3406}
3407
3408func (m *awsAwsjson11_serializeOpShutdownGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3409	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3410) {
3411	request, ok := in.Request.(*smithyhttp.Request)
3412	if !ok {
3413		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3414	}
3415
3416	input, ok := in.Parameters.(*ShutdownGatewayInput)
3417	_ = input
3418	if !ok {
3419		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3420	}
3421
3422	request.Request.URL.Path = "/"
3423	request.Request.Method = "POST"
3424	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3425	if err != nil {
3426		return out, metadata, &smithy.SerializationError{Err: err}
3427	}
3428	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3429	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.ShutdownGateway")
3430
3431	jsonEncoder := smithyjson.NewEncoder()
3432	if err := awsAwsjson11_serializeOpDocumentShutdownGatewayInput(input, jsonEncoder.Value); err != nil {
3433		return out, metadata, &smithy.SerializationError{Err: err}
3434	}
3435
3436	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3437		return out, metadata, &smithy.SerializationError{Err: err}
3438	}
3439
3440	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3441		return out, metadata, &smithy.SerializationError{Err: err}
3442	}
3443	in.Request = request
3444
3445	return next.HandleSerialize(ctx, in)
3446}
3447
3448type awsAwsjson11_serializeOpStartAvailabilityMonitorTest struct {
3449}
3450
3451func (*awsAwsjson11_serializeOpStartAvailabilityMonitorTest) ID() string {
3452	return "OperationSerializer"
3453}
3454
3455func (m *awsAwsjson11_serializeOpStartAvailabilityMonitorTest) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3456	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3457) {
3458	request, ok := in.Request.(*smithyhttp.Request)
3459	if !ok {
3460		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3461	}
3462
3463	input, ok := in.Parameters.(*StartAvailabilityMonitorTestInput)
3464	_ = input
3465	if !ok {
3466		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3467	}
3468
3469	request.Request.URL.Path = "/"
3470	request.Request.Method = "POST"
3471	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3472	if err != nil {
3473		return out, metadata, &smithy.SerializationError{Err: err}
3474	}
3475	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3476	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.StartAvailabilityMonitorTest")
3477
3478	jsonEncoder := smithyjson.NewEncoder()
3479	if err := awsAwsjson11_serializeOpDocumentStartAvailabilityMonitorTestInput(input, jsonEncoder.Value); err != nil {
3480		return out, metadata, &smithy.SerializationError{Err: err}
3481	}
3482
3483	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3484		return out, metadata, &smithy.SerializationError{Err: err}
3485	}
3486
3487	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3488		return out, metadata, &smithy.SerializationError{Err: err}
3489	}
3490	in.Request = request
3491
3492	return next.HandleSerialize(ctx, in)
3493}
3494
3495type awsAwsjson11_serializeOpStartGateway struct {
3496}
3497
3498func (*awsAwsjson11_serializeOpStartGateway) ID() string {
3499	return "OperationSerializer"
3500}
3501
3502func (m *awsAwsjson11_serializeOpStartGateway) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3503	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3504) {
3505	request, ok := in.Request.(*smithyhttp.Request)
3506	if !ok {
3507		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3508	}
3509
3510	input, ok := in.Parameters.(*StartGatewayInput)
3511	_ = input
3512	if !ok {
3513		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3514	}
3515
3516	request.Request.URL.Path = "/"
3517	request.Request.Method = "POST"
3518	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3519	if err != nil {
3520		return out, metadata, &smithy.SerializationError{Err: err}
3521	}
3522	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3523	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.StartGateway")
3524
3525	jsonEncoder := smithyjson.NewEncoder()
3526	if err := awsAwsjson11_serializeOpDocumentStartGatewayInput(input, jsonEncoder.Value); err != nil {
3527		return out, metadata, &smithy.SerializationError{Err: err}
3528	}
3529
3530	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3531		return out, metadata, &smithy.SerializationError{Err: err}
3532	}
3533
3534	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3535		return out, metadata, &smithy.SerializationError{Err: err}
3536	}
3537	in.Request = request
3538
3539	return next.HandleSerialize(ctx, in)
3540}
3541
3542type awsAwsjson11_serializeOpUpdateAutomaticTapeCreationPolicy struct {
3543}
3544
3545func (*awsAwsjson11_serializeOpUpdateAutomaticTapeCreationPolicy) ID() string {
3546	return "OperationSerializer"
3547}
3548
3549func (m *awsAwsjson11_serializeOpUpdateAutomaticTapeCreationPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3550	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3551) {
3552	request, ok := in.Request.(*smithyhttp.Request)
3553	if !ok {
3554		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3555	}
3556
3557	input, ok := in.Parameters.(*UpdateAutomaticTapeCreationPolicyInput)
3558	_ = input
3559	if !ok {
3560		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3561	}
3562
3563	request.Request.URL.Path = "/"
3564	request.Request.Method = "POST"
3565	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3566	if err != nil {
3567		return out, metadata, &smithy.SerializationError{Err: err}
3568	}
3569	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3570	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")
3571
3572	jsonEncoder := smithyjson.NewEncoder()
3573	if err := awsAwsjson11_serializeOpDocumentUpdateAutomaticTapeCreationPolicyInput(input, jsonEncoder.Value); err != nil {
3574		return out, metadata, &smithy.SerializationError{Err: err}
3575	}
3576
3577	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3578		return out, metadata, &smithy.SerializationError{Err: err}
3579	}
3580
3581	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3582		return out, metadata, &smithy.SerializationError{Err: err}
3583	}
3584	in.Request = request
3585
3586	return next.HandleSerialize(ctx, in)
3587}
3588
3589type awsAwsjson11_serializeOpUpdateBandwidthRateLimit struct {
3590}
3591
3592func (*awsAwsjson11_serializeOpUpdateBandwidthRateLimit) ID() string {
3593	return "OperationSerializer"
3594}
3595
3596func (m *awsAwsjson11_serializeOpUpdateBandwidthRateLimit) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3597	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3598) {
3599	request, ok := in.Request.(*smithyhttp.Request)
3600	if !ok {
3601		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3602	}
3603
3604	input, ok := in.Parameters.(*UpdateBandwidthRateLimitInput)
3605	_ = input
3606	if !ok {
3607		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3608	}
3609
3610	request.Request.URL.Path = "/"
3611	request.Request.Method = "POST"
3612	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3613	if err != nil {
3614		return out, metadata, &smithy.SerializationError{Err: err}
3615	}
3616	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3617	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateBandwidthRateLimit")
3618
3619	jsonEncoder := smithyjson.NewEncoder()
3620	if err := awsAwsjson11_serializeOpDocumentUpdateBandwidthRateLimitInput(input, jsonEncoder.Value); err != nil {
3621		return out, metadata, &smithy.SerializationError{Err: err}
3622	}
3623
3624	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3625		return out, metadata, &smithy.SerializationError{Err: err}
3626	}
3627
3628	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3629		return out, metadata, &smithy.SerializationError{Err: err}
3630	}
3631	in.Request = request
3632
3633	return next.HandleSerialize(ctx, in)
3634}
3635
3636type awsAwsjson11_serializeOpUpdateBandwidthRateLimitSchedule struct {
3637}
3638
3639func (*awsAwsjson11_serializeOpUpdateBandwidthRateLimitSchedule) ID() string {
3640	return "OperationSerializer"
3641}
3642
3643func (m *awsAwsjson11_serializeOpUpdateBandwidthRateLimitSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3644	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3645) {
3646	request, ok := in.Request.(*smithyhttp.Request)
3647	if !ok {
3648		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3649	}
3650
3651	input, ok := in.Parameters.(*UpdateBandwidthRateLimitScheduleInput)
3652	_ = input
3653	if !ok {
3654		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3655	}
3656
3657	request.Request.URL.Path = "/"
3658	request.Request.Method = "POST"
3659	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3660	if err != nil {
3661		return out, metadata, &smithy.SerializationError{Err: err}
3662	}
3663	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3664	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")
3665
3666	jsonEncoder := smithyjson.NewEncoder()
3667	if err := awsAwsjson11_serializeOpDocumentUpdateBandwidthRateLimitScheduleInput(input, jsonEncoder.Value); err != nil {
3668		return out, metadata, &smithy.SerializationError{Err: err}
3669	}
3670
3671	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3672		return out, metadata, &smithy.SerializationError{Err: err}
3673	}
3674
3675	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3676		return out, metadata, &smithy.SerializationError{Err: err}
3677	}
3678	in.Request = request
3679
3680	return next.HandleSerialize(ctx, in)
3681}
3682
3683type awsAwsjson11_serializeOpUpdateChapCredentials struct {
3684}
3685
3686func (*awsAwsjson11_serializeOpUpdateChapCredentials) ID() string {
3687	return "OperationSerializer"
3688}
3689
3690func (m *awsAwsjson11_serializeOpUpdateChapCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3691	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3692) {
3693	request, ok := in.Request.(*smithyhttp.Request)
3694	if !ok {
3695		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3696	}
3697
3698	input, ok := in.Parameters.(*UpdateChapCredentialsInput)
3699	_ = input
3700	if !ok {
3701		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3702	}
3703
3704	request.Request.URL.Path = "/"
3705	request.Request.Method = "POST"
3706	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3707	if err != nil {
3708		return out, metadata, &smithy.SerializationError{Err: err}
3709	}
3710	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3711	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateChapCredentials")
3712
3713	jsonEncoder := smithyjson.NewEncoder()
3714	if err := awsAwsjson11_serializeOpDocumentUpdateChapCredentialsInput(input, jsonEncoder.Value); err != nil {
3715		return out, metadata, &smithy.SerializationError{Err: err}
3716	}
3717
3718	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3719		return out, metadata, &smithy.SerializationError{Err: err}
3720	}
3721
3722	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3723		return out, metadata, &smithy.SerializationError{Err: err}
3724	}
3725	in.Request = request
3726
3727	return next.HandleSerialize(ctx, in)
3728}
3729
3730type awsAwsjson11_serializeOpUpdateFileSystemAssociation struct {
3731}
3732
3733func (*awsAwsjson11_serializeOpUpdateFileSystemAssociation) ID() string {
3734	return "OperationSerializer"
3735}
3736
3737func (m *awsAwsjson11_serializeOpUpdateFileSystemAssociation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3738	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3739) {
3740	request, ok := in.Request.(*smithyhttp.Request)
3741	if !ok {
3742		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3743	}
3744
3745	input, ok := in.Parameters.(*UpdateFileSystemAssociationInput)
3746	_ = input
3747	if !ok {
3748		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3749	}
3750
3751	request.Request.URL.Path = "/"
3752	request.Request.Method = "POST"
3753	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3754	if err != nil {
3755		return out, metadata, &smithy.SerializationError{Err: err}
3756	}
3757	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3758	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateFileSystemAssociation")
3759
3760	jsonEncoder := smithyjson.NewEncoder()
3761	if err := awsAwsjson11_serializeOpDocumentUpdateFileSystemAssociationInput(input, jsonEncoder.Value); err != nil {
3762		return out, metadata, &smithy.SerializationError{Err: err}
3763	}
3764
3765	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3766		return out, metadata, &smithy.SerializationError{Err: err}
3767	}
3768
3769	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3770		return out, metadata, &smithy.SerializationError{Err: err}
3771	}
3772	in.Request = request
3773
3774	return next.HandleSerialize(ctx, in)
3775}
3776
3777type awsAwsjson11_serializeOpUpdateGatewayInformation struct {
3778}
3779
3780func (*awsAwsjson11_serializeOpUpdateGatewayInformation) ID() string {
3781	return "OperationSerializer"
3782}
3783
3784func (m *awsAwsjson11_serializeOpUpdateGatewayInformation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3785	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3786) {
3787	request, ok := in.Request.(*smithyhttp.Request)
3788	if !ok {
3789		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3790	}
3791
3792	input, ok := in.Parameters.(*UpdateGatewayInformationInput)
3793	_ = input
3794	if !ok {
3795		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3796	}
3797
3798	request.Request.URL.Path = "/"
3799	request.Request.Method = "POST"
3800	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3801	if err != nil {
3802		return out, metadata, &smithy.SerializationError{Err: err}
3803	}
3804	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3805	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateGatewayInformation")
3806
3807	jsonEncoder := smithyjson.NewEncoder()
3808	if err := awsAwsjson11_serializeOpDocumentUpdateGatewayInformationInput(input, jsonEncoder.Value); err != nil {
3809		return out, metadata, &smithy.SerializationError{Err: err}
3810	}
3811
3812	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3813		return out, metadata, &smithy.SerializationError{Err: err}
3814	}
3815
3816	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3817		return out, metadata, &smithy.SerializationError{Err: err}
3818	}
3819	in.Request = request
3820
3821	return next.HandleSerialize(ctx, in)
3822}
3823
3824type awsAwsjson11_serializeOpUpdateGatewaySoftwareNow struct {
3825}
3826
3827func (*awsAwsjson11_serializeOpUpdateGatewaySoftwareNow) ID() string {
3828	return "OperationSerializer"
3829}
3830
3831func (m *awsAwsjson11_serializeOpUpdateGatewaySoftwareNow) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3832	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3833) {
3834	request, ok := in.Request.(*smithyhttp.Request)
3835	if !ok {
3836		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3837	}
3838
3839	input, ok := in.Parameters.(*UpdateGatewaySoftwareNowInput)
3840	_ = input
3841	if !ok {
3842		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3843	}
3844
3845	request.Request.URL.Path = "/"
3846	request.Request.Method = "POST"
3847	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3848	if err != nil {
3849		return out, metadata, &smithy.SerializationError{Err: err}
3850	}
3851	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3852	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateGatewaySoftwareNow")
3853
3854	jsonEncoder := smithyjson.NewEncoder()
3855	if err := awsAwsjson11_serializeOpDocumentUpdateGatewaySoftwareNowInput(input, jsonEncoder.Value); err != nil {
3856		return out, metadata, &smithy.SerializationError{Err: err}
3857	}
3858
3859	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3860		return out, metadata, &smithy.SerializationError{Err: err}
3861	}
3862
3863	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3864		return out, metadata, &smithy.SerializationError{Err: err}
3865	}
3866	in.Request = request
3867
3868	return next.HandleSerialize(ctx, in)
3869}
3870
3871type awsAwsjson11_serializeOpUpdateMaintenanceStartTime struct {
3872}
3873
3874func (*awsAwsjson11_serializeOpUpdateMaintenanceStartTime) ID() string {
3875	return "OperationSerializer"
3876}
3877
3878func (m *awsAwsjson11_serializeOpUpdateMaintenanceStartTime) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3879	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3880) {
3881	request, ok := in.Request.(*smithyhttp.Request)
3882	if !ok {
3883		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3884	}
3885
3886	input, ok := in.Parameters.(*UpdateMaintenanceStartTimeInput)
3887	_ = input
3888	if !ok {
3889		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3890	}
3891
3892	request.Request.URL.Path = "/"
3893	request.Request.Method = "POST"
3894	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3895	if err != nil {
3896		return out, metadata, &smithy.SerializationError{Err: err}
3897	}
3898	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3899	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateMaintenanceStartTime")
3900
3901	jsonEncoder := smithyjson.NewEncoder()
3902	if err := awsAwsjson11_serializeOpDocumentUpdateMaintenanceStartTimeInput(input, jsonEncoder.Value); err != nil {
3903		return out, metadata, &smithy.SerializationError{Err: err}
3904	}
3905
3906	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3907		return out, metadata, &smithy.SerializationError{Err: err}
3908	}
3909
3910	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3911		return out, metadata, &smithy.SerializationError{Err: err}
3912	}
3913	in.Request = request
3914
3915	return next.HandleSerialize(ctx, in)
3916}
3917
3918type awsAwsjson11_serializeOpUpdateNFSFileShare struct {
3919}
3920
3921func (*awsAwsjson11_serializeOpUpdateNFSFileShare) ID() string {
3922	return "OperationSerializer"
3923}
3924
3925func (m *awsAwsjson11_serializeOpUpdateNFSFileShare) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3926	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3927) {
3928	request, ok := in.Request.(*smithyhttp.Request)
3929	if !ok {
3930		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3931	}
3932
3933	input, ok := in.Parameters.(*UpdateNFSFileShareInput)
3934	_ = input
3935	if !ok {
3936		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3937	}
3938
3939	request.Request.URL.Path = "/"
3940	request.Request.Method = "POST"
3941	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3942	if err != nil {
3943		return out, metadata, &smithy.SerializationError{Err: err}
3944	}
3945	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3946	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateNFSFileShare")
3947
3948	jsonEncoder := smithyjson.NewEncoder()
3949	if err := awsAwsjson11_serializeOpDocumentUpdateNFSFileShareInput(input, jsonEncoder.Value); err != nil {
3950		return out, metadata, &smithy.SerializationError{Err: err}
3951	}
3952
3953	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3954		return out, metadata, &smithy.SerializationError{Err: err}
3955	}
3956
3957	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3958		return out, metadata, &smithy.SerializationError{Err: err}
3959	}
3960	in.Request = request
3961
3962	return next.HandleSerialize(ctx, in)
3963}
3964
3965type awsAwsjson11_serializeOpUpdateSMBFileShare struct {
3966}
3967
3968func (*awsAwsjson11_serializeOpUpdateSMBFileShare) ID() string {
3969	return "OperationSerializer"
3970}
3971
3972func (m *awsAwsjson11_serializeOpUpdateSMBFileShare) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3973	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3974) {
3975	request, ok := in.Request.(*smithyhttp.Request)
3976	if !ok {
3977		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3978	}
3979
3980	input, ok := in.Parameters.(*UpdateSMBFileShareInput)
3981	_ = input
3982	if !ok {
3983		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3984	}
3985
3986	request.Request.URL.Path = "/"
3987	request.Request.Method = "POST"
3988	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3989	if err != nil {
3990		return out, metadata, &smithy.SerializationError{Err: err}
3991	}
3992	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3993	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateSMBFileShare")
3994
3995	jsonEncoder := smithyjson.NewEncoder()
3996	if err := awsAwsjson11_serializeOpDocumentUpdateSMBFileShareInput(input, jsonEncoder.Value); err != nil {
3997		return out, metadata, &smithy.SerializationError{Err: err}
3998	}
3999
4000	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4001		return out, metadata, &smithy.SerializationError{Err: err}
4002	}
4003
4004	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4005		return out, metadata, &smithy.SerializationError{Err: err}
4006	}
4007	in.Request = request
4008
4009	return next.HandleSerialize(ctx, in)
4010}
4011
4012type awsAwsjson11_serializeOpUpdateSMBFileShareVisibility struct {
4013}
4014
4015func (*awsAwsjson11_serializeOpUpdateSMBFileShareVisibility) ID() string {
4016	return "OperationSerializer"
4017}
4018
4019func (m *awsAwsjson11_serializeOpUpdateSMBFileShareVisibility) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4020	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4021) {
4022	request, ok := in.Request.(*smithyhttp.Request)
4023	if !ok {
4024		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4025	}
4026
4027	input, ok := in.Parameters.(*UpdateSMBFileShareVisibilityInput)
4028	_ = input
4029	if !ok {
4030		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4031	}
4032
4033	request.Request.URL.Path = "/"
4034	request.Request.Method = "POST"
4035	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4036	if err != nil {
4037		return out, metadata, &smithy.SerializationError{Err: err}
4038	}
4039	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4040	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateSMBFileShareVisibility")
4041
4042	jsonEncoder := smithyjson.NewEncoder()
4043	if err := awsAwsjson11_serializeOpDocumentUpdateSMBFileShareVisibilityInput(input, jsonEncoder.Value); err != nil {
4044		return out, metadata, &smithy.SerializationError{Err: err}
4045	}
4046
4047	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4048		return out, metadata, &smithy.SerializationError{Err: err}
4049	}
4050
4051	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4052		return out, metadata, &smithy.SerializationError{Err: err}
4053	}
4054	in.Request = request
4055
4056	return next.HandleSerialize(ctx, in)
4057}
4058
4059type awsAwsjson11_serializeOpUpdateSMBSecurityStrategy struct {
4060}
4061
4062func (*awsAwsjson11_serializeOpUpdateSMBSecurityStrategy) ID() string {
4063	return "OperationSerializer"
4064}
4065
4066func (m *awsAwsjson11_serializeOpUpdateSMBSecurityStrategy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4067	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4068) {
4069	request, ok := in.Request.(*smithyhttp.Request)
4070	if !ok {
4071		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4072	}
4073
4074	input, ok := in.Parameters.(*UpdateSMBSecurityStrategyInput)
4075	_ = input
4076	if !ok {
4077		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4078	}
4079
4080	request.Request.URL.Path = "/"
4081	request.Request.Method = "POST"
4082	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4083	if err != nil {
4084		return out, metadata, &smithy.SerializationError{Err: err}
4085	}
4086	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4087	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateSMBSecurityStrategy")
4088
4089	jsonEncoder := smithyjson.NewEncoder()
4090	if err := awsAwsjson11_serializeOpDocumentUpdateSMBSecurityStrategyInput(input, jsonEncoder.Value); err != nil {
4091		return out, metadata, &smithy.SerializationError{Err: err}
4092	}
4093
4094	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4095		return out, metadata, &smithy.SerializationError{Err: err}
4096	}
4097
4098	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4099		return out, metadata, &smithy.SerializationError{Err: err}
4100	}
4101	in.Request = request
4102
4103	return next.HandleSerialize(ctx, in)
4104}
4105
4106type awsAwsjson11_serializeOpUpdateSnapshotSchedule struct {
4107}
4108
4109func (*awsAwsjson11_serializeOpUpdateSnapshotSchedule) ID() string {
4110	return "OperationSerializer"
4111}
4112
4113func (m *awsAwsjson11_serializeOpUpdateSnapshotSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4114	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4115) {
4116	request, ok := in.Request.(*smithyhttp.Request)
4117	if !ok {
4118		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4119	}
4120
4121	input, ok := in.Parameters.(*UpdateSnapshotScheduleInput)
4122	_ = input
4123	if !ok {
4124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4125	}
4126
4127	request.Request.URL.Path = "/"
4128	request.Request.Method = "POST"
4129	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4130	if err != nil {
4131		return out, metadata, &smithy.SerializationError{Err: err}
4132	}
4133	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4134	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateSnapshotSchedule")
4135
4136	jsonEncoder := smithyjson.NewEncoder()
4137	if err := awsAwsjson11_serializeOpDocumentUpdateSnapshotScheduleInput(input, jsonEncoder.Value); err != nil {
4138		return out, metadata, &smithy.SerializationError{Err: err}
4139	}
4140
4141	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4142		return out, metadata, &smithy.SerializationError{Err: err}
4143	}
4144
4145	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4146		return out, metadata, &smithy.SerializationError{Err: err}
4147	}
4148	in.Request = request
4149
4150	return next.HandleSerialize(ctx, in)
4151}
4152
4153type awsAwsjson11_serializeOpUpdateVTLDeviceType struct {
4154}
4155
4156func (*awsAwsjson11_serializeOpUpdateVTLDeviceType) ID() string {
4157	return "OperationSerializer"
4158}
4159
4160func (m *awsAwsjson11_serializeOpUpdateVTLDeviceType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4161	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4162) {
4163	request, ok := in.Request.(*smithyhttp.Request)
4164	if !ok {
4165		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4166	}
4167
4168	input, ok := in.Parameters.(*UpdateVTLDeviceTypeInput)
4169	_ = input
4170	if !ok {
4171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4172	}
4173
4174	request.Request.URL.Path = "/"
4175	request.Request.Method = "POST"
4176	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4177	if err != nil {
4178		return out, metadata, &smithy.SerializationError{Err: err}
4179	}
4180	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4181	httpBindingEncoder.SetHeader("X-Amz-Target").String("StorageGateway_20130630.UpdateVTLDeviceType")
4182
4183	jsonEncoder := smithyjson.NewEncoder()
4184	if err := awsAwsjson11_serializeOpDocumentUpdateVTLDeviceTypeInput(input, jsonEncoder.Value); err != nil {
4185		return out, metadata, &smithy.SerializationError{Err: err}
4186	}
4187
4188	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4189		return out, metadata, &smithy.SerializationError{Err: err}
4190	}
4191
4192	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4193		return out, metadata, &smithy.SerializationError{Err: err}
4194	}
4195	in.Request = request
4196
4197	return next.HandleSerialize(ctx, in)
4198}
4199func awsAwsjson11_serializeDocumentAutomaticTapeCreationRule(v *types.AutomaticTapeCreationRule, value smithyjson.Value) error {
4200	object := value.Object()
4201	defer object.Close()
4202
4203	if v.MinimumNumTapes != nil {
4204		ok := object.Key("MinimumNumTapes")
4205		ok.Integer(*v.MinimumNumTapes)
4206	}
4207
4208	if v.PoolId != nil {
4209		ok := object.Key("PoolId")
4210		ok.String(*v.PoolId)
4211	}
4212
4213	if v.TapeBarcodePrefix != nil {
4214		ok := object.Key("TapeBarcodePrefix")
4215		ok.String(*v.TapeBarcodePrefix)
4216	}
4217
4218	if v.TapeSizeInBytes != nil {
4219		ok := object.Key("TapeSizeInBytes")
4220		ok.Long(*v.TapeSizeInBytes)
4221	}
4222
4223	if v.Worm {
4224		ok := object.Key("Worm")
4225		ok.Boolean(v.Worm)
4226	}
4227
4228	return nil
4229}
4230
4231func awsAwsjson11_serializeDocumentAutomaticTapeCreationRules(v []types.AutomaticTapeCreationRule, value smithyjson.Value) error {
4232	array := value.Array()
4233	defer array.Close()
4234
4235	for i := range v {
4236		av := array.Value()
4237		if err := awsAwsjson11_serializeDocumentAutomaticTapeCreationRule(&v[i], av); err != nil {
4238			return err
4239		}
4240	}
4241	return nil
4242}
4243
4244func awsAwsjson11_serializeDocumentBandwidthRateLimitInterval(v *types.BandwidthRateLimitInterval, value smithyjson.Value) error {
4245	object := value.Object()
4246	defer object.Close()
4247
4248	if v.AverageDownloadRateLimitInBitsPerSec != nil {
4249		ok := object.Key("AverageDownloadRateLimitInBitsPerSec")
4250		ok.Long(*v.AverageDownloadRateLimitInBitsPerSec)
4251	}
4252
4253	if v.AverageUploadRateLimitInBitsPerSec != nil {
4254		ok := object.Key("AverageUploadRateLimitInBitsPerSec")
4255		ok.Long(*v.AverageUploadRateLimitInBitsPerSec)
4256	}
4257
4258	if v.DaysOfWeek != nil {
4259		ok := object.Key("DaysOfWeek")
4260		if err := awsAwsjson11_serializeDocumentDaysOfWeek(v.DaysOfWeek, ok); err != nil {
4261			return err
4262		}
4263	}
4264
4265	if v.EndHourOfDay != nil {
4266		ok := object.Key("EndHourOfDay")
4267		ok.Integer(*v.EndHourOfDay)
4268	}
4269
4270	if v.EndMinuteOfHour != nil {
4271		ok := object.Key("EndMinuteOfHour")
4272		ok.Integer(*v.EndMinuteOfHour)
4273	}
4274
4275	if v.StartHourOfDay != nil {
4276		ok := object.Key("StartHourOfDay")
4277		ok.Integer(*v.StartHourOfDay)
4278	}
4279
4280	if v.StartMinuteOfHour != nil {
4281		ok := object.Key("StartMinuteOfHour")
4282		ok.Integer(*v.StartMinuteOfHour)
4283	}
4284
4285	return nil
4286}
4287
4288func awsAwsjson11_serializeDocumentBandwidthRateLimitIntervals(v []types.BandwidthRateLimitInterval, value smithyjson.Value) error {
4289	array := value.Array()
4290	defer array.Close()
4291
4292	for i := range v {
4293		av := array.Value()
4294		if err := awsAwsjson11_serializeDocumentBandwidthRateLimitInterval(&v[i], av); err != nil {
4295			return err
4296		}
4297	}
4298	return nil
4299}
4300
4301func awsAwsjson11_serializeDocumentCacheAttributes(v *types.CacheAttributes, value smithyjson.Value) error {
4302	object := value.Object()
4303	defer object.Close()
4304
4305	if v.CacheStaleTimeoutInSeconds != nil {
4306		ok := object.Key("CacheStaleTimeoutInSeconds")
4307		ok.Integer(*v.CacheStaleTimeoutInSeconds)
4308	}
4309
4310	return nil
4311}
4312
4313func awsAwsjson11_serializeDocumentDaysOfWeek(v []int32, value smithyjson.Value) error {
4314	array := value.Array()
4315	defer array.Close()
4316
4317	for i := range v {
4318		av := array.Value()
4319		av.Integer(v[i])
4320	}
4321	return nil
4322}
4323
4324func awsAwsjson11_serializeDocumentDiskIds(v []string, value smithyjson.Value) error {
4325	array := value.Array()
4326	defer array.Close()
4327
4328	for i := range v {
4329		av := array.Value()
4330		av.String(v[i])
4331	}
4332	return nil
4333}
4334
4335func awsAwsjson11_serializeDocumentFileShareARNList(v []string, value smithyjson.Value) error {
4336	array := value.Array()
4337	defer array.Close()
4338
4339	for i := range v {
4340		av := array.Value()
4341		av.String(v[i])
4342	}
4343	return nil
4344}
4345
4346func awsAwsjson11_serializeDocumentFileShareClientList(v []string, value smithyjson.Value) error {
4347	array := value.Array()
4348	defer array.Close()
4349
4350	for i := range v {
4351		av := array.Value()
4352		av.String(v[i])
4353	}
4354	return nil
4355}
4356
4357func awsAwsjson11_serializeDocumentFileSystemAssociationARNList(v []string, value smithyjson.Value) error {
4358	array := value.Array()
4359	defer array.Close()
4360
4361	for i := range v {
4362		av := array.Value()
4363		av.String(v[i])
4364	}
4365	return nil
4366}
4367
4368func awsAwsjson11_serializeDocumentFolderList(v []string, value smithyjson.Value) error {
4369	array := value.Array()
4370	defer array.Close()
4371
4372	for i := range v {
4373		av := array.Value()
4374		av.String(v[i])
4375	}
4376	return nil
4377}
4378
4379func awsAwsjson11_serializeDocumentHosts(v []string, value smithyjson.Value) error {
4380	array := value.Array()
4381	defer array.Close()
4382
4383	for i := range v {
4384		av := array.Value()
4385		av.String(v[i])
4386	}
4387	return nil
4388}
4389
4390func awsAwsjson11_serializeDocumentNFSFileShareDefaults(v *types.NFSFileShareDefaults, value smithyjson.Value) error {
4391	object := value.Object()
4392	defer object.Close()
4393
4394	if v.DirectoryMode != nil {
4395		ok := object.Key("DirectoryMode")
4396		ok.String(*v.DirectoryMode)
4397	}
4398
4399	if v.FileMode != nil {
4400		ok := object.Key("FileMode")
4401		ok.String(*v.FileMode)
4402	}
4403
4404	if v.GroupId != nil {
4405		ok := object.Key("GroupId")
4406		ok.Long(*v.GroupId)
4407	}
4408
4409	if v.OwnerId != nil {
4410		ok := object.Key("OwnerId")
4411		ok.Long(*v.OwnerId)
4412	}
4413
4414	return nil
4415}
4416
4417func awsAwsjson11_serializeDocumentPoolARNs(v []string, value smithyjson.Value) error {
4418	array := value.Array()
4419	defer array.Close()
4420
4421	for i := range v {
4422		av := array.Value()
4423		av.String(v[i])
4424	}
4425	return nil
4426}
4427
4428func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
4429	object := value.Object()
4430	defer object.Close()
4431
4432	if v.Key != nil {
4433		ok := object.Key("Key")
4434		ok.String(*v.Key)
4435	}
4436
4437	if v.Value != nil {
4438		ok := object.Key("Value")
4439		ok.String(*v.Value)
4440	}
4441
4442	return nil
4443}
4444
4445func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error {
4446	array := value.Array()
4447	defer array.Close()
4448
4449	for i := range v {
4450		av := array.Value()
4451		av.String(v[i])
4452	}
4453	return nil
4454}
4455
4456func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
4457	array := value.Array()
4458	defer array.Close()
4459
4460	for i := range v {
4461		av := array.Value()
4462		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
4463			return err
4464		}
4465	}
4466	return nil
4467}
4468
4469func awsAwsjson11_serializeDocumentTapeARNs(v []string, value smithyjson.Value) error {
4470	array := value.Array()
4471	defer array.Close()
4472
4473	for i := range v {
4474		av := array.Value()
4475		av.String(v[i])
4476	}
4477	return nil
4478}
4479
4480func awsAwsjson11_serializeDocumentUserList(v []string, value smithyjson.Value) error {
4481	array := value.Array()
4482	defer array.Close()
4483
4484	for i := range v {
4485		av := array.Value()
4486		av.String(v[i])
4487	}
4488	return nil
4489}
4490
4491func awsAwsjson11_serializeDocumentVolumeARNs(v []string, value smithyjson.Value) error {
4492	array := value.Array()
4493	defer array.Close()
4494
4495	for i := range v {
4496		av := array.Value()
4497		av.String(v[i])
4498	}
4499	return nil
4500}
4501
4502func awsAwsjson11_serializeDocumentVTLDeviceARNs(v []string, value smithyjson.Value) error {
4503	array := value.Array()
4504	defer array.Close()
4505
4506	for i := range v {
4507		av := array.Value()
4508		av.String(v[i])
4509	}
4510	return nil
4511}
4512
4513func awsAwsjson11_serializeOpDocumentActivateGatewayInput(v *ActivateGatewayInput, value smithyjson.Value) error {
4514	object := value.Object()
4515	defer object.Close()
4516
4517	if v.ActivationKey != nil {
4518		ok := object.Key("ActivationKey")
4519		ok.String(*v.ActivationKey)
4520	}
4521
4522	if v.GatewayName != nil {
4523		ok := object.Key("GatewayName")
4524		ok.String(*v.GatewayName)
4525	}
4526
4527	if v.GatewayRegion != nil {
4528		ok := object.Key("GatewayRegion")
4529		ok.String(*v.GatewayRegion)
4530	}
4531
4532	if v.GatewayTimezone != nil {
4533		ok := object.Key("GatewayTimezone")
4534		ok.String(*v.GatewayTimezone)
4535	}
4536
4537	if v.GatewayType != nil {
4538		ok := object.Key("GatewayType")
4539		ok.String(*v.GatewayType)
4540	}
4541
4542	if v.MediumChangerType != nil {
4543		ok := object.Key("MediumChangerType")
4544		ok.String(*v.MediumChangerType)
4545	}
4546
4547	if v.Tags != nil {
4548		ok := object.Key("Tags")
4549		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4550			return err
4551		}
4552	}
4553
4554	if v.TapeDriveType != nil {
4555		ok := object.Key("TapeDriveType")
4556		ok.String(*v.TapeDriveType)
4557	}
4558
4559	return nil
4560}
4561
4562func awsAwsjson11_serializeOpDocumentAddCacheInput(v *AddCacheInput, value smithyjson.Value) error {
4563	object := value.Object()
4564	defer object.Close()
4565
4566	if v.DiskIds != nil {
4567		ok := object.Key("DiskIds")
4568		if err := awsAwsjson11_serializeDocumentDiskIds(v.DiskIds, ok); err != nil {
4569			return err
4570		}
4571	}
4572
4573	if v.GatewayARN != nil {
4574		ok := object.Key("GatewayARN")
4575		ok.String(*v.GatewayARN)
4576	}
4577
4578	return nil
4579}
4580
4581func awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value smithyjson.Value) error {
4582	object := value.Object()
4583	defer object.Close()
4584
4585	if v.ResourceARN != nil {
4586		ok := object.Key("ResourceARN")
4587		ok.String(*v.ResourceARN)
4588	}
4589
4590	if v.Tags != nil {
4591		ok := object.Key("Tags")
4592		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4593			return err
4594		}
4595	}
4596
4597	return nil
4598}
4599
4600func awsAwsjson11_serializeOpDocumentAddUploadBufferInput(v *AddUploadBufferInput, value smithyjson.Value) error {
4601	object := value.Object()
4602	defer object.Close()
4603
4604	if v.DiskIds != nil {
4605		ok := object.Key("DiskIds")
4606		if err := awsAwsjson11_serializeDocumentDiskIds(v.DiskIds, ok); err != nil {
4607			return err
4608		}
4609	}
4610
4611	if v.GatewayARN != nil {
4612		ok := object.Key("GatewayARN")
4613		ok.String(*v.GatewayARN)
4614	}
4615
4616	return nil
4617}
4618
4619func awsAwsjson11_serializeOpDocumentAddWorkingStorageInput(v *AddWorkingStorageInput, value smithyjson.Value) error {
4620	object := value.Object()
4621	defer object.Close()
4622
4623	if v.DiskIds != nil {
4624		ok := object.Key("DiskIds")
4625		if err := awsAwsjson11_serializeDocumentDiskIds(v.DiskIds, ok); err != nil {
4626			return err
4627		}
4628	}
4629
4630	if v.GatewayARN != nil {
4631		ok := object.Key("GatewayARN")
4632		ok.String(*v.GatewayARN)
4633	}
4634
4635	return nil
4636}
4637
4638func awsAwsjson11_serializeOpDocumentAssignTapePoolInput(v *AssignTapePoolInput, value smithyjson.Value) error {
4639	object := value.Object()
4640	defer object.Close()
4641
4642	if v.BypassGovernanceRetention {
4643		ok := object.Key("BypassGovernanceRetention")
4644		ok.Boolean(v.BypassGovernanceRetention)
4645	}
4646
4647	if v.PoolId != nil {
4648		ok := object.Key("PoolId")
4649		ok.String(*v.PoolId)
4650	}
4651
4652	if v.TapeARN != nil {
4653		ok := object.Key("TapeARN")
4654		ok.String(*v.TapeARN)
4655	}
4656
4657	return nil
4658}
4659
4660func awsAwsjson11_serializeOpDocumentAssociateFileSystemInput(v *AssociateFileSystemInput, value smithyjson.Value) error {
4661	object := value.Object()
4662	defer object.Close()
4663
4664	if v.AuditDestinationARN != nil {
4665		ok := object.Key("AuditDestinationARN")
4666		ok.String(*v.AuditDestinationARN)
4667	}
4668
4669	if v.CacheAttributes != nil {
4670		ok := object.Key("CacheAttributes")
4671		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
4672			return err
4673		}
4674	}
4675
4676	if v.ClientToken != nil {
4677		ok := object.Key("ClientToken")
4678		ok.String(*v.ClientToken)
4679	}
4680
4681	if v.GatewayARN != nil {
4682		ok := object.Key("GatewayARN")
4683		ok.String(*v.GatewayARN)
4684	}
4685
4686	if v.LocationARN != nil {
4687		ok := object.Key("LocationARN")
4688		ok.String(*v.LocationARN)
4689	}
4690
4691	if v.Password != nil {
4692		ok := object.Key("Password")
4693		ok.String(*v.Password)
4694	}
4695
4696	if v.Tags != nil {
4697		ok := object.Key("Tags")
4698		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4699			return err
4700		}
4701	}
4702
4703	if v.UserName != nil {
4704		ok := object.Key("UserName")
4705		ok.String(*v.UserName)
4706	}
4707
4708	return nil
4709}
4710
4711func awsAwsjson11_serializeOpDocumentAttachVolumeInput(v *AttachVolumeInput, value smithyjson.Value) error {
4712	object := value.Object()
4713	defer object.Close()
4714
4715	if v.DiskId != nil {
4716		ok := object.Key("DiskId")
4717		ok.String(*v.DiskId)
4718	}
4719
4720	if v.GatewayARN != nil {
4721		ok := object.Key("GatewayARN")
4722		ok.String(*v.GatewayARN)
4723	}
4724
4725	if v.NetworkInterfaceId != nil {
4726		ok := object.Key("NetworkInterfaceId")
4727		ok.String(*v.NetworkInterfaceId)
4728	}
4729
4730	if v.TargetName != nil {
4731		ok := object.Key("TargetName")
4732		ok.String(*v.TargetName)
4733	}
4734
4735	if v.VolumeARN != nil {
4736		ok := object.Key("VolumeARN")
4737		ok.String(*v.VolumeARN)
4738	}
4739
4740	return nil
4741}
4742
4743func awsAwsjson11_serializeOpDocumentCancelArchivalInput(v *CancelArchivalInput, value smithyjson.Value) error {
4744	object := value.Object()
4745	defer object.Close()
4746
4747	if v.GatewayARN != nil {
4748		ok := object.Key("GatewayARN")
4749		ok.String(*v.GatewayARN)
4750	}
4751
4752	if v.TapeARN != nil {
4753		ok := object.Key("TapeARN")
4754		ok.String(*v.TapeARN)
4755	}
4756
4757	return nil
4758}
4759
4760func awsAwsjson11_serializeOpDocumentCancelRetrievalInput(v *CancelRetrievalInput, value smithyjson.Value) error {
4761	object := value.Object()
4762	defer object.Close()
4763
4764	if v.GatewayARN != nil {
4765		ok := object.Key("GatewayARN")
4766		ok.String(*v.GatewayARN)
4767	}
4768
4769	if v.TapeARN != nil {
4770		ok := object.Key("TapeARN")
4771		ok.String(*v.TapeARN)
4772	}
4773
4774	return nil
4775}
4776
4777func awsAwsjson11_serializeOpDocumentCreateCachediSCSIVolumeInput(v *CreateCachediSCSIVolumeInput, value smithyjson.Value) error {
4778	object := value.Object()
4779	defer object.Close()
4780
4781	if v.ClientToken != nil {
4782		ok := object.Key("ClientToken")
4783		ok.String(*v.ClientToken)
4784	}
4785
4786	if v.GatewayARN != nil {
4787		ok := object.Key("GatewayARN")
4788		ok.String(*v.GatewayARN)
4789	}
4790
4791	if v.KMSEncrypted != nil {
4792		ok := object.Key("KMSEncrypted")
4793		ok.Boolean(*v.KMSEncrypted)
4794	}
4795
4796	if v.KMSKey != nil {
4797		ok := object.Key("KMSKey")
4798		ok.String(*v.KMSKey)
4799	}
4800
4801	if v.NetworkInterfaceId != nil {
4802		ok := object.Key("NetworkInterfaceId")
4803		ok.String(*v.NetworkInterfaceId)
4804	}
4805
4806	if v.SnapshotId != nil {
4807		ok := object.Key("SnapshotId")
4808		ok.String(*v.SnapshotId)
4809	}
4810
4811	if v.SourceVolumeARN != nil {
4812		ok := object.Key("SourceVolumeARN")
4813		ok.String(*v.SourceVolumeARN)
4814	}
4815
4816	if v.Tags != nil {
4817		ok := object.Key("Tags")
4818		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4819			return err
4820		}
4821	}
4822
4823	if v.TargetName != nil {
4824		ok := object.Key("TargetName")
4825		ok.String(*v.TargetName)
4826	}
4827
4828	{
4829		ok := object.Key("VolumeSizeInBytes")
4830		ok.Long(v.VolumeSizeInBytes)
4831	}
4832
4833	return nil
4834}
4835
4836func awsAwsjson11_serializeOpDocumentCreateNFSFileShareInput(v *CreateNFSFileShareInput, value smithyjson.Value) error {
4837	object := value.Object()
4838	defer object.Close()
4839
4840	if v.CacheAttributes != nil {
4841		ok := object.Key("CacheAttributes")
4842		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
4843			return err
4844		}
4845	}
4846
4847	if v.ClientList != nil {
4848		ok := object.Key("ClientList")
4849		if err := awsAwsjson11_serializeDocumentFileShareClientList(v.ClientList, ok); err != nil {
4850			return err
4851		}
4852	}
4853
4854	if v.ClientToken != nil {
4855		ok := object.Key("ClientToken")
4856		ok.String(*v.ClientToken)
4857	}
4858
4859	if v.DefaultStorageClass != nil {
4860		ok := object.Key("DefaultStorageClass")
4861		ok.String(*v.DefaultStorageClass)
4862	}
4863
4864	if v.FileShareName != nil {
4865		ok := object.Key("FileShareName")
4866		ok.String(*v.FileShareName)
4867	}
4868
4869	if v.GatewayARN != nil {
4870		ok := object.Key("GatewayARN")
4871		ok.String(*v.GatewayARN)
4872	}
4873
4874	if v.GuessMIMETypeEnabled != nil {
4875		ok := object.Key("GuessMIMETypeEnabled")
4876		ok.Boolean(*v.GuessMIMETypeEnabled)
4877	}
4878
4879	if v.KMSEncrypted != nil {
4880		ok := object.Key("KMSEncrypted")
4881		ok.Boolean(*v.KMSEncrypted)
4882	}
4883
4884	if v.KMSKey != nil {
4885		ok := object.Key("KMSKey")
4886		ok.String(*v.KMSKey)
4887	}
4888
4889	if v.LocationARN != nil {
4890		ok := object.Key("LocationARN")
4891		ok.String(*v.LocationARN)
4892	}
4893
4894	if v.NFSFileShareDefaults != nil {
4895		ok := object.Key("NFSFileShareDefaults")
4896		if err := awsAwsjson11_serializeDocumentNFSFileShareDefaults(v.NFSFileShareDefaults, ok); err != nil {
4897			return err
4898		}
4899	}
4900
4901	if v.NotificationPolicy != nil {
4902		ok := object.Key("NotificationPolicy")
4903		ok.String(*v.NotificationPolicy)
4904	}
4905
4906	if len(v.ObjectACL) > 0 {
4907		ok := object.Key("ObjectACL")
4908		ok.String(string(v.ObjectACL))
4909	}
4910
4911	if v.ReadOnly != nil {
4912		ok := object.Key("ReadOnly")
4913		ok.Boolean(*v.ReadOnly)
4914	}
4915
4916	if v.RequesterPays != nil {
4917		ok := object.Key("RequesterPays")
4918		ok.Boolean(*v.RequesterPays)
4919	}
4920
4921	if v.Role != nil {
4922		ok := object.Key("Role")
4923		ok.String(*v.Role)
4924	}
4925
4926	if v.Squash != nil {
4927		ok := object.Key("Squash")
4928		ok.String(*v.Squash)
4929	}
4930
4931	if v.Tags != nil {
4932		ok := object.Key("Tags")
4933		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
4934			return err
4935		}
4936	}
4937
4938	return nil
4939}
4940
4941func awsAwsjson11_serializeOpDocumentCreateSMBFileShareInput(v *CreateSMBFileShareInput, value smithyjson.Value) error {
4942	object := value.Object()
4943	defer object.Close()
4944
4945	if v.AccessBasedEnumeration != nil {
4946		ok := object.Key("AccessBasedEnumeration")
4947		ok.Boolean(*v.AccessBasedEnumeration)
4948	}
4949
4950	if v.AdminUserList != nil {
4951		ok := object.Key("AdminUserList")
4952		if err := awsAwsjson11_serializeDocumentUserList(v.AdminUserList, ok); err != nil {
4953			return err
4954		}
4955	}
4956
4957	if v.AuditDestinationARN != nil {
4958		ok := object.Key("AuditDestinationARN")
4959		ok.String(*v.AuditDestinationARN)
4960	}
4961
4962	if v.Authentication != nil {
4963		ok := object.Key("Authentication")
4964		ok.String(*v.Authentication)
4965	}
4966
4967	if v.CacheAttributes != nil {
4968		ok := object.Key("CacheAttributes")
4969		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
4970			return err
4971		}
4972	}
4973
4974	if len(v.CaseSensitivity) > 0 {
4975		ok := object.Key("CaseSensitivity")
4976		ok.String(string(v.CaseSensitivity))
4977	}
4978
4979	if v.ClientToken != nil {
4980		ok := object.Key("ClientToken")
4981		ok.String(*v.ClientToken)
4982	}
4983
4984	if v.DefaultStorageClass != nil {
4985		ok := object.Key("DefaultStorageClass")
4986		ok.String(*v.DefaultStorageClass)
4987	}
4988
4989	if v.FileShareName != nil {
4990		ok := object.Key("FileShareName")
4991		ok.String(*v.FileShareName)
4992	}
4993
4994	if v.GatewayARN != nil {
4995		ok := object.Key("GatewayARN")
4996		ok.String(*v.GatewayARN)
4997	}
4998
4999	if v.GuessMIMETypeEnabled != nil {
5000		ok := object.Key("GuessMIMETypeEnabled")
5001		ok.Boolean(*v.GuessMIMETypeEnabled)
5002	}
5003
5004	if v.InvalidUserList != nil {
5005		ok := object.Key("InvalidUserList")
5006		if err := awsAwsjson11_serializeDocumentUserList(v.InvalidUserList, ok); err != nil {
5007			return err
5008		}
5009	}
5010
5011	if v.KMSEncrypted != nil {
5012		ok := object.Key("KMSEncrypted")
5013		ok.Boolean(*v.KMSEncrypted)
5014	}
5015
5016	if v.KMSKey != nil {
5017		ok := object.Key("KMSKey")
5018		ok.String(*v.KMSKey)
5019	}
5020
5021	if v.LocationARN != nil {
5022		ok := object.Key("LocationARN")
5023		ok.String(*v.LocationARN)
5024	}
5025
5026	if v.NotificationPolicy != nil {
5027		ok := object.Key("NotificationPolicy")
5028		ok.String(*v.NotificationPolicy)
5029	}
5030
5031	if len(v.ObjectACL) > 0 {
5032		ok := object.Key("ObjectACL")
5033		ok.String(string(v.ObjectACL))
5034	}
5035
5036	if v.ReadOnly != nil {
5037		ok := object.Key("ReadOnly")
5038		ok.Boolean(*v.ReadOnly)
5039	}
5040
5041	if v.RequesterPays != nil {
5042		ok := object.Key("RequesterPays")
5043		ok.Boolean(*v.RequesterPays)
5044	}
5045
5046	if v.Role != nil {
5047		ok := object.Key("Role")
5048		ok.String(*v.Role)
5049	}
5050
5051	if v.SMBACLEnabled != nil {
5052		ok := object.Key("SMBACLEnabled")
5053		ok.Boolean(*v.SMBACLEnabled)
5054	}
5055
5056	if v.Tags != nil {
5057		ok := object.Key("Tags")
5058		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5059			return err
5060		}
5061	}
5062
5063	if v.ValidUserList != nil {
5064		ok := object.Key("ValidUserList")
5065		if err := awsAwsjson11_serializeDocumentUserList(v.ValidUserList, ok); err != nil {
5066			return err
5067		}
5068	}
5069
5070	return nil
5071}
5072
5073func awsAwsjson11_serializeOpDocumentCreateSnapshotFromVolumeRecoveryPointInput(v *CreateSnapshotFromVolumeRecoveryPointInput, value smithyjson.Value) error {
5074	object := value.Object()
5075	defer object.Close()
5076
5077	if v.SnapshotDescription != nil {
5078		ok := object.Key("SnapshotDescription")
5079		ok.String(*v.SnapshotDescription)
5080	}
5081
5082	if v.Tags != nil {
5083		ok := object.Key("Tags")
5084		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5085			return err
5086		}
5087	}
5088
5089	if v.VolumeARN != nil {
5090		ok := object.Key("VolumeARN")
5091		ok.String(*v.VolumeARN)
5092	}
5093
5094	return nil
5095}
5096
5097func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error {
5098	object := value.Object()
5099	defer object.Close()
5100
5101	if v.SnapshotDescription != nil {
5102		ok := object.Key("SnapshotDescription")
5103		ok.String(*v.SnapshotDescription)
5104	}
5105
5106	if v.Tags != nil {
5107		ok := object.Key("Tags")
5108		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5109			return err
5110		}
5111	}
5112
5113	if v.VolumeARN != nil {
5114		ok := object.Key("VolumeARN")
5115		ok.String(*v.VolumeARN)
5116	}
5117
5118	return nil
5119}
5120
5121func awsAwsjson11_serializeOpDocumentCreateStorediSCSIVolumeInput(v *CreateStorediSCSIVolumeInput, value smithyjson.Value) error {
5122	object := value.Object()
5123	defer object.Close()
5124
5125	if v.DiskId != nil {
5126		ok := object.Key("DiskId")
5127		ok.String(*v.DiskId)
5128	}
5129
5130	if v.GatewayARN != nil {
5131		ok := object.Key("GatewayARN")
5132		ok.String(*v.GatewayARN)
5133	}
5134
5135	if v.KMSEncrypted != nil {
5136		ok := object.Key("KMSEncrypted")
5137		ok.Boolean(*v.KMSEncrypted)
5138	}
5139
5140	if v.KMSKey != nil {
5141		ok := object.Key("KMSKey")
5142		ok.String(*v.KMSKey)
5143	}
5144
5145	if v.NetworkInterfaceId != nil {
5146		ok := object.Key("NetworkInterfaceId")
5147		ok.String(*v.NetworkInterfaceId)
5148	}
5149
5150	{
5151		ok := object.Key("PreserveExistingData")
5152		ok.Boolean(v.PreserveExistingData)
5153	}
5154
5155	if v.SnapshotId != nil {
5156		ok := object.Key("SnapshotId")
5157		ok.String(*v.SnapshotId)
5158	}
5159
5160	if v.Tags != nil {
5161		ok := object.Key("Tags")
5162		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5163			return err
5164		}
5165	}
5166
5167	if v.TargetName != nil {
5168		ok := object.Key("TargetName")
5169		ok.String(*v.TargetName)
5170	}
5171
5172	return nil
5173}
5174
5175func awsAwsjson11_serializeOpDocumentCreateTapePoolInput(v *CreateTapePoolInput, value smithyjson.Value) error {
5176	object := value.Object()
5177	defer object.Close()
5178
5179	if v.PoolName != nil {
5180		ok := object.Key("PoolName")
5181		ok.String(*v.PoolName)
5182	}
5183
5184	if v.RetentionLockTimeInDays != nil {
5185		ok := object.Key("RetentionLockTimeInDays")
5186		ok.Integer(*v.RetentionLockTimeInDays)
5187	}
5188
5189	if len(v.RetentionLockType) > 0 {
5190		ok := object.Key("RetentionLockType")
5191		ok.String(string(v.RetentionLockType))
5192	}
5193
5194	if len(v.StorageClass) > 0 {
5195		ok := object.Key("StorageClass")
5196		ok.String(string(v.StorageClass))
5197	}
5198
5199	if v.Tags != nil {
5200		ok := object.Key("Tags")
5201		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5202			return err
5203		}
5204	}
5205
5206	return nil
5207}
5208
5209func awsAwsjson11_serializeOpDocumentCreateTapesInput(v *CreateTapesInput, value smithyjson.Value) error {
5210	object := value.Object()
5211	defer object.Close()
5212
5213	if v.ClientToken != nil {
5214		ok := object.Key("ClientToken")
5215		ok.String(*v.ClientToken)
5216	}
5217
5218	if v.GatewayARN != nil {
5219		ok := object.Key("GatewayARN")
5220		ok.String(*v.GatewayARN)
5221	}
5222
5223	if v.KMSEncrypted != nil {
5224		ok := object.Key("KMSEncrypted")
5225		ok.Boolean(*v.KMSEncrypted)
5226	}
5227
5228	if v.KMSKey != nil {
5229		ok := object.Key("KMSKey")
5230		ok.String(*v.KMSKey)
5231	}
5232
5233	if v.NumTapesToCreate != nil {
5234		ok := object.Key("NumTapesToCreate")
5235		ok.Integer(*v.NumTapesToCreate)
5236	}
5237
5238	if v.PoolId != nil {
5239		ok := object.Key("PoolId")
5240		ok.String(*v.PoolId)
5241	}
5242
5243	if v.Tags != nil {
5244		ok := object.Key("Tags")
5245		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5246			return err
5247		}
5248	}
5249
5250	if v.TapeBarcodePrefix != nil {
5251		ok := object.Key("TapeBarcodePrefix")
5252		ok.String(*v.TapeBarcodePrefix)
5253	}
5254
5255	if v.TapeSizeInBytes != nil {
5256		ok := object.Key("TapeSizeInBytes")
5257		ok.Long(*v.TapeSizeInBytes)
5258	}
5259
5260	if v.Worm {
5261		ok := object.Key("Worm")
5262		ok.Boolean(v.Worm)
5263	}
5264
5265	return nil
5266}
5267
5268func awsAwsjson11_serializeOpDocumentCreateTapeWithBarcodeInput(v *CreateTapeWithBarcodeInput, value smithyjson.Value) error {
5269	object := value.Object()
5270	defer object.Close()
5271
5272	if v.GatewayARN != nil {
5273		ok := object.Key("GatewayARN")
5274		ok.String(*v.GatewayARN)
5275	}
5276
5277	if v.KMSEncrypted != nil {
5278		ok := object.Key("KMSEncrypted")
5279		ok.Boolean(*v.KMSEncrypted)
5280	}
5281
5282	if v.KMSKey != nil {
5283		ok := object.Key("KMSKey")
5284		ok.String(*v.KMSKey)
5285	}
5286
5287	if v.PoolId != nil {
5288		ok := object.Key("PoolId")
5289		ok.String(*v.PoolId)
5290	}
5291
5292	if v.Tags != nil {
5293		ok := object.Key("Tags")
5294		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
5295			return err
5296		}
5297	}
5298
5299	if v.TapeBarcode != nil {
5300		ok := object.Key("TapeBarcode")
5301		ok.String(*v.TapeBarcode)
5302	}
5303
5304	if v.TapeSizeInBytes != nil {
5305		ok := object.Key("TapeSizeInBytes")
5306		ok.Long(*v.TapeSizeInBytes)
5307	}
5308
5309	if v.Worm {
5310		ok := object.Key("Worm")
5311		ok.Boolean(v.Worm)
5312	}
5313
5314	return nil
5315}
5316
5317func awsAwsjson11_serializeOpDocumentDeleteAutomaticTapeCreationPolicyInput(v *DeleteAutomaticTapeCreationPolicyInput, value smithyjson.Value) error {
5318	object := value.Object()
5319	defer object.Close()
5320
5321	if v.GatewayARN != nil {
5322		ok := object.Key("GatewayARN")
5323		ok.String(*v.GatewayARN)
5324	}
5325
5326	return nil
5327}
5328
5329func awsAwsjson11_serializeOpDocumentDeleteBandwidthRateLimitInput(v *DeleteBandwidthRateLimitInput, value smithyjson.Value) error {
5330	object := value.Object()
5331	defer object.Close()
5332
5333	if v.BandwidthType != nil {
5334		ok := object.Key("BandwidthType")
5335		ok.String(*v.BandwidthType)
5336	}
5337
5338	if v.GatewayARN != nil {
5339		ok := object.Key("GatewayARN")
5340		ok.String(*v.GatewayARN)
5341	}
5342
5343	return nil
5344}
5345
5346func awsAwsjson11_serializeOpDocumentDeleteChapCredentialsInput(v *DeleteChapCredentialsInput, value smithyjson.Value) error {
5347	object := value.Object()
5348	defer object.Close()
5349
5350	if v.InitiatorName != nil {
5351		ok := object.Key("InitiatorName")
5352		ok.String(*v.InitiatorName)
5353	}
5354
5355	if v.TargetARN != nil {
5356		ok := object.Key("TargetARN")
5357		ok.String(*v.TargetARN)
5358	}
5359
5360	return nil
5361}
5362
5363func awsAwsjson11_serializeOpDocumentDeleteFileShareInput(v *DeleteFileShareInput, value smithyjson.Value) error {
5364	object := value.Object()
5365	defer object.Close()
5366
5367	if v.FileShareARN != nil {
5368		ok := object.Key("FileShareARN")
5369		ok.String(*v.FileShareARN)
5370	}
5371
5372	if v.ForceDelete {
5373		ok := object.Key("ForceDelete")
5374		ok.Boolean(v.ForceDelete)
5375	}
5376
5377	return nil
5378}
5379
5380func awsAwsjson11_serializeOpDocumentDeleteGatewayInput(v *DeleteGatewayInput, value smithyjson.Value) error {
5381	object := value.Object()
5382	defer object.Close()
5383
5384	if v.GatewayARN != nil {
5385		ok := object.Key("GatewayARN")
5386		ok.String(*v.GatewayARN)
5387	}
5388
5389	return nil
5390}
5391
5392func awsAwsjson11_serializeOpDocumentDeleteSnapshotScheduleInput(v *DeleteSnapshotScheduleInput, value smithyjson.Value) error {
5393	object := value.Object()
5394	defer object.Close()
5395
5396	if v.VolumeARN != nil {
5397		ok := object.Key("VolumeARN")
5398		ok.String(*v.VolumeARN)
5399	}
5400
5401	return nil
5402}
5403
5404func awsAwsjson11_serializeOpDocumentDeleteTapeArchiveInput(v *DeleteTapeArchiveInput, value smithyjson.Value) error {
5405	object := value.Object()
5406	defer object.Close()
5407
5408	if v.BypassGovernanceRetention {
5409		ok := object.Key("BypassGovernanceRetention")
5410		ok.Boolean(v.BypassGovernanceRetention)
5411	}
5412
5413	if v.TapeARN != nil {
5414		ok := object.Key("TapeARN")
5415		ok.String(*v.TapeARN)
5416	}
5417
5418	return nil
5419}
5420
5421func awsAwsjson11_serializeOpDocumentDeleteTapeInput(v *DeleteTapeInput, value smithyjson.Value) error {
5422	object := value.Object()
5423	defer object.Close()
5424
5425	if v.BypassGovernanceRetention {
5426		ok := object.Key("BypassGovernanceRetention")
5427		ok.Boolean(v.BypassGovernanceRetention)
5428	}
5429
5430	if v.GatewayARN != nil {
5431		ok := object.Key("GatewayARN")
5432		ok.String(*v.GatewayARN)
5433	}
5434
5435	if v.TapeARN != nil {
5436		ok := object.Key("TapeARN")
5437		ok.String(*v.TapeARN)
5438	}
5439
5440	return nil
5441}
5442
5443func awsAwsjson11_serializeOpDocumentDeleteTapePoolInput(v *DeleteTapePoolInput, value smithyjson.Value) error {
5444	object := value.Object()
5445	defer object.Close()
5446
5447	if v.PoolARN != nil {
5448		ok := object.Key("PoolARN")
5449		ok.String(*v.PoolARN)
5450	}
5451
5452	return nil
5453}
5454
5455func awsAwsjson11_serializeOpDocumentDeleteVolumeInput(v *DeleteVolumeInput, value smithyjson.Value) error {
5456	object := value.Object()
5457	defer object.Close()
5458
5459	if v.VolumeARN != nil {
5460		ok := object.Key("VolumeARN")
5461		ok.String(*v.VolumeARN)
5462	}
5463
5464	return nil
5465}
5466
5467func awsAwsjson11_serializeOpDocumentDescribeAvailabilityMonitorTestInput(v *DescribeAvailabilityMonitorTestInput, value smithyjson.Value) error {
5468	object := value.Object()
5469	defer object.Close()
5470
5471	if v.GatewayARN != nil {
5472		ok := object.Key("GatewayARN")
5473		ok.String(*v.GatewayARN)
5474	}
5475
5476	return nil
5477}
5478
5479func awsAwsjson11_serializeOpDocumentDescribeBandwidthRateLimitInput(v *DescribeBandwidthRateLimitInput, value smithyjson.Value) error {
5480	object := value.Object()
5481	defer object.Close()
5482
5483	if v.GatewayARN != nil {
5484		ok := object.Key("GatewayARN")
5485		ok.String(*v.GatewayARN)
5486	}
5487
5488	return nil
5489}
5490
5491func awsAwsjson11_serializeOpDocumentDescribeBandwidthRateLimitScheduleInput(v *DescribeBandwidthRateLimitScheduleInput, value smithyjson.Value) error {
5492	object := value.Object()
5493	defer object.Close()
5494
5495	if v.GatewayARN != nil {
5496		ok := object.Key("GatewayARN")
5497		ok.String(*v.GatewayARN)
5498	}
5499
5500	return nil
5501}
5502
5503func awsAwsjson11_serializeOpDocumentDescribeCachediSCSIVolumesInput(v *DescribeCachediSCSIVolumesInput, value smithyjson.Value) error {
5504	object := value.Object()
5505	defer object.Close()
5506
5507	if v.VolumeARNs != nil {
5508		ok := object.Key("VolumeARNs")
5509		if err := awsAwsjson11_serializeDocumentVolumeARNs(v.VolumeARNs, ok); err != nil {
5510			return err
5511		}
5512	}
5513
5514	return nil
5515}
5516
5517func awsAwsjson11_serializeOpDocumentDescribeCacheInput(v *DescribeCacheInput, value smithyjson.Value) error {
5518	object := value.Object()
5519	defer object.Close()
5520
5521	if v.GatewayARN != nil {
5522		ok := object.Key("GatewayARN")
5523		ok.String(*v.GatewayARN)
5524	}
5525
5526	return nil
5527}
5528
5529func awsAwsjson11_serializeOpDocumentDescribeChapCredentialsInput(v *DescribeChapCredentialsInput, value smithyjson.Value) error {
5530	object := value.Object()
5531	defer object.Close()
5532
5533	if v.TargetARN != nil {
5534		ok := object.Key("TargetARN")
5535		ok.String(*v.TargetARN)
5536	}
5537
5538	return nil
5539}
5540
5541func awsAwsjson11_serializeOpDocumentDescribeFileSystemAssociationsInput(v *DescribeFileSystemAssociationsInput, value smithyjson.Value) error {
5542	object := value.Object()
5543	defer object.Close()
5544
5545	if v.FileSystemAssociationARNList != nil {
5546		ok := object.Key("FileSystemAssociationARNList")
5547		if err := awsAwsjson11_serializeDocumentFileSystemAssociationARNList(v.FileSystemAssociationARNList, ok); err != nil {
5548			return err
5549		}
5550	}
5551
5552	return nil
5553}
5554
5555func awsAwsjson11_serializeOpDocumentDescribeGatewayInformationInput(v *DescribeGatewayInformationInput, value smithyjson.Value) error {
5556	object := value.Object()
5557	defer object.Close()
5558
5559	if v.GatewayARN != nil {
5560		ok := object.Key("GatewayARN")
5561		ok.String(*v.GatewayARN)
5562	}
5563
5564	return nil
5565}
5566
5567func awsAwsjson11_serializeOpDocumentDescribeMaintenanceStartTimeInput(v *DescribeMaintenanceStartTimeInput, value smithyjson.Value) error {
5568	object := value.Object()
5569	defer object.Close()
5570
5571	if v.GatewayARN != nil {
5572		ok := object.Key("GatewayARN")
5573		ok.String(*v.GatewayARN)
5574	}
5575
5576	return nil
5577}
5578
5579func awsAwsjson11_serializeOpDocumentDescribeNFSFileSharesInput(v *DescribeNFSFileSharesInput, value smithyjson.Value) error {
5580	object := value.Object()
5581	defer object.Close()
5582
5583	if v.FileShareARNList != nil {
5584		ok := object.Key("FileShareARNList")
5585		if err := awsAwsjson11_serializeDocumentFileShareARNList(v.FileShareARNList, ok); err != nil {
5586			return err
5587		}
5588	}
5589
5590	return nil
5591}
5592
5593func awsAwsjson11_serializeOpDocumentDescribeSMBFileSharesInput(v *DescribeSMBFileSharesInput, value smithyjson.Value) error {
5594	object := value.Object()
5595	defer object.Close()
5596
5597	if v.FileShareARNList != nil {
5598		ok := object.Key("FileShareARNList")
5599		if err := awsAwsjson11_serializeDocumentFileShareARNList(v.FileShareARNList, ok); err != nil {
5600			return err
5601		}
5602	}
5603
5604	return nil
5605}
5606
5607func awsAwsjson11_serializeOpDocumentDescribeSMBSettingsInput(v *DescribeSMBSettingsInput, value smithyjson.Value) error {
5608	object := value.Object()
5609	defer object.Close()
5610
5611	if v.GatewayARN != nil {
5612		ok := object.Key("GatewayARN")
5613		ok.String(*v.GatewayARN)
5614	}
5615
5616	return nil
5617}
5618
5619func awsAwsjson11_serializeOpDocumentDescribeSnapshotScheduleInput(v *DescribeSnapshotScheduleInput, value smithyjson.Value) error {
5620	object := value.Object()
5621	defer object.Close()
5622
5623	if v.VolumeARN != nil {
5624		ok := object.Key("VolumeARN")
5625		ok.String(*v.VolumeARN)
5626	}
5627
5628	return nil
5629}
5630
5631func awsAwsjson11_serializeOpDocumentDescribeStorediSCSIVolumesInput(v *DescribeStorediSCSIVolumesInput, value smithyjson.Value) error {
5632	object := value.Object()
5633	defer object.Close()
5634
5635	if v.VolumeARNs != nil {
5636		ok := object.Key("VolumeARNs")
5637		if err := awsAwsjson11_serializeDocumentVolumeARNs(v.VolumeARNs, ok); err != nil {
5638			return err
5639		}
5640	}
5641
5642	return nil
5643}
5644
5645func awsAwsjson11_serializeOpDocumentDescribeTapeArchivesInput(v *DescribeTapeArchivesInput, value smithyjson.Value) error {
5646	object := value.Object()
5647	defer object.Close()
5648
5649	if v.Limit != nil {
5650		ok := object.Key("Limit")
5651		ok.Integer(*v.Limit)
5652	}
5653
5654	if v.Marker != nil {
5655		ok := object.Key("Marker")
5656		ok.String(*v.Marker)
5657	}
5658
5659	if v.TapeARNs != nil {
5660		ok := object.Key("TapeARNs")
5661		if err := awsAwsjson11_serializeDocumentTapeARNs(v.TapeARNs, ok); err != nil {
5662			return err
5663		}
5664	}
5665
5666	return nil
5667}
5668
5669func awsAwsjson11_serializeOpDocumentDescribeTapeRecoveryPointsInput(v *DescribeTapeRecoveryPointsInput, value smithyjson.Value) error {
5670	object := value.Object()
5671	defer object.Close()
5672
5673	if v.GatewayARN != nil {
5674		ok := object.Key("GatewayARN")
5675		ok.String(*v.GatewayARN)
5676	}
5677
5678	if v.Limit != nil {
5679		ok := object.Key("Limit")
5680		ok.Integer(*v.Limit)
5681	}
5682
5683	if v.Marker != nil {
5684		ok := object.Key("Marker")
5685		ok.String(*v.Marker)
5686	}
5687
5688	return nil
5689}
5690
5691func awsAwsjson11_serializeOpDocumentDescribeTapesInput(v *DescribeTapesInput, value smithyjson.Value) error {
5692	object := value.Object()
5693	defer object.Close()
5694
5695	if v.GatewayARN != nil {
5696		ok := object.Key("GatewayARN")
5697		ok.String(*v.GatewayARN)
5698	}
5699
5700	if v.Limit != nil {
5701		ok := object.Key("Limit")
5702		ok.Integer(*v.Limit)
5703	}
5704
5705	if v.Marker != nil {
5706		ok := object.Key("Marker")
5707		ok.String(*v.Marker)
5708	}
5709
5710	if v.TapeARNs != nil {
5711		ok := object.Key("TapeARNs")
5712		if err := awsAwsjson11_serializeDocumentTapeARNs(v.TapeARNs, ok); err != nil {
5713			return err
5714		}
5715	}
5716
5717	return nil
5718}
5719
5720func awsAwsjson11_serializeOpDocumentDescribeUploadBufferInput(v *DescribeUploadBufferInput, value smithyjson.Value) error {
5721	object := value.Object()
5722	defer object.Close()
5723
5724	if v.GatewayARN != nil {
5725		ok := object.Key("GatewayARN")
5726		ok.String(*v.GatewayARN)
5727	}
5728
5729	return nil
5730}
5731
5732func awsAwsjson11_serializeOpDocumentDescribeVTLDevicesInput(v *DescribeVTLDevicesInput, value smithyjson.Value) error {
5733	object := value.Object()
5734	defer object.Close()
5735
5736	if v.GatewayARN != nil {
5737		ok := object.Key("GatewayARN")
5738		ok.String(*v.GatewayARN)
5739	}
5740
5741	if v.Limit != nil {
5742		ok := object.Key("Limit")
5743		ok.Integer(*v.Limit)
5744	}
5745
5746	if v.Marker != nil {
5747		ok := object.Key("Marker")
5748		ok.String(*v.Marker)
5749	}
5750
5751	if v.VTLDeviceARNs != nil {
5752		ok := object.Key("VTLDeviceARNs")
5753		if err := awsAwsjson11_serializeDocumentVTLDeviceARNs(v.VTLDeviceARNs, ok); err != nil {
5754			return err
5755		}
5756	}
5757
5758	return nil
5759}
5760
5761func awsAwsjson11_serializeOpDocumentDescribeWorkingStorageInput(v *DescribeWorkingStorageInput, value smithyjson.Value) error {
5762	object := value.Object()
5763	defer object.Close()
5764
5765	if v.GatewayARN != nil {
5766		ok := object.Key("GatewayARN")
5767		ok.String(*v.GatewayARN)
5768	}
5769
5770	return nil
5771}
5772
5773func awsAwsjson11_serializeOpDocumentDetachVolumeInput(v *DetachVolumeInput, value smithyjson.Value) error {
5774	object := value.Object()
5775	defer object.Close()
5776
5777	if v.ForceDetach != nil {
5778		ok := object.Key("ForceDetach")
5779		ok.Boolean(*v.ForceDetach)
5780	}
5781
5782	if v.VolumeARN != nil {
5783		ok := object.Key("VolumeARN")
5784		ok.String(*v.VolumeARN)
5785	}
5786
5787	return nil
5788}
5789
5790func awsAwsjson11_serializeOpDocumentDisableGatewayInput(v *DisableGatewayInput, value smithyjson.Value) error {
5791	object := value.Object()
5792	defer object.Close()
5793
5794	if v.GatewayARN != nil {
5795		ok := object.Key("GatewayARN")
5796		ok.String(*v.GatewayARN)
5797	}
5798
5799	return nil
5800}
5801
5802func awsAwsjson11_serializeOpDocumentDisassociateFileSystemInput(v *DisassociateFileSystemInput, value smithyjson.Value) error {
5803	object := value.Object()
5804	defer object.Close()
5805
5806	if v.FileSystemAssociationARN != nil {
5807		ok := object.Key("FileSystemAssociationARN")
5808		ok.String(*v.FileSystemAssociationARN)
5809	}
5810
5811	if v.ForceDelete {
5812		ok := object.Key("ForceDelete")
5813		ok.Boolean(v.ForceDelete)
5814	}
5815
5816	return nil
5817}
5818
5819func awsAwsjson11_serializeOpDocumentJoinDomainInput(v *JoinDomainInput, value smithyjson.Value) error {
5820	object := value.Object()
5821	defer object.Close()
5822
5823	if v.DomainControllers != nil {
5824		ok := object.Key("DomainControllers")
5825		if err := awsAwsjson11_serializeDocumentHosts(v.DomainControllers, ok); err != nil {
5826			return err
5827		}
5828	}
5829
5830	if v.DomainName != nil {
5831		ok := object.Key("DomainName")
5832		ok.String(*v.DomainName)
5833	}
5834
5835	if v.GatewayARN != nil {
5836		ok := object.Key("GatewayARN")
5837		ok.String(*v.GatewayARN)
5838	}
5839
5840	if v.OrganizationalUnit != nil {
5841		ok := object.Key("OrganizationalUnit")
5842		ok.String(*v.OrganizationalUnit)
5843	}
5844
5845	if v.Password != nil {
5846		ok := object.Key("Password")
5847		ok.String(*v.Password)
5848	}
5849
5850	if v.TimeoutInSeconds != nil {
5851		ok := object.Key("TimeoutInSeconds")
5852		ok.Integer(*v.TimeoutInSeconds)
5853	}
5854
5855	if v.UserName != nil {
5856		ok := object.Key("UserName")
5857		ok.String(*v.UserName)
5858	}
5859
5860	return nil
5861}
5862
5863func awsAwsjson11_serializeOpDocumentListAutomaticTapeCreationPoliciesInput(v *ListAutomaticTapeCreationPoliciesInput, value smithyjson.Value) error {
5864	object := value.Object()
5865	defer object.Close()
5866
5867	if v.GatewayARN != nil {
5868		ok := object.Key("GatewayARN")
5869		ok.String(*v.GatewayARN)
5870	}
5871
5872	return nil
5873}
5874
5875func awsAwsjson11_serializeOpDocumentListFileSharesInput(v *ListFileSharesInput, value smithyjson.Value) error {
5876	object := value.Object()
5877	defer object.Close()
5878
5879	if v.GatewayARN != nil {
5880		ok := object.Key("GatewayARN")
5881		ok.String(*v.GatewayARN)
5882	}
5883
5884	if v.Limit != nil {
5885		ok := object.Key("Limit")
5886		ok.Integer(*v.Limit)
5887	}
5888
5889	if v.Marker != nil {
5890		ok := object.Key("Marker")
5891		ok.String(*v.Marker)
5892	}
5893
5894	return nil
5895}
5896
5897func awsAwsjson11_serializeOpDocumentListFileSystemAssociationsInput(v *ListFileSystemAssociationsInput, value smithyjson.Value) error {
5898	object := value.Object()
5899	defer object.Close()
5900
5901	if v.GatewayARN != nil {
5902		ok := object.Key("GatewayARN")
5903		ok.String(*v.GatewayARN)
5904	}
5905
5906	if v.Limit != nil {
5907		ok := object.Key("Limit")
5908		ok.Integer(*v.Limit)
5909	}
5910
5911	if v.Marker != nil {
5912		ok := object.Key("Marker")
5913		ok.String(*v.Marker)
5914	}
5915
5916	return nil
5917}
5918
5919func awsAwsjson11_serializeOpDocumentListGatewaysInput(v *ListGatewaysInput, value smithyjson.Value) error {
5920	object := value.Object()
5921	defer object.Close()
5922
5923	if v.Limit != nil {
5924		ok := object.Key("Limit")
5925		ok.Integer(*v.Limit)
5926	}
5927
5928	if v.Marker != nil {
5929		ok := object.Key("Marker")
5930		ok.String(*v.Marker)
5931	}
5932
5933	return nil
5934}
5935
5936func awsAwsjson11_serializeOpDocumentListLocalDisksInput(v *ListLocalDisksInput, value smithyjson.Value) error {
5937	object := value.Object()
5938	defer object.Close()
5939
5940	if v.GatewayARN != nil {
5941		ok := object.Key("GatewayARN")
5942		ok.String(*v.GatewayARN)
5943	}
5944
5945	return nil
5946}
5947
5948func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
5949	object := value.Object()
5950	defer object.Close()
5951
5952	if v.Limit != nil {
5953		ok := object.Key("Limit")
5954		ok.Integer(*v.Limit)
5955	}
5956
5957	if v.Marker != nil {
5958		ok := object.Key("Marker")
5959		ok.String(*v.Marker)
5960	}
5961
5962	if v.ResourceARN != nil {
5963		ok := object.Key("ResourceARN")
5964		ok.String(*v.ResourceARN)
5965	}
5966
5967	return nil
5968}
5969
5970func awsAwsjson11_serializeOpDocumentListTapePoolsInput(v *ListTapePoolsInput, value smithyjson.Value) error {
5971	object := value.Object()
5972	defer object.Close()
5973
5974	if v.Limit != nil {
5975		ok := object.Key("Limit")
5976		ok.Integer(*v.Limit)
5977	}
5978
5979	if v.Marker != nil {
5980		ok := object.Key("Marker")
5981		ok.String(*v.Marker)
5982	}
5983
5984	if v.PoolARNs != nil {
5985		ok := object.Key("PoolARNs")
5986		if err := awsAwsjson11_serializeDocumentPoolARNs(v.PoolARNs, ok); err != nil {
5987			return err
5988		}
5989	}
5990
5991	return nil
5992}
5993
5994func awsAwsjson11_serializeOpDocumentListTapesInput(v *ListTapesInput, value smithyjson.Value) error {
5995	object := value.Object()
5996	defer object.Close()
5997
5998	if v.Limit != nil {
5999		ok := object.Key("Limit")
6000		ok.Integer(*v.Limit)
6001	}
6002
6003	if v.Marker != nil {
6004		ok := object.Key("Marker")
6005		ok.String(*v.Marker)
6006	}
6007
6008	if v.TapeARNs != nil {
6009		ok := object.Key("TapeARNs")
6010		if err := awsAwsjson11_serializeDocumentTapeARNs(v.TapeARNs, ok); err != nil {
6011			return err
6012		}
6013	}
6014
6015	return nil
6016}
6017
6018func awsAwsjson11_serializeOpDocumentListVolumeInitiatorsInput(v *ListVolumeInitiatorsInput, value smithyjson.Value) error {
6019	object := value.Object()
6020	defer object.Close()
6021
6022	if v.VolumeARN != nil {
6023		ok := object.Key("VolumeARN")
6024		ok.String(*v.VolumeARN)
6025	}
6026
6027	return nil
6028}
6029
6030func awsAwsjson11_serializeOpDocumentListVolumeRecoveryPointsInput(v *ListVolumeRecoveryPointsInput, value smithyjson.Value) error {
6031	object := value.Object()
6032	defer object.Close()
6033
6034	if v.GatewayARN != nil {
6035		ok := object.Key("GatewayARN")
6036		ok.String(*v.GatewayARN)
6037	}
6038
6039	return nil
6040}
6041
6042func awsAwsjson11_serializeOpDocumentListVolumesInput(v *ListVolumesInput, value smithyjson.Value) error {
6043	object := value.Object()
6044	defer object.Close()
6045
6046	if v.GatewayARN != nil {
6047		ok := object.Key("GatewayARN")
6048		ok.String(*v.GatewayARN)
6049	}
6050
6051	if v.Limit != nil {
6052		ok := object.Key("Limit")
6053		ok.Integer(*v.Limit)
6054	}
6055
6056	if v.Marker != nil {
6057		ok := object.Key("Marker")
6058		ok.String(*v.Marker)
6059	}
6060
6061	return nil
6062}
6063
6064func awsAwsjson11_serializeOpDocumentNotifyWhenUploadedInput(v *NotifyWhenUploadedInput, value smithyjson.Value) error {
6065	object := value.Object()
6066	defer object.Close()
6067
6068	if v.FileShareARN != nil {
6069		ok := object.Key("FileShareARN")
6070		ok.String(*v.FileShareARN)
6071	}
6072
6073	return nil
6074}
6075
6076func awsAwsjson11_serializeOpDocumentRefreshCacheInput(v *RefreshCacheInput, value smithyjson.Value) error {
6077	object := value.Object()
6078	defer object.Close()
6079
6080	if v.FileShareARN != nil {
6081		ok := object.Key("FileShareARN")
6082		ok.String(*v.FileShareARN)
6083	}
6084
6085	if v.FolderList != nil {
6086		ok := object.Key("FolderList")
6087		if err := awsAwsjson11_serializeDocumentFolderList(v.FolderList, ok); err != nil {
6088			return err
6089		}
6090	}
6091
6092	if v.Recursive != nil {
6093		ok := object.Key("Recursive")
6094		ok.Boolean(*v.Recursive)
6095	}
6096
6097	return nil
6098}
6099
6100func awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value smithyjson.Value) error {
6101	object := value.Object()
6102	defer object.Close()
6103
6104	if v.ResourceARN != nil {
6105		ok := object.Key("ResourceARN")
6106		ok.String(*v.ResourceARN)
6107	}
6108
6109	if v.TagKeys != nil {
6110		ok := object.Key("TagKeys")
6111		if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil {
6112			return err
6113		}
6114	}
6115
6116	return nil
6117}
6118
6119func awsAwsjson11_serializeOpDocumentResetCacheInput(v *ResetCacheInput, value smithyjson.Value) error {
6120	object := value.Object()
6121	defer object.Close()
6122
6123	if v.GatewayARN != nil {
6124		ok := object.Key("GatewayARN")
6125		ok.String(*v.GatewayARN)
6126	}
6127
6128	return nil
6129}
6130
6131func awsAwsjson11_serializeOpDocumentRetrieveTapeArchiveInput(v *RetrieveTapeArchiveInput, value smithyjson.Value) error {
6132	object := value.Object()
6133	defer object.Close()
6134
6135	if v.GatewayARN != nil {
6136		ok := object.Key("GatewayARN")
6137		ok.String(*v.GatewayARN)
6138	}
6139
6140	if v.TapeARN != nil {
6141		ok := object.Key("TapeARN")
6142		ok.String(*v.TapeARN)
6143	}
6144
6145	return nil
6146}
6147
6148func awsAwsjson11_serializeOpDocumentRetrieveTapeRecoveryPointInput(v *RetrieveTapeRecoveryPointInput, value smithyjson.Value) error {
6149	object := value.Object()
6150	defer object.Close()
6151
6152	if v.GatewayARN != nil {
6153		ok := object.Key("GatewayARN")
6154		ok.String(*v.GatewayARN)
6155	}
6156
6157	if v.TapeARN != nil {
6158		ok := object.Key("TapeARN")
6159		ok.String(*v.TapeARN)
6160	}
6161
6162	return nil
6163}
6164
6165func awsAwsjson11_serializeOpDocumentSetLocalConsolePasswordInput(v *SetLocalConsolePasswordInput, value smithyjson.Value) error {
6166	object := value.Object()
6167	defer object.Close()
6168
6169	if v.GatewayARN != nil {
6170		ok := object.Key("GatewayARN")
6171		ok.String(*v.GatewayARN)
6172	}
6173
6174	if v.LocalConsolePassword != nil {
6175		ok := object.Key("LocalConsolePassword")
6176		ok.String(*v.LocalConsolePassword)
6177	}
6178
6179	return nil
6180}
6181
6182func awsAwsjson11_serializeOpDocumentSetSMBGuestPasswordInput(v *SetSMBGuestPasswordInput, value smithyjson.Value) error {
6183	object := value.Object()
6184	defer object.Close()
6185
6186	if v.GatewayARN != nil {
6187		ok := object.Key("GatewayARN")
6188		ok.String(*v.GatewayARN)
6189	}
6190
6191	if v.Password != nil {
6192		ok := object.Key("Password")
6193		ok.String(*v.Password)
6194	}
6195
6196	return nil
6197}
6198
6199func awsAwsjson11_serializeOpDocumentShutdownGatewayInput(v *ShutdownGatewayInput, value smithyjson.Value) error {
6200	object := value.Object()
6201	defer object.Close()
6202
6203	if v.GatewayARN != nil {
6204		ok := object.Key("GatewayARN")
6205		ok.String(*v.GatewayARN)
6206	}
6207
6208	return nil
6209}
6210
6211func awsAwsjson11_serializeOpDocumentStartAvailabilityMonitorTestInput(v *StartAvailabilityMonitorTestInput, value smithyjson.Value) error {
6212	object := value.Object()
6213	defer object.Close()
6214
6215	if v.GatewayARN != nil {
6216		ok := object.Key("GatewayARN")
6217		ok.String(*v.GatewayARN)
6218	}
6219
6220	return nil
6221}
6222
6223func awsAwsjson11_serializeOpDocumentStartGatewayInput(v *StartGatewayInput, value smithyjson.Value) error {
6224	object := value.Object()
6225	defer object.Close()
6226
6227	if v.GatewayARN != nil {
6228		ok := object.Key("GatewayARN")
6229		ok.String(*v.GatewayARN)
6230	}
6231
6232	return nil
6233}
6234
6235func awsAwsjson11_serializeOpDocumentUpdateAutomaticTapeCreationPolicyInput(v *UpdateAutomaticTapeCreationPolicyInput, value smithyjson.Value) error {
6236	object := value.Object()
6237	defer object.Close()
6238
6239	if v.AutomaticTapeCreationRules != nil {
6240		ok := object.Key("AutomaticTapeCreationRules")
6241		if err := awsAwsjson11_serializeDocumentAutomaticTapeCreationRules(v.AutomaticTapeCreationRules, ok); err != nil {
6242			return err
6243		}
6244	}
6245
6246	if v.GatewayARN != nil {
6247		ok := object.Key("GatewayARN")
6248		ok.String(*v.GatewayARN)
6249	}
6250
6251	return nil
6252}
6253
6254func awsAwsjson11_serializeOpDocumentUpdateBandwidthRateLimitInput(v *UpdateBandwidthRateLimitInput, value smithyjson.Value) error {
6255	object := value.Object()
6256	defer object.Close()
6257
6258	if v.AverageDownloadRateLimitInBitsPerSec != nil {
6259		ok := object.Key("AverageDownloadRateLimitInBitsPerSec")
6260		ok.Long(*v.AverageDownloadRateLimitInBitsPerSec)
6261	}
6262
6263	if v.AverageUploadRateLimitInBitsPerSec != nil {
6264		ok := object.Key("AverageUploadRateLimitInBitsPerSec")
6265		ok.Long(*v.AverageUploadRateLimitInBitsPerSec)
6266	}
6267
6268	if v.GatewayARN != nil {
6269		ok := object.Key("GatewayARN")
6270		ok.String(*v.GatewayARN)
6271	}
6272
6273	return nil
6274}
6275
6276func awsAwsjson11_serializeOpDocumentUpdateBandwidthRateLimitScheduleInput(v *UpdateBandwidthRateLimitScheduleInput, value smithyjson.Value) error {
6277	object := value.Object()
6278	defer object.Close()
6279
6280	if v.BandwidthRateLimitIntervals != nil {
6281		ok := object.Key("BandwidthRateLimitIntervals")
6282		if err := awsAwsjson11_serializeDocumentBandwidthRateLimitIntervals(v.BandwidthRateLimitIntervals, ok); err != nil {
6283			return err
6284		}
6285	}
6286
6287	if v.GatewayARN != nil {
6288		ok := object.Key("GatewayARN")
6289		ok.String(*v.GatewayARN)
6290	}
6291
6292	return nil
6293}
6294
6295func awsAwsjson11_serializeOpDocumentUpdateChapCredentialsInput(v *UpdateChapCredentialsInput, value smithyjson.Value) error {
6296	object := value.Object()
6297	defer object.Close()
6298
6299	if v.InitiatorName != nil {
6300		ok := object.Key("InitiatorName")
6301		ok.String(*v.InitiatorName)
6302	}
6303
6304	if v.SecretToAuthenticateInitiator != nil {
6305		ok := object.Key("SecretToAuthenticateInitiator")
6306		ok.String(*v.SecretToAuthenticateInitiator)
6307	}
6308
6309	if v.SecretToAuthenticateTarget != nil {
6310		ok := object.Key("SecretToAuthenticateTarget")
6311		ok.String(*v.SecretToAuthenticateTarget)
6312	}
6313
6314	if v.TargetARN != nil {
6315		ok := object.Key("TargetARN")
6316		ok.String(*v.TargetARN)
6317	}
6318
6319	return nil
6320}
6321
6322func awsAwsjson11_serializeOpDocumentUpdateFileSystemAssociationInput(v *UpdateFileSystemAssociationInput, value smithyjson.Value) error {
6323	object := value.Object()
6324	defer object.Close()
6325
6326	if v.AuditDestinationARN != nil {
6327		ok := object.Key("AuditDestinationARN")
6328		ok.String(*v.AuditDestinationARN)
6329	}
6330
6331	if v.CacheAttributes != nil {
6332		ok := object.Key("CacheAttributes")
6333		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
6334			return err
6335		}
6336	}
6337
6338	if v.FileSystemAssociationARN != nil {
6339		ok := object.Key("FileSystemAssociationARN")
6340		ok.String(*v.FileSystemAssociationARN)
6341	}
6342
6343	if v.Password != nil {
6344		ok := object.Key("Password")
6345		ok.String(*v.Password)
6346	}
6347
6348	if v.UserName != nil {
6349		ok := object.Key("UserName")
6350		ok.String(*v.UserName)
6351	}
6352
6353	return nil
6354}
6355
6356func awsAwsjson11_serializeOpDocumentUpdateGatewayInformationInput(v *UpdateGatewayInformationInput, value smithyjson.Value) error {
6357	object := value.Object()
6358	defer object.Close()
6359
6360	if v.CloudWatchLogGroupARN != nil {
6361		ok := object.Key("CloudWatchLogGroupARN")
6362		ok.String(*v.CloudWatchLogGroupARN)
6363	}
6364
6365	if v.GatewayARN != nil {
6366		ok := object.Key("GatewayARN")
6367		ok.String(*v.GatewayARN)
6368	}
6369
6370	if v.GatewayName != nil {
6371		ok := object.Key("GatewayName")
6372		ok.String(*v.GatewayName)
6373	}
6374
6375	if v.GatewayTimezone != nil {
6376		ok := object.Key("GatewayTimezone")
6377		ok.String(*v.GatewayTimezone)
6378	}
6379
6380	return nil
6381}
6382
6383func awsAwsjson11_serializeOpDocumentUpdateGatewaySoftwareNowInput(v *UpdateGatewaySoftwareNowInput, value smithyjson.Value) error {
6384	object := value.Object()
6385	defer object.Close()
6386
6387	if v.GatewayARN != nil {
6388		ok := object.Key("GatewayARN")
6389		ok.String(*v.GatewayARN)
6390	}
6391
6392	return nil
6393}
6394
6395func awsAwsjson11_serializeOpDocumentUpdateMaintenanceStartTimeInput(v *UpdateMaintenanceStartTimeInput, value smithyjson.Value) error {
6396	object := value.Object()
6397	defer object.Close()
6398
6399	if v.DayOfMonth != nil {
6400		ok := object.Key("DayOfMonth")
6401		ok.Integer(*v.DayOfMonth)
6402	}
6403
6404	if v.DayOfWeek != nil {
6405		ok := object.Key("DayOfWeek")
6406		ok.Integer(*v.DayOfWeek)
6407	}
6408
6409	if v.GatewayARN != nil {
6410		ok := object.Key("GatewayARN")
6411		ok.String(*v.GatewayARN)
6412	}
6413
6414	if v.HourOfDay != nil {
6415		ok := object.Key("HourOfDay")
6416		ok.Integer(*v.HourOfDay)
6417	}
6418
6419	if v.MinuteOfHour != nil {
6420		ok := object.Key("MinuteOfHour")
6421		ok.Integer(*v.MinuteOfHour)
6422	}
6423
6424	return nil
6425}
6426
6427func awsAwsjson11_serializeOpDocumentUpdateNFSFileShareInput(v *UpdateNFSFileShareInput, value smithyjson.Value) error {
6428	object := value.Object()
6429	defer object.Close()
6430
6431	if v.CacheAttributes != nil {
6432		ok := object.Key("CacheAttributes")
6433		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
6434			return err
6435		}
6436	}
6437
6438	if v.ClientList != nil {
6439		ok := object.Key("ClientList")
6440		if err := awsAwsjson11_serializeDocumentFileShareClientList(v.ClientList, ok); err != nil {
6441			return err
6442		}
6443	}
6444
6445	if v.DefaultStorageClass != nil {
6446		ok := object.Key("DefaultStorageClass")
6447		ok.String(*v.DefaultStorageClass)
6448	}
6449
6450	if v.FileShareARN != nil {
6451		ok := object.Key("FileShareARN")
6452		ok.String(*v.FileShareARN)
6453	}
6454
6455	if v.FileShareName != nil {
6456		ok := object.Key("FileShareName")
6457		ok.String(*v.FileShareName)
6458	}
6459
6460	if v.GuessMIMETypeEnabled != nil {
6461		ok := object.Key("GuessMIMETypeEnabled")
6462		ok.Boolean(*v.GuessMIMETypeEnabled)
6463	}
6464
6465	if v.KMSEncrypted != nil {
6466		ok := object.Key("KMSEncrypted")
6467		ok.Boolean(*v.KMSEncrypted)
6468	}
6469
6470	if v.KMSKey != nil {
6471		ok := object.Key("KMSKey")
6472		ok.String(*v.KMSKey)
6473	}
6474
6475	if v.NFSFileShareDefaults != nil {
6476		ok := object.Key("NFSFileShareDefaults")
6477		if err := awsAwsjson11_serializeDocumentNFSFileShareDefaults(v.NFSFileShareDefaults, ok); err != nil {
6478			return err
6479		}
6480	}
6481
6482	if v.NotificationPolicy != nil {
6483		ok := object.Key("NotificationPolicy")
6484		ok.String(*v.NotificationPolicy)
6485	}
6486
6487	if len(v.ObjectACL) > 0 {
6488		ok := object.Key("ObjectACL")
6489		ok.String(string(v.ObjectACL))
6490	}
6491
6492	if v.ReadOnly != nil {
6493		ok := object.Key("ReadOnly")
6494		ok.Boolean(*v.ReadOnly)
6495	}
6496
6497	if v.RequesterPays != nil {
6498		ok := object.Key("RequesterPays")
6499		ok.Boolean(*v.RequesterPays)
6500	}
6501
6502	if v.Squash != nil {
6503		ok := object.Key("Squash")
6504		ok.String(*v.Squash)
6505	}
6506
6507	return nil
6508}
6509
6510func awsAwsjson11_serializeOpDocumentUpdateSMBFileShareInput(v *UpdateSMBFileShareInput, value smithyjson.Value) error {
6511	object := value.Object()
6512	defer object.Close()
6513
6514	if v.AccessBasedEnumeration != nil {
6515		ok := object.Key("AccessBasedEnumeration")
6516		ok.Boolean(*v.AccessBasedEnumeration)
6517	}
6518
6519	if v.AdminUserList != nil {
6520		ok := object.Key("AdminUserList")
6521		if err := awsAwsjson11_serializeDocumentUserList(v.AdminUserList, ok); err != nil {
6522			return err
6523		}
6524	}
6525
6526	if v.AuditDestinationARN != nil {
6527		ok := object.Key("AuditDestinationARN")
6528		ok.String(*v.AuditDestinationARN)
6529	}
6530
6531	if v.CacheAttributes != nil {
6532		ok := object.Key("CacheAttributes")
6533		if err := awsAwsjson11_serializeDocumentCacheAttributes(v.CacheAttributes, ok); err != nil {
6534			return err
6535		}
6536	}
6537
6538	if len(v.CaseSensitivity) > 0 {
6539		ok := object.Key("CaseSensitivity")
6540		ok.String(string(v.CaseSensitivity))
6541	}
6542
6543	if v.DefaultStorageClass != nil {
6544		ok := object.Key("DefaultStorageClass")
6545		ok.String(*v.DefaultStorageClass)
6546	}
6547
6548	if v.FileShareARN != nil {
6549		ok := object.Key("FileShareARN")
6550		ok.String(*v.FileShareARN)
6551	}
6552
6553	if v.FileShareName != nil {
6554		ok := object.Key("FileShareName")
6555		ok.String(*v.FileShareName)
6556	}
6557
6558	if v.GuessMIMETypeEnabled != nil {
6559		ok := object.Key("GuessMIMETypeEnabled")
6560		ok.Boolean(*v.GuessMIMETypeEnabled)
6561	}
6562
6563	if v.InvalidUserList != nil {
6564		ok := object.Key("InvalidUserList")
6565		if err := awsAwsjson11_serializeDocumentUserList(v.InvalidUserList, ok); err != nil {
6566			return err
6567		}
6568	}
6569
6570	if v.KMSEncrypted != nil {
6571		ok := object.Key("KMSEncrypted")
6572		ok.Boolean(*v.KMSEncrypted)
6573	}
6574
6575	if v.KMSKey != nil {
6576		ok := object.Key("KMSKey")
6577		ok.String(*v.KMSKey)
6578	}
6579
6580	if v.NotificationPolicy != nil {
6581		ok := object.Key("NotificationPolicy")
6582		ok.String(*v.NotificationPolicy)
6583	}
6584
6585	if len(v.ObjectACL) > 0 {
6586		ok := object.Key("ObjectACL")
6587		ok.String(string(v.ObjectACL))
6588	}
6589
6590	if v.ReadOnly != nil {
6591		ok := object.Key("ReadOnly")
6592		ok.Boolean(*v.ReadOnly)
6593	}
6594
6595	if v.RequesterPays != nil {
6596		ok := object.Key("RequesterPays")
6597		ok.Boolean(*v.RequesterPays)
6598	}
6599
6600	if v.SMBACLEnabled != nil {
6601		ok := object.Key("SMBACLEnabled")
6602		ok.Boolean(*v.SMBACLEnabled)
6603	}
6604
6605	if v.ValidUserList != nil {
6606		ok := object.Key("ValidUserList")
6607		if err := awsAwsjson11_serializeDocumentUserList(v.ValidUserList, ok); err != nil {
6608			return err
6609		}
6610	}
6611
6612	return nil
6613}
6614
6615func awsAwsjson11_serializeOpDocumentUpdateSMBFileShareVisibilityInput(v *UpdateSMBFileShareVisibilityInput, value smithyjson.Value) error {
6616	object := value.Object()
6617	defer object.Close()
6618
6619	if v.FileSharesVisible != nil {
6620		ok := object.Key("FileSharesVisible")
6621		ok.Boolean(*v.FileSharesVisible)
6622	}
6623
6624	if v.GatewayARN != nil {
6625		ok := object.Key("GatewayARN")
6626		ok.String(*v.GatewayARN)
6627	}
6628
6629	return nil
6630}
6631
6632func awsAwsjson11_serializeOpDocumentUpdateSMBSecurityStrategyInput(v *UpdateSMBSecurityStrategyInput, value smithyjson.Value) error {
6633	object := value.Object()
6634	defer object.Close()
6635
6636	if v.GatewayARN != nil {
6637		ok := object.Key("GatewayARN")
6638		ok.String(*v.GatewayARN)
6639	}
6640
6641	if len(v.SMBSecurityStrategy) > 0 {
6642		ok := object.Key("SMBSecurityStrategy")
6643		ok.String(string(v.SMBSecurityStrategy))
6644	}
6645
6646	return nil
6647}
6648
6649func awsAwsjson11_serializeOpDocumentUpdateSnapshotScheduleInput(v *UpdateSnapshotScheduleInput, value smithyjson.Value) error {
6650	object := value.Object()
6651	defer object.Close()
6652
6653	if v.Description != nil {
6654		ok := object.Key("Description")
6655		ok.String(*v.Description)
6656	}
6657
6658	if v.RecurrenceInHours != nil {
6659		ok := object.Key("RecurrenceInHours")
6660		ok.Integer(*v.RecurrenceInHours)
6661	}
6662
6663	if v.StartAt != nil {
6664		ok := object.Key("StartAt")
6665		ok.Integer(*v.StartAt)
6666	}
6667
6668	if v.Tags != nil {
6669		ok := object.Key("Tags")
6670		if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil {
6671			return err
6672		}
6673	}
6674
6675	if v.VolumeARN != nil {
6676		ok := object.Key("VolumeARN")
6677		ok.String(*v.VolumeARN)
6678	}
6679
6680	return nil
6681}
6682
6683func awsAwsjson11_serializeOpDocumentUpdateVTLDeviceTypeInput(v *UpdateVTLDeviceTypeInput, value smithyjson.Value) error {
6684	object := value.Object()
6685	defer object.Close()
6686
6687	if v.DeviceType != nil {
6688		ok := object.Key("DeviceType")
6689		ok.String(*v.DeviceType)
6690	}
6691
6692	if v.VTLDeviceARN != nil {
6693		ok := object.Key("VTLDeviceARN")
6694		ok.String(*v.VTLDeviceARN)
6695	}
6696
6697	return nil
6698}
6699