1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package memorydb
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/memorydb/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	smithytime "github.com/aws/smithy-go/time"
15	smithyhttp "github.com/aws/smithy-go/transport/http"
16)
17
18type awsAwsjson11_serializeOpBatchUpdateCluster struct {
19}
20
21func (*awsAwsjson11_serializeOpBatchUpdateCluster) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpBatchUpdateCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
26	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
27) {
28	request, ok := in.Request.(*smithyhttp.Request)
29	if !ok {
30		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
31	}
32
33	input, ok := in.Parameters.(*BatchUpdateClusterInput)
34	_ = input
35	if !ok {
36		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
37	}
38
39	request.Request.URL.Path = "/"
40	request.Request.Method = "POST"
41	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
42	if err != nil {
43		return out, metadata, &smithy.SerializationError{Err: err}
44	}
45	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
46	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.BatchUpdateCluster")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentBatchUpdateClusterInput(input, jsonEncoder.Value); err != nil {
50		return out, metadata, &smithy.SerializationError{Err: err}
51	}
52
53	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56
57	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
58		return out, metadata, &smithy.SerializationError{Err: err}
59	}
60	in.Request = request
61
62	return next.HandleSerialize(ctx, in)
63}
64
65type awsAwsjson11_serializeOpCopySnapshot struct {
66}
67
68func (*awsAwsjson11_serializeOpCopySnapshot) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpCopySnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
73	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
74) {
75	request, ok := in.Request.(*smithyhttp.Request)
76	if !ok {
77		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
78	}
79
80	input, ok := in.Parameters.(*CopySnapshotInput)
81	_ = input
82	if !ok {
83		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
84	}
85
86	request.Request.URL.Path = "/"
87	request.Request.Method = "POST"
88	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
89	if err != nil {
90		return out, metadata, &smithy.SerializationError{Err: err}
91	}
92	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
93	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CopySnapshot")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentCopySnapshotInput(input, jsonEncoder.Value); err != nil {
97		return out, metadata, &smithy.SerializationError{Err: err}
98	}
99
100	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
101		return out, metadata, &smithy.SerializationError{Err: err}
102	}
103
104	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
105		return out, metadata, &smithy.SerializationError{Err: err}
106	}
107	in.Request = request
108
109	return next.HandleSerialize(ctx, in)
110}
111
112type awsAwsjson11_serializeOpCreateACL struct {
113}
114
115func (*awsAwsjson11_serializeOpCreateACL) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpCreateACL) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
120	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
121) {
122	request, ok := in.Request.(*smithyhttp.Request)
123	if !ok {
124		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
125	}
126
127	input, ok := in.Parameters.(*CreateACLInput)
128	_ = input
129	if !ok {
130		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
131	}
132
133	request.Request.URL.Path = "/"
134	request.Request.Method = "POST"
135	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
136	if err != nil {
137		return out, metadata, &smithy.SerializationError{Err: err}
138	}
139	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
140	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateACL")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentCreateACLInput(input, jsonEncoder.Value); err != nil {
144		return out, metadata, &smithy.SerializationError{Err: err}
145	}
146
147	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
148		return out, metadata, &smithy.SerializationError{Err: err}
149	}
150
151	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
152		return out, metadata, &smithy.SerializationError{Err: err}
153	}
154	in.Request = request
155
156	return next.HandleSerialize(ctx, in)
157}
158
159type awsAwsjson11_serializeOpCreateCluster struct {
160}
161
162func (*awsAwsjson11_serializeOpCreateCluster) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpCreateCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
167	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
168) {
169	request, ok := in.Request.(*smithyhttp.Request)
170	if !ok {
171		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
172	}
173
174	input, ok := in.Parameters.(*CreateClusterInput)
175	_ = input
176	if !ok {
177		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
178	}
179
180	request.Request.URL.Path = "/"
181	request.Request.Method = "POST"
182	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
183	if err != nil {
184		return out, metadata, &smithy.SerializationError{Err: err}
185	}
186	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
187	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateCluster")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentCreateClusterInput(input, jsonEncoder.Value); err != nil {
191		return out, metadata, &smithy.SerializationError{Err: err}
192	}
193
194	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
195		return out, metadata, &smithy.SerializationError{Err: err}
196	}
197
198	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
199		return out, metadata, &smithy.SerializationError{Err: err}
200	}
201	in.Request = request
202
203	return next.HandleSerialize(ctx, in)
204}
205
206type awsAwsjson11_serializeOpCreateParameterGroup struct {
207}
208
209func (*awsAwsjson11_serializeOpCreateParameterGroup) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpCreateParameterGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
214	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
215) {
216	request, ok := in.Request.(*smithyhttp.Request)
217	if !ok {
218		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
219	}
220
221	input, ok := in.Parameters.(*CreateParameterGroupInput)
222	_ = input
223	if !ok {
224		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
225	}
226
227	request.Request.URL.Path = "/"
228	request.Request.Method = "POST"
229	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
230	if err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
234	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateParameterGroup")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentCreateParameterGroupInput(input, jsonEncoder.Value); err != nil {
238		return out, metadata, &smithy.SerializationError{Err: err}
239	}
240
241	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
242		return out, metadata, &smithy.SerializationError{Err: err}
243	}
244
245	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
246		return out, metadata, &smithy.SerializationError{Err: err}
247	}
248	in.Request = request
249
250	return next.HandleSerialize(ctx, in)
251}
252
253type awsAwsjson11_serializeOpCreateSnapshot struct {
254}
255
256func (*awsAwsjson11_serializeOpCreateSnapshot) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpCreateSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
262) {
263	request, ok := in.Request.(*smithyhttp.Request)
264	if !ok {
265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
266	}
267
268	input, ok := in.Parameters.(*CreateSnapshotInput)
269	_ = input
270	if !ok {
271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
272	}
273
274	request.Request.URL.Path = "/"
275	request.Request.Method = "POST"
276	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
277	if err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
281	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateSnapshot")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentCreateSnapshotInput(input, jsonEncoder.Value); err != nil {
285		return out, metadata, &smithy.SerializationError{Err: err}
286	}
287
288	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295	in.Request = request
296
297	return next.HandleSerialize(ctx, in)
298}
299
300type awsAwsjson11_serializeOpCreateSubnetGroup struct {
301}
302
303func (*awsAwsjson11_serializeOpCreateSubnetGroup) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpCreateSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
308	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
309) {
310	request, ok := in.Request.(*smithyhttp.Request)
311	if !ok {
312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
313	}
314
315	input, ok := in.Parameters.(*CreateSubnetGroupInput)
316	_ = input
317	if !ok {
318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
319	}
320
321	request.Request.URL.Path = "/"
322	request.Request.Method = "POST"
323	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
324	if err != nil {
325		return out, metadata, &smithy.SerializationError{Err: err}
326	}
327	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
328	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateSubnetGroup")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentCreateSubnetGroupInput(input, jsonEncoder.Value); err != nil {
332		return out, metadata, &smithy.SerializationError{Err: err}
333	}
334
335	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
336		return out, metadata, &smithy.SerializationError{Err: err}
337	}
338
339	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
340		return out, metadata, &smithy.SerializationError{Err: err}
341	}
342	in.Request = request
343
344	return next.HandleSerialize(ctx, in)
345}
346
347type awsAwsjson11_serializeOpCreateUser struct {
348}
349
350func (*awsAwsjson11_serializeOpCreateUser) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpCreateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
355	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
356) {
357	request, ok := in.Request.(*smithyhttp.Request)
358	if !ok {
359		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
360	}
361
362	input, ok := in.Parameters.(*CreateUserInput)
363	_ = input
364	if !ok {
365		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
366	}
367
368	request.Request.URL.Path = "/"
369	request.Request.Method = "POST"
370	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
371	if err != nil {
372		return out, metadata, &smithy.SerializationError{Err: err}
373	}
374	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
375	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateUser")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentCreateUserInput(input, jsonEncoder.Value); err != nil {
379		return out, metadata, &smithy.SerializationError{Err: err}
380	}
381
382	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
383		return out, metadata, &smithy.SerializationError{Err: err}
384	}
385
386	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
387		return out, metadata, &smithy.SerializationError{Err: err}
388	}
389	in.Request = request
390
391	return next.HandleSerialize(ctx, in)
392}
393
394type awsAwsjson11_serializeOpDeleteACL struct {
395}
396
397func (*awsAwsjson11_serializeOpDeleteACL) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpDeleteACL) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
402	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
403) {
404	request, ok := in.Request.(*smithyhttp.Request)
405	if !ok {
406		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
407	}
408
409	input, ok := in.Parameters.(*DeleteACLInput)
410	_ = input
411	if !ok {
412		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
413	}
414
415	request.Request.URL.Path = "/"
416	request.Request.Method = "POST"
417	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
418	if err != nil {
419		return out, metadata, &smithy.SerializationError{Err: err}
420	}
421	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
422	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteACL")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentDeleteACLInput(input, jsonEncoder.Value); err != nil {
426		return out, metadata, &smithy.SerializationError{Err: err}
427	}
428
429	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
430		return out, metadata, &smithy.SerializationError{Err: err}
431	}
432
433	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
434		return out, metadata, &smithy.SerializationError{Err: err}
435	}
436	in.Request = request
437
438	return next.HandleSerialize(ctx, in)
439}
440
441type awsAwsjson11_serializeOpDeleteCluster struct {
442}
443
444func (*awsAwsjson11_serializeOpDeleteCluster) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpDeleteCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
449	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
450) {
451	request, ok := in.Request.(*smithyhttp.Request)
452	if !ok {
453		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
454	}
455
456	input, ok := in.Parameters.(*DeleteClusterInput)
457	_ = input
458	if !ok {
459		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
460	}
461
462	request.Request.URL.Path = "/"
463	request.Request.Method = "POST"
464	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
465	if err != nil {
466		return out, metadata, &smithy.SerializationError{Err: err}
467	}
468	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
469	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteCluster")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentDeleteClusterInput(input, jsonEncoder.Value); err != nil {
473		return out, metadata, &smithy.SerializationError{Err: err}
474	}
475
476	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
477		return out, metadata, &smithy.SerializationError{Err: err}
478	}
479
480	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
481		return out, metadata, &smithy.SerializationError{Err: err}
482	}
483	in.Request = request
484
485	return next.HandleSerialize(ctx, in)
486}
487
488type awsAwsjson11_serializeOpDeleteParameterGroup struct {
489}
490
491func (*awsAwsjson11_serializeOpDeleteParameterGroup) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpDeleteParameterGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
497) {
498	request, ok := in.Request.(*smithyhttp.Request)
499	if !ok {
500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
501	}
502
503	input, ok := in.Parameters.(*DeleteParameterGroupInput)
504	_ = input
505	if !ok {
506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
507	}
508
509	request.Request.URL.Path = "/"
510	request.Request.Method = "POST"
511	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
512	if err != nil {
513		return out, metadata, &smithy.SerializationError{Err: err}
514	}
515	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
516	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteParameterGroup")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentDeleteParameterGroupInput(input, jsonEncoder.Value); err != nil {
520		return out, metadata, &smithy.SerializationError{Err: err}
521	}
522
523	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
524		return out, metadata, &smithy.SerializationError{Err: err}
525	}
526
527	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
528		return out, metadata, &smithy.SerializationError{Err: err}
529	}
530	in.Request = request
531
532	return next.HandleSerialize(ctx, in)
533}
534
535type awsAwsjson11_serializeOpDeleteSnapshot struct {
536}
537
538func (*awsAwsjson11_serializeOpDeleteSnapshot) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpDeleteSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
543	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
544) {
545	request, ok := in.Request.(*smithyhttp.Request)
546	if !ok {
547		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
548	}
549
550	input, ok := in.Parameters.(*DeleteSnapshotInput)
551	_ = input
552	if !ok {
553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
554	}
555
556	request.Request.URL.Path = "/"
557	request.Request.Method = "POST"
558	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
559	if err != nil {
560		return out, metadata, &smithy.SerializationError{Err: err}
561	}
562	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
563	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteSnapshot")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(input, jsonEncoder.Value); err != nil {
567		return out, metadata, &smithy.SerializationError{Err: err}
568	}
569
570	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
571		return out, metadata, &smithy.SerializationError{Err: err}
572	}
573
574	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
575		return out, metadata, &smithy.SerializationError{Err: err}
576	}
577	in.Request = request
578
579	return next.HandleSerialize(ctx, in)
580}
581
582type awsAwsjson11_serializeOpDeleteSubnetGroup struct {
583}
584
585func (*awsAwsjson11_serializeOpDeleteSubnetGroup) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpDeleteSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
590	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
591) {
592	request, ok := in.Request.(*smithyhttp.Request)
593	if !ok {
594		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
595	}
596
597	input, ok := in.Parameters.(*DeleteSubnetGroupInput)
598	_ = input
599	if !ok {
600		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
601	}
602
603	request.Request.URL.Path = "/"
604	request.Request.Method = "POST"
605	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
606	if err != nil {
607		return out, metadata, &smithy.SerializationError{Err: err}
608	}
609	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
610	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteSubnetGroup")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentDeleteSubnetGroupInput(input, jsonEncoder.Value); err != nil {
614		return out, metadata, &smithy.SerializationError{Err: err}
615	}
616
617	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
618		return out, metadata, &smithy.SerializationError{Err: err}
619	}
620
621	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
622		return out, metadata, &smithy.SerializationError{Err: err}
623	}
624	in.Request = request
625
626	return next.HandleSerialize(ctx, in)
627}
628
629type awsAwsjson11_serializeOpDeleteUser struct {
630}
631
632func (*awsAwsjson11_serializeOpDeleteUser) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
638) {
639	request, ok := in.Request.(*smithyhttp.Request)
640	if !ok {
641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
642	}
643
644	input, ok := in.Parameters.(*DeleteUserInput)
645	_ = input
646	if !ok {
647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
648	}
649
650	request.Request.URL.Path = "/"
651	request.Request.Method = "POST"
652	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
653	if err != nil {
654		return out, metadata, &smithy.SerializationError{Err: err}
655	}
656	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
657	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteUser")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentDeleteUserInput(input, jsonEncoder.Value); err != nil {
661		return out, metadata, &smithy.SerializationError{Err: err}
662	}
663
664	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
665		return out, metadata, &smithy.SerializationError{Err: err}
666	}
667
668	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
669		return out, metadata, &smithy.SerializationError{Err: err}
670	}
671	in.Request = request
672
673	return next.HandleSerialize(ctx, in)
674}
675
676type awsAwsjson11_serializeOpDescribeACLs struct {
677}
678
679func (*awsAwsjson11_serializeOpDescribeACLs) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpDescribeACLs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
684	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
685) {
686	request, ok := in.Request.(*smithyhttp.Request)
687	if !ok {
688		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
689	}
690
691	input, ok := in.Parameters.(*DescribeACLsInput)
692	_ = input
693	if !ok {
694		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
695	}
696
697	request.Request.URL.Path = "/"
698	request.Request.Method = "POST"
699	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
700	if err != nil {
701		return out, metadata, &smithy.SerializationError{Err: err}
702	}
703	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
704	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeACLs")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentDescribeACLsInput(input, jsonEncoder.Value); err != nil {
708		return out, metadata, &smithy.SerializationError{Err: err}
709	}
710
711	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
712		return out, metadata, &smithy.SerializationError{Err: err}
713	}
714
715	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
716		return out, metadata, &smithy.SerializationError{Err: err}
717	}
718	in.Request = request
719
720	return next.HandleSerialize(ctx, in)
721}
722
723type awsAwsjson11_serializeOpDescribeClusters struct {
724}
725
726func (*awsAwsjson11_serializeOpDescribeClusters) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpDescribeClusters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
732) {
733	request, ok := in.Request.(*smithyhttp.Request)
734	if !ok {
735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
736	}
737
738	input, ok := in.Parameters.(*DescribeClustersInput)
739	_ = input
740	if !ok {
741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
742	}
743
744	request.Request.URL.Path = "/"
745	request.Request.Method = "POST"
746	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
747	if err != nil {
748		return out, metadata, &smithy.SerializationError{Err: err}
749	}
750	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
751	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeClusters")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentDescribeClustersInput(input, jsonEncoder.Value); err != nil {
755		return out, metadata, &smithy.SerializationError{Err: err}
756	}
757
758	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
759		return out, metadata, &smithy.SerializationError{Err: err}
760	}
761
762	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
763		return out, metadata, &smithy.SerializationError{Err: err}
764	}
765	in.Request = request
766
767	return next.HandleSerialize(ctx, in)
768}
769
770type awsAwsjson11_serializeOpDescribeEngineVersions struct {
771}
772
773func (*awsAwsjson11_serializeOpDescribeEngineVersions) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpDescribeEngineVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
778	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
779) {
780	request, ok := in.Request.(*smithyhttp.Request)
781	if !ok {
782		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
783	}
784
785	input, ok := in.Parameters.(*DescribeEngineVersionsInput)
786	_ = input
787	if !ok {
788		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
789	}
790
791	request.Request.URL.Path = "/"
792	request.Request.Method = "POST"
793	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
794	if err != nil {
795		return out, metadata, &smithy.SerializationError{Err: err}
796	}
797	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
798	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeEngineVersions")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentDescribeEngineVersionsInput(input, jsonEncoder.Value); err != nil {
802		return out, metadata, &smithy.SerializationError{Err: err}
803	}
804
805	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
806		return out, metadata, &smithy.SerializationError{Err: err}
807	}
808
809	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
810		return out, metadata, &smithy.SerializationError{Err: err}
811	}
812	in.Request = request
813
814	return next.HandleSerialize(ctx, in)
815}
816
817type awsAwsjson11_serializeOpDescribeEvents struct {
818}
819
820func (*awsAwsjson11_serializeOpDescribeEvents) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpDescribeEvents) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
825	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
826) {
827	request, ok := in.Request.(*smithyhttp.Request)
828	if !ok {
829		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
830	}
831
832	input, ok := in.Parameters.(*DescribeEventsInput)
833	_ = input
834	if !ok {
835		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
836	}
837
838	request.Request.URL.Path = "/"
839	request.Request.Method = "POST"
840	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
841	if err != nil {
842		return out, metadata, &smithy.SerializationError{Err: err}
843	}
844	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
845	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeEvents")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentDescribeEventsInput(input, jsonEncoder.Value); err != nil {
849		return out, metadata, &smithy.SerializationError{Err: err}
850	}
851
852	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
853		return out, metadata, &smithy.SerializationError{Err: err}
854	}
855
856	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
857		return out, metadata, &smithy.SerializationError{Err: err}
858	}
859	in.Request = request
860
861	return next.HandleSerialize(ctx, in)
862}
863
864type awsAwsjson11_serializeOpDescribeParameterGroups struct {
865}
866
867func (*awsAwsjson11_serializeOpDescribeParameterGroups) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpDescribeParameterGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
872	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
873) {
874	request, ok := in.Request.(*smithyhttp.Request)
875	if !ok {
876		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
877	}
878
879	input, ok := in.Parameters.(*DescribeParameterGroupsInput)
880	_ = input
881	if !ok {
882		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
883	}
884
885	request.Request.URL.Path = "/"
886	request.Request.Method = "POST"
887	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
888	if err != nil {
889		return out, metadata, &smithy.SerializationError{Err: err}
890	}
891	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
892	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeParameterGroups")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentDescribeParameterGroupsInput(input, jsonEncoder.Value); err != nil {
896		return out, metadata, &smithy.SerializationError{Err: err}
897	}
898
899	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
900		return out, metadata, &smithy.SerializationError{Err: err}
901	}
902
903	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
904		return out, metadata, &smithy.SerializationError{Err: err}
905	}
906	in.Request = request
907
908	return next.HandleSerialize(ctx, in)
909}
910
911type awsAwsjson11_serializeOpDescribeParameters struct {
912}
913
914func (*awsAwsjson11_serializeOpDescribeParameters) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpDescribeParameters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
919	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
920) {
921	request, ok := in.Request.(*smithyhttp.Request)
922	if !ok {
923		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
924	}
925
926	input, ok := in.Parameters.(*DescribeParametersInput)
927	_ = input
928	if !ok {
929		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
930	}
931
932	request.Request.URL.Path = "/"
933	request.Request.Method = "POST"
934	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
935	if err != nil {
936		return out, metadata, &smithy.SerializationError{Err: err}
937	}
938	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
939	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeParameters")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentDescribeParametersInput(input, jsonEncoder.Value); err != nil {
943		return out, metadata, &smithy.SerializationError{Err: err}
944	}
945
946	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
947		return out, metadata, &smithy.SerializationError{Err: err}
948	}
949
950	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
951		return out, metadata, &smithy.SerializationError{Err: err}
952	}
953	in.Request = request
954
955	return next.HandleSerialize(ctx, in)
956}
957
958type awsAwsjson11_serializeOpDescribeServiceUpdates struct {
959}
960
961func (*awsAwsjson11_serializeOpDescribeServiceUpdates) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpDescribeServiceUpdates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
966	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
967) {
968	request, ok := in.Request.(*smithyhttp.Request)
969	if !ok {
970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
971	}
972
973	input, ok := in.Parameters.(*DescribeServiceUpdatesInput)
974	_ = input
975	if !ok {
976		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
977	}
978
979	request.Request.URL.Path = "/"
980	request.Request.Method = "POST"
981	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
982	if err != nil {
983		return out, metadata, &smithy.SerializationError{Err: err}
984	}
985	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
986	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeServiceUpdates")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentDescribeServiceUpdatesInput(input, jsonEncoder.Value); err != nil {
990		return out, metadata, &smithy.SerializationError{Err: err}
991	}
992
993	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
994		return out, metadata, &smithy.SerializationError{Err: err}
995	}
996
997	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
998		return out, metadata, &smithy.SerializationError{Err: err}
999	}
1000	in.Request = request
1001
1002	return next.HandleSerialize(ctx, in)
1003}
1004
1005type awsAwsjson11_serializeOpDescribeSnapshots struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpDescribeSnapshots) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpDescribeSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1013	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1014) {
1015	request, ok := in.Request.(*smithyhttp.Request)
1016	if !ok {
1017		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1018	}
1019
1020	input, ok := in.Parameters.(*DescribeSnapshotsInput)
1021	_ = input
1022	if !ok {
1023		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1024	}
1025
1026	request.Request.URL.Path = "/"
1027	request.Request.Method = "POST"
1028	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1029	if err != nil {
1030		return out, metadata, &smithy.SerializationError{Err: err}
1031	}
1032	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1033	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeSnapshots")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(input, jsonEncoder.Value); err != nil {
1037		return out, metadata, &smithy.SerializationError{Err: err}
1038	}
1039
1040	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1041		return out, metadata, &smithy.SerializationError{Err: err}
1042	}
1043
1044	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047	in.Request = request
1048
1049	return next.HandleSerialize(ctx, in)
1050}
1051
1052type awsAwsjson11_serializeOpDescribeSubnetGroups struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpDescribeSubnetGroups) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpDescribeSubnetGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1060	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	request, ok := in.Request.(*smithyhttp.Request)
1063	if !ok {
1064		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1065	}
1066
1067	input, ok := in.Parameters.(*DescribeSubnetGroupsInput)
1068	_ = input
1069	if !ok {
1070		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1071	}
1072
1073	request.Request.URL.Path = "/"
1074	request.Request.Method = "POST"
1075	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1076	if err != nil {
1077		return out, metadata, &smithy.SerializationError{Err: err}
1078	}
1079	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1080	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeSubnetGroups")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentDescribeSubnetGroupsInput(input, jsonEncoder.Value); err != nil {
1084		return out, metadata, &smithy.SerializationError{Err: err}
1085	}
1086
1087	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1088		return out, metadata, &smithy.SerializationError{Err: err}
1089	}
1090
1091	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1092		return out, metadata, &smithy.SerializationError{Err: err}
1093	}
1094	in.Request = request
1095
1096	return next.HandleSerialize(ctx, in)
1097}
1098
1099type awsAwsjson11_serializeOpDescribeUsers struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpDescribeUsers) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpDescribeUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1107	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1108) {
1109	request, ok := in.Request.(*smithyhttp.Request)
1110	if !ok {
1111		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1112	}
1113
1114	input, ok := in.Parameters.(*DescribeUsersInput)
1115	_ = input
1116	if !ok {
1117		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1118	}
1119
1120	request.Request.URL.Path = "/"
1121	request.Request.Method = "POST"
1122	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1123	if err != nil {
1124		return out, metadata, &smithy.SerializationError{Err: err}
1125	}
1126	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1127	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeUsers")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentDescribeUsersInput(input, jsonEncoder.Value); err != nil {
1131		return out, metadata, &smithy.SerializationError{Err: err}
1132	}
1133
1134	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1135		return out, metadata, &smithy.SerializationError{Err: err}
1136	}
1137
1138	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1139		return out, metadata, &smithy.SerializationError{Err: err}
1140	}
1141	in.Request = request
1142
1143	return next.HandleSerialize(ctx, in)
1144}
1145
1146type awsAwsjson11_serializeOpFailoverShard struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpFailoverShard) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpFailoverShard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1154	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1155) {
1156	request, ok := in.Request.(*smithyhttp.Request)
1157	if !ok {
1158		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1159	}
1160
1161	input, ok := in.Parameters.(*FailoverShardInput)
1162	_ = input
1163	if !ok {
1164		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1165	}
1166
1167	request.Request.URL.Path = "/"
1168	request.Request.Method = "POST"
1169	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1170	if err != nil {
1171		return out, metadata, &smithy.SerializationError{Err: err}
1172	}
1173	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1174	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.FailoverShard")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentFailoverShardInput(input, jsonEncoder.Value); err != nil {
1178		return out, metadata, &smithy.SerializationError{Err: err}
1179	}
1180
1181	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1182		return out, metadata, &smithy.SerializationError{Err: err}
1183	}
1184
1185	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1186		return out, metadata, &smithy.SerializationError{Err: err}
1187	}
1188	in.Request = request
1189
1190	return next.HandleSerialize(ctx, in)
1191}
1192
1193type awsAwsjson11_serializeOpListAllowedNodeTypeUpdates struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpListAllowedNodeTypeUpdates) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpListAllowedNodeTypeUpdates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1201	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	request, ok := in.Request.(*smithyhttp.Request)
1204	if !ok {
1205		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1206	}
1207
1208	input, ok := in.Parameters.(*ListAllowedNodeTypeUpdatesInput)
1209	_ = input
1210	if !ok {
1211		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1212	}
1213
1214	request.Request.URL.Path = "/"
1215	request.Request.Method = "POST"
1216	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1217	if err != nil {
1218		return out, metadata, &smithy.SerializationError{Err: err}
1219	}
1220	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1221	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ListAllowedNodeTypeUpdates")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentListAllowedNodeTypeUpdatesInput(input, jsonEncoder.Value); err != nil {
1225		return out, metadata, &smithy.SerializationError{Err: err}
1226	}
1227
1228	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1229		return out, metadata, &smithy.SerializationError{Err: err}
1230	}
1231
1232	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1233		return out, metadata, &smithy.SerializationError{Err: err}
1234	}
1235	in.Request = request
1236
1237	return next.HandleSerialize(ctx, in)
1238}
1239
1240type awsAwsjson11_serializeOpListTags struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpListTags) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpListTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1248	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1249) {
1250	request, ok := in.Request.(*smithyhttp.Request)
1251	if !ok {
1252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1253	}
1254
1255	input, ok := in.Parameters.(*ListTagsInput)
1256	_ = input
1257	if !ok {
1258		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1259	}
1260
1261	request.Request.URL.Path = "/"
1262	request.Request.Method = "POST"
1263	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1264	if err != nil {
1265		return out, metadata, &smithy.SerializationError{Err: err}
1266	}
1267	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1268	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ListTags")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentListTagsInput(input, jsonEncoder.Value); err != nil {
1272		return out, metadata, &smithy.SerializationError{Err: err}
1273	}
1274
1275	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1276		return out, metadata, &smithy.SerializationError{Err: err}
1277	}
1278
1279	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1280		return out, metadata, &smithy.SerializationError{Err: err}
1281	}
1282	in.Request = request
1283
1284	return next.HandleSerialize(ctx, in)
1285}
1286
1287type awsAwsjson11_serializeOpResetParameterGroup struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpResetParameterGroup) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpResetParameterGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1295	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1296) {
1297	request, ok := in.Request.(*smithyhttp.Request)
1298	if !ok {
1299		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1300	}
1301
1302	input, ok := in.Parameters.(*ResetParameterGroupInput)
1303	_ = input
1304	if !ok {
1305		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1306	}
1307
1308	request.Request.URL.Path = "/"
1309	request.Request.Method = "POST"
1310	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1311	if err != nil {
1312		return out, metadata, &smithy.SerializationError{Err: err}
1313	}
1314	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1315	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ResetParameterGroup")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentResetParameterGroupInput(input, jsonEncoder.Value); err != nil {
1319		return out, metadata, &smithy.SerializationError{Err: err}
1320	}
1321
1322	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1323		return out, metadata, &smithy.SerializationError{Err: err}
1324	}
1325
1326	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1327		return out, metadata, &smithy.SerializationError{Err: err}
1328	}
1329	in.Request = request
1330
1331	return next.HandleSerialize(ctx, in)
1332}
1333
1334type awsAwsjson11_serializeOpTagResource struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpTagResource) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1342	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1343) {
1344	request, ok := in.Request.(*smithyhttp.Request)
1345	if !ok {
1346		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1347	}
1348
1349	input, ok := in.Parameters.(*TagResourceInput)
1350	_ = input
1351	if !ok {
1352		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1353	}
1354
1355	request.Request.URL.Path = "/"
1356	request.Request.Method = "POST"
1357	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1358	if err != nil {
1359		return out, metadata, &smithy.SerializationError{Err: err}
1360	}
1361	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1362	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.TagResource")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
1366		return out, metadata, &smithy.SerializationError{Err: err}
1367	}
1368
1369	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1370		return out, metadata, &smithy.SerializationError{Err: err}
1371	}
1372
1373	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1374		return out, metadata, &smithy.SerializationError{Err: err}
1375	}
1376	in.Request = request
1377
1378	return next.HandleSerialize(ctx, in)
1379}
1380
1381type awsAwsjson11_serializeOpUntagResource struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpUntagResource) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1390) {
1391	request, ok := in.Request.(*smithyhttp.Request)
1392	if !ok {
1393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1394	}
1395
1396	input, ok := in.Parameters.(*UntagResourceInput)
1397	_ = input
1398	if !ok {
1399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1400	}
1401
1402	request.Request.URL.Path = "/"
1403	request.Request.Method = "POST"
1404	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1405	if err != nil {
1406		return out, metadata, &smithy.SerializationError{Err: err}
1407	}
1408	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1409	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UntagResource")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
1413		return out, metadata, &smithy.SerializationError{Err: err}
1414	}
1415
1416	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1417		return out, metadata, &smithy.SerializationError{Err: err}
1418	}
1419
1420	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1421		return out, metadata, &smithy.SerializationError{Err: err}
1422	}
1423	in.Request = request
1424
1425	return next.HandleSerialize(ctx, in)
1426}
1427
1428type awsAwsjson11_serializeOpUpdateACL struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpUpdateACL) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpUpdateACL) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1436	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1437) {
1438	request, ok := in.Request.(*smithyhttp.Request)
1439	if !ok {
1440		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1441	}
1442
1443	input, ok := in.Parameters.(*UpdateACLInput)
1444	_ = input
1445	if !ok {
1446		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1447	}
1448
1449	request.Request.URL.Path = "/"
1450	request.Request.Method = "POST"
1451	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1452	if err != nil {
1453		return out, metadata, &smithy.SerializationError{Err: err}
1454	}
1455	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1456	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateACL")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentUpdateACLInput(input, jsonEncoder.Value); err != nil {
1460		return out, metadata, &smithy.SerializationError{Err: err}
1461	}
1462
1463	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1464		return out, metadata, &smithy.SerializationError{Err: err}
1465	}
1466
1467	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1468		return out, metadata, &smithy.SerializationError{Err: err}
1469	}
1470	in.Request = request
1471
1472	return next.HandleSerialize(ctx, in)
1473}
1474
1475type awsAwsjson11_serializeOpUpdateCluster struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpUpdateCluster) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpUpdateCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1483	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1484) {
1485	request, ok := in.Request.(*smithyhttp.Request)
1486	if !ok {
1487		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1488	}
1489
1490	input, ok := in.Parameters.(*UpdateClusterInput)
1491	_ = input
1492	if !ok {
1493		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1494	}
1495
1496	request.Request.URL.Path = "/"
1497	request.Request.Method = "POST"
1498	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1499	if err != nil {
1500		return out, metadata, &smithy.SerializationError{Err: err}
1501	}
1502	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1503	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateCluster")
1504
1505	jsonEncoder := smithyjson.NewEncoder()
1506	if err := awsAwsjson11_serializeOpDocumentUpdateClusterInput(input, jsonEncoder.Value); err != nil {
1507		return out, metadata, &smithy.SerializationError{Err: err}
1508	}
1509
1510	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1511		return out, metadata, &smithy.SerializationError{Err: err}
1512	}
1513
1514	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1515		return out, metadata, &smithy.SerializationError{Err: err}
1516	}
1517	in.Request = request
1518
1519	return next.HandleSerialize(ctx, in)
1520}
1521
1522type awsAwsjson11_serializeOpUpdateParameterGroup struct {
1523}
1524
1525func (*awsAwsjson11_serializeOpUpdateParameterGroup) ID() string {
1526	return "OperationSerializer"
1527}
1528
1529func (m *awsAwsjson11_serializeOpUpdateParameterGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1530	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1531) {
1532	request, ok := in.Request.(*smithyhttp.Request)
1533	if !ok {
1534		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1535	}
1536
1537	input, ok := in.Parameters.(*UpdateParameterGroupInput)
1538	_ = input
1539	if !ok {
1540		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1541	}
1542
1543	request.Request.URL.Path = "/"
1544	request.Request.Method = "POST"
1545	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1546	if err != nil {
1547		return out, metadata, &smithy.SerializationError{Err: err}
1548	}
1549	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1550	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateParameterGroup")
1551
1552	jsonEncoder := smithyjson.NewEncoder()
1553	if err := awsAwsjson11_serializeOpDocumentUpdateParameterGroupInput(input, jsonEncoder.Value); err != nil {
1554		return out, metadata, &smithy.SerializationError{Err: err}
1555	}
1556
1557	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1558		return out, metadata, &smithy.SerializationError{Err: err}
1559	}
1560
1561	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1562		return out, metadata, &smithy.SerializationError{Err: err}
1563	}
1564	in.Request = request
1565
1566	return next.HandleSerialize(ctx, in)
1567}
1568
1569type awsAwsjson11_serializeOpUpdateSubnetGroup struct {
1570}
1571
1572func (*awsAwsjson11_serializeOpUpdateSubnetGroup) ID() string {
1573	return "OperationSerializer"
1574}
1575
1576func (m *awsAwsjson11_serializeOpUpdateSubnetGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1577	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1578) {
1579	request, ok := in.Request.(*smithyhttp.Request)
1580	if !ok {
1581		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1582	}
1583
1584	input, ok := in.Parameters.(*UpdateSubnetGroupInput)
1585	_ = input
1586	if !ok {
1587		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1588	}
1589
1590	request.Request.URL.Path = "/"
1591	request.Request.Method = "POST"
1592	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1593	if err != nil {
1594		return out, metadata, &smithy.SerializationError{Err: err}
1595	}
1596	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1597	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateSubnetGroup")
1598
1599	jsonEncoder := smithyjson.NewEncoder()
1600	if err := awsAwsjson11_serializeOpDocumentUpdateSubnetGroupInput(input, jsonEncoder.Value); err != nil {
1601		return out, metadata, &smithy.SerializationError{Err: err}
1602	}
1603
1604	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1605		return out, metadata, &smithy.SerializationError{Err: err}
1606	}
1607
1608	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1609		return out, metadata, &smithy.SerializationError{Err: err}
1610	}
1611	in.Request = request
1612
1613	return next.HandleSerialize(ctx, in)
1614}
1615
1616type awsAwsjson11_serializeOpUpdateUser struct {
1617}
1618
1619func (*awsAwsjson11_serializeOpUpdateUser) ID() string {
1620	return "OperationSerializer"
1621}
1622
1623func (m *awsAwsjson11_serializeOpUpdateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1624	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1625) {
1626	request, ok := in.Request.(*smithyhttp.Request)
1627	if !ok {
1628		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1629	}
1630
1631	input, ok := in.Parameters.(*UpdateUserInput)
1632	_ = input
1633	if !ok {
1634		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1635	}
1636
1637	request.Request.URL.Path = "/"
1638	request.Request.Method = "POST"
1639	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1640	if err != nil {
1641		return out, metadata, &smithy.SerializationError{Err: err}
1642	}
1643	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1644	httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateUser")
1645
1646	jsonEncoder := smithyjson.NewEncoder()
1647	if err := awsAwsjson11_serializeOpDocumentUpdateUserInput(input, jsonEncoder.Value); err != nil {
1648		return out, metadata, &smithy.SerializationError{Err: err}
1649	}
1650
1651	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1652		return out, metadata, &smithy.SerializationError{Err: err}
1653	}
1654
1655	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1656		return out, metadata, &smithy.SerializationError{Err: err}
1657	}
1658	in.Request = request
1659
1660	return next.HandleSerialize(ctx, in)
1661}
1662func awsAwsjson11_serializeDocumentAuthenticationMode(v *types.AuthenticationMode, value smithyjson.Value) error {
1663	object := value.Object()
1664	defer object.Close()
1665
1666	if v.Passwords != nil {
1667		ok := object.Key("Passwords")
1668		if err := awsAwsjson11_serializeDocumentPasswordListInput(v.Passwords, ok); err != nil {
1669			return err
1670		}
1671	}
1672
1673	if len(v.Type) > 0 {
1674		ok := object.Key("Type")
1675		ok.String(string(v.Type))
1676	}
1677
1678	return nil
1679}
1680
1681func awsAwsjson11_serializeDocumentClusterNameList(v []string, value smithyjson.Value) error {
1682	array := value.Array()
1683	defer array.Close()
1684
1685	for i := range v {
1686		av := array.Value()
1687		av.String(v[i])
1688	}
1689	return nil
1690}
1691
1692func awsAwsjson11_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
1693	object := value.Object()
1694	defer object.Close()
1695
1696	if v.Name != nil {
1697		ok := object.Key("Name")
1698		ok.String(*v.Name)
1699	}
1700
1701	if v.Values != nil {
1702		ok := object.Key("Values")
1703		if err := awsAwsjson11_serializeDocumentFilterValueList(v.Values, ok); err != nil {
1704			return err
1705		}
1706	}
1707
1708	return nil
1709}
1710
1711func awsAwsjson11_serializeDocumentFilterList(v []types.Filter, value smithyjson.Value) error {
1712	array := value.Array()
1713	defer array.Close()
1714
1715	for i := range v {
1716		av := array.Value()
1717		if err := awsAwsjson11_serializeDocumentFilter(&v[i], av); err != nil {
1718			return err
1719		}
1720	}
1721	return nil
1722}
1723
1724func awsAwsjson11_serializeDocumentFilterValueList(v []string, value smithyjson.Value) error {
1725	array := value.Array()
1726	defer array.Close()
1727
1728	for i := range v {
1729		av := array.Value()
1730		av.String(v[i])
1731	}
1732	return nil
1733}
1734
1735func awsAwsjson11_serializeDocumentKeyList(v []string, value smithyjson.Value) error {
1736	array := value.Array()
1737	defer array.Close()
1738
1739	for i := range v {
1740		av := array.Value()
1741		av.String(v[i])
1742	}
1743	return nil
1744}
1745
1746func awsAwsjson11_serializeDocumentParameterNameList(v []string, value smithyjson.Value) error {
1747	array := value.Array()
1748	defer array.Close()
1749
1750	for i := range v {
1751		av := array.Value()
1752		av.String(v[i])
1753	}
1754	return nil
1755}
1756
1757func awsAwsjson11_serializeDocumentParameterNameValue(v *types.ParameterNameValue, value smithyjson.Value) error {
1758	object := value.Object()
1759	defer object.Close()
1760
1761	if v.ParameterName != nil {
1762		ok := object.Key("ParameterName")
1763		ok.String(*v.ParameterName)
1764	}
1765
1766	if v.ParameterValue != nil {
1767		ok := object.Key("ParameterValue")
1768		ok.String(*v.ParameterValue)
1769	}
1770
1771	return nil
1772}
1773
1774func awsAwsjson11_serializeDocumentParameterNameValueList(v []types.ParameterNameValue, value smithyjson.Value) error {
1775	array := value.Array()
1776	defer array.Close()
1777
1778	for i := range v {
1779		av := array.Value()
1780		if err := awsAwsjson11_serializeDocumentParameterNameValue(&v[i], av); err != nil {
1781			return err
1782		}
1783	}
1784	return nil
1785}
1786
1787func awsAwsjson11_serializeDocumentPasswordListInput(v []string, value smithyjson.Value) error {
1788	array := value.Array()
1789	defer array.Close()
1790
1791	for i := range v {
1792		av := array.Value()
1793		av.String(v[i])
1794	}
1795	return nil
1796}
1797
1798func awsAwsjson11_serializeDocumentReplicaConfigurationRequest(v *types.ReplicaConfigurationRequest, value smithyjson.Value) error {
1799	object := value.Object()
1800	defer object.Close()
1801
1802	if v.ReplicaCount != 0 {
1803		ok := object.Key("ReplicaCount")
1804		ok.Integer(v.ReplicaCount)
1805	}
1806
1807	return nil
1808}
1809
1810func awsAwsjson11_serializeDocumentSecurityGroupIdsList(v []string, value smithyjson.Value) error {
1811	array := value.Array()
1812	defer array.Close()
1813
1814	for i := range v {
1815		av := array.Value()
1816		av.String(v[i])
1817	}
1818	return nil
1819}
1820
1821func awsAwsjson11_serializeDocumentServiceUpdateRequest(v *types.ServiceUpdateRequest, value smithyjson.Value) error {
1822	object := value.Object()
1823	defer object.Close()
1824
1825	if v.ServiceUpdateNameToApply != nil {
1826		ok := object.Key("ServiceUpdateNameToApply")
1827		ok.String(*v.ServiceUpdateNameToApply)
1828	}
1829
1830	return nil
1831}
1832
1833func awsAwsjson11_serializeDocumentServiceUpdateStatusList(v []types.ServiceUpdateStatus, value smithyjson.Value) error {
1834	array := value.Array()
1835	defer array.Close()
1836
1837	for i := range v {
1838		av := array.Value()
1839		av.String(string(v[i]))
1840	}
1841	return nil
1842}
1843
1844func awsAwsjson11_serializeDocumentShardConfigurationRequest(v *types.ShardConfigurationRequest, value smithyjson.Value) error {
1845	object := value.Object()
1846	defer object.Close()
1847
1848	if v.ShardCount != 0 {
1849		ok := object.Key("ShardCount")
1850		ok.Integer(v.ShardCount)
1851	}
1852
1853	return nil
1854}
1855
1856func awsAwsjson11_serializeDocumentSnapshotArnsList(v []string, value smithyjson.Value) error {
1857	array := value.Array()
1858	defer array.Close()
1859
1860	for i := range v {
1861		av := array.Value()
1862		av.String(v[i])
1863	}
1864	return nil
1865}
1866
1867func awsAwsjson11_serializeDocumentSubnetIdentifierList(v []string, value smithyjson.Value) error {
1868	array := value.Array()
1869	defer array.Close()
1870
1871	for i := range v {
1872		av := array.Value()
1873		av.String(v[i])
1874	}
1875	return nil
1876}
1877
1878func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
1879	object := value.Object()
1880	defer object.Close()
1881
1882	if v.Key != nil {
1883		ok := object.Key("Key")
1884		ok.String(*v.Key)
1885	}
1886
1887	if v.Value != nil {
1888		ok := object.Key("Value")
1889		ok.String(*v.Value)
1890	}
1891
1892	return nil
1893}
1894
1895func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
1896	array := value.Array()
1897	defer array.Close()
1898
1899	for i := range v {
1900		av := array.Value()
1901		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
1902			return err
1903		}
1904	}
1905	return nil
1906}
1907
1908func awsAwsjson11_serializeDocumentUserNameListInput(v []string, value smithyjson.Value) error {
1909	array := value.Array()
1910	defer array.Close()
1911
1912	for i := range v {
1913		av := array.Value()
1914		av.String(v[i])
1915	}
1916	return nil
1917}
1918
1919func awsAwsjson11_serializeOpDocumentBatchUpdateClusterInput(v *BatchUpdateClusterInput, value smithyjson.Value) error {
1920	object := value.Object()
1921	defer object.Close()
1922
1923	if v.ClusterNames != nil {
1924		ok := object.Key("ClusterNames")
1925		if err := awsAwsjson11_serializeDocumentClusterNameList(v.ClusterNames, ok); err != nil {
1926			return err
1927		}
1928	}
1929
1930	if v.ServiceUpdate != nil {
1931		ok := object.Key("ServiceUpdate")
1932		if err := awsAwsjson11_serializeDocumentServiceUpdateRequest(v.ServiceUpdate, ok); err != nil {
1933			return err
1934		}
1935	}
1936
1937	return nil
1938}
1939
1940func awsAwsjson11_serializeOpDocumentCopySnapshotInput(v *CopySnapshotInput, value smithyjson.Value) error {
1941	object := value.Object()
1942	defer object.Close()
1943
1944	if v.KmsKeyId != nil {
1945		ok := object.Key("KmsKeyId")
1946		ok.String(*v.KmsKeyId)
1947	}
1948
1949	if v.SourceSnapshotName != nil {
1950		ok := object.Key("SourceSnapshotName")
1951		ok.String(*v.SourceSnapshotName)
1952	}
1953
1954	if v.Tags != nil {
1955		ok := object.Key("Tags")
1956		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
1957			return err
1958		}
1959	}
1960
1961	if v.TargetBucket != nil {
1962		ok := object.Key("TargetBucket")
1963		ok.String(*v.TargetBucket)
1964	}
1965
1966	if v.TargetSnapshotName != nil {
1967		ok := object.Key("TargetSnapshotName")
1968		ok.String(*v.TargetSnapshotName)
1969	}
1970
1971	return nil
1972}
1973
1974func awsAwsjson11_serializeOpDocumentCreateACLInput(v *CreateACLInput, value smithyjson.Value) error {
1975	object := value.Object()
1976	defer object.Close()
1977
1978	if v.ACLName != nil {
1979		ok := object.Key("ACLName")
1980		ok.String(*v.ACLName)
1981	}
1982
1983	if v.Tags != nil {
1984		ok := object.Key("Tags")
1985		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
1986			return err
1987		}
1988	}
1989
1990	if v.UserNames != nil {
1991		ok := object.Key("UserNames")
1992		if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNames, ok); err != nil {
1993			return err
1994		}
1995	}
1996
1997	return nil
1998}
1999
2000func awsAwsjson11_serializeOpDocumentCreateClusterInput(v *CreateClusterInput, value smithyjson.Value) error {
2001	object := value.Object()
2002	defer object.Close()
2003
2004	if v.ACLName != nil {
2005		ok := object.Key("ACLName")
2006		ok.String(*v.ACLName)
2007	}
2008
2009	if v.AutoMinorVersionUpgrade != nil {
2010		ok := object.Key("AutoMinorVersionUpgrade")
2011		ok.Boolean(*v.AutoMinorVersionUpgrade)
2012	}
2013
2014	if v.ClusterName != nil {
2015		ok := object.Key("ClusterName")
2016		ok.String(*v.ClusterName)
2017	}
2018
2019	if v.Description != nil {
2020		ok := object.Key("Description")
2021		ok.String(*v.Description)
2022	}
2023
2024	if v.EngineVersion != nil {
2025		ok := object.Key("EngineVersion")
2026		ok.String(*v.EngineVersion)
2027	}
2028
2029	if v.KmsKeyId != nil {
2030		ok := object.Key("KmsKeyId")
2031		ok.String(*v.KmsKeyId)
2032	}
2033
2034	if v.MaintenanceWindow != nil {
2035		ok := object.Key("MaintenanceWindow")
2036		ok.String(*v.MaintenanceWindow)
2037	}
2038
2039	if v.NodeType != nil {
2040		ok := object.Key("NodeType")
2041		ok.String(*v.NodeType)
2042	}
2043
2044	if v.NumReplicasPerShard != nil {
2045		ok := object.Key("NumReplicasPerShard")
2046		ok.Integer(*v.NumReplicasPerShard)
2047	}
2048
2049	if v.NumShards != nil {
2050		ok := object.Key("NumShards")
2051		ok.Integer(*v.NumShards)
2052	}
2053
2054	if v.ParameterGroupName != nil {
2055		ok := object.Key("ParameterGroupName")
2056		ok.String(*v.ParameterGroupName)
2057	}
2058
2059	if v.Port != nil {
2060		ok := object.Key("Port")
2061		ok.Integer(*v.Port)
2062	}
2063
2064	if v.SecurityGroupIds != nil {
2065		ok := object.Key("SecurityGroupIds")
2066		if err := awsAwsjson11_serializeDocumentSecurityGroupIdsList(v.SecurityGroupIds, ok); err != nil {
2067			return err
2068		}
2069	}
2070
2071	if v.SnapshotArns != nil {
2072		ok := object.Key("SnapshotArns")
2073		if err := awsAwsjson11_serializeDocumentSnapshotArnsList(v.SnapshotArns, ok); err != nil {
2074			return err
2075		}
2076	}
2077
2078	if v.SnapshotName != nil {
2079		ok := object.Key("SnapshotName")
2080		ok.String(*v.SnapshotName)
2081	}
2082
2083	if v.SnapshotRetentionLimit != nil {
2084		ok := object.Key("SnapshotRetentionLimit")
2085		ok.Integer(*v.SnapshotRetentionLimit)
2086	}
2087
2088	if v.SnapshotWindow != nil {
2089		ok := object.Key("SnapshotWindow")
2090		ok.String(*v.SnapshotWindow)
2091	}
2092
2093	if v.SnsTopicArn != nil {
2094		ok := object.Key("SnsTopicArn")
2095		ok.String(*v.SnsTopicArn)
2096	}
2097
2098	if v.SubnetGroupName != nil {
2099		ok := object.Key("SubnetGroupName")
2100		ok.String(*v.SubnetGroupName)
2101	}
2102
2103	if v.Tags != nil {
2104		ok := object.Key("Tags")
2105		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2106			return err
2107		}
2108	}
2109
2110	if v.TLSEnabled != nil {
2111		ok := object.Key("TLSEnabled")
2112		ok.Boolean(*v.TLSEnabled)
2113	}
2114
2115	return nil
2116}
2117
2118func awsAwsjson11_serializeOpDocumentCreateParameterGroupInput(v *CreateParameterGroupInput, value smithyjson.Value) error {
2119	object := value.Object()
2120	defer object.Close()
2121
2122	if v.Description != nil {
2123		ok := object.Key("Description")
2124		ok.String(*v.Description)
2125	}
2126
2127	if v.Family != nil {
2128		ok := object.Key("Family")
2129		ok.String(*v.Family)
2130	}
2131
2132	if v.ParameterGroupName != nil {
2133		ok := object.Key("ParameterGroupName")
2134		ok.String(*v.ParameterGroupName)
2135	}
2136
2137	if v.Tags != nil {
2138		ok := object.Key("Tags")
2139		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2140			return err
2141		}
2142	}
2143
2144	return nil
2145}
2146
2147func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error {
2148	object := value.Object()
2149	defer object.Close()
2150
2151	if v.ClusterName != nil {
2152		ok := object.Key("ClusterName")
2153		ok.String(*v.ClusterName)
2154	}
2155
2156	if v.KmsKeyId != nil {
2157		ok := object.Key("KmsKeyId")
2158		ok.String(*v.KmsKeyId)
2159	}
2160
2161	if v.SnapshotName != nil {
2162		ok := object.Key("SnapshotName")
2163		ok.String(*v.SnapshotName)
2164	}
2165
2166	if v.Tags != nil {
2167		ok := object.Key("Tags")
2168		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2169			return err
2170		}
2171	}
2172
2173	return nil
2174}
2175
2176func awsAwsjson11_serializeOpDocumentCreateSubnetGroupInput(v *CreateSubnetGroupInput, value smithyjson.Value) error {
2177	object := value.Object()
2178	defer object.Close()
2179
2180	if v.Description != nil {
2181		ok := object.Key("Description")
2182		ok.String(*v.Description)
2183	}
2184
2185	if v.SubnetGroupName != nil {
2186		ok := object.Key("SubnetGroupName")
2187		ok.String(*v.SubnetGroupName)
2188	}
2189
2190	if v.SubnetIds != nil {
2191		ok := object.Key("SubnetIds")
2192		if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
2193			return err
2194		}
2195	}
2196
2197	if v.Tags != nil {
2198		ok := object.Key("Tags")
2199		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2200			return err
2201		}
2202	}
2203
2204	return nil
2205}
2206
2207func awsAwsjson11_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error {
2208	object := value.Object()
2209	defer object.Close()
2210
2211	if v.AccessString != nil {
2212		ok := object.Key("AccessString")
2213		ok.String(*v.AccessString)
2214	}
2215
2216	if v.AuthenticationMode != nil {
2217		ok := object.Key("AuthenticationMode")
2218		if err := awsAwsjson11_serializeDocumentAuthenticationMode(v.AuthenticationMode, ok); err != nil {
2219			return err
2220		}
2221	}
2222
2223	if v.Tags != nil {
2224		ok := object.Key("Tags")
2225		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2226			return err
2227		}
2228	}
2229
2230	if v.UserName != nil {
2231		ok := object.Key("UserName")
2232		ok.String(*v.UserName)
2233	}
2234
2235	return nil
2236}
2237
2238func awsAwsjson11_serializeOpDocumentDeleteACLInput(v *DeleteACLInput, value smithyjson.Value) error {
2239	object := value.Object()
2240	defer object.Close()
2241
2242	if v.ACLName != nil {
2243		ok := object.Key("ACLName")
2244		ok.String(*v.ACLName)
2245	}
2246
2247	return nil
2248}
2249
2250func awsAwsjson11_serializeOpDocumentDeleteClusterInput(v *DeleteClusterInput, value smithyjson.Value) error {
2251	object := value.Object()
2252	defer object.Close()
2253
2254	if v.ClusterName != nil {
2255		ok := object.Key("ClusterName")
2256		ok.String(*v.ClusterName)
2257	}
2258
2259	if v.FinalSnapshotName != nil {
2260		ok := object.Key("FinalSnapshotName")
2261		ok.String(*v.FinalSnapshotName)
2262	}
2263
2264	return nil
2265}
2266
2267func awsAwsjson11_serializeOpDocumentDeleteParameterGroupInput(v *DeleteParameterGroupInput, value smithyjson.Value) error {
2268	object := value.Object()
2269	defer object.Close()
2270
2271	if v.ParameterGroupName != nil {
2272		ok := object.Key("ParameterGroupName")
2273		ok.String(*v.ParameterGroupName)
2274	}
2275
2276	return nil
2277}
2278
2279func awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(v *DeleteSnapshotInput, value smithyjson.Value) error {
2280	object := value.Object()
2281	defer object.Close()
2282
2283	if v.SnapshotName != nil {
2284		ok := object.Key("SnapshotName")
2285		ok.String(*v.SnapshotName)
2286	}
2287
2288	return nil
2289}
2290
2291func awsAwsjson11_serializeOpDocumentDeleteSubnetGroupInput(v *DeleteSubnetGroupInput, value smithyjson.Value) error {
2292	object := value.Object()
2293	defer object.Close()
2294
2295	if v.SubnetGroupName != nil {
2296		ok := object.Key("SubnetGroupName")
2297		ok.String(*v.SubnetGroupName)
2298	}
2299
2300	return nil
2301}
2302
2303func awsAwsjson11_serializeOpDocumentDeleteUserInput(v *DeleteUserInput, value smithyjson.Value) error {
2304	object := value.Object()
2305	defer object.Close()
2306
2307	if v.UserName != nil {
2308		ok := object.Key("UserName")
2309		ok.String(*v.UserName)
2310	}
2311
2312	return nil
2313}
2314
2315func awsAwsjson11_serializeOpDocumentDescribeACLsInput(v *DescribeACLsInput, value smithyjson.Value) error {
2316	object := value.Object()
2317	defer object.Close()
2318
2319	if v.ACLName != nil {
2320		ok := object.Key("ACLName")
2321		ok.String(*v.ACLName)
2322	}
2323
2324	if v.MaxResults != nil {
2325		ok := object.Key("MaxResults")
2326		ok.Integer(*v.MaxResults)
2327	}
2328
2329	if v.NextToken != nil {
2330		ok := object.Key("NextToken")
2331		ok.String(*v.NextToken)
2332	}
2333
2334	return nil
2335}
2336
2337func awsAwsjson11_serializeOpDocumentDescribeClustersInput(v *DescribeClustersInput, value smithyjson.Value) error {
2338	object := value.Object()
2339	defer object.Close()
2340
2341	if v.ClusterName != nil {
2342		ok := object.Key("ClusterName")
2343		ok.String(*v.ClusterName)
2344	}
2345
2346	if v.MaxResults != nil {
2347		ok := object.Key("MaxResults")
2348		ok.Integer(*v.MaxResults)
2349	}
2350
2351	if v.NextToken != nil {
2352		ok := object.Key("NextToken")
2353		ok.String(*v.NextToken)
2354	}
2355
2356	if v.ShowShardDetails != nil {
2357		ok := object.Key("ShowShardDetails")
2358		ok.Boolean(*v.ShowShardDetails)
2359	}
2360
2361	return nil
2362}
2363
2364func awsAwsjson11_serializeOpDocumentDescribeEngineVersionsInput(v *DescribeEngineVersionsInput, value smithyjson.Value) error {
2365	object := value.Object()
2366	defer object.Close()
2367
2368	if v.DefaultOnly {
2369		ok := object.Key("DefaultOnly")
2370		ok.Boolean(v.DefaultOnly)
2371	}
2372
2373	if v.EngineVersion != nil {
2374		ok := object.Key("EngineVersion")
2375		ok.String(*v.EngineVersion)
2376	}
2377
2378	if v.MaxResults != nil {
2379		ok := object.Key("MaxResults")
2380		ok.Integer(*v.MaxResults)
2381	}
2382
2383	if v.NextToken != nil {
2384		ok := object.Key("NextToken")
2385		ok.String(*v.NextToken)
2386	}
2387
2388	if v.ParameterGroupFamily != nil {
2389		ok := object.Key("ParameterGroupFamily")
2390		ok.String(*v.ParameterGroupFamily)
2391	}
2392
2393	return nil
2394}
2395
2396func awsAwsjson11_serializeOpDocumentDescribeEventsInput(v *DescribeEventsInput, value smithyjson.Value) error {
2397	object := value.Object()
2398	defer object.Close()
2399
2400	if v.Duration != nil {
2401		ok := object.Key("Duration")
2402		ok.Integer(*v.Duration)
2403	}
2404
2405	if v.EndTime != nil {
2406		ok := object.Key("EndTime")
2407		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
2408	}
2409
2410	if v.MaxResults != nil {
2411		ok := object.Key("MaxResults")
2412		ok.Integer(*v.MaxResults)
2413	}
2414
2415	if v.NextToken != nil {
2416		ok := object.Key("NextToken")
2417		ok.String(*v.NextToken)
2418	}
2419
2420	if v.SourceName != nil {
2421		ok := object.Key("SourceName")
2422		ok.String(*v.SourceName)
2423	}
2424
2425	if len(v.SourceType) > 0 {
2426		ok := object.Key("SourceType")
2427		ok.String(string(v.SourceType))
2428	}
2429
2430	if v.StartTime != nil {
2431		ok := object.Key("StartTime")
2432		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
2433	}
2434
2435	return nil
2436}
2437
2438func awsAwsjson11_serializeOpDocumentDescribeParameterGroupsInput(v *DescribeParameterGroupsInput, value smithyjson.Value) error {
2439	object := value.Object()
2440	defer object.Close()
2441
2442	if v.MaxResults != nil {
2443		ok := object.Key("MaxResults")
2444		ok.Integer(*v.MaxResults)
2445	}
2446
2447	if v.NextToken != nil {
2448		ok := object.Key("NextToken")
2449		ok.String(*v.NextToken)
2450	}
2451
2452	if v.ParameterGroupName != nil {
2453		ok := object.Key("ParameterGroupName")
2454		ok.String(*v.ParameterGroupName)
2455	}
2456
2457	return nil
2458}
2459
2460func awsAwsjson11_serializeOpDocumentDescribeParametersInput(v *DescribeParametersInput, value smithyjson.Value) error {
2461	object := value.Object()
2462	defer object.Close()
2463
2464	if v.MaxResults != nil {
2465		ok := object.Key("MaxResults")
2466		ok.Integer(*v.MaxResults)
2467	}
2468
2469	if v.NextToken != nil {
2470		ok := object.Key("NextToken")
2471		ok.String(*v.NextToken)
2472	}
2473
2474	if v.ParameterGroupName != nil {
2475		ok := object.Key("ParameterGroupName")
2476		ok.String(*v.ParameterGroupName)
2477	}
2478
2479	return nil
2480}
2481
2482func awsAwsjson11_serializeOpDocumentDescribeServiceUpdatesInput(v *DescribeServiceUpdatesInput, value smithyjson.Value) error {
2483	object := value.Object()
2484	defer object.Close()
2485
2486	if v.ClusterNames != nil {
2487		ok := object.Key("ClusterNames")
2488		if err := awsAwsjson11_serializeDocumentClusterNameList(v.ClusterNames, ok); err != nil {
2489			return err
2490		}
2491	}
2492
2493	if v.MaxResults != nil {
2494		ok := object.Key("MaxResults")
2495		ok.Integer(*v.MaxResults)
2496	}
2497
2498	if v.NextToken != nil {
2499		ok := object.Key("NextToken")
2500		ok.String(*v.NextToken)
2501	}
2502
2503	if v.ServiceUpdateName != nil {
2504		ok := object.Key("ServiceUpdateName")
2505		ok.String(*v.ServiceUpdateName)
2506	}
2507
2508	if v.Status != nil {
2509		ok := object.Key("Status")
2510		if err := awsAwsjson11_serializeDocumentServiceUpdateStatusList(v.Status, ok); err != nil {
2511			return err
2512		}
2513	}
2514
2515	return nil
2516}
2517
2518func awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(v *DescribeSnapshotsInput, value smithyjson.Value) error {
2519	object := value.Object()
2520	defer object.Close()
2521
2522	if v.ClusterName != nil {
2523		ok := object.Key("ClusterName")
2524		ok.String(*v.ClusterName)
2525	}
2526
2527	if v.MaxResults != nil {
2528		ok := object.Key("MaxResults")
2529		ok.Integer(*v.MaxResults)
2530	}
2531
2532	if v.NextToken != nil {
2533		ok := object.Key("NextToken")
2534		ok.String(*v.NextToken)
2535	}
2536
2537	if v.ShowDetail != nil {
2538		ok := object.Key("ShowDetail")
2539		ok.Boolean(*v.ShowDetail)
2540	}
2541
2542	if v.SnapshotName != nil {
2543		ok := object.Key("SnapshotName")
2544		ok.String(*v.SnapshotName)
2545	}
2546
2547	if v.Source != nil {
2548		ok := object.Key("Source")
2549		ok.String(*v.Source)
2550	}
2551
2552	return nil
2553}
2554
2555func awsAwsjson11_serializeOpDocumentDescribeSubnetGroupsInput(v *DescribeSubnetGroupsInput, value smithyjson.Value) error {
2556	object := value.Object()
2557	defer object.Close()
2558
2559	if v.MaxResults != nil {
2560		ok := object.Key("MaxResults")
2561		ok.Integer(*v.MaxResults)
2562	}
2563
2564	if v.NextToken != nil {
2565		ok := object.Key("NextToken")
2566		ok.String(*v.NextToken)
2567	}
2568
2569	if v.SubnetGroupName != nil {
2570		ok := object.Key("SubnetGroupName")
2571		ok.String(*v.SubnetGroupName)
2572	}
2573
2574	return nil
2575}
2576
2577func awsAwsjson11_serializeOpDocumentDescribeUsersInput(v *DescribeUsersInput, value smithyjson.Value) error {
2578	object := value.Object()
2579	defer object.Close()
2580
2581	if v.Filters != nil {
2582		ok := object.Key("Filters")
2583		if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, ok); err != nil {
2584			return err
2585		}
2586	}
2587
2588	if v.MaxResults != nil {
2589		ok := object.Key("MaxResults")
2590		ok.Integer(*v.MaxResults)
2591	}
2592
2593	if v.NextToken != nil {
2594		ok := object.Key("NextToken")
2595		ok.String(*v.NextToken)
2596	}
2597
2598	if v.UserName != nil {
2599		ok := object.Key("UserName")
2600		ok.String(*v.UserName)
2601	}
2602
2603	return nil
2604}
2605
2606func awsAwsjson11_serializeOpDocumentFailoverShardInput(v *FailoverShardInput, value smithyjson.Value) error {
2607	object := value.Object()
2608	defer object.Close()
2609
2610	if v.ClusterName != nil {
2611		ok := object.Key("ClusterName")
2612		ok.String(*v.ClusterName)
2613	}
2614
2615	if v.ShardName != nil {
2616		ok := object.Key("ShardName")
2617		ok.String(*v.ShardName)
2618	}
2619
2620	return nil
2621}
2622
2623func awsAwsjson11_serializeOpDocumentListAllowedNodeTypeUpdatesInput(v *ListAllowedNodeTypeUpdatesInput, value smithyjson.Value) error {
2624	object := value.Object()
2625	defer object.Close()
2626
2627	if v.ClusterName != nil {
2628		ok := object.Key("ClusterName")
2629		ok.String(*v.ClusterName)
2630	}
2631
2632	return nil
2633}
2634
2635func awsAwsjson11_serializeOpDocumentListTagsInput(v *ListTagsInput, value smithyjson.Value) error {
2636	object := value.Object()
2637	defer object.Close()
2638
2639	if v.ResourceArn != nil {
2640		ok := object.Key("ResourceArn")
2641		ok.String(*v.ResourceArn)
2642	}
2643
2644	return nil
2645}
2646
2647func awsAwsjson11_serializeOpDocumentResetParameterGroupInput(v *ResetParameterGroupInput, value smithyjson.Value) error {
2648	object := value.Object()
2649	defer object.Close()
2650
2651	if v.AllParameters {
2652		ok := object.Key("AllParameters")
2653		ok.Boolean(v.AllParameters)
2654	}
2655
2656	if v.ParameterGroupName != nil {
2657		ok := object.Key("ParameterGroupName")
2658		ok.String(*v.ParameterGroupName)
2659	}
2660
2661	if v.ParameterNames != nil {
2662		ok := object.Key("ParameterNames")
2663		if err := awsAwsjson11_serializeDocumentParameterNameList(v.ParameterNames, ok); err != nil {
2664			return err
2665		}
2666	}
2667
2668	return nil
2669}
2670
2671func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
2672	object := value.Object()
2673	defer object.Close()
2674
2675	if v.ResourceArn != nil {
2676		ok := object.Key("ResourceArn")
2677		ok.String(*v.ResourceArn)
2678	}
2679
2680	if v.Tags != nil {
2681		ok := object.Key("Tags")
2682		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
2683			return err
2684		}
2685	}
2686
2687	return nil
2688}
2689
2690func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
2691	object := value.Object()
2692	defer object.Close()
2693
2694	if v.ResourceArn != nil {
2695		ok := object.Key("ResourceArn")
2696		ok.String(*v.ResourceArn)
2697	}
2698
2699	if v.TagKeys != nil {
2700		ok := object.Key("TagKeys")
2701		if err := awsAwsjson11_serializeDocumentKeyList(v.TagKeys, ok); err != nil {
2702			return err
2703		}
2704	}
2705
2706	return nil
2707}
2708
2709func awsAwsjson11_serializeOpDocumentUpdateACLInput(v *UpdateACLInput, value smithyjson.Value) error {
2710	object := value.Object()
2711	defer object.Close()
2712
2713	if v.ACLName != nil {
2714		ok := object.Key("ACLName")
2715		ok.String(*v.ACLName)
2716	}
2717
2718	if v.UserNamesToAdd != nil {
2719		ok := object.Key("UserNamesToAdd")
2720		if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNamesToAdd, ok); err != nil {
2721			return err
2722		}
2723	}
2724
2725	if v.UserNamesToRemove != nil {
2726		ok := object.Key("UserNamesToRemove")
2727		if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNamesToRemove, ok); err != nil {
2728			return err
2729		}
2730	}
2731
2732	return nil
2733}
2734
2735func awsAwsjson11_serializeOpDocumentUpdateClusterInput(v *UpdateClusterInput, value smithyjson.Value) error {
2736	object := value.Object()
2737	defer object.Close()
2738
2739	if v.ACLName != nil {
2740		ok := object.Key("ACLName")
2741		ok.String(*v.ACLName)
2742	}
2743
2744	if v.ClusterName != nil {
2745		ok := object.Key("ClusterName")
2746		ok.String(*v.ClusterName)
2747	}
2748
2749	if v.Description != nil {
2750		ok := object.Key("Description")
2751		ok.String(*v.Description)
2752	}
2753
2754	if v.EngineVersion != nil {
2755		ok := object.Key("EngineVersion")
2756		ok.String(*v.EngineVersion)
2757	}
2758
2759	if v.MaintenanceWindow != nil {
2760		ok := object.Key("MaintenanceWindow")
2761		ok.String(*v.MaintenanceWindow)
2762	}
2763
2764	if v.NodeType != nil {
2765		ok := object.Key("NodeType")
2766		ok.String(*v.NodeType)
2767	}
2768
2769	if v.ParameterGroupName != nil {
2770		ok := object.Key("ParameterGroupName")
2771		ok.String(*v.ParameterGroupName)
2772	}
2773
2774	if v.ReplicaConfiguration != nil {
2775		ok := object.Key("ReplicaConfiguration")
2776		if err := awsAwsjson11_serializeDocumentReplicaConfigurationRequest(v.ReplicaConfiguration, ok); err != nil {
2777			return err
2778		}
2779	}
2780
2781	if v.SecurityGroupIds != nil {
2782		ok := object.Key("SecurityGroupIds")
2783		if err := awsAwsjson11_serializeDocumentSecurityGroupIdsList(v.SecurityGroupIds, ok); err != nil {
2784			return err
2785		}
2786	}
2787
2788	if v.ShardConfiguration != nil {
2789		ok := object.Key("ShardConfiguration")
2790		if err := awsAwsjson11_serializeDocumentShardConfigurationRequest(v.ShardConfiguration, ok); err != nil {
2791			return err
2792		}
2793	}
2794
2795	if v.SnapshotRetentionLimit != nil {
2796		ok := object.Key("SnapshotRetentionLimit")
2797		ok.Integer(*v.SnapshotRetentionLimit)
2798	}
2799
2800	if v.SnapshotWindow != nil {
2801		ok := object.Key("SnapshotWindow")
2802		ok.String(*v.SnapshotWindow)
2803	}
2804
2805	if v.SnsTopicArn != nil {
2806		ok := object.Key("SnsTopicArn")
2807		ok.String(*v.SnsTopicArn)
2808	}
2809
2810	if v.SnsTopicStatus != nil {
2811		ok := object.Key("SnsTopicStatus")
2812		ok.String(*v.SnsTopicStatus)
2813	}
2814
2815	return nil
2816}
2817
2818func awsAwsjson11_serializeOpDocumentUpdateParameterGroupInput(v *UpdateParameterGroupInput, value smithyjson.Value) error {
2819	object := value.Object()
2820	defer object.Close()
2821
2822	if v.ParameterGroupName != nil {
2823		ok := object.Key("ParameterGroupName")
2824		ok.String(*v.ParameterGroupName)
2825	}
2826
2827	if v.ParameterNameValues != nil {
2828		ok := object.Key("ParameterNameValues")
2829		if err := awsAwsjson11_serializeDocumentParameterNameValueList(v.ParameterNameValues, ok); err != nil {
2830			return err
2831		}
2832	}
2833
2834	return nil
2835}
2836
2837func awsAwsjson11_serializeOpDocumentUpdateSubnetGroupInput(v *UpdateSubnetGroupInput, value smithyjson.Value) error {
2838	object := value.Object()
2839	defer object.Close()
2840
2841	if v.Description != nil {
2842		ok := object.Key("Description")
2843		ok.String(*v.Description)
2844	}
2845
2846	if v.SubnetGroupName != nil {
2847		ok := object.Key("SubnetGroupName")
2848		ok.String(*v.SubnetGroupName)
2849	}
2850
2851	if v.SubnetIds != nil {
2852		ok := object.Key("SubnetIds")
2853		if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
2854			return err
2855		}
2856	}
2857
2858	return nil
2859}
2860
2861func awsAwsjson11_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error {
2862	object := value.Object()
2863	defer object.Close()
2864
2865	if v.AccessString != nil {
2866		ok := object.Key("AccessString")
2867		ok.String(*v.AccessString)
2868	}
2869
2870	if v.AuthenticationMode != nil {
2871		ok := object.Key("AuthenticationMode")
2872		if err := awsAwsjson11_serializeDocumentAuthenticationMode(v.AuthenticationMode, ok); err != nil {
2873			return err
2874		}
2875	}
2876
2877	if v.UserName != nil {
2878		ok := object.Key("UserName")
2879		ok.String(*v.UserName)
2880	}
2881
2882	return nil
2883}
2884