1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package gamelift
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/gamelift/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_serializeOpAcceptMatch struct {
19}
20
21func (*awsAwsjson11_serializeOpAcceptMatch) ID() string {
22	return "OperationSerializer"
23}
24
25func (m *awsAwsjson11_serializeOpAcceptMatch) 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.(*AcceptMatchInput)
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("GameLift.AcceptMatch")
47
48	jsonEncoder := smithyjson.NewEncoder()
49	if err := awsAwsjson11_serializeOpDocumentAcceptMatchInput(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_serializeOpClaimGameServer struct {
66}
67
68func (*awsAwsjson11_serializeOpClaimGameServer) ID() string {
69	return "OperationSerializer"
70}
71
72func (m *awsAwsjson11_serializeOpClaimGameServer) 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.(*ClaimGameServerInput)
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("GameLift.ClaimGameServer")
94
95	jsonEncoder := smithyjson.NewEncoder()
96	if err := awsAwsjson11_serializeOpDocumentClaimGameServerInput(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_serializeOpCreateAlias struct {
113}
114
115func (*awsAwsjson11_serializeOpCreateAlias) ID() string {
116	return "OperationSerializer"
117}
118
119func (m *awsAwsjson11_serializeOpCreateAlias) 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.(*CreateAliasInput)
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("GameLift.CreateAlias")
141
142	jsonEncoder := smithyjson.NewEncoder()
143	if err := awsAwsjson11_serializeOpDocumentCreateAliasInput(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_serializeOpCreateBuild struct {
160}
161
162func (*awsAwsjson11_serializeOpCreateBuild) ID() string {
163	return "OperationSerializer"
164}
165
166func (m *awsAwsjson11_serializeOpCreateBuild) 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.(*CreateBuildInput)
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("GameLift.CreateBuild")
188
189	jsonEncoder := smithyjson.NewEncoder()
190	if err := awsAwsjson11_serializeOpDocumentCreateBuildInput(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_serializeOpCreateFleet struct {
207}
208
209func (*awsAwsjson11_serializeOpCreateFleet) ID() string {
210	return "OperationSerializer"
211}
212
213func (m *awsAwsjson11_serializeOpCreateFleet) 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.(*CreateFleetInput)
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("GameLift.CreateFleet")
235
236	jsonEncoder := smithyjson.NewEncoder()
237	if err := awsAwsjson11_serializeOpDocumentCreateFleetInput(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_serializeOpCreateGameServerGroup struct {
254}
255
256func (*awsAwsjson11_serializeOpCreateGameServerGroup) ID() string {
257	return "OperationSerializer"
258}
259
260func (m *awsAwsjson11_serializeOpCreateGameServerGroup) 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.(*CreateGameServerGroupInput)
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("GameLift.CreateGameServerGroup")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsAwsjson11_serializeOpDocumentCreateGameServerGroupInput(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_serializeOpCreateGameSession struct {
301}
302
303func (*awsAwsjson11_serializeOpCreateGameSession) ID() string {
304	return "OperationSerializer"
305}
306
307func (m *awsAwsjson11_serializeOpCreateGameSession) 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.(*CreateGameSessionInput)
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("GameLift.CreateGameSession")
329
330	jsonEncoder := smithyjson.NewEncoder()
331	if err := awsAwsjson11_serializeOpDocumentCreateGameSessionInput(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_serializeOpCreateGameSessionQueue struct {
348}
349
350func (*awsAwsjson11_serializeOpCreateGameSessionQueue) ID() string {
351	return "OperationSerializer"
352}
353
354func (m *awsAwsjson11_serializeOpCreateGameSessionQueue) 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.(*CreateGameSessionQueueInput)
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("GameLift.CreateGameSessionQueue")
376
377	jsonEncoder := smithyjson.NewEncoder()
378	if err := awsAwsjson11_serializeOpDocumentCreateGameSessionQueueInput(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_serializeOpCreateMatchmakingConfiguration struct {
395}
396
397func (*awsAwsjson11_serializeOpCreateMatchmakingConfiguration) ID() string {
398	return "OperationSerializer"
399}
400
401func (m *awsAwsjson11_serializeOpCreateMatchmakingConfiguration) 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.(*CreateMatchmakingConfigurationInput)
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("GameLift.CreateMatchmakingConfiguration")
423
424	jsonEncoder := smithyjson.NewEncoder()
425	if err := awsAwsjson11_serializeOpDocumentCreateMatchmakingConfigurationInput(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_serializeOpCreateMatchmakingRuleSet struct {
442}
443
444func (*awsAwsjson11_serializeOpCreateMatchmakingRuleSet) ID() string {
445	return "OperationSerializer"
446}
447
448func (m *awsAwsjson11_serializeOpCreateMatchmakingRuleSet) 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.(*CreateMatchmakingRuleSetInput)
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("GameLift.CreateMatchmakingRuleSet")
470
471	jsonEncoder := smithyjson.NewEncoder()
472	if err := awsAwsjson11_serializeOpDocumentCreateMatchmakingRuleSetInput(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_serializeOpCreatePlayerSession struct {
489}
490
491func (*awsAwsjson11_serializeOpCreatePlayerSession) ID() string {
492	return "OperationSerializer"
493}
494
495func (m *awsAwsjson11_serializeOpCreatePlayerSession) 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.(*CreatePlayerSessionInput)
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("GameLift.CreatePlayerSession")
517
518	jsonEncoder := smithyjson.NewEncoder()
519	if err := awsAwsjson11_serializeOpDocumentCreatePlayerSessionInput(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_serializeOpCreatePlayerSessions struct {
536}
537
538func (*awsAwsjson11_serializeOpCreatePlayerSessions) ID() string {
539	return "OperationSerializer"
540}
541
542func (m *awsAwsjson11_serializeOpCreatePlayerSessions) 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.(*CreatePlayerSessionsInput)
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("GameLift.CreatePlayerSessions")
564
565	jsonEncoder := smithyjson.NewEncoder()
566	if err := awsAwsjson11_serializeOpDocumentCreatePlayerSessionsInput(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_serializeOpCreateScript struct {
583}
584
585func (*awsAwsjson11_serializeOpCreateScript) ID() string {
586	return "OperationSerializer"
587}
588
589func (m *awsAwsjson11_serializeOpCreateScript) 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.(*CreateScriptInput)
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("GameLift.CreateScript")
611
612	jsonEncoder := smithyjson.NewEncoder()
613	if err := awsAwsjson11_serializeOpDocumentCreateScriptInput(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_serializeOpCreateVpcPeeringAuthorization struct {
630}
631
632func (*awsAwsjson11_serializeOpCreateVpcPeeringAuthorization) ID() string {
633	return "OperationSerializer"
634}
635
636func (m *awsAwsjson11_serializeOpCreateVpcPeeringAuthorization) 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.(*CreateVpcPeeringAuthorizationInput)
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("GameLift.CreateVpcPeeringAuthorization")
658
659	jsonEncoder := smithyjson.NewEncoder()
660	if err := awsAwsjson11_serializeOpDocumentCreateVpcPeeringAuthorizationInput(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_serializeOpCreateVpcPeeringConnection struct {
677}
678
679func (*awsAwsjson11_serializeOpCreateVpcPeeringConnection) ID() string {
680	return "OperationSerializer"
681}
682
683func (m *awsAwsjson11_serializeOpCreateVpcPeeringConnection) 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.(*CreateVpcPeeringConnectionInput)
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("GameLift.CreateVpcPeeringConnection")
705
706	jsonEncoder := smithyjson.NewEncoder()
707	if err := awsAwsjson11_serializeOpDocumentCreateVpcPeeringConnectionInput(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_serializeOpDeleteAlias struct {
724}
725
726func (*awsAwsjson11_serializeOpDeleteAlias) ID() string {
727	return "OperationSerializer"
728}
729
730func (m *awsAwsjson11_serializeOpDeleteAlias) 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.(*DeleteAliasInput)
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("GameLift.DeleteAlias")
752
753	jsonEncoder := smithyjson.NewEncoder()
754	if err := awsAwsjson11_serializeOpDocumentDeleteAliasInput(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_serializeOpDeleteBuild struct {
771}
772
773func (*awsAwsjson11_serializeOpDeleteBuild) ID() string {
774	return "OperationSerializer"
775}
776
777func (m *awsAwsjson11_serializeOpDeleteBuild) 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.(*DeleteBuildInput)
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("GameLift.DeleteBuild")
799
800	jsonEncoder := smithyjson.NewEncoder()
801	if err := awsAwsjson11_serializeOpDocumentDeleteBuildInput(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_serializeOpDeleteFleet struct {
818}
819
820func (*awsAwsjson11_serializeOpDeleteFleet) ID() string {
821	return "OperationSerializer"
822}
823
824func (m *awsAwsjson11_serializeOpDeleteFleet) 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.(*DeleteFleetInput)
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("GameLift.DeleteFleet")
846
847	jsonEncoder := smithyjson.NewEncoder()
848	if err := awsAwsjson11_serializeOpDocumentDeleteFleetInput(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_serializeOpDeleteGameServerGroup struct {
865}
866
867func (*awsAwsjson11_serializeOpDeleteGameServerGroup) ID() string {
868	return "OperationSerializer"
869}
870
871func (m *awsAwsjson11_serializeOpDeleteGameServerGroup) 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.(*DeleteGameServerGroupInput)
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("GameLift.DeleteGameServerGroup")
893
894	jsonEncoder := smithyjson.NewEncoder()
895	if err := awsAwsjson11_serializeOpDocumentDeleteGameServerGroupInput(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_serializeOpDeleteGameSessionQueue struct {
912}
913
914func (*awsAwsjson11_serializeOpDeleteGameSessionQueue) ID() string {
915	return "OperationSerializer"
916}
917
918func (m *awsAwsjson11_serializeOpDeleteGameSessionQueue) 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.(*DeleteGameSessionQueueInput)
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("GameLift.DeleteGameSessionQueue")
940
941	jsonEncoder := smithyjson.NewEncoder()
942	if err := awsAwsjson11_serializeOpDocumentDeleteGameSessionQueueInput(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_serializeOpDeleteMatchmakingConfiguration struct {
959}
960
961func (*awsAwsjson11_serializeOpDeleteMatchmakingConfiguration) ID() string {
962	return "OperationSerializer"
963}
964
965func (m *awsAwsjson11_serializeOpDeleteMatchmakingConfiguration) 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.(*DeleteMatchmakingConfigurationInput)
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("GameLift.DeleteMatchmakingConfiguration")
987
988	jsonEncoder := smithyjson.NewEncoder()
989	if err := awsAwsjson11_serializeOpDocumentDeleteMatchmakingConfigurationInput(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_serializeOpDeleteMatchmakingRuleSet struct {
1006}
1007
1008func (*awsAwsjson11_serializeOpDeleteMatchmakingRuleSet) ID() string {
1009	return "OperationSerializer"
1010}
1011
1012func (m *awsAwsjson11_serializeOpDeleteMatchmakingRuleSet) 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.(*DeleteMatchmakingRuleSetInput)
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("GameLift.DeleteMatchmakingRuleSet")
1034
1035	jsonEncoder := smithyjson.NewEncoder()
1036	if err := awsAwsjson11_serializeOpDocumentDeleteMatchmakingRuleSetInput(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_serializeOpDeleteScalingPolicy struct {
1053}
1054
1055func (*awsAwsjson11_serializeOpDeleteScalingPolicy) ID() string {
1056	return "OperationSerializer"
1057}
1058
1059func (m *awsAwsjson11_serializeOpDeleteScalingPolicy) 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.(*DeleteScalingPolicyInput)
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("GameLift.DeleteScalingPolicy")
1081
1082	jsonEncoder := smithyjson.NewEncoder()
1083	if err := awsAwsjson11_serializeOpDocumentDeleteScalingPolicyInput(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_serializeOpDeleteScript struct {
1100}
1101
1102func (*awsAwsjson11_serializeOpDeleteScript) ID() string {
1103	return "OperationSerializer"
1104}
1105
1106func (m *awsAwsjson11_serializeOpDeleteScript) 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.(*DeleteScriptInput)
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("GameLift.DeleteScript")
1128
1129	jsonEncoder := smithyjson.NewEncoder()
1130	if err := awsAwsjson11_serializeOpDocumentDeleteScriptInput(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_serializeOpDeleteVpcPeeringAuthorization struct {
1147}
1148
1149func (*awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization) ID() string {
1150	return "OperationSerializer"
1151}
1152
1153func (m *awsAwsjson11_serializeOpDeleteVpcPeeringAuthorization) 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.(*DeleteVpcPeeringAuthorizationInput)
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("GameLift.DeleteVpcPeeringAuthorization")
1175
1176	jsonEncoder := smithyjson.NewEncoder()
1177	if err := awsAwsjson11_serializeOpDocumentDeleteVpcPeeringAuthorizationInput(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_serializeOpDeleteVpcPeeringConnection struct {
1194}
1195
1196func (*awsAwsjson11_serializeOpDeleteVpcPeeringConnection) ID() string {
1197	return "OperationSerializer"
1198}
1199
1200func (m *awsAwsjson11_serializeOpDeleteVpcPeeringConnection) 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.(*DeleteVpcPeeringConnectionInput)
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("GameLift.DeleteVpcPeeringConnection")
1222
1223	jsonEncoder := smithyjson.NewEncoder()
1224	if err := awsAwsjson11_serializeOpDocumentDeleteVpcPeeringConnectionInput(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_serializeOpDeregisterGameServer struct {
1241}
1242
1243func (*awsAwsjson11_serializeOpDeregisterGameServer) ID() string {
1244	return "OperationSerializer"
1245}
1246
1247func (m *awsAwsjson11_serializeOpDeregisterGameServer) 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.(*DeregisterGameServerInput)
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("GameLift.DeregisterGameServer")
1269
1270	jsonEncoder := smithyjson.NewEncoder()
1271	if err := awsAwsjson11_serializeOpDocumentDeregisterGameServerInput(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_serializeOpDescribeAlias struct {
1288}
1289
1290func (*awsAwsjson11_serializeOpDescribeAlias) ID() string {
1291	return "OperationSerializer"
1292}
1293
1294func (m *awsAwsjson11_serializeOpDescribeAlias) 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.(*DescribeAliasInput)
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("GameLift.DescribeAlias")
1316
1317	jsonEncoder := smithyjson.NewEncoder()
1318	if err := awsAwsjson11_serializeOpDocumentDescribeAliasInput(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_serializeOpDescribeBuild struct {
1335}
1336
1337func (*awsAwsjson11_serializeOpDescribeBuild) ID() string {
1338	return "OperationSerializer"
1339}
1340
1341func (m *awsAwsjson11_serializeOpDescribeBuild) 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.(*DescribeBuildInput)
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("GameLift.DescribeBuild")
1363
1364	jsonEncoder := smithyjson.NewEncoder()
1365	if err := awsAwsjson11_serializeOpDocumentDescribeBuildInput(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_serializeOpDescribeEC2InstanceLimits struct {
1382}
1383
1384func (*awsAwsjson11_serializeOpDescribeEC2InstanceLimits) ID() string {
1385	return "OperationSerializer"
1386}
1387
1388func (m *awsAwsjson11_serializeOpDescribeEC2InstanceLimits) 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.(*DescribeEC2InstanceLimitsInput)
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("GameLift.DescribeEC2InstanceLimits")
1410
1411	jsonEncoder := smithyjson.NewEncoder()
1412	if err := awsAwsjson11_serializeOpDocumentDescribeEC2InstanceLimitsInput(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_serializeOpDescribeFleetAttributes struct {
1429}
1430
1431func (*awsAwsjson11_serializeOpDescribeFleetAttributes) ID() string {
1432	return "OperationSerializer"
1433}
1434
1435func (m *awsAwsjson11_serializeOpDescribeFleetAttributes) 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.(*DescribeFleetAttributesInput)
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("GameLift.DescribeFleetAttributes")
1457
1458	jsonEncoder := smithyjson.NewEncoder()
1459	if err := awsAwsjson11_serializeOpDocumentDescribeFleetAttributesInput(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_serializeOpDescribeFleetCapacity struct {
1476}
1477
1478func (*awsAwsjson11_serializeOpDescribeFleetCapacity) ID() string {
1479	return "OperationSerializer"
1480}
1481
1482func (m *awsAwsjson11_serializeOpDescribeFleetCapacity) 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.(*DescribeFleetCapacityInput)
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("GameLift.DescribeFleetCapacity")
1504
1505	jsonEncoder := smithyjson.NewEncoder()
1506	if err := awsAwsjson11_serializeOpDocumentDescribeFleetCapacityInput(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_serializeOpDescribeFleetEvents struct {
1523}
1524
1525func (*awsAwsjson11_serializeOpDescribeFleetEvents) ID() string {
1526	return "OperationSerializer"
1527}
1528
1529func (m *awsAwsjson11_serializeOpDescribeFleetEvents) 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.(*DescribeFleetEventsInput)
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("GameLift.DescribeFleetEvents")
1551
1552	jsonEncoder := smithyjson.NewEncoder()
1553	if err := awsAwsjson11_serializeOpDocumentDescribeFleetEventsInput(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_serializeOpDescribeFleetPortSettings struct {
1570}
1571
1572func (*awsAwsjson11_serializeOpDescribeFleetPortSettings) ID() string {
1573	return "OperationSerializer"
1574}
1575
1576func (m *awsAwsjson11_serializeOpDescribeFleetPortSettings) 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.(*DescribeFleetPortSettingsInput)
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("GameLift.DescribeFleetPortSettings")
1598
1599	jsonEncoder := smithyjson.NewEncoder()
1600	if err := awsAwsjson11_serializeOpDocumentDescribeFleetPortSettingsInput(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_serializeOpDescribeFleetUtilization struct {
1617}
1618
1619func (*awsAwsjson11_serializeOpDescribeFleetUtilization) ID() string {
1620	return "OperationSerializer"
1621}
1622
1623func (m *awsAwsjson11_serializeOpDescribeFleetUtilization) 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.(*DescribeFleetUtilizationInput)
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("GameLift.DescribeFleetUtilization")
1645
1646	jsonEncoder := smithyjson.NewEncoder()
1647	if err := awsAwsjson11_serializeOpDocumentDescribeFleetUtilizationInput(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}
1662
1663type awsAwsjson11_serializeOpDescribeGameServer struct {
1664}
1665
1666func (*awsAwsjson11_serializeOpDescribeGameServer) ID() string {
1667	return "OperationSerializer"
1668}
1669
1670func (m *awsAwsjson11_serializeOpDescribeGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1671	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1672) {
1673	request, ok := in.Request.(*smithyhttp.Request)
1674	if !ok {
1675		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1676	}
1677
1678	input, ok := in.Parameters.(*DescribeGameServerInput)
1679	_ = input
1680	if !ok {
1681		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1682	}
1683
1684	request.Request.URL.Path = "/"
1685	request.Request.Method = "POST"
1686	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1687	if err != nil {
1688		return out, metadata, &smithy.SerializationError{Err: err}
1689	}
1690	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1691	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServer")
1692
1693	jsonEncoder := smithyjson.NewEncoder()
1694	if err := awsAwsjson11_serializeOpDocumentDescribeGameServerInput(input, jsonEncoder.Value); err != nil {
1695		return out, metadata, &smithy.SerializationError{Err: err}
1696	}
1697
1698	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1699		return out, metadata, &smithy.SerializationError{Err: err}
1700	}
1701
1702	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1703		return out, metadata, &smithy.SerializationError{Err: err}
1704	}
1705	in.Request = request
1706
1707	return next.HandleSerialize(ctx, in)
1708}
1709
1710type awsAwsjson11_serializeOpDescribeGameServerGroup struct {
1711}
1712
1713func (*awsAwsjson11_serializeOpDescribeGameServerGroup) ID() string {
1714	return "OperationSerializer"
1715}
1716
1717func (m *awsAwsjson11_serializeOpDescribeGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1718	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1719) {
1720	request, ok := in.Request.(*smithyhttp.Request)
1721	if !ok {
1722		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1723	}
1724
1725	input, ok := in.Parameters.(*DescribeGameServerGroupInput)
1726	_ = input
1727	if !ok {
1728		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1729	}
1730
1731	request.Request.URL.Path = "/"
1732	request.Request.Method = "POST"
1733	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1734	if err != nil {
1735		return out, metadata, &smithy.SerializationError{Err: err}
1736	}
1737	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1738	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServerGroup")
1739
1740	jsonEncoder := smithyjson.NewEncoder()
1741	if err := awsAwsjson11_serializeOpDocumentDescribeGameServerGroupInput(input, jsonEncoder.Value); err != nil {
1742		return out, metadata, &smithy.SerializationError{Err: err}
1743	}
1744
1745	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1746		return out, metadata, &smithy.SerializationError{Err: err}
1747	}
1748
1749	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1750		return out, metadata, &smithy.SerializationError{Err: err}
1751	}
1752	in.Request = request
1753
1754	return next.HandleSerialize(ctx, in)
1755}
1756
1757type awsAwsjson11_serializeOpDescribeGameServerInstances struct {
1758}
1759
1760func (*awsAwsjson11_serializeOpDescribeGameServerInstances) ID() string {
1761	return "OperationSerializer"
1762}
1763
1764func (m *awsAwsjson11_serializeOpDescribeGameServerInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1765	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1766) {
1767	request, ok := in.Request.(*smithyhttp.Request)
1768	if !ok {
1769		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1770	}
1771
1772	input, ok := in.Parameters.(*DescribeGameServerInstancesInput)
1773	_ = input
1774	if !ok {
1775		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1776	}
1777
1778	request.Request.URL.Path = "/"
1779	request.Request.Method = "POST"
1780	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1781	if err != nil {
1782		return out, metadata, &smithy.SerializationError{Err: err}
1783	}
1784	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1785	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameServerInstances")
1786
1787	jsonEncoder := smithyjson.NewEncoder()
1788	if err := awsAwsjson11_serializeOpDocumentDescribeGameServerInstancesInput(input, jsonEncoder.Value); err != nil {
1789		return out, metadata, &smithy.SerializationError{Err: err}
1790	}
1791
1792	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1793		return out, metadata, &smithy.SerializationError{Err: err}
1794	}
1795
1796	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1797		return out, metadata, &smithy.SerializationError{Err: err}
1798	}
1799	in.Request = request
1800
1801	return next.HandleSerialize(ctx, in)
1802}
1803
1804type awsAwsjson11_serializeOpDescribeGameSessionDetails struct {
1805}
1806
1807func (*awsAwsjson11_serializeOpDescribeGameSessionDetails) ID() string {
1808	return "OperationSerializer"
1809}
1810
1811func (m *awsAwsjson11_serializeOpDescribeGameSessionDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1812	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1813) {
1814	request, ok := in.Request.(*smithyhttp.Request)
1815	if !ok {
1816		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1817	}
1818
1819	input, ok := in.Parameters.(*DescribeGameSessionDetailsInput)
1820	_ = input
1821	if !ok {
1822		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1823	}
1824
1825	request.Request.URL.Path = "/"
1826	request.Request.Method = "POST"
1827	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1828	if err != nil {
1829		return out, metadata, &smithy.SerializationError{Err: err}
1830	}
1831	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1832	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionDetails")
1833
1834	jsonEncoder := smithyjson.NewEncoder()
1835	if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionDetailsInput(input, jsonEncoder.Value); err != nil {
1836		return out, metadata, &smithy.SerializationError{Err: err}
1837	}
1838
1839	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1840		return out, metadata, &smithy.SerializationError{Err: err}
1841	}
1842
1843	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1844		return out, metadata, &smithy.SerializationError{Err: err}
1845	}
1846	in.Request = request
1847
1848	return next.HandleSerialize(ctx, in)
1849}
1850
1851type awsAwsjson11_serializeOpDescribeGameSessionPlacement struct {
1852}
1853
1854func (*awsAwsjson11_serializeOpDescribeGameSessionPlacement) ID() string {
1855	return "OperationSerializer"
1856}
1857
1858func (m *awsAwsjson11_serializeOpDescribeGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1859	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1860) {
1861	request, ok := in.Request.(*smithyhttp.Request)
1862	if !ok {
1863		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1864	}
1865
1866	input, ok := in.Parameters.(*DescribeGameSessionPlacementInput)
1867	_ = input
1868	if !ok {
1869		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1870	}
1871
1872	request.Request.URL.Path = "/"
1873	request.Request.Method = "POST"
1874	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1875	if err != nil {
1876		return out, metadata, &smithy.SerializationError{Err: err}
1877	}
1878	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1879	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionPlacement")
1880
1881	jsonEncoder := smithyjson.NewEncoder()
1882	if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
1883		return out, metadata, &smithy.SerializationError{Err: err}
1884	}
1885
1886	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1887		return out, metadata, &smithy.SerializationError{Err: err}
1888	}
1889
1890	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1891		return out, metadata, &smithy.SerializationError{Err: err}
1892	}
1893	in.Request = request
1894
1895	return next.HandleSerialize(ctx, in)
1896}
1897
1898type awsAwsjson11_serializeOpDescribeGameSessionQueues struct {
1899}
1900
1901func (*awsAwsjson11_serializeOpDescribeGameSessionQueues) ID() string {
1902	return "OperationSerializer"
1903}
1904
1905func (m *awsAwsjson11_serializeOpDescribeGameSessionQueues) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1906	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1907) {
1908	request, ok := in.Request.(*smithyhttp.Request)
1909	if !ok {
1910		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1911	}
1912
1913	input, ok := in.Parameters.(*DescribeGameSessionQueuesInput)
1914	_ = input
1915	if !ok {
1916		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1917	}
1918
1919	request.Request.URL.Path = "/"
1920	request.Request.Method = "POST"
1921	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1922	if err != nil {
1923		return out, metadata, &smithy.SerializationError{Err: err}
1924	}
1925	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1926	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessionQueues")
1927
1928	jsonEncoder := smithyjson.NewEncoder()
1929	if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionQueuesInput(input, jsonEncoder.Value); err != nil {
1930		return out, metadata, &smithy.SerializationError{Err: err}
1931	}
1932
1933	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1934		return out, metadata, &smithy.SerializationError{Err: err}
1935	}
1936
1937	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1938		return out, metadata, &smithy.SerializationError{Err: err}
1939	}
1940	in.Request = request
1941
1942	return next.HandleSerialize(ctx, in)
1943}
1944
1945type awsAwsjson11_serializeOpDescribeGameSessions struct {
1946}
1947
1948func (*awsAwsjson11_serializeOpDescribeGameSessions) ID() string {
1949	return "OperationSerializer"
1950}
1951
1952func (m *awsAwsjson11_serializeOpDescribeGameSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1953	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1954) {
1955	request, ok := in.Request.(*smithyhttp.Request)
1956	if !ok {
1957		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1958	}
1959
1960	input, ok := in.Parameters.(*DescribeGameSessionsInput)
1961	_ = input
1962	if !ok {
1963		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1964	}
1965
1966	request.Request.URL.Path = "/"
1967	request.Request.Method = "POST"
1968	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1969	if err != nil {
1970		return out, metadata, &smithy.SerializationError{Err: err}
1971	}
1972	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1973	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeGameSessions")
1974
1975	jsonEncoder := smithyjson.NewEncoder()
1976	if err := awsAwsjson11_serializeOpDocumentDescribeGameSessionsInput(input, jsonEncoder.Value); err != nil {
1977		return out, metadata, &smithy.SerializationError{Err: err}
1978	}
1979
1980	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1981		return out, metadata, &smithy.SerializationError{Err: err}
1982	}
1983
1984	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1985		return out, metadata, &smithy.SerializationError{Err: err}
1986	}
1987	in.Request = request
1988
1989	return next.HandleSerialize(ctx, in)
1990}
1991
1992type awsAwsjson11_serializeOpDescribeInstances struct {
1993}
1994
1995func (*awsAwsjson11_serializeOpDescribeInstances) ID() string {
1996	return "OperationSerializer"
1997}
1998
1999func (m *awsAwsjson11_serializeOpDescribeInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2000	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2001) {
2002	request, ok := in.Request.(*smithyhttp.Request)
2003	if !ok {
2004		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2005	}
2006
2007	input, ok := in.Parameters.(*DescribeInstancesInput)
2008	_ = input
2009	if !ok {
2010		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2011	}
2012
2013	request.Request.URL.Path = "/"
2014	request.Request.Method = "POST"
2015	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2016	if err != nil {
2017		return out, metadata, &smithy.SerializationError{Err: err}
2018	}
2019	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2020	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeInstances")
2021
2022	jsonEncoder := smithyjson.NewEncoder()
2023	if err := awsAwsjson11_serializeOpDocumentDescribeInstancesInput(input, jsonEncoder.Value); err != nil {
2024		return out, metadata, &smithy.SerializationError{Err: err}
2025	}
2026
2027	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2028		return out, metadata, &smithy.SerializationError{Err: err}
2029	}
2030
2031	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2032		return out, metadata, &smithy.SerializationError{Err: err}
2033	}
2034	in.Request = request
2035
2036	return next.HandleSerialize(ctx, in)
2037}
2038
2039type awsAwsjson11_serializeOpDescribeMatchmaking struct {
2040}
2041
2042func (*awsAwsjson11_serializeOpDescribeMatchmaking) ID() string {
2043	return "OperationSerializer"
2044}
2045
2046func (m *awsAwsjson11_serializeOpDescribeMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2047	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2048) {
2049	request, ok := in.Request.(*smithyhttp.Request)
2050	if !ok {
2051		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2052	}
2053
2054	input, ok := in.Parameters.(*DescribeMatchmakingInput)
2055	_ = input
2056	if !ok {
2057		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2058	}
2059
2060	request.Request.URL.Path = "/"
2061	request.Request.Method = "POST"
2062	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2063	if err != nil {
2064		return out, metadata, &smithy.SerializationError{Err: err}
2065	}
2066	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2067	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmaking")
2068
2069	jsonEncoder := smithyjson.NewEncoder()
2070	if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingInput(input, jsonEncoder.Value); err != nil {
2071		return out, metadata, &smithy.SerializationError{Err: err}
2072	}
2073
2074	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2075		return out, metadata, &smithy.SerializationError{Err: err}
2076	}
2077
2078	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2079		return out, metadata, &smithy.SerializationError{Err: err}
2080	}
2081	in.Request = request
2082
2083	return next.HandleSerialize(ctx, in)
2084}
2085
2086type awsAwsjson11_serializeOpDescribeMatchmakingConfigurations struct {
2087}
2088
2089func (*awsAwsjson11_serializeOpDescribeMatchmakingConfigurations) ID() string {
2090	return "OperationSerializer"
2091}
2092
2093func (m *awsAwsjson11_serializeOpDescribeMatchmakingConfigurations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2094	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2095) {
2096	request, ok := in.Request.(*smithyhttp.Request)
2097	if !ok {
2098		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2099	}
2100
2101	input, ok := in.Parameters.(*DescribeMatchmakingConfigurationsInput)
2102	_ = input
2103	if !ok {
2104		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2105	}
2106
2107	request.Request.URL.Path = "/"
2108	request.Request.Method = "POST"
2109	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2110	if err != nil {
2111		return out, metadata, &smithy.SerializationError{Err: err}
2112	}
2113	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2114	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmakingConfigurations")
2115
2116	jsonEncoder := smithyjson.NewEncoder()
2117	if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingConfigurationsInput(input, jsonEncoder.Value); err != nil {
2118		return out, metadata, &smithy.SerializationError{Err: err}
2119	}
2120
2121	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2122		return out, metadata, &smithy.SerializationError{Err: err}
2123	}
2124
2125	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2126		return out, metadata, &smithy.SerializationError{Err: err}
2127	}
2128	in.Request = request
2129
2130	return next.HandleSerialize(ctx, in)
2131}
2132
2133type awsAwsjson11_serializeOpDescribeMatchmakingRuleSets struct {
2134}
2135
2136func (*awsAwsjson11_serializeOpDescribeMatchmakingRuleSets) ID() string {
2137	return "OperationSerializer"
2138}
2139
2140func (m *awsAwsjson11_serializeOpDescribeMatchmakingRuleSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2141	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	request, ok := in.Request.(*smithyhttp.Request)
2144	if !ok {
2145		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2146	}
2147
2148	input, ok := in.Parameters.(*DescribeMatchmakingRuleSetsInput)
2149	_ = input
2150	if !ok {
2151		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2152	}
2153
2154	request.Request.URL.Path = "/"
2155	request.Request.Method = "POST"
2156	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2157	if err != nil {
2158		return out, metadata, &smithy.SerializationError{Err: err}
2159	}
2160	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2161	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeMatchmakingRuleSets")
2162
2163	jsonEncoder := smithyjson.NewEncoder()
2164	if err := awsAwsjson11_serializeOpDocumentDescribeMatchmakingRuleSetsInput(input, jsonEncoder.Value); err != nil {
2165		return out, metadata, &smithy.SerializationError{Err: err}
2166	}
2167
2168	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2169		return out, metadata, &smithy.SerializationError{Err: err}
2170	}
2171
2172	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2173		return out, metadata, &smithy.SerializationError{Err: err}
2174	}
2175	in.Request = request
2176
2177	return next.HandleSerialize(ctx, in)
2178}
2179
2180type awsAwsjson11_serializeOpDescribePlayerSessions struct {
2181}
2182
2183func (*awsAwsjson11_serializeOpDescribePlayerSessions) ID() string {
2184	return "OperationSerializer"
2185}
2186
2187func (m *awsAwsjson11_serializeOpDescribePlayerSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2188	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2189) {
2190	request, ok := in.Request.(*smithyhttp.Request)
2191	if !ok {
2192		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2193	}
2194
2195	input, ok := in.Parameters.(*DescribePlayerSessionsInput)
2196	_ = input
2197	if !ok {
2198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2199	}
2200
2201	request.Request.URL.Path = "/"
2202	request.Request.Method = "POST"
2203	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2204	if err != nil {
2205		return out, metadata, &smithy.SerializationError{Err: err}
2206	}
2207	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2208	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribePlayerSessions")
2209
2210	jsonEncoder := smithyjson.NewEncoder()
2211	if err := awsAwsjson11_serializeOpDocumentDescribePlayerSessionsInput(input, jsonEncoder.Value); err != nil {
2212		return out, metadata, &smithy.SerializationError{Err: err}
2213	}
2214
2215	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2216		return out, metadata, &smithy.SerializationError{Err: err}
2217	}
2218
2219	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2220		return out, metadata, &smithy.SerializationError{Err: err}
2221	}
2222	in.Request = request
2223
2224	return next.HandleSerialize(ctx, in)
2225}
2226
2227type awsAwsjson11_serializeOpDescribeRuntimeConfiguration struct {
2228}
2229
2230func (*awsAwsjson11_serializeOpDescribeRuntimeConfiguration) ID() string {
2231	return "OperationSerializer"
2232}
2233
2234func (m *awsAwsjson11_serializeOpDescribeRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2235	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2236) {
2237	request, ok := in.Request.(*smithyhttp.Request)
2238	if !ok {
2239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2240	}
2241
2242	input, ok := in.Parameters.(*DescribeRuntimeConfigurationInput)
2243	_ = input
2244	if !ok {
2245		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2246	}
2247
2248	request.Request.URL.Path = "/"
2249	request.Request.Method = "POST"
2250	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2251	if err != nil {
2252		return out, metadata, &smithy.SerializationError{Err: err}
2253	}
2254	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2255	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeRuntimeConfiguration")
2256
2257	jsonEncoder := smithyjson.NewEncoder()
2258	if err := awsAwsjson11_serializeOpDocumentDescribeRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil {
2259		return out, metadata, &smithy.SerializationError{Err: err}
2260	}
2261
2262	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2263		return out, metadata, &smithy.SerializationError{Err: err}
2264	}
2265
2266	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2267		return out, metadata, &smithy.SerializationError{Err: err}
2268	}
2269	in.Request = request
2270
2271	return next.HandleSerialize(ctx, in)
2272}
2273
2274type awsAwsjson11_serializeOpDescribeScalingPolicies struct {
2275}
2276
2277func (*awsAwsjson11_serializeOpDescribeScalingPolicies) ID() string {
2278	return "OperationSerializer"
2279}
2280
2281func (m *awsAwsjson11_serializeOpDescribeScalingPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2282	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2283) {
2284	request, ok := in.Request.(*smithyhttp.Request)
2285	if !ok {
2286		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2287	}
2288
2289	input, ok := in.Parameters.(*DescribeScalingPoliciesInput)
2290	_ = input
2291	if !ok {
2292		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2293	}
2294
2295	request.Request.URL.Path = "/"
2296	request.Request.Method = "POST"
2297	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2298	if err != nil {
2299		return out, metadata, &smithy.SerializationError{Err: err}
2300	}
2301	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2302	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeScalingPolicies")
2303
2304	jsonEncoder := smithyjson.NewEncoder()
2305	if err := awsAwsjson11_serializeOpDocumentDescribeScalingPoliciesInput(input, jsonEncoder.Value); err != nil {
2306		return out, metadata, &smithy.SerializationError{Err: err}
2307	}
2308
2309	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2310		return out, metadata, &smithy.SerializationError{Err: err}
2311	}
2312
2313	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2314		return out, metadata, &smithy.SerializationError{Err: err}
2315	}
2316	in.Request = request
2317
2318	return next.HandleSerialize(ctx, in)
2319}
2320
2321type awsAwsjson11_serializeOpDescribeScript struct {
2322}
2323
2324func (*awsAwsjson11_serializeOpDescribeScript) ID() string {
2325	return "OperationSerializer"
2326}
2327
2328func (m *awsAwsjson11_serializeOpDescribeScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2329	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2330) {
2331	request, ok := in.Request.(*smithyhttp.Request)
2332	if !ok {
2333		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2334	}
2335
2336	input, ok := in.Parameters.(*DescribeScriptInput)
2337	_ = input
2338	if !ok {
2339		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2340	}
2341
2342	request.Request.URL.Path = "/"
2343	request.Request.Method = "POST"
2344	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2345	if err != nil {
2346		return out, metadata, &smithy.SerializationError{Err: err}
2347	}
2348	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2349	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeScript")
2350
2351	jsonEncoder := smithyjson.NewEncoder()
2352	if err := awsAwsjson11_serializeOpDocumentDescribeScriptInput(input, jsonEncoder.Value); err != nil {
2353		return out, metadata, &smithy.SerializationError{Err: err}
2354	}
2355
2356	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2357		return out, metadata, &smithy.SerializationError{Err: err}
2358	}
2359
2360	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2361		return out, metadata, &smithy.SerializationError{Err: err}
2362	}
2363	in.Request = request
2364
2365	return next.HandleSerialize(ctx, in)
2366}
2367
2368type awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations struct {
2369}
2370
2371func (*awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations) ID() string {
2372	return "OperationSerializer"
2373}
2374
2375func (m *awsAwsjson11_serializeOpDescribeVpcPeeringAuthorizations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2376	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2377) {
2378	request, ok := in.Request.(*smithyhttp.Request)
2379	if !ok {
2380		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2381	}
2382
2383	input, ok := in.Parameters.(*DescribeVpcPeeringAuthorizationsInput)
2384	_ = input
2385	if !ok {
2386		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2387	}
2388
2389	request.Request.URL.Path = "/"
2390	request.Request.Method = "POST"
2391	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2392	if err != nil {
2393		return out, metadata, &smithy.SerializationError{Err: err}
2394	}
2395	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2396	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeVpcPeeringAuthorizations")
2397
2398	jsonEncoder := smithyjson.NewEncoder()
2399	if err := awsAwsjson11_serializeOpDocumentDescribeVpcPeeringAuthorizationsInput(input, jsonEncoder.Value); err != nil {
2400		return out, metadata, &smithy.SerializationError{Err: err}
2401	}
2402
2403	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2404		return out, metadata, &smithy.SerializationError{Err: err}
2405	}
2406
2407	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2408		return out, metadata, &smithy.SerializationError{Err: err}
2409	}
2410	in.Request = request
2411
2412	return next.HandleSerialize(ctx, in)
2413}
2414
2415type awsAwsjson11_serializeOpDescribeVpcPeeringConnections struct {
2416}
2417
2418func (*awsAwsjson11_serializeOpDescribeVpcPeeringConnections) ID() string {
2419	return "OperationSerializer"
2420}
2421
2422func (m *awsAwsjson11_serializeOpDescribeVpcPeeringConnections) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2423	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2424) {
2425	request, ok := in.Request.(*smithyhttp.Request)
2426	if !ok {
2427		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2428	}
2429
2430	input, ok := in.Parameters.(*DescribeVpcPeeringConnectionsInput)
2431	_ = input
2432	if !ok {
2433		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2434	}
2435
2436	request.Request.URL.Path = "/"
2437	request.Request.Method = "POST"
2438	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2439	if err != nil {
2440		return out, metadata, &smithy.SerializationError{Err: err}
2441	}
2442	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2443	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.DescribeVpcPeeringConnections")
2444
2445	jsonEncoder := smithyjson.NewEncoder()
2446	if err := awsAwsjson11_serializeOpDocumentDescribeVpcPeeringConnectionsInput(input, jsonEncoder.Value); err != nil {
2447		return out, metadata, &smithy.SerializationError{Err: err}
2448	}
2449
2450	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2451		return out, metadata, &smithy.SerializationError{Err: err}
2452	}
2453
2454	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2455		return out, metadata, &smithy.SerializationError{Err: err}
2456	}
2457	in.Request = request
2458
2459	return next.HandleSerialize(ctx, in)
2460}
2461
2462type awsAwsjson11_serializeOpGetGameSessionLogUrl struct {
2463}
2464
2465func (*awsAwsjson11_serializeOpGetGameSessionLogUrl) ID() string {
2466	return "OperationSerializer"
2467}
2468
2469func (m *awsAwsjson11_serializeOpGetGameSessionLogUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2470	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2471) {
2472	request, ok := in.Request.(*smithyhttp.Request)
2473	if !ok {
2474		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2475	}
2476
2477	input, ok := in.Parameters.(*GetGameSessionLogUrlInput)
2478	_ = input
2479	if !ok {
2480		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2481	}
2482
2483	request.Request.URL.Path = "/"
2484	request.Request.Method = "POST"
2485	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2486	if err != nil {
2487		return out, metadata, &smithy.SerializationError{Err: err}
2488	}
2489	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2490	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetGameSessionLogUrl")
2491
2492	jsonEncoder := smithyjson.NewEncoder()
2493	if err := awsAwsjson11_serializeOpDocumentGetGameSessionLogUrlInput(input, jsonEncoder.Value); err != nil {
2494		return out, metadata, &smithy.SerializationError{Err: err}
2495	}
2496
2497	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2498		return out, metadata, &smithy.SerializationError{Err: err}
2499	}
2500
2501	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2502		return out, metadata, &smithy.SerializationError{Err: err}
2503	}
2504	in.Request = request
2505
2506	return next.HandleSerialize(ctx, in)
2507}
2508
2509type awsAwsjson11_serializeOpGetInstanceAccess struct {
2510}
2511
2512func (*awsAwsjson11_serializeOpGetInstanceAccess) ID() string {
2513	return "OperationSerializer"
2514}
2515
2516func (m *awsAwsjson11_serializeOpGetInstanceAccess) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2517	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2518) {
2519	request, ok := in.Request.(*smithyhttp.Request)
2520	if !ok {
2521		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2522	}
2523
2524	input, ok := in.Parameters.(*GetInstanceAccessInput)
2525	_ = input
2526	if !ok {
2527		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2528	}
2529
2530	request.Request.URL.Path = "/"
2531	request.Request.Method = "POST"
2532	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2533	if err != nil {
2534		return out, metadata, &smithy.SerializationError{Err: err}
2535	}
2536	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2537	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.GetInstanceAccess")
2538
2539	jsonEncoder := smithyjson.NewEncoder()
2540	if err := awsAwsjson11_serializeOpDocumentGetInstanceAccessInput(input, jsonEncoder.Value); err != nil {
2541		return out, metadata, &smithy.SerializationError{Err: err}
2542	}
2543
2544	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2545		return out, metadata, &smithy.SerializationError{Err: err}
2546	}
2547
2548	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2549		return out, metadata, &smithy.SerializationError{Err: err}
2550	}
2551	in.Request = request
2552
2553	return next.HandleSerialize(ctx, in)
2554}
2555
2556type awsAwsjson11_serializeOpListAliases struct {
2557}
2558
2559func (*awsAwsjson11_serializeOpListAliases) ID() string {
2560	return "OperationSerializer"
2561}
2562
2563func (m *awsAwsjson11_serializeOpListAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2564	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2565) {
2566	request, ok := in.Request.(*smithyhttp.Request)
2567	if !ok {
2568		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2569	}
2570
2571	input, ok := in.Parameters.(*ListAliasesInput)
2572	_ = input
2573	if !ok {
2574		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2575	}
2576
2577	request.Request.URL.Path = "/"
2578	request.Request.Method = "POST"
2579	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2580	if err != nil {
2581		return out, metadata, &smithy.SerializationError{Err: err}
2582	}
2583	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2584	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListAliases")
2585
2586	jsonEncoder := smithyjson.NewEncoder()
2587	if err := awsAwsjson11_serializeOpDocumentListAliasesInput(input, jsonEncoder.Value); err != nil {
2588		return out, metadata, &smithy.SerializationError{Err: err}
2589	}
2590
2591	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2592		return out, metadata, &smithy.SerializationError{Err: err}
2593	}
2594
2595	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2596		return out, metadata, &smithy.SerializationError{Err: err}
2597	}
2598	in.Request = request
2599
2600	return next.HandleSerialize(ctx, in)
2601}
2602
2603type awsAwsjson11_serializeOpListBuilds struct {
2604}
2605
2606func (*awsAwsjson11_serializeOpListBuilds) ID() string {
2607	return "OperationSerializer"
2608}
2609
2610func (m *awsAwsjson11_serializeOpListBuilds) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2611	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2612) {
2613	request, ok := in.Request.(*smithyhttp.Request)
2614	if !ok {
2615		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2616	}
2617
2618	input, ok := in.Parameters.(*ListBuildsInput)
2619	_ = input
2620	if !ok {
2621		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2622	}
2623
2624	request.Request.URL.Path = "/"
2625	request.Request.Method = "POST"
2626	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2627	if err != nil {
2628		return out, metadata, &smithy.SerializationError{Err: err}
2629	}
2630	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2631	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListBuilds")
2632
2633	jsonEncoder := smithyjson.NewEncoder()
2634	if err := awsAwsjson11_serializeOpDocumentListBuildsInput(input, jsonEncoder.Value); err != nil {
2635		return out, metadata, &smithy.SerializationError{Err: err}
2636	}
2637
2638	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2639		return out, metadata, &smithy.SerializationError{Err: err}
2640	}
2641
2642	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2643		return out, metadata, &smithy.SerializationError{Err: err}
2644	}
2645	in.Request = request
2646
2647	return next.HandleSerialize(ctx, in)
2648}
2649
2650type awsAwsjson11_serializeOpListFleets struct {
2651}
2652
2653func (*awsAwsjson11_serializeOpListFleets) ID() string {
2654	return "OperationSerializer"
2655}
2656
2657func (m *awsAwsjson11_serializeOpListFleets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2658	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2659) {
2660	request, ok := in.Request.(*smithyhttp.Request)
2661	if !ok {
2662		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2663	}
2664
2665	input, ok := in.Parameters.(*ListFleetsInput)
2666	_ = input
2667	if !ok {
2668		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2669	}
2670
2671	request.Request.URL.Path = "/"
2672	request.Request.Method = "POST"
2673	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2674	if err != nil {
2675		return out, metadata, &smithy.SerializationError{Err: err}
2676	}
2677	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2678	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListFleets")
2679
2680	jsonEncoder := smithyjson.NewEncoder()
2681	if err := awsAwsjson11_serializeOpDocumentListFleetsInput(input, jsonEncoder.Value); err != nil {
2682		return out, metadata, &smithy.SerializationError{Err: err}
2683	}
2684
2685	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2686		return out, metadata, &smithy.SerializationError{Err: err}
2687	}
2688
2689	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2690		return out, metadata, &smithy.SerializationError{Err: err}
2691	}
2692	in.Request = request
2693
2694	return next.HandleSerialize(ctx, in)
2695}
2696
2697type awsAwsjson11_serializeOpListGameServerGroups struct {
2698}
2699
2700func (*awsAwsjson11_serializeOpListGameServerGroups) ID() string {
2701	return "OperationSerializer"
2702}
2703
2704func (m *awsAwsjson11_serializeOpListGameServerGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2705	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2706) {
2707	request, ok := in.Request.(*smithyhttp.Request)
2708	if !ok {
2709		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2710	}
2711
2712	input, ok := in.Parameters.(*ListGameServerGroupsInput)
2713	_ = input
2714	if !ok {
2715		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2716	}
2717
2718	request.Request.URL.Path = "/"
2719	request.Request.Method = "POST"
2720	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2721	if err != nil {
2722		return out, metadata, &smithy.SerializationError{Err: err}
2723	}
2724	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2725	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListGameServerGroups")
2726
2727	jsonEncoder := smithyjson.NewEncoder()
2728	if err := awsAwsjson11_serializeOpDocumentListGameServerGroupsInput(input, jsonEncoder.Value); err != nil {
2729		return out, metadata, &smithy.SerializationError{Err: err}
2730	}
2731
2732	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2733		return out, metadata, &smithy.SerializationError{Err: err}
2734	}
2735
2736	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2737		return out, metadata, &smithy.SerializationError{Err: err}
2738	}
2739	in.Request = request
2740
2741	return next.HandleSerialize(ctx, in)
2742}
2743
2744type awsAwsjson11_serializeOpListGameServers struct {
2745}
2746
2747func (*awsAwsjson11_serializeOpListGameServers) ID() string {
2748	return "OperationSerializer"
2749}
2750
2751func (m *awsAwsjson11_serializeOpListGameServers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2752	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2753) {
2754	request, ok := in.Request.(*smithyhttp.Request)
2755	if !ok {
2756		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2757	}
2758
2759	input, ok := in.Parameters.(*ListGameServersInput)
2760	_ = input
2761	if !ok {
2762		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2763	}
2764
2765	request.Request.URL.Path = "/"
2766	request.Request.Method = "POST"
2767	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2768	if err != nil {
2769		return out, metadata, &smithy.SerializationError{Err: err}
2770	}
2771	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2772	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListGameServers")
2773
2774	jsonEncoder := smithyjson.NewEncoder()
2775	if err := awsAwsjson11_serializeOpDocumentListGameServersInput(input, jsonEncoder.Value); err != nil {
2776		return out, metadata, &smithy.SerializationError{Err: err}
2777	}
2778
2779	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2780		return out, metadata, &smithy.SerializationError{Err: err}
2781	}
2782
2783	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2784		return out, metadata, &smithy.SerializationError{Err: err}
2785	}
2786	in.Request = request
2787
2788	return next.HandleSerialize(ctx, in)
2789}
2790
2791type awsAwsjson11_serializeOpListScripts struct {
2792}
2793
2794func (*awsAwsjson11_serializeOpListScripts) ID() string {
2795	return "OperationSerializer"
2796}
2797
2798func (m *awsAwsjson11_serializeOpListScripts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2799	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2800) {
2801	request, ok := in.Request.(*smithyhttp.Request)
2802	if !ok {
2803		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2804	}
2805
2806	input, ok := in.Parameters.(*ListScriptsInput)
2807	_ = input
2808	if !ok {
2809		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2810	}
2811
2812	request.Request.URL.Path = "/"
2813	request.Request.Method = "POST"
2814	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2815	if err != nil {
2816		return out, metadata, &smithy.SerializationError{Err: err}
2817	}
2818	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2819	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListScripts")
2820
2821	jsonEncoder := smithyjson.NewEncoder()
2822	if err := awsAwsjson11_serializeOpDocumentListScriptsInput(input, jsonEncoder.Value); err != nil {
2823		return out, metadata, &smithy.SerializationError{Err: err}
2824	}
2825
2826	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2827		return out, metadata, &smithy.SerializationError{Err: err}
2828	}
2829
2830	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2831		return out, metadata, &smithy.SerializationError{Err: err}
2832	}
2833	in.Request = request
2834
2835	return next.HandleSerialize(ctx, in)
2836}
2837
2838type awsAwsjson11_serializeOpListTagsForResource struct {
2839}
2840
2841func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
2842	return "OperationSerializer"
2843}
2844
2845func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2846	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2847) {
2848	request, ok := in.Request.(*smithyhttp.Request)
2849	if !ok {
2850		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2851	}
2852
2853	input, ok := in.Parameters.(*ListTagsForResourceInput)
2854	_ = input
2855	if !ok {
2856		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2857	}
2858
2859	request.Request.URL.Path = "/"
2860	request.Request.Method = "POST"
2861	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2862	if err != nil {
2863		return out, metadata, &smithy.SerializationError{Err: err}
2864	}
2865	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2866	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ListTagsForResource")
2867
2868	jsonEncoder := smithyjson.NewEncoder()
2869	if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
2870		return out, metadata, &smithy.SerializationError{Err: err}
2871	}
2872
2873	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2874		return out, metadata, &smithy.SerializationError{Err: err}
2875	}
2876
2877	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2878		return out, metadata, &smithy.SerializationError{Err: err}
2879	}
2880	in.Request = request
2881
2882	return next.HandleSerialize(ctx, in)
2883}
2884
2885type awsAwsjson11_serializeOpPutScalingPolicy struct {
2886}
2887
2888func (*awsAwsjson11_serializeOpPutScalingPolicy) ID() string {
2889	return "OperationSerializer"
2890}
2891
2892func (m *awsAwsjson11_serializeOpPutScalingPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2893	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2894) {
2895	request, ok := in.Request.(*smithyhttp.Request)
2896	if !ok {
2897		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2898	}
2899
2900	input, ok := in.Parameters.(*PutScalingPolicyInput)
2901	_ = input
2902	if !ok {
2903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2904	}
2905
2906	request.Request.URL.Path = "/"
2907	request.Request.Method = "POST"
2908	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2909	if err != nil {
2910		return out, metadata, &smithy.SerializationError{Err: err}
2911	}
2912	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2913	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.PutScalingPolicy")
2914
2915	jsonEncoder := smithyjson.NewEncoder()
2916	if err := awsAwsjson11_serializeOpDocumentPutScalingPolicyInput(input, jsonEncoder.Value); err != nil {
2917		return out, metadata, &smithy.SerializationError{Err: err}
2918	}
2919
2920	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2921		return out, metadata, &smithy.SerializationError{Err: err}
2922	}
2923
2924	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2925		return out, metadata, &smithy.SerializationError{Err: err}
2926	}
2927	in.Request = request
2928
2929	return next.HandleSerialize(ctx, in)
2930}
2931
2932type awsAwsjson11_serializeOpRegisterGameServer struct {
2933}
2934
2935func (*awsAwsjson11_serializeOpRegisterGameServer) ID() string {
2936	return "OperationSerializer"
2937}
2938
2939func (m *awsAwsjson11_serializeOpRegisterGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2940	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2941) {
2942	request, ok := in.Request.(*smithyhttp.Request)
2943	if !ok {
2944		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2945	}
2946
2947	input, ok := in.Parameters.(*RegisterGameServerInput)
2948	_ = input
2949	if !ok {
2950		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2951	}
2952
2953	request.Request.URL.Path = "/"
2954	request.Request.Method = "POST"
2955	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2956	if err != nil {
2957		return out, metadata, &smithy.SerializationError{Err: err}
2958	}
2959	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2960	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.RegisterGameServer")
2961
2962	jsonEncoder := smithyjson.NewEncoder()
2963	if err := awsAwsjson11_serializeOpDocumentRegisterGameServerInput(input, jsonEncoder.Value); err != nil {
2964		return out, metadata, &smithy.SerializationError{Err: err}
2965	}
2966
2967	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2968		return out, metadata, &smithy.SerializationError{Err: err}
2969	}
2970
2971	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2972		return out, metadata, &smithy.SerializationError{Err: err}
2973	}
2974	in.Request = request
2975
2976	return next.HandleSerialize(ctx, in)
2977}
2978
2979type awsAwsjson11_serializeOpRequestUploadCredentials struct {
2980}
2981
2982func (*awsAwsjson11_serializeOpRequestUploadCredentials) ID() string {
2983	return "OperationSerializer"
2984}
2985
2986func (m *awsAwsjson11_serializeOpRequestUploadCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2987	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2988) {
2989	request, ok := in.Request.(*smithyhttp.Request)
2990	if !ok {
2991		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2992	}
2993
2994	input, ok := in.Parameters.(*RequestUploadCredentialsInput)
2995	_ = input
2996	if !ok {
2997		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2998	}
2999
3000	request.Request.URL.Path = "/"
3001	request.Request.Method = "POST"
3002	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3003	if err != nil {
3004		return out, metadata, &smithy.SerializationError{Err: err}
3005	}
3006	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3007	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.RequestUploadCredentials")
3008
3009	jsonEncoder := smithyjson.NewEncoder()
3010	if err := awsAwsjson11_serializeOpDocumentRequestUploadCredentialsInput(input, jsonEncoder.Value); err != nil {
3011		return out, metadata, &smithy.SerializationError{Err: err}
3012	}
3013
3014	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3015		return out, metadata, &smithy.SerializationError{Err: err}
3016	}
3017
3018	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3019		return out, metadata, &smithy.SerializationError{Err: err}
3020	}
3021	in.Request = request
3022
3023	return next.HandleSerialize(ctx, in)
3024}
3025
3026type awsAwsjson11_serializeOpResolveAlias struct {
3027}
3028
3029func (*awsAwsjson11_serializeOpResolveAlias) ID() string {
3030	return "OperationSerializer"
3031}
3032
3033func (m *awsAwsjson11_serializeOpResolveAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3034	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3035) {
3036	request, ok := in.Request.(*smithyhttp.Request)
3037	if !ok {
3038		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3039	}
3040
3041	input, ok := in.Parameters.(*ResolveAliasInput)
3042	_ = input
3043	if !ok {
3044		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3045	}
3046
3047	request.Request.URL.Path = "/"
3048	request.Request.Method = "POST"
3049	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3050	if err != nil {
3051		return out, metadata, &smithy.SerializationError{Err: err}
3052	}
3053	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3054	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ResolveAlias")
3055
3056	jsonEncoder := smithyjson.NewEncoder()
3057	if err := awsAwsjson11_serializeOpDocumentResolveAliasInput(input, jsonEncoder.Value); err != nil {
3058		return out, metadata, &smithy.SerializationError{Err: err}
3059	}
3060
3061	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3062		return out, metadata, &smithy.SerializationError{Err: err}
3063	}
3064
3065	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3066		return out, metadata, &smithy.SerializationError{Err: err}
3067	}
3068	in.Request = request
3069
3070	return next.HandleSerialize(ctx, in)
3071}
3072
3073type awsAwsjson11_serializeOpResumeGameServerGroup struct {
3074}
3075
3076func (*awsAwsjson11_serializeOpResumeGameServerGroup) ID() string {
3077	return "OperationSerializer"
3078}
3079
3080func (m *awsAwsjson11_serializeOpResumeGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3081	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3082) {
3083	request, ok := in.Request.(*smithyhttp.Request)
3084	if !ok {
3085		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3086	}
3087
3088	input, ok := in.Parameters.(*ResumeGameServerGroupInput)
3089	_ = input
3090	if !ok {
3091		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3092	}
3093
3094	request.Request.URL.Path = "/"
3095	request.Request.Method = "POST"
3096	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3097	if err != nil {
3098		return out, metadata, &smithy.SerializationError{Err: err}
3099	}
3100	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3101	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ResumeGameServerGroup")
3102
3103	jsonEncoder := smithyjson.NewEncoder()
3104	if err := awsAwsjson11_serializeOpDocumentResumeGameServerGroupInput(input, jsonEncoder.Value); err != nil {
3105		return out, metadata, &smithy.SerializationError{Err: err}
3106	}
3107
3108	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3109		return out, metadata, &smithy.SerializationError{Err: err}
3110	}
3111
3112	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3113		return out, metadata, &smithy.SerializationError{Err: err}
3114	}
3115	in.Request = request
3116
3117	return next.HandleSerialize(ctx, in)
3118}
3119
3120type awsAwsjson11_serializeOpSearchGameSessions struct {
3121}
3122
3123func (*awsAwsjson11_serializeOpSearchGameSessions) ID() string {
3124	return "OperationSerializer"
3125}
3126
3127func (m *awsAwsjson11_serializeOpSearchGameSessions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3128	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3129) {
3130	request, ok := in.Request.(*smithyhttp.Request)
3131	if !ok {
3132		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3133	}
3134
3135	input, ok := in.Parameters.(*SearchGameSessionsInput)
3136	_ = input
3137	if !ok {
3138		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3139	}
3140
3141	request.Request.URL.Path = "/"
3142	request.Request.Method = "POST"
3143	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3144	if err != nil {
3145		return out, metadata, &smithy.SerializationError{Err: err}
3146	}
3147	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3148	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.SearchGameSessions")
3149
3150	jsonEncoder := smithyjson.NewEncoder()
3151	if err := awsAwsjson11_serializeOpDocumentSearchGameSessionsInput(input, jsonEncoder.Value); err != nil {
3152		return out, metadata, &smithy.SerializationError{Err: err}
3153	}
3154
3155	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3156		return out, metadata, &smithy.SerializationError{Err: err}
3157	}
3158
3159	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3160		return out, metadata, &smithy.SerializationError{Err: err}
3161	}
3162	in.Request = request
3163
3164	return next.HandleSerialize(ctx, in)
3165}
3166
3167type awsAwsjson11_serializeOpStartFleetActions struct {
3168}
3169
3170func (*awsAwsjson11_serializeOpStartFleetActions) ID() string {
3171	return "OperationSerializer"
3172}
3173
3174func (m *awsAwsjson11_serializeOpStartFleetActions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3175	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3176) {
3177	request, ok := in.Request.(*smithyhttp.Request)
3178	if !ok {
3179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3180	}
3181
3182	input, ok := in.Parameters.(*StartFleetActionsInput)
3183	_ = input
3184	if !ok {
3185		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3186	}
3187
3188	request.Request.URL.Path = "/"
3189	request.Request.Method = "POST"
3190	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3191	if err != nil {
3192		return out, metadata, &smithy.SerializationError{Err: err}
3193	}
3194	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3195	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartFleetActions")
3196
3197	jsonEncoder := smithyjson.NewEncoder()
3198	if err := awsAwsjson11_serializeOpDocumentStartFleetActionsInput(input, jsonEncoder.Value); err != nil {
3199		return out, metadata, &smithy.SerializationError{Err: err}
3200	}
3201
3202	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3203		return out, metadata, &smithy.SerializationError{Err: err}
3204	}
3205
3206	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3207		return out, metadata, &smithy.SerializationError{Err: err}
3208	}
3209	in.Request = request
3210
3211	return next.HandleSerialize(ctx, in)
3212}
3213
3214type awsAwsjson11_serializeOpStartGameSessionPlacement struct {
3215}
3216
3217func (*awsAwsjson11_serializeOpStartGameSessionPlacement) ID() string {
3218	return "OperationSerializer"
3219}
3220
3221func (m *awsAwsjson11_serializeOpStartGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3222	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3223) {
3224	request, ok := in.Request.(*smithyhttp.Request)
3225	if !ok {
3226		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3227	}
3228
3229	input, ok := in.Parameters.(*StartGameSessionPlacementInput)
3230	_ = input
3231	if !ok {
3232		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3233	}
3234
3235	request.Request.URL.Path = "/"
3236	request.Request.Method = "POST"
3237	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3238	if err != nil {
3239		return out, metadata, &smithy.SerializationError{Err: err}
3240	}
3241	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3242	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartGameSessionPlacement")
3243
3244	jsonEncoder := smithyjson.NewEncoder()
3245	if err := awsAwsjson11_serializeOpDocumentStartGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
3246		return out, metadata, &smithy.SerializationError{Err: err}
3247	}
3248
3249	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3250		return out, metadata, &smithy.SerializationError{Err: err}
3251	}
3252
3253	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3254		return out, metadata, &smithy.SerializationError{Err: err}
3255	}
3256	in.Request = request
3257
3258	return next.HandleSerialize(ctx, in)
3259}
3260
3261type awsAwsjson11_serializeOpStartMatchBackfill struct {
3262}
3263
3264func (*awsAwsjson11_serializeOpStartMatchBackfill) ID() string {
3265	return "OperationSerializer"
3266}
3267
3268func (m *awsAwsjson11_serializeOpStartMatchBackfill) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3269	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3270) {
3271	request, ok := in.Request.(*smithyhttp.Request)
3272	if !ok {
3273		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3274	}
3275
3276	input, ok := in.Parameters.(*StartMatchBackfillInput)
3277	_ = input
3278	if !ok {
3279		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3280	}
3281
3282	request.Request.URL.Path = "/"
3283	request.Request.Method = "POST"
3284	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3285	if err != nil {
3286		return out, metadata, &smithy.SerializationError{Err: err}
3287	}
3288	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3289	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartMatchBackfill")
3290
3291	jsonEncoder := smithyjson.NewEncoder()
3292	if err := awsAwsjson11_serializeOpDocumentStartMatchBackfillInput(input, jsonEncoder.Value); err != nil {
3293		return out, metadata, &smithy.SerializationError{Err: err}
3294	}
3295
3296	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3297		return out, metadata, &smithy.SerializationError{Err: err}
3298	}
3299
3300	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3301		return out, metadata, &smithy.SerializationError{Err: err}
3302	}
3303	in.Request = request
3304
3305	return next.HandleSerialize(ctx, in)
3306}
3307
3308type awsAwsjson11_serializeOpStartMatchmaking struct {
3309}
3310
3311func (*awsAwsjson11_serializeOpStartMatchmaking) ID() string {
3312	return "OperationSerializer"
3313}
3314
3315func (m *awsAwsjson11_serializeOpStartMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3316	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3317) {
3318	request, ok := in.Request.(*smithyhttp.Request)
3319	if !ok {
3320		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3321	}
3322
3323	input, ok := in.Parameters.(*StartMatchmakingInput)
3324	_ = input
3325	if !ok {
3326		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3327	}
3328
3329	request.Request.URL.Path = "/"
3330	request.Request.Method = "POST"
3331	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3332	if err != nil {
3333		return out, metadata, &smithy.SerializationError{Err: err}
3334	}
3335	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3336	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StartMatchmaking")
3337
3338	jsonEncoder := smithyjson.NewEncoder()
3339	if err := awsAwsjson11_serializeOpDocumentStartMatchmakingInput(input, jsonEncoder.Value); err != nil {
3340		return out, metadata, &smithy.SerializationError{Err: err}
3341	}
3342
3343	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3344		return out, metadata, &smithy.SerializationError{Err: err}
3345	}
3346
3347	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3348		return out, metadata, &smithy.SerializationError{Err: err}
3349	}
3350	in.Request = request
3351
3352	return next.HandleSerialize(ctx, in)
3353}
3354
3355type awsAwsjson11_serializeOpStopFleetActions struct {
3356}
3357
3358func (*awsAwsjson11_serializeOpStopFleetActions) ID() string {
3359	return "OperationSerializer"
3360}
3361
3362func (m *awsAwsjson11_serializeOpStopFleetActions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3363	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3364) {
3365	request, ok := in.Request.(*smithyhttp.Request)
3366	if !ok {
3367		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3368	}
3369
3370	input, ok := in.Parameters.(*StopFleetActionsInput)
3371	_ = input
3372	if !ok {
3373		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3374	}
3375
3376	request.Request.URL.Path = "/"
3377	request.Request.Method = "POST"
3378	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3379	if err != nil {
3380		return out, metadata, &smithy.SerializationError{Err: err}
3381	}
3382	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3383	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopFleetActions")
3384
3385	jsonEncoder := smithyjson.NewEncoder()
3386	if err := awsAwsjson11_serializeOpDocumentStopFleetActionsInput(input, jsonEncoder.Value); err != nil {
3387		return out, metadata, &smithy.SerializationError{Err: err}
3388	}
3389
3390	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3391		return out, metadata, &smithy.SerializationError{Err: err}
3392	}
3393
3394	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3395		return out, metadata, &smithy.SerializationError{Err: err}
3396	}
3397	in.Request = request
3398
3399	return next.HandleSerialize(ctx, in)
3400}
3401
3402type awsAwsjson11_serializeOpStopGameSessionPlacement struct {
3403}
3404
3405func (*awsAwsjson11_serializeOpStopGameSessionPlacement) ID() string {
3406	return "OperationSerializer"
3407}
3408
3409func (m *awsAwsjson11_serializeOpStopGameSessionPlacement) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3410	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3411) {
3412	request, ok := in.Request.(*smithyhttp.Request)
3413	if !ok {
3414		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3415	}
3416
3417	input, ok := in.Parameters.(*StopGameSessionPlacementInput)
3418	_ = input
3419	if !ok {
3420		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3421	}
3422
3423	request.Request.URL.Path = "/"
3424	request.Request.Method = "POST"
3425	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3426	if err != nil {
3427		return out, metadata, &smithy.SerializationError{Err: err}
3428	}
3429	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3430	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopGameSessionPlacement")
3431
3432	jsonEncoder := smithyjson.NewEncoder()
3433	if err := awsAwsjson11_serializeOpDocumentStopGameSessionPlacementInput(input, jsonEncoder.Value); err != nil {
3434		return out, metadata, &smithy.SerializationError{Err: err}
3435	}
3436
3437	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3438		return out, metadata, &smithy.SerializationError{Err: err}
3439	}
3440
3441	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3442		return out, metadata, &smithy.SerializationError{Err: err}
3443	}
3444	in.Request = request
3445
3446	return next.HandleSerialize(ctx, in)
3447}
3448
3449type awsAwsjson11_serializeOpStopMatchmaking struct {
3450}
3451
3452func (*awsAwsjson11_serializeOpStopMatchmaking) ID() string {
3453	return "OperationSerializer"
3454}
3455
3456func (m *awsAwsjson11_serializeOpStopMatchmaking) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3457	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3458) {
3459	request, ok := in.Request.(*smithyhttp.Request)
3460	if !ok {
3461		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3462	}
3463
3464	input, ok := in.Parameters.(*StopMatchmakingInput)
3465	_ = input
3466	if !ok {
3467		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3468	}
3469
3470	request.Request.URL.Path = "/"
3471	request.Request.Method = "POST"
3472	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3473	if err != nil {
3474		return out, metadata, &smithy.SerializationError{Err: err}
3475	}
3476	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3477	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.StopMatchmaking")
3478
3479	jsonEncoder := smithyjson.NewEncoder()
3480	if err := awsAwsjson11_serializeOpDocumentStopMatchmakingInput(input, jsonEncoder.Value); err != nil {
3481		return out, metadata, &smithy.SerializationError{Err: err}
3482	}
3483
3484	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3485		return out, metadata, &smithy.SerializationError{Err: err}
3486	}
3487
3488	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3489		return out, metadata, &smithy.SerializationError{Err: err}
3490	}
3491	in.Request = request
3492
3493	return next.HandleSerialize(ctx, in)
3494}
3495
3496type awsAwsjson11_serializeOpSuspendGameServerGroup struct {
3497}
3498
3499func (*awsAwsjson11_serializeOpSuspendGameServerGroup) ID() string {
3500	return "OperationSerializer"
3501}
3502
3503func (m *awsAwsjson11_serializeOpSuspendGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3504	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3505) {
3506	request, ok := in.Request.(*smithyhttp.Request)
3507	if !ok {
3508		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3509	}
3510
3511	input, ok := in.Parameters.(*SuspendGameServerGroupInput)
3512	_ = input
3513	if !ok {
3514		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3515	}
3516
3517	request.Request.URL.Path = "/"
3518	request.Request.Method = "POST"
3519	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3520	if err != nil {
3521		return out, metadata, &smithy.SerializationError{Err: err}
3522	}
3523	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3524	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.SuspendGameServerGroup")
3525
3526	jsonEncoder := smithyjson.NewEncoder()
3527	if err := awsAwsjson11_serializeOpDocumentSuspendGameServerGroupInput(input, jsonEncoder.Value); err != nil {
3528		return out, metadata, &smithy.SerializationError{Err: err}
3529	}
3530
3531	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3532		return out, metadata, &smithy.SerializationError{Err: err}
3533	}
3534
3535	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3536		return out, metadata, &smithy.SerializationError{Err: err}
3537	}
3538	in.Request = request
3539
3540	return next.HandleSerialize(ctx, in)
3541}
3542
3543type awsAwsjson11_serializeOpTagResource struct {
3544}
3545
3546func (*awsAwsjson11_serializeOpTagResource) ID() string {
3547	return "OperationSerializer"
3548}
3549
3550func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3551	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3552) {
3553	request, ok := in.Request.(*smithyhttp.Request)
3554	if !ok {
3555		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3556	}
3557
3558	input, ok := in.Parameters.(*TagResourceInput)
3559	_ = input
3560	if !ok {
3561		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3562	}
3563
3564	request.Request.URL.Path = "/"
3565	request.Request.Method = "POST"
3566	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3567	if err != nil {
3568		return out, metadata, &smithy.SerializationError{Err: err}
3569	}
3570	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3571	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.TagResource")
3572
3573	jsonEncoder := smithyjson.NewEncoder()
3574	if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
3575		return out, metadata, &smithy.SerializationError{Err: err}
3576	}
3577
3578	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3579		return out, metadata, &smithy.SerializationError{Err: err}
3580	}
3581
3582	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3583		return out, metadata, &smithy.SerializationError{Err: err}
3584	}
3585	in.Request = request
3586
3587	return next.HandleSerialize(ctx, in)
3588}
3589
3590type awsAwsjson11_serializeOpUntagResource struct {
3591}
3592
3593func (*awsAwsjson11_serializeOpUntagResource) ID() string {
3594	return "OperationSerializer"
3595}
3596
3597func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3598	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3599) {
3600	request, ok := in.Request.(*smithyhttp.Request)
3601	if !ok {
3602		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3603	}
3604
3605	input, ok := in.Parameters.(*UntagResourceInput)
3606	_ = input
3607	if !ok {
3608		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3609	}
3610
3611	request.Request.URL.Path = "/"
3612	request.Request.Method = "POST"
3613	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3614	if err != nil {
3615		return out, metadata, &smithy.SerializationError{Err: err}
3616	}
3617	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3618	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UntagResource")
3619
3620	jsonEncoder := smithyjson.NewEncoder()
3621	if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
3622		return out, metadata, &smithy.SerializationError{Err: err}
3623	}
3624
3625	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3626		return out, metadata, &smithy.SerializationError{Err: err}
3627	}
3628
3629	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3630		return out, metadata, &smithy.SerializationError{Err: err}
3631	}
3632	in.Request = request
3633
3634	return next.HandleSerialize(ctx, in)
3635}
3636
3637type awsAwsjson11_serializeOpUpdateAlias struct {
3638}
3639
3640func (*awsAwsjson11_serializeOpUpdateAlias) ID() string {
3641	return "OperationSerializer"
3642}
3643
3644func (m *awsAwsjson11_serializeOpUpdateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3645	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3646) {
3647	request, ok := in.Request.(*smithyhttp.Request)
3648	if !ok {
3649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3650	}
3651
3652	input, ok := in.Parameters.(*UpdateAliasInput)
3653	_ = input
3654	if !ok {
3655		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3656	}
3657
3658	request.Request.URL.Path = "/"
3659	request.Request.Method = "POST"
3660	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3661	if err != nil {
3662		return out, metadata, &smithy.SerializationError{Err: err}
3663	}
3664	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3665	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateAlias")
3666
3667	jsonEncoder := smithyjson.NewEncoder()
3668	if err := awsAwsjson11_serializeOpDocumentUpdateAliasInput(input, jsonEncoder.Value); err != nil {
3669		return out, metadata, &smithy.SerializationError{Err: err}
3670	}
3671
3672	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3673		return out, metadata, &smithy.SerializationError{Err: err}
3674	}
3675
3676	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3677		return out, metadata, &smithy.SerializationError{Err: err}
3678	}
3679	in.Request = request
3680
3681	return next.HandleSerialize(ctx, in)
3682}
3683
3684type awsAwsjson11_serializeOpUpdateBuild struct {
3685}
3686
3687func (*awsAwsjson11_serializeOpUpdateBuild) ID() string {
3688	return "OperationSerializer"
3689}
3690
3691func (m *awsAwsjson11_serializeOpUpdateBuild) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3692	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3693) {
3694	request, ok := in.Request.(*smithyhttp.Request)
3695	if !ok {
3696		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3697	}
3698
3699	input, ok := in.Parameters.(*UpdateBuildInput)
3700	_ = input
3701	if !ok {
3702		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3703	}
3704
3705	request.Request.URL.Path = "/"
3706	request.Request.Method = "POST"
3707	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3708	if err != nil {
3709		return out, metadata, &smithy.SerializationError{Err: err}
3710	}
3711	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3712	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateBuild")
3713
3714	jsonEncoder := smithyjson.NewEncoder()
3715	if err := awsAwsjson11_serializeOpDocumentUpdateBuildInput(input, jsonEncoder.Value); err != nil {
3716		return out, metadata, &smithy.SerializationError{Err: err}
3717	}
3718
3719	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3720		return out, metadata, &smithy.SerializationError{Err: err}
3721	}
3722
3723	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3724		return out, metadata, &smithy.SerializationError{Err: err}
3725	}
3726	in.Request = request
3727
3728	return next.HandleSerialize(ctx, in)
3729}
3730
3731type awsAwsjson11_serializeOpUpdateFleetAttributes struct {
3732}
3733
3734func (*awsAwsjson11_serializeOpUpdateFleetAttributes) ID() string {
3735	return "OperationSerializer"
3736}
3737
3738func (m *awsAwsjson11_serializeOpUpdateFleetAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3739	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3740) {
3741	request, ok := in.Request.(*smithyhttp.Request)
3742	if !ok {
3743		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3744	}
3745
3746	input, ok := in.Parameters.(*UpdateFleetAttributesInput)
3747	_ = input
3748	if !ok {
3749		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3750	}
3751
3752	request.Request.URL.Path = "/"
3753	request.Request.Method = "POST"
3754	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3755	if err != nil {
3756		return out, metadata, &smithy.SerializationError{Err: err}
3757	}
3758	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3759	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetAttributes")
3760
3761	jsonEncoder := smithyjson.NewEncoder()
3762	if err := awsAwsjson11_serializeOpDocumentUpdateFleetAttributesInput(input, jsonEncoder.Value); err != nil {
3763		return out, metadata, &smithy.SerializationError{Err: err}
3764	}
3765
3766	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3767		return out, metadata, &smithy.SerializationError{Err: err}
3768	}
3769
3770	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3771		return out, metadata, &smithy.SerializationError{Err: err}
3772	}
3773	in.Request = request
3774
3775	return next.HandleSerialize(ctx, in)
3776}
3777
3778type awsAwsjson11_serializeOpUpdateFleetCapacity struct {
3779}
3780
3781func (*awsAwsjson11_serializeOpUpdateFleetCapacity) ID() string {
3782	return "OperationSerializer"
3783}
3784
3785func (m *awsAwsjson11_serializeOpUpdateFleetCapacity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3786	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3787) {
3788	request, ok := in.Request.(*smithyhttp.Request)
3789	if !ok {
3790		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3791	}
3792
3793	input, ok := in.Parameters.(*UpdateFleetCapacityInput)
3794	_ = input
3795	if !ok {
3796		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3797	}
3798
3799	request.Request.URL.Path = "/"
3800	request.Request.Method = "POST"
3801	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3802	if err != nil {
3803		return out, metadata, &smithy.SerializationError{Err: err}
3804	}
3805	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3806	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetCapacity")
3807
3808	jsonEncoder := smithyjson.NewEncoder()
3809	if err := awsAwsjson11_serializeOpDocumentUpdateFleetCapacityInput(input, jsonEncoder.Value); err != nil {
3810		return out, metadata, &smithy.SerializationError{Err: err}
3811	}
3812
3813	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3814		return out, metadata, &smithy.SerializationError{Err: err}
3815	}
3816
3817	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3818		return out, metadata, &smithy.SerializationError{Err: err}
3819	}
3820	in.Request = request
3821
3822	return next.HandleSerialize(ctx, in)
3823}
3824
3825type awsAwsjson11_serializeOpUpdateFleetPortSettings struct {
3826}
3827
3828func (*awsAwsjson11_serializeOpUpdateFleetPortSettings) ID() string {
3829	return "OperationSerializer"
3830}
3831
3832func (m *awsAwsjson11_serializeOpUpdateFleetPortSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3833	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3834) {
3835	request, ok := in.Request.(*smithyhttp.Request)
3836	if !ok {
3837		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3838	}
3839
3840	input, ok := in.Parameters.(*UpdateFleetPortSettingsInput)
3841	_ = input
3842	if !ok {
3843		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3844	}
3845
3846	request.Request.URL.Path = "/"
3847	request.Request.Method = "POST"
3848	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3849	if err != nil {
3850		return out, metadata, &smithy.SerializationError{Err: err}
3851	}
3852	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3853	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateFleetPortSettings")
3854
3855	jsonEncoder := smithyjson.NewEncoder()
3856	if err := awsAwsjson11_serializeOpDocumentUpdateFleetPortSettingsInput(input, jsonEncoder.Value); err != nil {
3857		return out, metadata, &smithy.SerializationError{Err: err}
3858	}
3859
3860	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3861		return out, metadata, &smithy.SerializationError{Err: err}
3862	}
3863
3864	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3865		return out, metadata, &smithy.SerializationError{Err: err}
3866	}
3867	in.Request = request
3868
3869	return next.HandleSerialize(ctx, in)
3870}
3871
3872type awsAwsjson11_serializeOpUpdateGameServer struct {
3873}
3874
3875func (*awsAwsjson11_serializeOpUpdateGameServer) ID() string {
3876	return "OperationSerializer"
3877}
3878
3879func (m *awsAwsjson11_serializeOpUpdateGameServer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3880	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3881) {
3882	request, ok := in.Request.(*smithyhttp.Request)
3883	if !ok {
3884		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3885	}
3886
3887	input, ok := in.Parameters.(*UpdateGameServerInput)
3888	_ = input
3889	if !ok {
3890		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3891	}
3892
3893	request.Request.URL.Path = "/"
3894	request.Request.Method = "POST"
3895	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3896	if err != nil {
3897		return out, metadata, &smithy.SerializationError{Err: err}
3898	}
3899	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3900	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameServer")
3901
3902	jsonEncoder := smithyjson.NewEncoder()
3903	if err := awsAwsjson11_serializeOpDocumentUpdateGameServerInput(input, jsonEncoder.Value); err != nil {
3904		return out, metadata, &smithy.SerializationError{Err: err}
3905	}
3906
3907	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3908		return out, metadata, &smithy.SerializationError{Err: err}
3909	}
3910
3911	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3912		return out, metadata, &smithy.SerializationError{Err: err}
3913	}
3914	in.Request = request
3915
3916	return next.HandleSerialize(ctx, in)
3917}
3918
3919type awsAwsjson11_serializeOpUpdateGameServerGroup struct {
3920}
3921
3922func (*awsAwsjson11_serializeOpUpdateGameServerGroup) ID() string {
3923	return "OperationSerializer"
3924}
3925
3926func (m *awsAwsjson11_serializeOpUpdateGameServerGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3927	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3928) {
3929	request, ok := in.Request.(*smithyhttp.Request)
3930	if !ok {
3931		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3932	}
3933
3934	input, ok := in.Parameters.(*UpdateGameServerGroupInput)
3935	_ = input
3936	if !ok {
3937		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3938	}
3939
3940	request.Request.URL.Path = "/"
3941	request.Request.Method = "POST"
3942	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3943	if err != nil {
3944		return out, metadata, &smithy.SerializationError{Err: err}
3945	}
3946	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3947	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameServerGroup")
3948
3949	jsonEncoder := smithyjson.NewEncoder()
3950	if err := awsAwsjson11_serializeOpDocumentUpdateGameServerGroupInput(input, jsonEncoder.Value); err != nil {
3951		return out, metadata, &smithy.SerializationError{Err: err}
3952	}
3953
3954	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3955		return out, metadata, &smithy.SerializationError{Err: err}
3956	}
3957
3958	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
3959		return out, metadata, &smithy.SerializationError{Err: err}
3960	}
3961	in.Request = request
3962
3963	return next.HandleSerialize(ctx, in)
3964}
3965
3966type awsAwsjson11_serializeOpUpdateGameSession struct {
3967}
3968
3969func (*awsAwsjson11_serializeOpUpdateGameSession) ID() string {
3970	return "OperationSerializer"
3971}
3972
3973func (m *awsAwsjson11_serializeOpUpdateGameSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3974	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3975) {
3976	request, ok := in.Request.(*smithyhttp.Request)
3977	if !ok {
3978		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3979	}
3980
3981	input, ok := in.Parameters.(*UpdateGameSessionInput)
3982	_ = input
3983	if !ok {
3984		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3985	}
3986
3987	request.Request.URL.Path = "/"
3988	request.Request.Method = "POST"
3989	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3990	if err != nil {
3991		return out, metadata, &smithy.SerializationError{Err: err}
3992	}
3993	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
3994	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameSession")
3995
3996	jsonEncoder := smithyjson.NewEncoder()
3997	if err := awsAwsjson11_serializeOpDocumentUpdateGameSessionInput(input, jsonEncoder.Value); err != nil {
3998		return out, metadata, &smithy.SerializationError{Err: err}
3999	}
4000
4001	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4002		return out, metadata, &smithy.SerializationError{Err: err}
4003	}
4004
4005	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4006		return out, metadata, &smithy.SerializationError{Err: err}
4007	}
4008	in.Request = request
4009
4010	return next.HandleSerialize(ctx, in)
4011}
4012
4013type awsAwsjson11_serializeOpUpdateGameSessionQueue struct {
4014}
4015
4016func (*awsAwsjson11_serializeOpUpdateGameSessionQueue) ID() string {
4017	return "OperationSerializer"
4018}
4019
4020func (m *awsAwsjson11_serializeOpUpdateGameSessionQueue) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4021	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4022) {
4023	request, ok := in.Request.(*smithyhttp.Request)
4024	if !ok {
4025		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4026	}
4027
4028	input, ok := in.Parameters.(*UpdateGameSessionQueueInput)
4029	_ = input
4030	if !ok {
4031		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4032	}
4033
4034	request.Request.URL.Path = "/"
4035	request.Request.Method = "POST"
4036	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4037	if err != nil {
4038		return out, metadata, &smithy.SerializationError{Err: err}
4039	}
4040	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4041	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateGameSessionQueue")
4042
4043	jsonEncoder := smithyjson.NewEncoder()
4044	if err := awsAwsjson11_serializeOpDocumentUpdateGameSessionQueueInput(input, jsonEncoder.Value); err != nil {
4045		return out, metadata, &smithy.SerializationError{Err: err}
4046	}
4047
4048	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4049		return out, metadata, &smithy.SerializationError{Err: err}
4050	}
4051
4052	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4053		return out, metadata, &smithy.SerializationError{Err: err}
4054	}
4055	in.Request = request
4056
4057	return next.HandleSerialize(ctx, in)
4058}
4059
4060type awsAwsjson11_serializeOpUpdateMatchmakingConfiguration struct {
4061}
4062
4063func (*awsAwsjson11_serializeOpUpdateMatchmakingConfiguration) ID() string {
4064	return "OperationSerializer"
4065}
4066
4067func (m *awsAwsjson11_serializeOpUpdateMatchmakingConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4068	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4069) {
4070	request, ok := in.Request.(*smithyhttp.Request)
4071	if !ok {
4072		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4073	}
4074
4075	input, ok := in.Parameters.(*UpdateMatchmakingConfigurationInput)
4076	_ = input
4077	if !ok {
4078		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4079	}
4080
4081	request.Request.URL.Path = "/"
4082	request.Request.Method = "POST"
4083	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4084	if err != nil {
4085		return out, metadata, &smithy.SerializationError{Err: err}
4086	}
4087	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4088	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateMatchmakingConfiguration")
4089
4090	jsonEncoder := smithyjson.NewEncoder()
4091	if err := awsAwsjson11_serializeOpDocumentUpdateMatchmakingConfigurationInput(input, jsonEncoder.Value); err != nil {
4092		return out, metadata, &smithy.SerializationError{Err: err}
4093	}
4094
4095	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4096		return out, metadata, &smithy.SerializationError{Err: err}
4097	}
4098
4099	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4100		return out, metadata, &smithy.SerializationError{Err: err}
4101	}
4102	in.Request = request
4103
4104	return next.HandleSerialize(ctx, in)
4105}
4106
4107type awsAwsjson11_serializeOpUpdateRuntimeConfiguration struct {
4108}
4109
4110func (*awsAwsjson11_serializeOpUpdateRuntimeConfiguration) ID() string {
4111	return "OperationSerializer"
4112}
4113
4114func (m *awsAwsjson11_serializeOpUpdateRuntimeConfiguration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4115	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4116) {
4117	request, ok := in.Request.(*smithyhttp.Request)
4118	if !ok {
4119		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4120	}
4121
4122	input, ok := in.Parameters.(*UpdateRuntimeConfigurationInput)
4123	_ = input
4124	if !ok {
4125		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4126	}
4127
4128	request.Request.URL.Path = "/"
4129	request.Request.Method = "POST"
4130	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4131	if err != nil {
4132		return out, metadata, &smithy.SerializationError{Err: err}
4133	}
4134	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4135	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateRuntimeConfiguration")
4136
4137	jsonEncoder := smithyjson.NewEncoder()
4138	if err := awsAwsjson11_serializeOpDocumentUpdateRuntimeConfigurationInput(input, jsonEncoder.Value); err != nil {
4139		return out, metadata, &smithy.SerializationError{Err: err}
4140	}
4141
4142	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4143		return out, metadata, &smithy.SerializationError{Err: err}
4144	}
4145
4146	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4147		return out, metadata, &smithy.SerializationError{Err: err}
4148	}
4149	in.Request = request
4150
4151	return next.HandleSerialize(ctx, in)
4152}
4153
4154type awsAwsjson11_serializeOpUpdateScript struct {
4155}
4156
4157func (*awsAwsjson11_serializeOpUpdateScript) ID() string {
4158	return "OperationSerializer"
4159}
4160
4161func (m *awsAwsjson11_serializeOpUpdateScript) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4162	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4163) {
4164	request, ok := in.Request.(*smithyhttp.Request)
4165	if !ok {
4166		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4167	}
4168
4169	input, ok := in.Parameters.(*UpdateScriptInput)
4170	_ = input
4171	if !ok {
4172		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4173	}
4174
4175	request.Request.URL.Path = "/"
4176	request.Request.Method = "POST"
4177	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4178	if err != nil {
4179		return out, metadata, &smithy.SerializationError{Err: err}
4180	}
4181	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4182	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.UpdateScript")
4183
4184	jsonEncoder := smithyjson.NewEncoder()
4185	if err := awsAwsjson11_serializeOpDocumentUpdateScriptInput(input, jsonEncoder.Value); err != nil {
4186		return out, metadata, &smithy.SerializationError{Err: err}
4187	}
4188
4189	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4190		return out, metadata, &smithy.SerializationError{Err: err}
4191	}
4192
4193	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4194		return out, metadata, &smithy.SerializationError{Err: err}
4195	}
4196	in.Request = request
4197
4198	return next.HandleSerialize(ctx, in)
4199}
4200
4201type awsAwsjson11_serializeOpValidateMatchmakingRuleSet struct {
4202}
4203
4204func (*awsAwsjson11_serializeOpValidateMatchmakingRuleSet) ID() string {
4205	return "OperationSerializer"
4206}
4207
4208func (m *awsAwsjson11_serializeOpValidateMatchmakingRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4209	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4210) {
4211	request, ok := in.Request.(*smithyhttp.Request)
4212	if !ok {
4213		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4214	}
4215
4216	input, ok := in.Parameters.(*ValidateMatchmakingRuleSetInput)
4217	_ = input
4218	if !ok {
4219		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4220	}
4221
4222	request.Request.URL.Path = "/"
4223	request.Request.Method = "POST"
4224	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4225	if err != nil {
4226		return out, metadata, &smithy.SerializationError{Err: err}
4227	}
4228	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
4229	httpBindingEncoder.SetHeader("X-Amz-Target").String("GameLift.ValidateMatchmakingRuleSet")
4230
4231	jsonEncoder := smithyjson.NewEncoder()
4232	if err := awsAwsjson11_serializeOpDocumentValidateMatchmakingRuleSetInput(input, jsonEncoder.Value); err != nil {
4233		return out, metadata, &smithy.SerializationError{Err: err}
4234	}
4235
4236	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4237		return out, metadata, &smithy.SerializationError{Err: err}
4238	}
4239
4240	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
4241		return out, metadata, &smithy.SerializationError{Err: err}
4242	}
4243	in.Request = request
4244
4245	return next.HandleSerialize(ctx, in)
4246}
4247func awsAwsjson11_serializeDocumentAttributeValue(v *types.AttributeValue, value smithyjson.Value) error {
4248	object := value.Object()
4249	defer object.Close()
4250
4251	if v.N != nil {
4252		ok := object.Key("N")
4253		ok.Double(*v.N)
4254	}
4255
4256	if v.S != nil {
4257		ok := object.Key("S")
4258		ok.String(*v.S)
4259	}
4260
4261	if v.SDM != nil {
4262		ok := object.Key("SDM")
4263		if err := awsAwsjson11_serializeDocumentStringDoubleMap(v.SDM, ok); err != nil {
4264			return err
4265		}
4266	}
4267
4268	if v.SL != nil {
4269		ok := object.Key("SL")
4270		if err := awsAwsjson11_serializeDocumentStringList(v.SL, ok); err != nil {
4271			return err
4272		}
4273	}
4274
4275	return nil
4276}
4277
4278func awsAwsjson11_serializeDocumentCertificateConfiguration(v *types.CertificateConfiguration, value smithyjson.Value) error {
4279	object := value.Object()
4280	defer object.Close()
4281
4282	if len(v.CertificateType) > 0 {
4283		ok := object.Key("CertificateType")
4284		ok.String(string(v.CertificateType))
4285	}
4286
4287	return nil
4288}
4289
4290func awsAwsjson11_serializeDocumentDesiredPlayerSession(v *types.DesiredPlayerSession, value smithyjson.Value) error {
4291	object := value.Object()
4292	defer object.Close()
4293
4294	if v.PlayerData != nil {
4295		ok := object.Key("PlayerData")
4296		ok.String(*v.PlayerData)
4297	}
4298
4299	if v.PlayerId != nil {
4300		ok := object.Key("PlayerId")
4301		ok.String(*v.PlayerId)
4302	}
4303
4304	return nil
4305}
4306
4307func awsAwsjson11_serializeDocumentDesiredPlayerSessionList(v []types.DesiredPlayerSession, value smithyjson.Value) error {
4308	array := value.Array()
4309	defer array.Close()
4310
4311	for i := range v {
4312		av := array.Value()
4313		if err := awsAwsjson11_serializeDocumentDesiredPlayerSession(&v[i], av); err != nil {
4314			return err
4315		}
4316	}
4317	return nil
4318}
4319
4320func awsAwsjson11_serializeDocumentFleetActionList(v []types.FleetAction, value smithyjson.Value) error {
4321	array := value.Array()
4322	defer array.Close()
4323
4324	for i := range v {
4325		av := array.Value()
4326		av.String(string(v[i]))
4327	}
4328	return nil
4329}
4330
4331func awsAwsjson11_serializeDocumentFleetIdOrArnList(v []string, value smithyjson.Value) error {
4332	array := value.Array()
4333	defer array.Close()
4334
4335	for i := range v {
4336		av := array.Value()
4337		av.String(v[i])
4338	}
4339	return nil
4340}
4341
4342func awsAwsjson11_serializeDocumentGameProperty(v *types.GameProperty, value smithyjson.Value) error {
4343	object := value.Object()
4344	defer object.Close()
4345
4346	if v.Key != nil {
4347		ok := object.Key("Key")
4348		ok.String(*v.Key)
4349	}
4350
4351	if v.Value != nil {
4352		ok := object.Key("Value")
4353		ok.String(*v.Value)
4354	}
4355
4356	return nil
4357}
4358
4359func awsAwsjson11_serializeDocumentGamePropertyList(v []types.GameProperty, value smithyjson.Value) error {
4360	array := value.Array()
4361	defer array.Close()
4362
4363	for i := range v {
4364		av := array.Value()
4365		if err := awsAwsjson11_serializeDocumentGameProperty(&v[i], av); err != nil {
4366			return err
4367		}
4368	}
4369	return nil
4370}
4371
4372func awsAwsjson11_serializeDocumentGameServerGroupActions(v []types.GameServerGroupAction, value smithyjson.Value) error {
4373	array := value.Array()
4374	defer array.Close()
4375
4376	for i := range v {
4377		av := array.Value()
4378		av.String(string(v[i]))
4379	}
4380	return nil
4381}
4382
4383func awsAwsjson11_serializeDocumentGameServerGroupAutoScalingPolicy(v *types.GameServerGroupAutoScalingPolicy, value smithyjson.Value) error {
4384	object := value.Object()
4385	defer object.Close()
4386
4387	if v.EstimatedInstanceWarmup != nil {
4388		ok := object.Key("EstimatedInstanceWarmup")
4389		ok.Integer(*v.EstimatedInstanceWarmup)
4390	}
4391
4392	if v.TargetTrackingConfiguration != nil {
4393		ok := object.Key("TargetTrackingConfiguration")
4394		if err := awsAwsjson11_serializeDocumentTargetTrackingConfiguration(v.TargetTrackingConfiguration, ok); err != nil {
4395			return err
4396		}
4397	}
4398
4399	return nil
4400}
4401
4402func awsAwsjson11_serializeDocumentGameServerInstanceIds(v []string, value smithyjson.Value) error {
4403	array := value.Array()
4404	defer array.Close()
4405
4406	for i := range v {
4407		av := array.Value()
4408		av.String(v[i])
4409	}
4410	return nil
4411}
4412
4413func awsAwsjson11_serializeDocumentGameSessionQueueDestination(v *types.GameSessionQueueDestination, value smithyjson.Value) error {
4414	object := value.Object()
4415	defer object.Close()
4416
4417	if v.DestinationArn != nil {
4418		ok := object.Key("DestinationArn")
4419		ok.String(*v.DestinationArn)
4420	}
4421
4422	return nil
4423}
4424
4425func awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v []types.GameSessionQueueDestination, value smithyjson.Value) error {
4426	array := value.Array()
4427	defer array.Close()
4428
4429	for i := range v {
4430		av := array.Value()
4431		if err := awsAwsjson11_serializeDocumentGameSessionQueueDestination(&v[i], av); err != nil {
4432			return err
4433		}
4434	}
4435	return nil
4436}
4437
4438func awsAwsjson11_serializeDocumentGameSessionQueueNameOrArnList(v []string, value smithyjson.Value) error {
4439	array := value.Array()
4440	defer array.Close()
4441
4442	for i := range v {
4443		av := array.Value()
4444		av.String(v[i])
4445	}
4446	return nil
4447}
4448
4449func awsAwsjson11_serializeDocumentInstanceDefinition(v *types.InstanceDefinition, value smithyjson.Value) error {
4450	object := value.Object()
4451	defer object.Close()
4452
4453	if len(v.InstanceType) > 0 {
4454		ok := object.Key("InstanceType")
4455		ok.String(string(v.InstanceType))
4456	}
4457
4458	if v.WeightedCapacity != nil {
4459		ok := object.Key("WeightedCapacity")
4460		ok.String(*v.WeightedCapacity)
4461	}
4462
4463	return nil
4464}
4465
4466func awsAwsjson11_serializeDocumentInstanceDefinitions(v []types.InstanceDefinition, value smithyjson.Value) error {
4467	array := value.Array()
4468	defer array.Close()
4469
4470	for i := range v {
4471		av := array.Value()
4472		if err := awsAwsjson11_serializeDocumentInstanceDefinition(&v[i], av); err != nil {
4473			return err
4474		}
4475	}
4476	return nil
4477}
4478
4479func awsAwsjson11_serializeDocumentIpPermission(v *types.IpPermission, value smithyjson.Value) error {
4480	object := value.Object()
4481	defer object.Close()
4482
4483	if v.FromPort != nil {
4484		ok := object.Key("FromPort")
4485		ok.Integer(*v.FromPort)
4486	}
4487
4488	if v.IpRange != nil {
4489		ok := object.Key("IpRange")
4490		ok.String(*v.IpRange)
4491	}
4492
4493	if len(v.Protocol) > 0 {
4494		ok := object.Key("Protocol")
4495		ok.String(string(v.Protocol))
4496	}
4497
4498	if v.ToPort != nil {
4499		ok := object.Key("ToPort")
4500		ok.Integer(*v.ToPort)
4501	}
4502
4503	return nil
4504}
4505
4506func awsAwsjson11_serializeDocumentIpPermissionsList(v []types.IpPermission, value smithyjson.Value) error {
4507	array := value.Array()
4508	defer array.Close()
4509
4510	for i := range v {
4511		av := array.Value()
4512		if err := awsAwsjson11_serializeDocumentIpPermission(&v[i], av); err != nil {
4513			return err
4514		}
4515	}
4516	return nil
4517}
4518
4519func awsAwsjson11_serializeDocumentLatencyMap(v map[string]int32, value smithyjson.Value) error {
4520	object := value.Object()
4521	defer object.Close()
4522
4523	for key := range v {
4524		om := object.Key(key)
4525		om.Integer(v[key])
4526	}
4527	return nil
4528}
4529
4530func awsAwsjson11_serializeDocumentLaunchTemplateSpecification(v *types.LaunchTemplateSpecification, value smithyjson.Value) error {
4531	object := value.Object()
4532	defer object.Close()
4533
4534	if v.LaunchTemplateId != nil {
4535		ok := object.Key("LaunchTemplateId")
4536		ok.String(*v.LaunchTemplateId)
4537	}
4538
4539	if v.LaunchTemplateName != nil {
4540		ok := object.Key("LaunchTemplateName")
4541		ok.String(*v.LaunchTemplateName)
4542	}
4543
4544	if v.Version != nil {
4545		ok := object.Key("Version")
4546		ok.String(*v.Version)
4547	}
4548
4549	return nil
4550}
4551
4552func awsAwsjson11_serializeDocumentMatchmakingConfigurationNameList(v []string, value smithyjson.Value) error {
4553	array := value.Array()
4554	defer array.Close()
4555
4556	for i := range v {
4557		av := array.Value()
4558		av.String(v[i])
4559	}
4560	return nil
4561}
4562
4563func awsAwsjson11_serializeDocumentMatchmakingIdList(v []string, value smithyjson.Value) error {
4564	array := value.Array()
4565	defer array.Close()
4566
4567	for i := range v {
4568		av := array.Value()
4569		av.String(v[i])
4570	}
4571	return nil
4572}
4573
4574func awsAwsjson11_serializeDocumentMatchmakingRuleSetNameList(v []string, value smithyjson.Value) error {
4575	array := value.Array()
4576	defer array.Close()
4577
4578	for i := range v {
4579		av := array.Value()
4580		av.String(v[i])
4581	}
4582	return nil
4583}
4584
4585func awsAwsjson11_serializeDocumentMetricGroupList(v []string, value smithyjson.Value) error {
4586	array := value.Array()
4587	defer array.Close()
4588
4589	for i := range v {
4590		av := array.Value()
4591		av.String(v[i])
4592	}
4593	return nil
4594}
4595
4596func awsAwsjson11_serializeDocumentPlayer(v *types.Player, value smithyjson.Value) error {
4597	object := value.Object()
4598	defer object.Close()
4599
4600	if v.LatencyInMs != nil {
4601		ok := object.Key("LatencyInMs")
4602		if err := awsAwsjson11_serializeDocumentLatencyMap(v.LatencyInMs, ok); err != nil {
4603			return err
4604		}
4605	}
4606
4607	if v.PlayerAttributes != nil {
4608		ok := object.Key("PlayerAttributes")
4609		if err := awsAwsjson11_serializeDocumentPlayerAttributeMap(v.PlayerAttributes, ok); err != nil {
4610			return err
4611		}
4612	}
4613
4614	if v.PlayerId != nil {
4615		ok := object.Key("PlayerId")
4616		ok.String(*v.PlayerId)
4617	}
4618
4619	if v.Team != nil {
4620		ok := object.Key("Team")
4621		ok.String(*v.Team)
4622	}
4623
4624	return nil
4625}
4626
4627func awsAwsjson11_serializeDocumentPlayerAttributeMap(v map[string]types.AttributeValue, value smithyjson.Value) error {
4628	object := value.Object()
4629	defer object.Close()
4630
4631	for key := range v {
4632		om := object.Key(key)
4633		mapVar := v[key]
4634		if err := awsAwsjson11_serializeDocumentAttributeValue(&mapVar, om); err != nil {
4635			return err
4636		}
4637	}
4638	return nil
4639}
4640
4641func awsAwsjson11_serializeDocumentPlayerDataMap(v map[string]string, value smithyjson.Value) error {
4642	object := value.Object()
4643	defer object.Close()
4644
4645	for key := range v {
4646		om := object.Key(key)
4647		om.String(v[key])
4648	}
4649	return nil
4650}
4651
4652func awsAwsjson11_serializeDocumentPlayerIdList(v []string, value smithyjson.Value) error {
4653	array := value.Array()
4654	defer array.Close()
4655
4656	for i := range v {
4657		av := array.Value()
4658		av.String(v[i])
4659	}
4660	return nil
4661}
4662
4663func awsAwsjson11_serializeDocumentPlayerLatency(v *types.PlayerLatency, value smithyjson.Value) error {
4664	object := value.Object()
4665	defer object.Close()
4666
4667	if v.LatencyInMilliseconds != 0 {
4668		ok := object.Key("LatencyInMilliseconds")
4669		ok.Float(v.LatencyInMilliseconds)
4670	}
4671
4672	if v.PlayerId != nil {
4673		ok := object.Key("PlayerId")
4674		ok.String(*v.PlayerId)
4675	}
4676
4677	if v.RegionIdentifier != nil {
4678		ok := object.Key("RegionIdentifier")
4679		ok.String(*v.RegionIdentifier)
4680	}
4681
4682	return nil
4683}
4684
4685func awsAwsjson11_serializeDocumentPlayerLatencyList(v []types.PlayerLatency, value smithyjson.Value) error {
4686	array := value.Array()
4687	defer array.Close()
4688
4689	for i := range v {
4690		av := array.Value()
4691		if err := awsAwsjson11_serializeDocumentPlayerLatency(&v[i], av); err != nil {
4692			return err
4693		}
4694	}
4695	return nil
4696}
4697
4698func awsAwsjson11_serializeDocumentPlayerLatencyPolicy(v *types.PlayerLatencyPolicy, value smithyjson.Value) error {
4699	object := value.Object()
4700	defer object.Close()
4701
4702	if v.MaximumIndividualPlayerLatencyMilliseconds != nil {
4703		ok := object.Key("MaximumIndividualPlayerLatencyMilliseconds")
4704		ok.Integer(*v.MaximumIndividualPlayerLatencyMilliseconds)
4705	}
4706
4707	if v.PolicyDurationSeconds != nil {
4708		ok := object.Key("PolicyDurationSeconds")
4709		ok.Integer(*v.PolicyDurationSeconds)
4710	}
4711
4712	return nil
4713}
4714
4715func awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v []types.PlayerLatencyPolicy, value smithyjson.Value) error {
4716	array := value.Array()
4717	defer array.Close()
4718
4719	for i := range v {
4720		av := array.Value()
4721		if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicy(&v[i], av); err != nil {
4722			return err
4723		}
4724	}
4725	return nil
4726}
4727
4728func awsAwsjson11_serializeDocumentPlayerList(v []types.Player, value smithyjson.Value) error {
4729	array := value.Array()
4730	defer array.Close()
4731
4732	for i := range v {
4733		av := array.Value()
4734		if err := awsAwsjson11_serializeDocumentPlayer(&v[i], av); err != nil {
4735			return err
4736		}
4737	}
4738	return nil
4739}
4740
4741func awsAwsjson11_serializeDocumentQueueArnsList(v []string, value smithyjson.Value) error {
4742	array := value.Array()
4743	defer array.Close()
4744
4745	for i := range v {
4746		av := array.Value()
4747		av.String(v[i])
4748	}
4749	return nil
4750}
4751
4752func awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v *types.ResourceCreationLimitPolicy, value smithyjson.Value) error {
4753	object := value.Object()
4754	defer object.Close()
4755
4756	if v.NewGameSessionsPerCreator != nil {
4757		ok := object.Key("NewGameSessionsPerCreator")
4758		ok.Integer(*v.NewGameSessionsPerCreator)
4759	}
4760
4761	if v.PolicyPeriodInMinutes != nil {
4762		ok := object.Key("PolicyPeriodInMinutes")
4763		ok.Integer(*v.PolicyPeriodInMinutes)
4764	}
4765
4766	return nil
4767}
4768
4769func awsAwsjson11_serializeDocumentRoutingStrategy(v *types.RoutingStrategy, value smithyjson.Value) error {
4770	object := value.Object()
4771	defer object.Close()
4772
4773	if v.FleetId != nil {
4774		ok := object.Key("FleetId")
4775		ok.String(*v.FleetId)
4776	}
4777
4778	if v.Message != nil {
4779		ok := object.Key("Message")
4780		ok.String(*v.Message)
4781	}
4782
4783	if len(v.Type) > 0 {
4784		ok := object.Key("Type")
4785		ok.String(string(v.Type))
4786	}
4787
4788	return nil
4789}
4790
4791func awsAwsjson11_serializeDocumentRuntimeConfiguration(v *types.RuntimeConfiguration, value smithyjson.Value) error {
4792	object := value.Object()
4793	defer object.Close()
4794
4795	if v.GameSessionActivationTimeoutSeconds != nil {
4796		ok := object.Key("GameSessionActivationTimeoutSeconds")
4797		ok.Integer(*v.GameSessionActivationTimeoutSeconds)
4798	}
4799
4800	if v.MaxConcurrentGameSessionActivations != nil {
4801		ok := object.Key("MaxConcurrentGameSessionActivations")
4802		ok.Integer(*v.MaxConcurrentGameSessionActivations)
4803	}
4804
4805	if v.ServerProcesses != nil {
4806		ok := object.Key("ServerProcesses")
4807		if err := awsAwsjson11_serializeDocumentServerProcessList(v.ServerProcesses, ok); err != nil {
4808			return err
4809		}
4810	}
4811
4812	return nil
4813}
4814
4815func awsAwsjson11_serializeDocumentS3Location(v *types.S3Location, value smithyjson.Value) error {
4816	object := value.Object()
4817	defer object.Close()
4818
4819	if v.Bucket != nil {
4820		ok := object.Key("Bucket")
4821		ok.String(*v.Bucket)
4822	}
4823
4824	if v.Key != nil {
4825		ok := object.Key("Key")
4826		ok.String(*v.Key)
4827	}
4828
4829	if v.ObjectVersion != nil {
4830		ok := object.Key("ObjectVersion")
4831		ok.String(*v.ObjectVersion)
4832	}
4833
4834	if v.RoleArn != nil {
4835		ok := object.Key("RoleArn")
4836		ok.String(*v.RoleArn)
4837	}
4838
4839	return nil
4840}
4841
4842func awsAwsjson11_serializeDocumentServerProcess(v *types.ServerProcess, value smithyjson.Value) error {
4843	object := value.Object()
4844	defer object.Close()
4845
4846	if v.ConcurrentExecutions != nil {
4847		ok := object.Key("ConcurrentExecutions")
4848		ok.Integer(*v.ConcurrentExecutions)
4849	}
4850
4851	if v.LaunchPath != nil {
4852		ok := object.Key("LaunchPath")
4853		ok.String(*v.LaunchPath)
4854	}
4855
4856	if v.Parameters != nil {
4857		ok := object.Key("Parameters")
4858		ok.String(*v.Parameters)
4859	}
4860
4861	return nil
4862}
4863
4864func awsAwsjson11_serializeDocumentServerProcessList(v []types.ServerProcess, value smithyjson.Value) error {
4865	array := value.Array()
4866	defer array.Close()
4867
4868	for i := range v {
4869		av := array.Value()
4870		if err := awsAwsjson11_serializeDocumentServerProcess(&v[i], av); err != nil {
4871			return err
4872		}
4873	}
4874	return nil
4875}
4876
4877func awsAwsjson11_serializeDocumentStringDoubleMap(v map[string]float64, value smithyjson.Value) error {
4878	object := value.Object()
4879	defer object.Close()
4880
4881	for key := range v {
4882		om := object.Key(key)
4883		om.Double(v[key])
4884	}
4885	return nil
4886}
4887
4888func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error {
4889	array := value.Array()
4890	defer array.Close()
4891
4892	for i := range v {
4893		av := array.Value()
4894		av.String(v[i])
4895	}
4896	return nil
4897}
4898
4899func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
4900	object := value.Object()
4901	defer object.Close()
4902
4903	if v.Key != nil {
4904		ok := object.Key("Key")
4905		ok.String(*v.Key)
4906	}
4907
4908	if v.Value != nil {
4909		ok := object.Key("Value")
4910		ok.String(*v.Value)
4911	}
4912
4913	return nil
4914}
4915
4916func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
4917	array := value.Array()
4918	defer array.Close()
4919
4920	for i := range v {
4921		av := array.Value()
4922		av.String(v[i])
4923	}
4924	return nil
4925}
4926
4927func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
4928	array := value.Array()
4929	defer array.Close()
4930
4931	for i := range v {
4932		av := array.Value()
4933		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
4934			return err
4935		}
4936	}
4937	return nil
4938}
4939
4940func awsAwsjson11_serializeDocumentTargetConfiguration(v *types.TargetConfiguration, value smithyjson.Value) error {
4941	object := value.Object()
4942	defer object.Close()
4943
4944	if v.TargetValue != 0 {
4945		ok := object.Key("TargetValue")
4946		ok.Double(v.TargetValue)
4947	}
4948
4949	return nil
4950}
4951
4952func awsAwsjson11_serializeDocumentTargetTrackingConfiguration(v *types.TargetTrackingConfiguration, value smithyjson.Value) error {
4953	object := value.Object()
4954	defer object.Close()
4955
4956	if v.TargetValue != nil {
4957		ok := object.Key("TargetValue")
4958		ok.Double(*v.TargetValue)
4959	}
4960
4961	return nil
4962}
4963
4964func awsAwsjson11_serializeDocumentVpcSubnets(v []string, value smithyjson.Value) error {
4965	array := value.Array()
4966	defer array.Close()
4967
4968	for i := range v {
4969		av := array.Value()
4970		av.String(v[i])
4971	}
4972	return nil
4973}
4974
4975func awsAwsjson11_serializeOpDocumentAcceptMatchInput(v *AcceptMatchInput, value smithyjson.Value) error {
4976	object := value.Object()
4977	defer object.Close()
4978
4979	if len(v.AcceptanceType) > 0 {
4980		ok := object.Key("AcceptanceType")
4981		ok.String(string(v.AcceptanceType))
4982	}
4983
4984	if v.PlayerIds != nil {
4985		ok := object.Key("PlayerIds")
4986		if err := awsAwsjson11_serializeDocumentStringList(v.PlayerIds, ok); err != nil {
4987			return err
4988		}
4989	}
4990
4991	if v.TicketId != nil {
4992		ok := object.Key("TicketId")
4993		ok.String(*v.TicketId)
4994	}
4995
4996	return nil
4997}
4998
4999func awsAwsjson11_serializeOpDocumentClaimGameServerInput(v *ClaimGameServerInput, value smithyjson.Value) error {
5000	object := value.Object()
5001	defer object.Close()
5002
5003	if v.GameServerData != nil {
5004		ok := object.Key("GameServerData")
5005		ok.String(*v.GameServerData)
5006	}
5007
5008	if v.GameServerGroupName != nil {
5009		ok := object.Key("GameServerGroupName")
5010		ok.String(*v.GameServerGroupName)
5011	}
5012
5013	if v.GameServerId != nil {
5014		ok := object.Key("GameServerId")
5015		ok.String(*v.GameServerId)
5016	}
5017
5018	return nil
5019}
5020
5021func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error {
5022	object := value.Object()
5023	defer object.Close()
5024
5025	if v.Description != nil {
5026		ok := object.Key("Description")
5027		ok.String(*v.Description)
5028	}
5029
5030	if v.Name != nil {
5031		ok := object.Key("Name")
5032		ok.String(*v.Name)
5033	}
5034
5035	if v.RoutingStrategy != nil {
5036		ok := object.Key("RoutingStrategy")
5037		if err := awsAwsjson11_serializeDocumentRoutingStrategy(v.RoutingStrategy, ok); err != nil {
5038			return err
5039		}
5040	}
5041
5042	if v.Tags != nil {
5043		ok := object.Key("Tags")
5044		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5045			return err
5046		}
5047	}
5048
5049	return nil
5050}
5051
5052func awsAwsjson11_serializeOpDocumentCreateBuildInput(v *CreateBuildInput, value smithyjson.Value) error {
5053	object := value.Object()
5054	defer object.Close()
5055
5056	if v.Name != nil {
5057		ok := object.Key("Name")
5058		ok.String(*v.Name)
5059	}
5060
5061	if len(v.OperatingSystem) > 0 {
5062		ok := object.Key("OperatingSystem")
5063		ok.String(string(v.OperatingSystem))
5064	}
5065
5066	if v.StorageLocation != nil {
5067		ok := object.Key("StorageLocation")
5068		if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
5069			return err
5070		}
5071	}
5072
5073	if v.Tags != nil {
5074		ok := object.Key("Tags")
5075		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5076			return err
5077		}
5078	}
5079
5080	if v.Version != nil {
5081		ok := object.Key("Version")
5082		ok.String(*v.Version)
5083	}
5084
5085	return nil
5086}
5087
5088func awsAwsjson11_serializeOpDocumentCreateFleetInput(v *CreateFleetInput, value smithyjson.Value) error {
5089	object := value.Object()
5090	defer object.Close()
5091
5092	if v.BuildId != nil {
5093		ok := object.Key("BuildId")
5094		ok.String(*v.BuildId)
5095	}
5096
5097	if v.CertificateConfiguration != nil {
5098		ok := object.Key("CertificateConfiguration")
5099		if err := awsAwsjson11_serializeDocumentCertificateConfiguration(v.CertificateConfiguration, ok); err != nil {
5100			return err
5101		}
5102	}
5103
5104	if v.Description != nil {
5105		ok := object.Key("Description")
5106		ok.String(*v.Description)
5107	}
5108
5109	if v.EC2InboundPermissions != nil {
5110		ok := object.Key("EC2InboundPermissions")
5111		if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.EC2InboundPermissions, ok); err != nil {
5112			return err
5113		}
5114	}
5115
5116	if len(v.EC2InstanceType) > 0 {
5117		ok := object.Key("EC2InstanceType")
5118		ok.String(string(v.EC2InstanceType))
5119	}
5120
5121	if len(v.FleetType) > 0 {
5122		ok := object.Key("FleetType")
5123		ok.String(string(v.FleetType))
5124	}
5125
5126	if v.InstanceRoleArn != nil {
5127		ok := object.Key("InstanceRoleArn")
5128		ok.String(*v.InstanceRoleArn)
5129	}
5130
5131	if v.LogPaths != nil {
5132		ok := object.Key("LogPaths")
5133		if err := awsAwsjson11_serializeDocumentStringList(v.LogPaths, ok); err != nil {
5134			return err
5135		}
5136	}
5137
5138	if v.MetricGroups != nil {
5139		ok := object.Key("MetricGroups")
5140		if err := awsAwsjson11_serializeDocumentMetricGroupList(v.MetricGroups, ok); err != nil {
5141			return err
5142		}
5143	}
5144
5145	if v.Name != nil {
5146		ok := object.Key("Name")
5147		ok.String(*v.Name)
5148	}
5149
5150	if len(v.NewGameSessionProtectionPolicy) > 0 {
5151		ok := object.Key("NewGameSessionProtectionPolicy")
5152		ok.String(string(v.NewGameSessionProtectionPolicy))
5153	}
5154
5155	if v.PeerVpcAwsAccountId != nil {
5156		ok := object.Key("PeerVpcAwsAccountId")
5157		ok.String(*v.PeerVpcAwsAccountId)
5158	}
5159
5160	if v.PeerVpcId != nil {
5161		ok := object.Key("PeerVpcId")
5162		ok.String(*v.PeerVpcId)
5163	}
5164
5165	if v.ResourceCreationLimitPolicy != nil {
5166		ok := object.Key("ResourceCreationLimitPolicy")
5167		if err := awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v.ResourceCreationLimitPolicy, ok); err != nil {
5168			return err
5169		}
5170	}
5171
5172	if v.RuntimeConfiguration != nil {
5173		ok := object.Key("RuntimeConfiguration")
5174		if err := awsAwsjson11_serializeDocumentRuntimeConfiguration(v.RuntimeConfiguration, ok); err != nil {
5175			return err
5176		}
5177	}
5178
5179	if v.ScriptId != nil {
5180		ok := object.Key("ScriptId")
5181		ok.String(*v.ScriptId)
5182	}
5183
5184	if v.ServerLaunchParameters != nil {
5185		ok := object.Key("ServerLaunchParameters")
5186		ok.String(*v.ServerLaunchParameters)
5187	}
5188
5189	if v.ServerLaunchPath != nil {
5190		ok := object.Key("ServerLaunchPath")
5191		ok.String(*v.ServerLaunchPath)
5192	}
5193
5194	if v.Tags != nil {
5195		ok := object.Key("Tags")
5196		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5197			return err
5198		}
5199	}
5200
5201	return nil
5202}
5203
5204func awsAwsjson11_serializeOpDocumentCreateGameServerGroupInput(v *CreateGameServerGroupInput, value smithyjson.Value) error {
5205	object := value.Object()
5206	defer object.Close()
5207
5208	if v.AutoScalingPolicy != nil {
5209		ok := object.Key("AutoScalingPolicy")
5210		if err := awsAwsjson11_serializeDocumentGameServerGroupAutoScalingPolicy(v.AutoScalingPolicy, ok); err != nil {
5211			return err
5212		}
5213	}
5214
5215	if len(v.BalancingStrategy) > 0 {
5216		ok := object.Key("BalancingStrategy")
5217		ok.String(string(v.BalancingStrategy))
5218	}
5219
5220	if v.GameServerGroupName != nil {
5221		ok := object.Key("GameServerGroupName")
5222		ok.String(*v.GameServerGroupName)
5223	}
5224
5225	if len(v.GameServerProtectionPolicy) > 0 {
5226		ok := object.Key("GameServerProtectionPolicy")
5227		ok.String(string(v.GameServerProtectionPolicy))
5228	}
5229
5230	if v.InstanceDefinitions != nil {
5231		ok := object.Key("InstanceDefinitions")
5232		if err := awsAwsjson11_serializeDocumentInstanceDefinitions(v.InstanceDefinitions, ok); err != nil {
5233			return err
5234		}
5235	}
5236
5237	if v.LaunchTemplate != nil {
5238		ok := object.Key("LaunchTemplate")
5239		if err := awsAwsjson11_serializeDocumentLaunchTemplateSpecification(v.LaunchTemplate, ok); err != nil {
5240			return err
5241		}
5242	}
5243
5244	if v.MaxSize != nil {
5245		ok := object.Key("MaxSize")
5246		ok.Integer(*v.MaxSize)
5247	}
5248
5249	if v.MinSize != nil {
5250		ok := object.Key("MinSize")
5251		ok.Integer(*v.MinSize)
5252	}
5253
5254	if v.RoleArn != nil {
5255		ok := object.Key("RoleArn")
5256		ok.String(*v.RoleArn)
5257	}
5258
5259	if v.Tags != nil {
5260		ok := object.Key("Tags")
5261		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5262			return err
5263		}
5264	}
5265
5266	if v.VpcSubnets != nil {
5267		ok := object.Key("VpcSubnets")
5268		if err := awsAwsjson11_serializeDocumentVpcSubnets(v.VpcSubnets, ok); err != nil {
5269			return err
5270		}
5271	}
5272
5273	return nil
5274}
5275
5276func awsAwsjson11_serializeOpDocumentCreateGameSessionInput(v *CreateGameSessionInput, value smithyjson.Value) error {
5277	object := value.Object()
5278	defer object.Close()
5279
5280	if v.AliasId != nil {
5281		ok := object.Key("AliasId")
5282		ok.String(*v.AliasId)
5283	}
5284
5285	if v.CreatorId != nil {
5286		ok := object.Key("CreatorId")
5287		ok.String(*v.CreatorId)
5288	}
5289
5290	if v.FleetId != nil {
5291		ok := object.Key("FleetId")
5292		ok.String(*v.FleetId)
5293	}
5294
5295	if v.GameProperties != nil {
5296		ok := object.Key("GameProperties")
5297		if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
5298			return err
5299		}
5300	}
5301
5302	if v.GameSessionData != nil {
5303		ok := object.Key("GameSessionData")
5304		ok.String(*v.GameSessionData)
5305	}
5306
5307	if v.GameSessionId != nil {
5308		ok := object.Key("GameSessionId")
5309		ok.String(*v.GameSessionId)
5310	}
5311
5312	if v.IdempotencyToken != nil {
5313		ok := object.Key("IdempotencyToken")
5314		ok.String(*v.IdempotencyToken)
5315	}
5316
5317	if v.MaximumPlayerSessionCount != nil {
5318		ok := object.Key("MaximumPlayerSessionCount")
5319		ok.Integer(*v.MaximumPlayerSessionCount)
5320	}
5321
5322	if v.Name != nil {
5323		ok := object.Key("Name")
5324		ok.String(*v.Name)
5325	}
5326
5327	return nil
5328}
5329
5330func awsAwsjson11_serializeOpDocumentCreateGameSessionQueueInput(v *CreateGameSessionQueueInput, value smithyjson.Value) error {
5331	object := value.Object()
5332	defer object.Close()
5333
5334	if v.Destinations != nil {
5335		ok := object.Key("Destinations")
5336		if err := awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v.Destinations, ok); err != nil {
5337			return err
5338		}
5339	}
5340
5341	if v.Name != nil {
5342		ok := object.Key("Name")
5343		ok.String(*v.Name)
5344	}
5345
5346	if v.PlayerLatencyPolicies != nil {
5347		ok := object.Key("PlayerLatencyPolicies")
5348		if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v.PlayerLatencyPolicies, ok); err != nil {
5349			return err
5350		}
5351	}
5352
5353	if v.Tags != nil {
5354		ok := object.Key("Tags")
5355		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5356			return err
5357		}
5358	}
5359
5360	if v.TimeoutInSeconds != nil {
5361		ok := object.Key("TimeoutInSeconds")
5362		ok.Integer(*v.TimeoutInSeconds)
5363	}
5364
5365	return nil
5366}
5367
5368func awsAwsjson11_serializeOpDocumentCreateMatchmakingConfigurationInput(v *CreateMatchmakingConfigurationInput, value smithyjson.Value) error {
5369	object := value.Object()
5370	defer object.Close()
5371
5372	if v.AcceptanceRequired != nil {
5373		ok := object.Key("AcceptanceRequired")
5374		ok.Boolean(*v.AcceptanceRequired)
5375	}
5376
5377	if v.AcceptanceTimeoutSeconds != nil {
5378		ok := object.Key("AcceptanceTimeoutSeconds")
5379		ok.Integer(*v.AcceptanceTimeoutSeconds)
5380	}
5381
5382	if v.AdditionalPlayerCount != nil {
5383		ok := object.Key("AdditionalPlayerCount")
5384		ok.Integer(*v.AdditionalPlayerCount)
5385	}
5386
5387	if len(v.BackfillMode) > 0 {
5388		ok := object.Key("BackfillMode")
5389		ok.String(string(v.BackfillMode))
5390	}
5391
5392	if v.CustomEventData != nil {
5393		ok := object.Key("CustomEventData")
5394		ok.String(*v.CustomEventData)
5395	}
5396
5397	if v.Description != nil {
5398		ok := object.Key("Description")
5399		ok.String(*v.Description)
5400	}
5401
5402	if len(v.FlexMatchMode) > 0 {
5403		ok := object.Key("FlexMatchMode")
5404		ok.String(string(v.FlexMatchMode))
5405	}
5406
5407	if v.GameProperties != nil {
5408		ok := object.Key("GameProperties")
5409		if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
5410			return err
5411		}
5412	}
5413
5414	if v.GameSessionData != nil {
5415		ok := object.Key("GameSessionData")
5416		ok.String(*v.GameSessionData)
5417	}
5418
5419	if v.GameSessionQueueArns != nil {
5420		ok := object.Key("GameSessionQueueArns")
5421		if err := awsAwsjson11_serializeDocumentQueueArnsList(v.GameSessionQueueArns, ok); err != nil {
5422			return err
5423		}
5424	}
5425
5426	if v.Name != nil {
5427		ok := object.Key("Name")
5428		ok.String(*v.Name)
5429	}
5430
5431	if v.NotificationTarget != nil {
5432		ok := object.Key("NotificationTarget")
5433		ok.String(*v.NotificationTarget)
5434	}
5435
5436	if v.RequestTimeoutSeconds != nil {
5437		ok := object.Key("RequestTimeoutSeconds")
5438		ok.Integer(*v.RequestTimeoutSeconds)
5439	}
5440
5441	if v.RuleSetName != nil {
5442		ok := object.Key("RuleSetName")
5443		ok.String(*v.RuleSetName)
5444	}
5445
5446	if v.Tags != nil {
5447		ok := object.Key("Tags")
5448		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5449			return err
5450		}
5451	}
5452
5453	return nil
5454}
5455
5456func awsAwsjson11_serializeOpDocumentCreateMatchmakingRuleSetInput(v *CreateMatchmakingRuleSetInput, value smithyjson.Value) error {
5457	object := value.Object()
5458	defer object.Close()
5459
5460	if v.Name != nil {
5461		ok := object.Key("Name")
5462		ok.String(*v.Name)
5463	}
5464
5465	if v.RuleSetBody != nil {
5466		ok := object.Key("RuleSetBody")
5467		ok.String(*v.RuleSetBody)
5468	}
5469
5470	if v.Tags != nil {
5471		ok := object.Key("Tags")
5472		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5473			return err
5474		}
5475	}
5476
5477	return nil
5478}
5479
5480func awsAwsjson11_serializeOpDocumentCreatePlayerSessionInput(v *CreatePlayerSessionInput, value smithyjson.Value) error {
5481	object := value.Object()
5482	defer object.Close()
5483
5484	if v.GameSessionId != nil {
5485		ok := object.Key("GameSessionId")
5486		ok.String(*v.GameSessionId)
5487	}
5488
5489	if v.PlayerData != nil {
5490		ok := object.Key("PlayerData")
5491		ok.String(*v.PlayerData)
5492	}
5493
5494	if v.PlayerId != nil {
5495		ok := object.Key("PlayerId")
5496		ok.String(*v.PlayerId)
5497	}
5498
5499	return nil
5500}
5501
5502func awsAwsjson11_serializeOpDocumentCreatePlayerSessionsInput(v *CreatePlayerSessionsInput, value smithyjson.Value) error {
5503	object := value.Object()
5504	defer object.Close()
5505
5506	if v.GameSessionId != nil {
5507		ok := object.Key("GameSessionId")
5508		ok.String(*v.GameSessionId)
5509	}
5510
5511	if v.PlayerDataMap != nil {
5512		ok := object.Key("PlayerDataMap")
5513		if err := awsAwsjson11_serializeDocumentPlayerDataMap(v.PlayerDataMap, ok); err != nil {
5514			return err
5515		}
5516	}
5517
5518	if v.PlayerIds != nil {
5519		ok := object.Key("PlayerIds")
5520		if err := awsAwsjson11_serializeDocumentPlayerIdList(v.PlayerIds, ok); err != nil {
5521			return err
5522		}
5523	}
5524
5525	return nil
5526}
5527
5528func awsAwsjson11_serializeOpDocumentCreateScriptInput(v *CreateScriptInput, value smithyjson.Value) error {
5529	object := value.Object()
5530	defer object.Close()
5531
5532	if v.Name != nil {
5533		ok := object.Key("Name")
5534		ok.String(*v.Name)
5535	}
5536
5537	if v.StorageLocation != nil {
5538		ok := object.Key("StorageLocation")
5539		if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
5540			return err
5541		}
5542	}
5543
5544	if v.Tags != nil {
5545		ok := object.Key("Tags")
5546		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
5547			return err
5548		}
5549	}
5550
5551	if v.Version != nil {
5552		ok := object.Key("Version")
5553		ok.String(*v.Version)
5554	}
5555
5556	if v.ZipFile != nil {
5557		ok := object.Key("ZipFile")
5558		ok.Base64EncodeBytes(v.ZipFile)
5559	}
5560
5561	return nil
5562}
5563
5564func awsAwsjson11_serializeOpDocumentCreateVpcPeeringAuthorizationInput(v *CreateVpcPeeringAuthorizationInput, value smithyjson.Value) error {
5565	object := value.Object()
5566	defer object.Close()
5567
5568	if v.GameLiftAwsAccountId != nil {
5569		ok := object.Key("GameLiftAwsAccountId")
5570		ok.String(*v.GameLiftAwsAccountId)
5571	}
5572
5573	if v.PeerVpcId != nil {
5574		ok := object.Key("PeerVpcId")
5575		ok.String(*v.PeerVpcId)
5576	}
5577
5578	return nil
5579}
5580
5581func awsAwsjson11_serializeOpDocumentCreateVpcPeeringConnectionInput(v *CreateVpcPeeringConnectionInput, value smithyjson.Value) error {
5582	object := value.Object()
5583	defer object.Close()
5584
5585	if v.FleetId != nil {
5586		ok := object.Key("FleetId")
5587		ok.String(*v.FleetId)
5588	}
5589
5590	if v.PeerVpcAwsAccountId != nil {
5591		ok := object.Key("PeerVpcAwsAccountId")
5592		ok.String(*v.PeerVpcAwsAccountId)
5593	}
5594
5595	if v.PeerVpcId != nil {
5596		ok := object.Key("PeerVpcId")
5597		ok.String(*v.PeerVpcId)
5598	}
5599
5600	return nil
5601}
5602
5603func awsAwsjson11_serializeOpDocumentDeleteAliasInput(v *DeleteAliasInput, value smithyjson.Value) error {
5604	object := value.Object()
5605	defer object.Close()
5606
5607	if v.AliasId != nil {
5608		ok := object.Key("AliasId")
5609		ok.String(*v.AliasId)
5610	}
5611
5612	return nil
5613}
5614
5615func awsAwsjson11_serializeOpDocumentDeleteBuildInput(v *DeleteBuildInput, value smithyjson.Value) error {
5616	object := value.Object()
5617	defer object.Close()
5618
5619	if v.BuildId != nil {
5620		ok := object.Key("BuildId")
5621		ok.String(*v.BuildId)
5622	}
5623
5624	return nil
5625}
5626
5627func awsAwsjson11_serializeOpDocumentDeleteFleetInput(v *DeleteFleetInput, value smithyjson.Value) error {
5628	object := value.Object()
5629	defer object.Close()
5630
5631	if v.FleetId != nil {
5632		ok := object.Key("FleetId")
5633		ok.String(*v.FleetId)
5634	}
5635
5636	return nil
5637}
5638
5639func awsAwsjson11_serializeOpDocumentDeleteGameServerGroupInput(v *DeleteGameServerGroupInput, value smithyjson.Value) error {
5640	object := value.Object()
5641	defer object.Close()
5642
5643	if len(v.DeleteOption) > 0 {
5644		ok := object.Key("DeleteOption")
5645		ok.String(string(v.DeleteOption))
5646	}
5647
5648	if v.GameServerGroupName != nil {
5649		ok := object.Key("GameServerGroupName")
5650		ok.String(*v.GameServerGroupName)
5651	}
5652
5653	return nil
5654}
5655
5656func awsAwsjson11_serializeOpDocumentDeleteGameSessionQueueInput(v *DeleteGameSessionQueueInput, value smithyjson.Value) error {
5657	object := value.Object()
5658	defer object.Close()
5659
5660	if v.Name != nil {
5661		ok := object.Key("Name")
5662		ok.String(*v.Name)
5663	}
5664
5665	return nil
5666}
5667
5668func awsAwsjson11_serializeOpDocumentDeleteMatchmakingConfigurationInput(v *DeleteMatchmakingConfigurationInput, value smithyjson.Value) error {
5669	object := value.Object()
5670	defer object.Close()
5671
5672	if v.Name != nil {
5673		ok := object.Key("Name")
5674		ok.String(*v.Name)
5675	}
5676
5677	return nil
5678}
5679
5680func awsAwsjson11_serializeOpDocumentDeleteMatchmakingRuleSetInput(v *DeleteMatchmakingRuleSetInput, value smithyjson.Value) error {
5681	object := value.Object()
5682	defer object.Close()
5683
5684	if v.Name != nil {
5685		ok := object.Key("Name")
5686		ok.String(*v.Name)
5687	}
5688
5689	return nil
5690}
5691
5692func awsAwsjson11_serializeOpDocumentDeleteScalingPolicyInput(v *DeleteScalingPolicyInput, value smithyjson.Value) error {
5693	object := value.Object()
5694	defer object.Close()
5695
5696	if v.FleetId != nil {
5697		ok := object.Key("FleetId")
5698		ok.String(*v.FleetId)
5699	}
5700
5701	if v.Name != nil {
5702		ok := object.Key("Name")
5703		ok.String(*v.Name)
5704	}
5705
5706	return nil
5707}
5708
5709func awsAwsjson11_serializeOpDocumentDeleteScriptInput(v *DeleteScriptInput, value smithyjson.Value) error {
5710	object := value.Object()
5711	defer object.Close()
5712
5713	if v.ScriptId != nil {
5714		ok := object.Key("ScriptId")
5715		ok.String(*v.ScriptId)
5716	}
5717
5718	return nil
5719}
5720
5721func awsAwsjson11_serializeOpDocumentDeleteVpcPeeringAuthorizationInput(v *DeleteVpcPeeringAuthorizationInput, value smithyjson.Value) error {
5722	object := value.Object()
5723	defer object.Close()
5724
5725	if v.GameLiftAwsAccountId != nil {
5726		ok := object.Key("GameLiftAwsAccountId")
5727		ok.String(*v.GameLiftAwsAccountId)
5728	}
5729
5730	if v.PeerVpcId != nil {
5731		ok := object.Key("PeerVpcId")
5732		ok.String(*v.PeerVpcId)
5733	}
5734
5735	return nil
5736}
5737
5738func awsAwsjson11_serializeOpDocumentDeleteVpcPeeringConnectionInput(v *DeleteVpcPeeringConnectionInput, value smithyjson.Value) error {
5739	object := value.Object()
5740	defer object.Close()
5741
5742	if v.FleetId != nil {
5743		ok := object.Key("FleetId")
5744		ok.String(*v.FleetId)
5745	}
5746
5747	if v.VpcPeeringConnectionId != nil {
5748		ok := object.Key("VpcPeeringConnectionId")
5749		ok.String(*v.VpcPeeringConnectionId)
5750	}
5751
5752	return nil
5753}
5754
5755func awsAwsjson11_serializeOpDocumentDeregisterGameServerInput(v *DeregisterGameServerInput, value smithyjson.Value) error {
5756	object := value.Object()
5757	defer object.Close()
5758
5759	if v.GameServerGroupName != nil {
5760		ok := object.Key("GameServerGroupName")
5761		ok.String(*v.GameServerGroupName)
5762	}
5763
5764	if v.GameServerId != nil {
5765		ok := object.Key("GameServerId")
5766		ok.String(*v.GameServerId)
5767	}
5768
5769	return nil
5770}
5771
5772func awsAwsjson11_serializeOpDocumentDescribeAliasInput(v *DescribeAliasInput, value smithyjson.Value) error {
5773	object := value.Object()
5774	defer object.Close()
5775
5776	if v.AliasId != nil {
5777		ok := object.Key("AliasId")
5778		ok.String(*v.AliasId)
5779	}
5780
5781	return nil
5782}
5783
5784func awsAwsjson11_serializeOpDocumentDescribeBuildInput(v *DescribeBuildInput, value smithyjson.Value) error {
5785	object := value.Object()
5786	defer object.Close()
5787
5788	if v.BuildId != nil {
5789		ok := object.Key("BuildId")
5790		ok.String(*v.BuildId)
5791	}
5792
5793	return nil
5794}
5795
5796func awsAwsjson11_serializeOpDocumentDescribeEC2InstanceLimitsInput(v *DescribeEC2InstanceLimitsInput, value smithyjson.Value) error {
5797	object := value.Object()
5798	defer object.Close()
5799
5800	if len(v.EC2InstanceType) > 0 {
5801		ok := object.Key("EC2InstanceType")
5802		ok.String(string(v.EC2InstanceType))
5803	}
5804
5805	return nil
5806}
5807
5808func awsAwsjson11_serializeOpDocumentDescribeFleetAttributesInput(v *DescribeFleetAttributesInput, value smithyjson.Value) error {
5809	object := value.Object()
5810	defer object.Close()
5811
5812	if v.FleetIds != nil {
5813		ok := object.Key("FleetIds")
5814		if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
5815			return err
5816		}
5817	}
5818
5819	if v.Limit != nil {
5820		ok := object.Key("Limit")
5821		ok.Integer(*v.Limit)
5822	}
5823
5824	if v.NextToken != nil {
5825		ok := object.Key("NextToken")
5826		ok.String(*v.NextToken)
5827	}
5828
5829	return nil
5830}
5831
5832func awsAwsjson11_serializeOpDocumentDescribeFleetCapacityInput(v *DescribeFleetCapacityInput, value smithyjson.Value) error {
5833	object := value.Object()
5834	defer object.Close()
5835
5836	if v.FleetIds != nil {
5837		ok := object.Key("FleetIds")
5838		if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
5839			return err
5840		}
5841	}
5842
5843	if v.Limit != nil {
5844		ok := object.Key("Limit")
5845		ok.Integer(*v.Limit)
5846	}
5847
5848	if v.NextToken != nil {
5849		ok := object.Key("NextToken")
5850		ok.String(*v.NextToken)
5851	}
5852
5853	return nil
5854}
5855
5856func awsAwsjson11_serializeOpDocumentDescribeFleetEventsInput(v *DescribeFleetEventsInput, value smithyjson.Value) error {
5857	object := value.Object()
5858	defer object.Close()
5859
5860	if v.EndTime != nil {
5861		ok := object.Key("EndTime")
5862		ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
5863	}
5864
5865	if v.FleetId != nil {
5866		ok := object.Key("FleetId")
5867		ok.String(*v.FleetId)
5868	}
5869
5870	if v.Limit != nil {
5871		ok := object.Key("Limit")
5872		ok.Integer(*v.Limit)
5873	}
5874
5875	if v.NextToken != nil {
5876		ok := object.Key("NextToken")
5877		ok.String(*v.NextToken)
5878	}
5879
5880	if v.StartTime != nil {
5881		ok := object.Key("StartTime")
5882		ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
5883	}
5884
5885	return nil
5886}
5887
5888func awsAwsjson11_serializeOpDocumentDescribeFleetPortSettingsInput(v *DescribeFleetPortSettingsInput, value smithyjson.Value) error {
5889	object := value.Object()
5890	defer object.Close()
5891
5892	if v.FleetId != nil {
5893		ok := object.Key("FleetId")
5894		ok.String(*v.FleetId)
5895	}
5896
5897	return nil
5898}
5899
5900func awsAwsjson11_serializeOpDocumentDescribeFleetUtilizationInput(v *DescribeFleetUtilizationInput, value smithyjson.Value) error {
5901	object := value.Object()
5902	defer object.Close()
5903
5904	if v.FleetIds != nil {
5905		ok := object.Key("FleetIds")
5906		if err := awsAwsjson11_serializeDocumentFleetIdOrArnList(v.FleetIds, ok); err != nil {
5907			return err
5908		}
5909	}
5910
5911	if v.Limit != nil {
5912		ok := object.Key("Limit")
5913		ok.Integer(*v.Limit)
5914	}
5915
5916	if v.NextToken != nil {
5917		ok := object.Key("NextToken")
5918		ok.String(*v.NextToken)
5919	}
5920
5921	return nil
5922}
5923
5924func awsAwsjson11_serializeOpDocumentDescribeGameServerGroupInput(v *DescribeGameServerGroupInput, value smithyjson.Value) error {
5925	object := value.Object()
5926	defer object.Close()
5927
5928	if v.GameServerGroupName != nil {
5929		ok := object.Key("GameServerGroupName")
5930		ok.String(*v.GameServerGroupName)
5931	}
5932
5933	return nil
5934}
5935
5936func awsAwsjson11_serializeOpDocumentDescribeGameServerInput(v *DescribeGameServerInput, value smithyjson.Value) error {
5937	object := value.Object()
5938	defer object.Close()
5939
5940	if v.GameServerGroupName != nil {
5941		ok := object.Key("GameServerGroupName")
5942		ok.String(*v.GameServerGroupName)
5943	}
5944
5945	if v.GameServerId != nil {
5946		ok := object.Key("GameServerId")
5947		ok.String(*v.GameServerId)
5948	}
5949
5950	return nil
5951}
5952
5953func awsAwsjson11_serializeOpDocumentDescribeGameServerInstancesInput(v *DescribeGameServerInstancesInput, value smithyjson.Value) error {
5954	object := value.Object()
5955	defer object.Close()
5956
5957	if v.GameServerGroupName != nil {
5958		ok := object.Key("GameServerGroupName")
5959		ok.String(*v.GameServerGroupName)
5960	}
5961
5962	if v.InstanceIds != nil {
5963		ok := object.Key("InstanceIds")
5964		if err := awsAwsjson11_serializeDocumentGameServerInstanceIds(v.InstanceIds, ok); err != nil {
5965			return err
5966		}
5967	}
5968
5969	if v.Limit != nil {
5970		ok := object.Key("Limit")
5971		ok.Integer(*v.Limit)
5972	}
5973
5974	if v.NextToken != nil {
5975		ok := object.Key("NextToken")
5976		ok.String(*v.NextToken)
5977	}
5978
5979	return nil
5980}
5981
5982func awsAwsjson11_serializeOpDocumentDescribeGameSessionDetailsInput(v *DescribeGameSessionDetailsInput, value smithyjson.Value) error {
5983	object := value.Object()
5984	defer object.Close()
5985
5986	if v.AliasId != nil {
5987		ok := object.Key("AliasId")
5988		ok.String(*v.AliasId)
5989	}
5990
5991	if v.FleetId != nil {
5992		ok := object.Key("FleetId")
5993		ok.String(*v.FleetId)
5994	}
5995
5996	if v.GameSessionId != nil {
5997		ok := object.Key("GameSessionId")
5998		ok.String(*v.GameSessionId)
5999	}
6000
6001	if v.Limit != nil {
6002		ok := object.Key("Limit")
6003		ok.Integer(*v.Limit)
6004	}
6005
6006	if v.NextToken != nil {
6007		ok := object.Key("NextToken")
6008		ok.String(*v.NextToken)
6009	}
6010
6011	if v.StatusFilter != nil {
6012		ok := object.Key("StatusFilter")
6013		ok.String(*v.StatusFilter)
6014	}
6015
6016	return nil
6017}
6018
6019func awsAwsjson11_serializeOpDocumentDescribeGameSessionPlacementInput(v *DescribeGameSessionPlacementInput, value smithyjson.Value) error {
6020	object := value.Object()
6021	defer object.Close()
6022
6023	if v.PlacementId != nil {
6024		ok := object.Key("PlacementId")
6025		ok.String(*v.PlacementId)
6026	}
6027
6028	return nil
6029}
6030
6031func awsAwsjson11_serializeOpDocumentDescribeGameSessionQueuesInput(v *DescribeGameSessionQueuesInput, value smithyjson.Value) error {
6032	object := value.Object()
6033	defer object.Close()
6034
6035	if v.Limit != nil {
6036		ok := object.Key("Limit")
6037		ok.Integer(*v.Limit)
6038	}
6039
6040	if v.Names != nil {
6041		ok := object.Key("Names")
6042		if err := awsAwsjson11_serializeDocumentGameSessionQueueNameOrArnList(v.Names, ok); err != nil {
6043			return err
6044		}
6045	}
6046
6047	if v.NextToken != nil {
6048		ok := object.Key("NextToken")
6049		ok.String(*v.NextToken)
6050	}
6051
6052	return nil
6053}
6054
6055func awsAwsjson11_serializeOpDocumentDescribeGameSessionsInput(v *DescribeGameSessionsInput, value smithyjson.Value) error {
6056	object := value.Object()
6057	defer object.Close()
6058
6059	if v.AliasId != nil {
6060		ok := object.Key("AliasId")
6061		ok.String(*v.AliasId)
6062	}
6063
6064	if v.FleetId != nil {
6065		ok := object.Key("FleetId")
6066		ok.String(*v.FleetId)
6067	}
6068
6069	if v.GameSessionId != nil {
6070		ok := object.Key("GameSessionId")
6071		ok.String(*v.GameSessionId)
6072	}
6073
6074	if v.Limit != nil {
6075		ok := object.Key("Limit")
6076		ok.Integer(*v.Limit)
6077	}
6078
6079	if v.NextToken != nil {
6080		ok := object.Key("NextToken")
6081		ok.String(*v.NextToken)
6082	}
6083
6084	if v.StatusFilter != nil {
6085		ok := object.Key("StatusFilter")
6086		ok.String(*v.StatusFilter)
6087	}
6088
6089	return nil
6090}
6091
6092func awsAwsjson11_serializeOpDocumentDescribeInstancesInput(v *DescribeInstancesInput, value smithyjson.Value) error {
6093	object := value.Object()
6094	defer object.Close()
6095
6096	if v.FleetId != nil {
6097		ok := object.Key("FleetId")
6098		ok.String(*v.FleetId)
6099	}
6100
6101	if v.InstanceId != nil {
6102		ok := object.Key("InstanceId")
6103		ok.String(*v.InstanceId)
6104	}
6105
6106	if v.Limit != nil {
6107		ok := object.Key("Limit")
6108		ok.Integer(*v.Limit)
6109	}
6110
6111	if v.NextToken != nil {
6112		ok := object.Key("NextToken")
6113		ok.String(*v.NextToken)
6114	}
6115
6116	return nil
6117}
6118
6119func awsAwsjson11_serializeOpDocumentDescribeMatchmakingConfigurationsInput(v *DescribeMatchmakingConfigurationsInput, value smithyjson.Value) error {
6120	object := value.Object()
6121	defer object.Close()
6122
6123	if v.Limit != nil {
6124		ok := object.Key("Limit")
6125		ok.Integer(*v.Limit)
6126	}
6127
6128	if v.Names != nil {
6129		ok := object.Key("Names")
6130		if err := awsAwsjson11_serializeDocumentMatchmakingConfigurationNameList(v.Names, ok); err != nil {
6131			return err
6132		}
6133	}
6134
6135	if v.NextToken != nil {
6136		ok := object.Key("NextToken")
6137		ok.String(*v.NextToken)
6138	}
6139
6140	if v.RuleSetName != nil {
6141		ok := object.Key("RuleSetName")
6142		ok.String(*v.RuleSetName)
6143	}
6144
6145	return nil
6146}
6147
6148func awsAwsjson11_serializeOpDocumentDescribeMatchmakingInput(v *DescribeMatchmakingInput, value smithyjson.Value) error {
6149	object := value.Object()
6150	defer object.Close()
6151
6152	if v.TicketIds != nil {
6153		ok := object.Key("TicketIds")
6154		if err := awsAwsjson11_serializeDocumentMatchmakingIdList(v.TicketIds, ok); err != nil {
6155			return err
6156		}
6157	}
6158
6159	return nil
6160}
6161
6162func awsAwsjson11_serializeOpDocumentDescribeMatchmakingRuleSetsInput(v *DescribeMatchmakingRuleSetsInput, value smithyjson.Value) error {
6163	object := value.Object()
6164	defer object.Close()
6165
6166	if v.Limit != nil {
6167		ok := object.Key("Limit")
6168		ok.Integer(*v.Limit)
6169	}
6170
6171	if v.Names != nil {
6172		ok := object.Key("Names")
6173		if err := awsAwsjson11_serializeDocumentMatchmakingRuleSetNameList(v.Names, ok); err != nil {
6174			return err
6175		}
6176	}
6177
6178	if v.NextToken != nil {
6179		ok := object.Key("NextToken")
6180		ok.String(*v.NextToken)
6181	}
6182
6183	return nil
6184}
6185
6186func awsAwsjson11_serializeOpDocumentDescribePlayerSessionsInput(v *DescribePlayerSessionsInput, value smithyjson.Value) error {
6187	object := value.Object()
6188	defer object.Close()
6189
6190	if v.GameSessionId != nil {
6191		ok := object.Key("GameSessionId")
6192		ok.String(*v.GameSessionId)
6193	}
6194
6195	if v.Limit != nil {
6196		ok := object.Key("Limit")
6197		ok.Integer(*v.Limit)
6198	}
6199
6200	if v.NextToken != nil {
6201		ok := object.Key("NextToken")
6202		ok.String(*v.NextToken)
6203	}
6204
6205	if v.PlayerId != nil {
6206		ok := object.Key("PlayerId")
6207		ok.String(*v.PlayerId)
6208	}
6209
6210	if v.PlayerSessionId != nil {
6211		ok := object.Key("PlayerSessionId")
6212		ok.String(*v.PlayerSessionId)
6213	}
6214
6215	if v.PlayerSessionStatusFilter != nil {
6216		ok := object.Key("PlayerSessionStatusFilter")
6217		ok.String(*v.PlayerSessionStatusFilter)
6218	}
6219
6220	return nil
6221}
6222
6223func awsAwsjson11_serializeOpDocumentDescribeRuntimeConfigurationInput(v *DescribeRuntimeConfigurationInput, value smithyjson.Value) error {
6224	object := value.Object()
6225	defer object.Close()
6226
6227	if v.FleetId != nil {
6228		ok := object.Key("FleetId")
6229		ok.String(*v.FleetId)
6230	}
6231
6232	return nil
6233}
6234
6235func awsAwsjson11_serializeOpDocumentDescribeScalingPoliciesInput(v *DescribeScalingPoliciesInput, value smithyjson.Value) error {
6236	object := value.Object()
6237	defer object.Close()
6238
6239	if v.FleetId != nil {
6240		ok := object.Key("FleetId")
6241		ok.String(*v.FleetId)
6242	}
6243
6244	if v.Limit != nil {
6245		ok := object.Key("Limit")
6246		ok.Integer(*v.Limit)
6247	}
6248
6249	if v.NextToken != nil {
6250		ok := object.Key("NextToken")
6251		ok.String(*v.NextToken)
6252	}
6253
6254	if len(v.StatusFilter) > 0 {
6255		ok := object.Key("StatusFilter")
6256		ok.String(string(v.StatusFilter))
6257	}
6258
6259	return nil
6260}
6261
6262func awsAwsjson11_serializeOpDocumentDescribeScriptInput(v *DescribeScriptInput, value smithyjson.Value) error {
6263	object := value.Object()
6264	defer object.Close()
6265
6266	if v.ScriptId != nil {
6267		ok := object.Key("ScriptId")
6268		ok.String(*v.ScriptId)
6269	}
6270
6271	return nil
6272}
6273
6274func awsAwsjson11_serializeOpDocumentDescribeVpcPeeringAuthorizationsInput(v *DescribeVpcPeeringAuthorizationsInput, value smithyjson.Value) error {
6275	object := value.Object()
6276	defer object.Close()
6277
6278	return nil
6279}
6280
6281func awsAwsjson11_serializeOpDocumentDescribeVpcPeeringConnectionsInput(v *DescribeVpcPeeringConnectionsInput, value smithyjson.Value) error {
6282	object := value.Object()
6283	defer object.Close()
6284
6285	if v.FleetId != nil {
6286		ok := object.Key("FleetId")
6287		ok.String(*v.FleetId)
6288	}
6289
6290	return nil
6291}
6292
6293func awsAwsjson11_serializeOpDocumentGetGameSessionLogUrlInput(v *GetGameSessionLogUrlInput, value smithyjson.Value) error {
6294	object := value.Object()
6295	defer object.Close()
6296
6297	if v.GameSessionId != nil {
6298		ok := object.Key("GameSessionId")
6299		ok.String(*v.GameSessionId)
6300	}
6301
6302	return nil
6303}
6304
6305func awsAwsjson11_serializeOpDocumentGetInstanceAccessInput(v *GetInstanceAccessInput, value smithyjson.Value) error {
6306	object := value.Object()
6307	defer object.Close()
6308
6309	if v.FleetId != nil {
6310		ok := object.Key("FleetId")
6311		ok.String(*v.FleetId)
6312	}
6313
6314	if v.InstanceId != nil {
6315		ok := object.Key("InstanceId")
6316		ok.String(*v.InstanceId)
6317	}
6318
6319	return nil
6320}
6321
6322func awsAwsjson11_serializeOpDocumentListAliasesInput(v *ListAliasesInput, value smithyjson.Value) error {
6323	object := value.Object()
6324	defer object.Close()
6325
6326	if v.Limit != nil {
6327		ok := object.Key("Limit")
6328		ok.Integer(*v.Limit)
6329	}
6330
6331	if v.Name != nil {
6332		ok := object.Key("Name")
6333		ok.String(*v.Name)
6334	}
6335
6336	if v.NextToken != nil {
6337		ok := object.Key("NextToken")
6338		ok.String(*v.NextToken)
6339	}
6340
6341	if len(v.RoutingStrategyType) > 0 {
6342		ok := object.Key("RoutingStrategyType")
6343		ok.String(string(v.RoutingStrategyType))
6344	}
6345
6346	return nil
6347}
6348
6349func awsAwsjson11_serializeOpDocumentListBuildsInput(v *ListBuildsInput, value smithyjson.Value) error {
6350	object := value.Object()
6351	defer object.Close()
6352
6353	if v.Limit != nil {
6354		ok := object.Key("Limit")
6355		ok.Integer(*v.Limit)
6356	}
6357
6358	if v.NextToken != nil {
6359		ok := object.Key("NextToken")
6360		ok.String(*v.NextToken)
6361	}
6362
6363	if len(v.Status) > 0 {
6364		ok := object.Key("Status")
6365		ok.String(string(v.Status))
6366	}
6367
6368	return nil
6369}
6370
6371func awsAwsjson11_serializeOpDocumentListFleetsInput(v *ListFleetsInput, value smithyjson.Value) error {
6372	object := value.Object()
6373	defer object.Close()
6374
6375	if v.BuildId != nil {
6376		ok := object.Key("BuildId")
6377		ok.String(*v.BuildId)
6378	}
6379
6380	if v.Limit != nil {
6381		ok := object.Key("Limit")
6382		ok.Integer(*v.Limit)
6383	}
6384
6385	if v.NextToken != nil {
6386		ok := object.Key("NextToken")
6387		ok.String(*v.NextToken)
6388	}
6389
6390	if v.ScriptId != nil {
6391		ok := object.Key("ScriptId")
6392		ok.String(*v.ScriptId)
6393	}
6394
6395	return nil
6396}
6397
6398func awsAwsjson11_serializeOpDocumentListGameServerGroupsInput(v *ListGameServerGroupsInput, value smithyjson.Value) error {
6399	object := value.Object()
6400	defer object.Close()
6401
6402	if v.Limit != nil {
6403		ok := object.Key("Limit")
6404		ok.Integer(*v.Limit)
6405	}
6406
6407	if v.NextToken != nil {
6408		ok := object.Key("NextToken")
6409		ok.String(*v.NextToken)
6410	}
6411
6412	return nil
6413}
6414
6415func awsAwsjson11_serializeOpDocumentListGameServersInput(v *ListGameServersInput, value smithyjson.Value) error {
6416	object := value.Object()
6417	defer object.Close()
6418
6419	if v.GameServerGroupName != nil {
6420		ok := object.Key("GameServerGroupName")
6421		ok.String(*v.GameServerGroupName)
6422	}
6423
6424	if v.Limit != nil {
6425		ok := object.Key("Limit")
6426		ok.Integer(*v.Limit)
6427	}
6428
6429	if v.NextToken != nil {
6430		ok := object.Key("NextToken")
6431		ok.String(*v.NextToken)
6432	}
6433
6434	if len(v.SortOrder) > 0 {
6435		ok := object.Key("SortOrder")
6436		ok.String(string(v.SortOrder))
6437	}
6438
6439	return nil
6440}
6441
6442func awsAwsjson11_serializeOpDocumentListScriptsInput(v *ListScriptsInput, value smithyjson.Value) error {
6443	object := value.Object()
6444	defer object.Close()
6445
6446	if v.Limit != nil {
6447		ok := object.Key("Limit")
6448		ok.Integer(*v.Limit)
6449	}
6450
6451	if v.NextToken != nil {
6452		ok := object.Key("NextToken")
6453		ok.String(*v.NextToken)
6454	}
6455
6456	return nil
6457}
6458
6459func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
6460	object := value.Object()
6461	defer object.Close()
6462
6463	if v.ResourceARN != nil {
6464		ok := object.Key("ResourceARN")
6465		ok.String(*v.ResourceARN)
6466	}
6467
6468	return nil
6469}
6470
6471func awsAwsjson11_serializeOpDocumentPutScalingPolicyInput(v *PutScalingPolicyInput, value smithyjson.Value) error {
6472	object := value.Object()
6473	defer object.Close()
6474
6475	if len(v.ComparisonOperator) > 0 {
6476		ok := object.Key("ComparisonOperator")
6477		ok.String(string(v.ComparisonOperator))
6478	}
6479
6480	if v.EvaluationPeriods != nil {
6481		ok := object.Key("EvaluationPeriods")
6482		ok.Integer(*v.EvaluationPeriods)
6483	}
6484
6485	if v.FleetId != nil {
6486		ok := object.Key("FleetId")
6487		ok.String(*v.FleetId)
6488	}
6489
6490	if len(v.MetricName) > 0 {
6491		ok := object.Key("MetricName")
6492		ok.String(string(v.MetricName))
6493	}
6494
6495	if v.Name != nil {
6496		ok := object.Key("Name")
6497		ok.String(*v.Name)
6498	}
6499
6500	if len(v.PolicyType) > 0 {
6501		ok := object.Key("PolicyType")
6502		ok.String(string(v.PolicyType))
6503	}
6504
6505	if v.ScalingAdjustment != 0 {
6506		ok := object.Key("ScalingAdjustment")
6507		ok.Integer(v.ScalingAdjustment)
6508	}
6509
6510	if len(v.ScalingAdjustmentType) > 0 {
6511		ok := object.Key("ScalingAdjustmentType")
6512		ok.String(string(v.ScalingAdjustmentType))
6513	}
6514
6515	if v.TargetConfiguration != nil {
6516		ok := object.Key("TargetConfiguration")
6517		if err := awsAwsjson11_serializeDocumentTargetConfiguration(v.TargetConfiguration, ok); err != nil {
6518			return err
6519		}
6520	}
6521
6522	if v.Threshold != 0 {
6523		ok := object.Key("Threshold")
6524		ok.Double(v.Threshold)
6525	}
6526
6527	return nil
6528}
6529
6530func awsAwsjson11_serializeOpDocumentRegisterGameServerInput(v *RegisterGameServerInput, value smithyjson.Value) error {
6531	object := value.Object()
6532	defer object.Close()
6533
6534	if v.ConnectionInfo != nil {
6535		ok := object.Key("ConnectionInfo")
6536		ok.String(*v.ConnectionInfo)
6537	}
6538
6539	if v.GameServerData != nil {
6540		ok := object.Key("GameServerData")
6541		ok.String(*v.GameServerData)
6542	}
6543
6544	if v.GameServerGroupName != nil {
6545		ok := object.Key("GameServerGroupName")
6546		ok.String(*v.GameServerGroupName)
6547	}
6548
6549	if v.GameServerId != nil {
6550		ok := object.Key("GameServerId")
6551		ok.String(*v.GameServerId)
6552	}
6553
6554	if v.InstanceId != nil {
6555		ok := object.Key("InstanceId")
6556		ok.String(*v.InstanceId)
6557	}
6558
6559	return nil
6560}
6561
6562func awsAwsjson11_serializeOpDocumentRequestUploadCredentialsInput(v *RequestUploadCredentialsInput, value smithyjson.Value) error {
6563	object := value.Object()
6564	defer object.Close()
6565
6566	if v.BuildId != nil {
6567		ok := object.Key("BuildId")
6568		ok.String(*v.BuildId)
6569	}
6570
6571	return nil
6572}
6573
6574func awsAwsjson11_serializeOpDocumentResolveAliasInput(v *ResolveAliasInput, value smithyjson.Value) error {
6575	object := value.Object()
6576	defer object.Close()
6577
6578	if v.AliasId != nil {
6579		ok := object.Key("AliasId")
6580		ok.String(*v.AliasId)
6581	}
6582
6583	return nil
6584}
6585
6586func awsAwsjson11_serializeOpDocumentResumeGameServerGroupInput(v *ResumeGameServerGroupInput, value smithyjson.Value) error {
6587	object := value.Object()
6588	defer object.Close()
6589
6590	if v.GameServerGroupName != nil {
6591		ok := object.Key("GameServerGroupName")
6592		ok.String(*v.GameServerGroupName)
6593	}
6594
6595	if v.ResumeActions != nil {
6596		ok := object.Key("ResumeActions")
6597		if err := awsAwsjson11_serializeDocumentGameServerGroupActions(v.ResumeActions, ok); err != nil {
6598			return err
6599		}
6600	}
6601
6602	return nil
6603}
6604
6605func awsAwsjson11_serializeOpDocumentSearchGameSessionsInput(v *SearchGameSessionsInput, value smithyjson.Value) error {
6606	object := value.Object()
6607	defer object.Close()
6608
6609	if v.AliasId != nil {
6610		ok := object.Key("AliasId")
6611		ok.String(*v.AliasId)
6612	}
6613
6614	if v.FilterExpression != nil {
6615		ok := object.Key("FilterExpression")
6616		ok.String(*v.FilterExpression)
6617	}
6618
6619	if v.FleetId != nil {
6620		ok := object.Key("FleetId")
6621		ok.String(*v.FleetId)
6622	}
6623
6624	if v.Limit != nil {
6625		ok := object.Key("Limit")
6626		ok.Integer(*v.Limit)
6627	}
6628
6629	if v.NextToken != nil {
6630		ok := object.Key("NextToken")
6631		ok.String(*v.NextToken)
6632	}
6633
6634	if v.SortExpression != nil {
6635		ok := object.Key("SortExpression")
6636		ok.String(*v.SortExpression)
6637	}
6638
6639	return nil
6640}
6641
6642func awsAwsjson11_serializeOpDocumentStartFleetActionsInput(v *StartFleetActionsInput, value smithyjson.Value) error {
6643	object := value.Object()
6644	defer object.Close()
6645
6646	if v.Actions != nil {
6647		ok := object.Key("Actions")
6648		if err := awsAwsjson11_serializeDocumentFleetActionList(v.Actions, ok); err != nil {
6649			return err
6650		}
6651	}
6652
6653	if v.FleetId != nil {
6654		ok := object.Key("FleetId")
6655		ok.String(*v.FleetId)
6656	}
6657
6658	return nil
6659}
6660
6661func awsAwsjson11_serializeOpDocumentStartGameSessionPlacementInput(v *StartGameSessionPlacementInput, value smithyjson.Value) error {
6662	object := value.Object()
6663	defer object.Close()
6664
6665	if v.DesiredPlayerSessions != nil {
6666		ok := object.Key("DesiredPlayerSessions")
6667		if err := awsAwsjson11_serializeDocumentDesiredPlayerSessionList(v.DesiredPlayerSessions, ok); err != nil {
6668			return err
6669		}
6670	}
6671
6672	if v.GameProperties != nil {
6673		ok := object.Key("GameProperties")
6674		if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
6675			return err
6676		}
6677	}
6678
6679	if v.GameSessionData != nil {
6680		ok := object.Key("GameSessionData")
6681		ok.String(*v.GameSessionData)
6682	}
6683
6684	if v.GameSessionName != nil {
6685		ok := object.Key("GameSessionName")
6686		ok.String(*v.GameSessionName)
6687	}
6688
6689	if v.GameSessionQueueName != nil {
6690		ok := object.Key("GameSessionQueueName")
6691		ok.String(*v.GameSessionQueueName)
6692	}
6693
6694	if v.MaximumPlayerSessionCount != nil {
6695		ok := object.Key("MaximumPlayerSessionCount")
6696		ok.Integer(*v.MaximumPlayerSessionCount)
6697	}
6698
6699	if v.PlacementId != nil {
6700		ok := object.Key("PlacementId")
6701		ok.String(*v.PlacementId)
6702	}
6703
6704	if v.PlayerLatencies != nil {
6705		ok := object.Key("PlayerLatencies")
6706		if err := awsAwsjson11_serializeDocumentPlayerLatencyList(v.PlayerLatencies, ok); err != nil {
6707			return err
6708		}
6709	}
6710
6711	return nil
6712}
6713
6714func awsAwsjson11_serializeOpDocumentStartMatchBackfillInput(v *StartMatchBackfillInput, value smithyjson.Value) error {
6715	object := value.Object()
6716	defer object.Close()
6717
6718	if v.ConfigurationName != nil {
6719		ok := object.Key("ConfigurationName")
6720		ok.String(*v.ConfigurationName)
6721	}
6722
6723	if v.GameSessionArn != nil {
6724		ok := object.Key("GameSessionArn")
6725		ok.String(*v.GameSessionArn)
6726	}
6727
6728	if v.Players != nil {
6729		ok := object.Key("Players")
6730		if err := awsAwsjson11_serializeDocumentPlayerList(v.Players, ok); err != nil {
6731			return err
6732		}
6733	}
6734
6735	if v.TicketId != nil {
6736		ok := object.Key("TicketId")
6737		ok.String(*v.TicketId)
6738	}
6739
6740	return nil
6741}
6742
6743func awsAwsjson11_serializeOpDocumentStartMatchmakingInput(v *StartMatchmakingInput, value smithyjson.Value) error {
6744	object := value.Object()
6745	defer object.Close()
6746
6747	if v.ConfigurationName != nil {
6748		ok := object.Key("ConfigurationName")
6749		ok.String(*v.ConfigurationName)
6750	}
6751
6752	if v.Players != nil {
6753		ok := object.Key("Players")
6754		if err := awsAwsjson11_serializeDocumentPlayerList(v.Players, ok); err != nil {
6755			return err
6756		}
6757	}
6758
6759	if v.TicketId != nil {
6760		ok := object.Key("TicketId")
6761		ok.String(*v.TicketId)
6762	}
6763
6764	return nil
6765}
6766
6767func awsAwsjson11_serializeOpDocumentStopFleetActionsInput(v *StopFleetActionsInput, value smithyjson.Value) error {
6768	object := value.Object()
6769	defer object.Close()
6770
6771	if v.Actions != nil {
6772		ok := object.Key("Actions")
6773		if err := awsAwsjson11_serializeDocumentFleetActionList(v.Actions, ok); err != nil {
6774			return err
6775		}
6776	}
6777
6778	if v.FleetId != nil {
6779		ok := object.Key("FleetId")
6780		ok.String(*v.FleetId)
6781	}
6782
6783	return nil
6784}
6785
6786func awsAwsjson11_serializeOpDocumentStopGameSessionPlacementInput(v *StopGameSessionPlacementInput, value smithyjson.Value) error {
6787	object := value.Object()
6788	defer object.Close()
6789
6790	if v.PlacementId != nil {
6791		ok := object.Key("PlacementId")
6792		ok.String(*v.PlacementId)
6793	}
6794
6795	return nil
6796}
6797
6798func awsAwsjson11_serializeOpDocumentStopMatchmakingInput(v *StopMatchmakingInput, value smithyjson.Value) error {
6799	object := value.Object()
6800	defer object.Close()
6801
6802	if v.TicketId != nil {
6803		ok := object.Key("TicketId")
6804		ok.String(*v.TicketId)
6805	}
6806
6807	return nil
6808}
6809
6810func awsAwsjson11_serializeOpDocumentSuspendGameServerGroupInput(v *SuspendGameServerGroupInput, value smithyjson.Value) error {
6811	object := value.Object()
6812	defer object.Close()
6813
6814	if v.GameServerGroupName != nil {
6815		ok := object.Key("GameServerGroupName")
6816		ok.String(*v.GameServerGroupName)
6817	}
6818
6819	if v.SuspendActions != nil {
6820		ok := object.Key("SuspendActions")
6821		if err := awsAwsjson11_serializeDocumentGameServerGroupActions(v.SuspendActions, ok); err != nil {
6822			return err
6823		}
6824	}
6825
6826	return nil
6827}
6828
6829func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
6830	object := value.Object()
6831	defer object.Close()
6832
6833	if v.ResourceARN != nil {
6834		ok := object.Key("ResourceARN")
6835		ok.String(*v.ResourceARN)
6836	}
6837
6838	if v.Tags != nil {
6839		ok := object.Key("Tags")
6840		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
6841			return err
6842		}
6843	}
6844
6845	return nil
6846}
6847
6848func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
6849	object := value.Object()
6850	defer object.Close()
6851
6852	if v.ResourceARN != nil {
6853		ok := object.Key("ResourceARN")
6854		ok.String(*v.ResourceARN)
6855	}
6856
6857	if v.TagKeys != nil {
6858		ok := object.Key("TagKeys")
6859		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
6860			return err
6861		}
6862	}
6863
6864	return nil
6865}
6866
6867func awsAwsjson11_serializeOpDocumentUpdateAliasInput(v *UpdateAliasInput, value smithyjson.Value) error {
6868	object := value.Object()
6869	defer object.Close()
6870
6871	if v.AliasId != nil {
6872		ok := object.Key("AliasId")
6873		ok.String(*v.AliasId)
6874	}
6875
6876	if v.Description != nil {
6877		ok := object.Key("Description")
6878		ok.String(*v.Description)
6879	}
6880
6881	if v.Name != nil {
6882		ok := object.Key("Name")
6883		ok.String(*v.Name)
6884	}
6885
6886	if v.RoutingStrategy != nil {
6887		ok := object.Key("RoutingStrategy")
6888		if err := awsAwsjson11_serializeDocumentRoutingStrategy(v.RoutingStrategy, ok); err != nil {
6889			return err
6890		}
6891	}
6892
6893	return nil
6894}
6895
6896func awsAwsjson11_serializeOpDocumentUpdateBuildInput(v *UpdateBuildInput, value smithyjson.Value) error {
6897	object := value.Object()
6898	defer object.Close()
6899
6900	if v.BuildId != nil {
6901		ok := object.Key("BuildId")
6902		ok.String(*v.BuildId)
6903	}
6904
6905	if v.Name != nil {
6906		ok := object.Key("Name")
6907		ok.String(*v.Name)
6908	}
6909
6910	if v.Version != nil {
6911		ok := object.Key("Version")
6912		ok.String(*v.Version)
6913	}
6914
6915	return nil
6916}
6917
6918func awsAwsjson11_serializeOpDocumentUpdateFleetAttributesInput(v *UpdateFleetAttributesInput, value smithyjson.Value) error {
6919	object := value.Object()
6920	defer object.Close()
6921
6922	if v.Description != nil {
6923		ok := object.Key("Description")
6924		ok.String(*v.Description)
6925	}
6926
6927	if v.FleetId != nil {
6928		ok := object.Key("FleetId")
6929		ok.String(*v.FleetId)
6930	}
6931
6932	if v.MetricGroups != nil {
6933		ok := object.Key("MetricGroups")
6934		if err := awsAwsjson11_serializeDocumentMetricGroupList(v.MetricGroups, ok); err != nil {
6935			return err
6936		}
6937	}
6938
6939	if v.Name != nil {
6940		ok := object.Key("Name")
6941		ok.String(*v.Name)
6942	}
6943
6944	if len(v.NewGameSessionProtectionPolicy) > 0 {
6945		ok := object.Key("NewGameSessionProtectionPolicy")
6946		ok.String(string(v.NewGameSessionProtectionPolicy))
6947	}
6948
6949	if v.ResourceCreationLimitPolicy != nil {
6950		ok := object.Key("ResourceCreationLimitPolicy")
6951		if err := awsAwsjson11_serializeDocumentResourceCreationLimitPolicy(v.ResourceCreationLimitPolicy, ok); err != nil {
6952			return err
6953		}
6954	}
6955
6956	return nil
6957}
6958
6959func awsAwsjson11_serializeOpDocumentUpdateFleetCapacityInput(v *UpdateFleetCapacityInput, value smithyjson.Value) error {
6960	object := value.Object()
6961	defer object.Close()
6962
6963	if v.DesiredInstances != nil {
6964		ok := object.Key("DesiredInstances")
6965		ok.Integer(*v.DesiredInstances)
6966	}
6967
6968	if v.FleetId != nil {
6969		ok := object.Key("FleetId")
6970		ok.String(*v.FleetId)
6971	}
6972
6973	if v.MaxSize != nil {
6974		ok := object.Key("MaxSize")
6975		ok.Integer(*v.MaxSize)
6976	}
6977
6978	if v.MinSize != nil {
6979		ok := object.Key("MinSize")
6980		ok.Integer(*v.MinSize)
6981	}
6982
6983	return nil
6984}
6985
6986func awsAwsjson11_serializeOpDocumentUpdateFleetPortSettingsInput(v *UpdateFleetPortSettingsInput, value smithyjson.Value) error {
6987	object := value.Object()
6988	defer object.Close()
6989
6990	if v.FleetId != nil {
6991		ok := object.Key("FleetId")
6992		ok.String(*v.FleetId)
6993	}
6994
6995	if v.InboundPermissionAuthorizations != nil {
6996		ok := object.Key("InboundPermissionAuthorizations")
6997		if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.InboundPermissionAuthorizations, ok); err != nil {
6998			return err
6999		}
7000	}
7001
7002	if v.InboundPermissionRevocations != nil {
7003		ok := object.Key("InboundPermissionRevocations")
7004		if err := awsAwsjson11_serializeDocumentIpPermissionsList(v.InboundPermissionRevocations, ok); err != nil {
7005			return err
7006		}
7007	}
7008
7009	return nil
7010}
7011
7012func awsAwsjson11_serializeOpDocumentUpdateGameServerGroupInput(v *UpdateGameServerGroupInput, value smithyjson.Value) error {
7013	object := value.Object()
7014	defer object.Close()
7015
7016	if len(v.BalancingStrategy) > 0 {
7017		ok := object.Key("BalancingStrategy")
7018		ok.String(string(v.BalancingStrategy))
7019	}
7020
7021	if v.GameServerGroupName != nil {
7022		ok := object.Key("GameServerGroupName")
7023		ok.String(*v.GameServerGroupName)
7024	}
7025
7026	if len(v.GameServerProtectionPolicy) > 0 {
7027		ok := object.Key("GameServerProtectionPolicy")
7028		ok.String(string(v.GameServerProtectionPolicy))
7029	}
7030
7031	if v.InstanceDefinitions != nil {
7032		ok := object.Key("InstanceDefinitions")
7033		if err := awsAwsjson11_serializeDocumentInstanceDefinitions(v.InstanceDefinitions, ok); err != nil {
7034			return err
7035		}
7036	}
7037
7038	if v.RoleArn != nil {
7039		ok := object.Key("RoleArn")
7040		ok.String(*v.RoleArn)
7041	}
7042
7043	return nil
7044}
7045
7046func awsAwsjson11_serializeOpDocumentUpdateGameServerInput(v *UpdateGameServerInput, value smithyjson.Value) error {
7047	object := value.Object()
7048	defer object.Close()
7049
7050	if v.GameServerData != nil {
7051		ok := object.Key("GameServerData")
7052		ok.String(*v.GameServerData)
7053	}
7054
7055	if v.GameServerGroupName != nil {
7056		ok := object.Key("GameServerGroupName")
7057		ok.String(*v.GameServerGroupName)
7058	}
7059
7060	if v.GameServerId != nil {
7061		ok := object.Key("GameServerId")
7062		ok.String(*v.GameServerId)
7063	}
7064
7065	if len(v.HealthCheck) > 0 {
7066		ok := object.Key("HealthCheck")
7067		ok.String(string(v.HealthCheck))
7068	}
7069
7070	if len(v.UtilizationStatus) > 0 {
7071		ok := object.Key("UtilizationStatus")
7072		ok.String(string(v.UtilizationStatus))
7073	}
7074
7075	return nil
7076}
7077
7078func awsAwsjson11_serializeOpDocumentUpdateGameSessionInput(v *UpdateGameSessionInput, value smithyjson.Value) error {
7079	object := value.Object()
7080	defer object.Close()
7081
7082	if v.GameSessionId != nil {
7083		ok := object.Key("GameSessionId")
7084		ok.String(*v.GameSessionId)
7085	}
7086
7087	if v.MaximumPlayerSessionCount != nil {
7088		ok := object.Key("MaximumPlayerSessionCount")
7089		ok.Integer(*v.MaximumPlayerSessionCount)
7090	}
7091
7092	if v.Name != nil {
7093		ok := object.Key("Name")
7094		ok.String(*v.Name)
7095	}
7096
7097	if len(v.PlayerSessionCreationPolicy) > 0 {
7098		ok := object.Key("PlayerSessionCreationPolicy")
7099		ok.String(string(v.PlayerSessionCreationPolicy))
7100	}
7101
7102	if len(v.ProtectionPolicy) > 0 {
7103		ok := object.Key("ProtectionPolicy")
7104		ok.String(string(v.ProtectionPolicy))
7105	}
7106
7107	return nil
7108}
7109
7110func awsAwsjson11_serializeOpDocumentUpdateGameSessionQueueInput(v *UpdateGameSessionQueueInput, value smithyjson.Value) error {
7111	object := value.Object()
7112	defer object.Close()
7113
7114	if v.Destinations != nil {
7115		ok := object.Key("Destinations")
7116		if err := awsAwsjson11_serializeDocumentGameSessionQueueDestinationList(v.Destinations, ok); err != nil {
7117			return err
7118		}
7119	}
7120
7121	if v.Name != nil {
7122		ok := object.Key("Name")
7123		ok.String(*v.Name)
7124	}
7125
7126	if v.PlayerLatencyPolicies != nil {
7127		ok := object.Key("PlayerLatencyPolicies")
7128		if err := awsAwsjson11_serializeDocumentPlayerLatencyPolicyList(v.PlayerLatencyPolicies, ok); err != nil {
7129			return err
7130		}
7131	}
7132
7133	if v.TimeoutInSeconds != nil {
7134		ok := object.Key("TimeoutInSeconds")
7135		ok.Integer(*v.TimeoutInSeconds)
7136	}
7137
7138	return nil
7139}
7140
7141func awsAwsjson11_serializeOpDocumentUpdateMatchmakingConfigurationInput(v *UpdateMatchmakingConfigurationInput, value smithyjson.Value) error {
7142	object := value.Object()
7143	defer object.Close()
7144
7145	if v.AcceptanceRequired != nil {
7146		ok := object.Key("AcceptanceRequired")
7147		ok.Boolean(*v.AcceptanceRequired)
7148	}
7149
7150	if v.AcceptanceTimeoutSeconds != nil {
7151		ok := object.Key("AcceptanceTimeoutSeconds")
7152		ok.Integer(*v.AcceptanceTimeoutSeconds)
7153	}
7154
7155	if v.AdditionalPlayerCount != nil {
7156		ok := object.Key("AdditionalPlayerCount")
7157		ok.Integer(*v.AdditionalPlayerCount)
7158	}
7159
7160	if len(v.BackfillMode) > 0 {
7161		ok := object.Key("BackfillMode")
7162		ok.String(string(v.BackfillMode))
7163	}
7164
7165	if v.CustomEventData != nil {
7166		ok := object.Key("CustomEventData")
7167		ok.String(*v.CustomEventData)
7168	}
7169
7170	if v.Description != nil {
7171		ok := object.Key("Description")
7172		ok.String(*v.Description)
7173	}
7174
7175	if len(v.FlexMatchMode) > 0 {
7176		ok := object.Key("FlexMatchMode")
7177		ok.String(string(v.FlexMatchMode))
7178	}
7179
7180	if v.GameProperties != nil {
7181		ok := object.Key("GameProperties")
7182		if err := awsAwsjson11_serializeDocumentGamePropertyList(v.GameProperties, ok); err != nil {
7183			return err
7184		}
7185	}
7186
7187	if v.GameSessionData != nil {
7188		ok := object.Key("GameSessionData")
7189		ok.String(*v.GameSessionData)
7190	}
7191
7192	if v.GameSessionQueueArns != nil {
7193		ok := object.Key("GameSessionQueueArns")
7194		if err := awsAwsjson11_serializeDocumentQueueArnsList(v.GameSessionQueueArns, ok); err != nil {
7195			return err
7196		}
7197	}
7198
7199	if v.Name != nil {
7200		ok := object.Key("Name")
7201		ok.String(*v.Name)
7202	}
7203
7204	if v.NotificationTarget != nil {
7205		ok := object.Key("NotificationTarget")
7206		ok.String(*v.NotificationTarget)
7207	}
7208
7209	if v.RequestTimeoutSeconds != nil {
7210		ok := object.Key("RequestTimeoutSeconds")
7211		ok.Integer(*v.RequestTimeoutSeconds)
7212	}
7213
7214	if v.RuleSetName != nil {
7215		ok := object.Key("RuleSetName")
7216		ok.String(*v.RuleSetName)
7217	}
7218
7219	return nil
7220}
7221
7222func awsAwsjson11_serializeOpDocumentUpdateRuntimeConfigurationInput(v *UpdateRuntimeConfigurationInput, value smithyjson.Value) error {
7223	object := value.Object()
7224	defer object.Close()
7225
7226	if v.FleetId != nil {
7227		ok := object.Key("FleetId")
7228		ok.String(*v.FleetId)
7229	}
7230
7231	if v.RuntimeConfiguration != nil {
7232		ok := object.Key("RuntimeConfiguration")
7233		if err := awsAwsjson11_serializeDocumentRuntimeConfiguration(v.RuntimeConfiguration, ok); err != nil {
7234			return err
7235		}
7236	}
7237
7238	return nil
7239}
7240
7241func awsAwsjson11_serializeOpDocumentUpdateScriptInput(v *UpdateScriptInput, value smithyjson.Value) error {
7242	object := value.Object()
7243	defer object.Close()
7244
7245	if v.Name != nil {
7246		ok := object.Key("Name")
7247		ok.String(*v.Name)
7248	}
7249
7250	if v.ScriptId != nil {
7251		ok := object.Key("ScriptId")
7252		ok.String(*v.ScriptId)
7253	}
7254
7255	if v.StorageLocation != nil {
7256		ok := object.Key("StorageLocation")
7257		if err := awsAwsjson11_serializeDocumentS3Location(v.StorageLocation, ok); err != nil {
7258			return err
7259		}
7260	}
7261
7262	if v.Version != nil {
7263		ok := object.Key("Version")
7264		ok.String(*v.Version)
7265	}
7266
7267	if v.ZipFile != nil {
7268		ok := object.Key("ZipFile")
7269		ok.Base64EncodeBytes(v.ZipFile)
7270	}
7271
7272	return nil
7273}
7274
7275func awsAwsjson11_serializeOpDocumentValidateMatchmakingRuleSetInput(v *ValidateMatchmakingRuleSetInput, value smithyjson.Value) error {
7276	object := value.Object()
7277	defer object.Close()
7278
7279	if v.RuleSetBody != nil {
7280		ok := object.Key("RuleSetBody")
7281		ok.String(*v.RuleSetBody)
7282	}
7283
7284	return nil
7285}
7286