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