1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package apigateway
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/apigateway/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsRestjson1_serializeOpCreateApiKey struct {
18}
19
20func (*awsRestjson1_serializeOpCreateApiKey) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsRestjson1_serializeOpCreateApiKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*CreateApiKeyInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	opPath, opQuery := httpbinding.SplitURI("/apikeys")
39	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
40	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
41	request.Method = "POST"
42	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
43	if err != nil {
44		return out, metadata, &smithy.SerializationError{Err: err}
45	}
46
47	restEncoder.SetHeader("Content-Type").String("application/json")
48
49	jsonEncoder := smithyjson.NewEncoder()
50	if err := awsRestjson1_serializeOpDocumentCreateApiKeyInput(input, jsonEncoder.Value); err != nil {
51		return out, metadata, &smithy.SerializationError{Err: err}
52	}
53
54	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
55		return out, metadata, &smithy.SerializationError{Err: err}
56	}
57
58	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
59		return out, metadata, &smithy.SerializationError{Err: err}
60	}
61	in.Request = request
62
63	return next.HandleSerialize(ctx, in)
64}
65func awsRestjson1_serializeOpHttpBindingsCreateApiKeyInput(v *CreateApiKeyInput, encoder *httpbinding.Encoder) error {
66	if v == nil {
67		return fmt.Errorf("unsupported serialization of nil %T", v)
68	}
69
70	return nil
71}
72
73func awsRestjson1_serializeOpDocumentCreateApiKeyInput(v *CreateApiKeyInput, value smithyjson.Value) error {
74	object := value.Object()
75	defer object.Close()
76
77	if v.CustomerId != nil {
78		ok := object.Key("customerId")
79		ok.String(*v.CustomerId)
80	}
81
82	if v.Description != nil {
83		ok := object.Key("description")
84		ok.String(*v.Description)
85	}
86
87	if v.Enabled {
88		ok := object.Key("enabled")
89		ok.Boolean(v.Enabled)
90	}
91
92	if v.GenerateDistinctId {
93		ok := object.Key("generateDistinctId")
94		ok.Boolean(v.GenerateDistinctId)
95	}
96
97	if v.Name != nil {
98		ok := object.Key("name")
99		ok.String(*v.Name)
100	}
101
102	if v.StageKeys != nil {
103		ok := object.Key("stageKeys")
104		if err := awsRestjson1_serializeDocumentListOfStageKeys(v.StageKeys, ok); err != nil {
105			return err
106		}
107	}
108
109	if v.Tags != nil {
110		ok := object.Key("tags")
111		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
112			return err
113		}
114	}
115
116	if v.Value != nil {
117		ok := object.Key("value")
118		ok.String(*v.Value)
119	}
120
121	return nil
122}
123
124type awsRestjson1_serializeOpCreateAuthorizer struct {
125}
126
127func (*awsRestjson1_serializeOpCreateAuthorizer) ID() string {
128	return "OperationSerializer"
129}
130
131func (m *awsRestjson1_serializeOpCreateAuthorizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
132	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
133) {
134	request, ok := in.Request.(*smithyhttp.Request)
135	if !ok {
136		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
137	}
138
139	input, ok := in.Parameters.(*CreateAuthorizerInput)
140	_ = input
141	if !ok {
142		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
143	}
144
145	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers")
146	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
147	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
148	request.Method = "POST"
149	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
150	if err != nil {
151		return out, metadata, &smithy.SerializationError{Err: err}
152	}
153
154	if err := awsRestjson1_serializeOpHttpBindingsCreateAuthorizerInput(input, restEncoder); err != nil {
155		return out, metadata, &smithy.SerializationError{Err: err}
156	}
157
158	restEncoder.SetHeader("Content-Type").String("application/json")
159
160	jsonEncoder := smithyjson.NewEncoder()
161	if err := awsRestjson1_serializeOpDocumentCreateAuthorizerInput(input, jsonEncoder.Value); err != nil {
162		return out, metadata, &smithy.SerializationError{Err: err}
163	}
164
165	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
166		return out, metadata, &smithy.SerializationError{Err: err}
167	}
168
169	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
170		return out, metadata, &smithy.SerializationError{Err: err}
171	}
172	in.Request = request
173
174	return next.HandleSerialize(ctx, in)
175}
176func awsRestjson1_serializeOpHttpBindingsCreateAuthorizerInput(v *CreateAuthorizerInput, encoder *httpbinding.Encoder) error {
177	if v == nil {
178		return fmt.Errorf("unsupported serialization of nil %T", v)
179	}
180
181	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
182		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
183	}
184	if v.RestApiId != nil {
185		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
186			return err
187		}
188	}
189
190	return nil
191}
192
193func awsRestjson1_serializeOpDocumentCreateAuthorizerInput(v *CreateAuthorizerInput, value smithyjson.Value) error {
194	object := value.Object()
195	defer object.Close()
196
197	if v.AuthorizerCredentials != nil {
198		ok := object.Key("authorizerCredentials")
199		ok.String(*v.AuthorizerCredentials)
200	}
201
202	if v.AuthorizerResultTtlInSeconds != nil {
203		ok := object.Key("authorizerResultTtlInSeconds")
204		ok.Integer(*v.AuthorizerResultTtlInSeconds)
205	}
206
207	if v.AuthorizerUri != nil {
208		ok := object.Key("authorizerUri")
209		ok.String(*v.AuthorizerUri)
210	}
211
212	if v.AuthType != nil {
213		ok := object.Key("authType")
214		ok.String(*v.AuthType)
215	}
216
217	if v.IdentitySource != nil {
218		ok := object.Key("identitySource")
219		ok.String(*v.IdentitySource)
220	}
221
222	if v.IdentityValidationExpression != nil {
223		ok := object.Key("identityValidationExpression")
224		ok.String(*v.IdentityValidationExpression)
225	}
226
227	if v.Name != nil {
228		ok := object.Key("name")
229		ok.String(*v.Name)
230	}
231
232	if v.ProviderARNs != nil {
233		ok := object.Key("providerARNs")
234		if err := awsRestjson1_serializeDocumentListOfARNs(v.ProviderARNs, ok); err != nil {
235			return err
236		}
237	}
238
239	if len(v.Type) > 0 {
240		ok := object.Key("type")
241		ok.String(string(v.Type))
242	}
243
244	return nil
245}
246
247type awsRestjson1_serializeOpCreateBasePathMapping struct {
248}
249
250func (*awsRestjson1_serializeOpCreateBasePathMapping) ID() string {
251	return "OperationSerializer"
252}
253
254func (m *awsRestjson1_serializeOpCreateBasePathMapping) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
255	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
256) {
257	request, ok := in.Request.(*smithyhttp.Request)
258	if !ok {
259		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
260	}
261
262	input, ok := in.Parameters.(*CreateBasePathMappingInput)
263	_ = input
264	if !ok {
265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
266	}
267
268	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}/basepathmappings")
269	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
270	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
271	request.Method = "POST"
272	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
273	if err != nil {
274		return out, metadata, &smithy.SerializationError{Err: err}
275	}
276
277	if err := awsRestjson1_serializeOpHttpBindingsCreateBasePathMappingInput(input, restEncoder); err != nil {
278		return out, metadata, &smithy.SerializationError{Err: err}
279	}
280
281	restEncoder.SetHeader("Content-Type").String("application/json")
282
283	jsonEncoder := smithyjson.NewEncoder()
284	if err := awsRestjson1_serializeOpDocumentCreateBasePathMappingInput(input, jsonEncoder.Value); err != nil {
285		return out, metadata, &smithy.SerializationError{Err: err}
286	}
287
288	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
289		return out, metadata, &smithy.SerializationError{Err: err}
290	}
291
292	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
293		return out, metadata, &smithy.SerializationError{Err: err}
294	}
295	in.Request = request
296
297	return next.HandleSerialize(ctx, in)
298}
299func awsRestjson1_serializeOpHttpBindingsCreateBasePathMappingInput(v *CreateBasePathMappingInput, encoder *httpbinding.Encoder) error {
300	if v == nil {
301		return fmt.Errorf("unsupported serialization of nil %T", v)
302	}
303
304	if v.DomainName == nil || len(*v.DomainName) == 0 {
305		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
306	}
307	if v.DomainName != nil {
308		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
309			return err
310		}
311	}
312
313	return nil
314}
315
316func awsRestjson1_serializeOpDocumentCreateBasePathMappingInput(v *CreateBasePathMappingInput, value smithyjson.Value) error {
317	object := value.Object()
318	defer object.Close()
319
320	if v.BasePath != nil {
321		ok := object.Key("basePath")
322		ok.String(*v.BasePath)
323	}
324
325	if v.RestApiId != nil {
326		ok := object.Key("restApiId")
327		ok.String(*v.RestApiId)
328	}
329
330	if v.Stage != nil {
331		ok := object.Key("stage")
332		ok.String(*v.Stage)
333	}
334
335	return nil
336}
337
338type awsRestjson1_serializeOpCreateDeployment struct {
339}
340
341func (*awsRestjson1_serializeOpCreateDeployment) ID() string {
342	return "OperationSerializer"
343}
344
345func (m *awsRestjson1_serializeOpCreateDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
346	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
347) {
348	request, ok := in.Request.(*smithyhttp.Request)
349	if !ok {
350		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
351	}
352
353	input, ok := in.Parameters.(*CreateDeploymentInput)
354	_ = input
355	if !ok {
356		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
357	}
358
359	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/deployments")
360	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
361	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
362	request.Method = "POST"
363	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
364	if err != nil {
365		return out, metadata, &smithy.SerializationError{Err: err}
366	}
367
368	if err := awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(input, restEncoder); err != nil {
369		return out, metadata, &smithy.SerializationError{Err: err}
370	}
371
372	restEncoder.SetHeader("Content-Type").String("application/json")
373
374	jsonEncoder := smithyjson.NewEncoder()
375	if err := awsRestjson1_serializeOpDocumentCreateDeploymentInput(input, jsonEncoder.Value); err != nil {
376		return out, metadata, &smithy.SerializationError{Err: err}
377	}
378
379	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
380		return out, metadata, &smithy.SerializationError{Err: err}
381	}
382
383	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
384		return out, metadata, &smithy.SerializationError{Err: err}
385	}
386	in.Request = request
387
388	return next.HandleSerialize(ctx, in)
389}
390func awsRestjson1_serializeOpHttpBindingsCreateDeploymentInput(v *CreateDeploymentInput, encoder *httpbinding.Encoder) error {
391	if v == nil {
392		return fmt.Errorf("unsupported serialization of nil %T", v)
393	}
394
395	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
396		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
397	}
398	if v.RestApiId != nil {
399		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
400			return err
401		}
402	}
403
404	return nil
405}
406
407func awsRestjson1_serializeOpDocumentCreateDeploymentInput(v *CreateDeploymentInput, value smithyjson.Value) error {
408	object := value.Object()
409	defer object.Close()
410
411	if v.CacheClusterEnabled != nil {
412		ok := object.Key("cacheClusterEnabled")
413		ok.Boolean(*v.CacheClusterEnabled)
414	}
415
416	if len(v.CacheClusterSize) > 0 {
417		ok := object.Key("cacheClusterSize")
418		ok.String(string(v.CacheClusterSize))
419	}
420
421	if v.CanarySettings != nil {
422		ok := object.Key("canarySettings")
423		if err := awsRestjson1_serializeDocumentDeploymentCanarySettings(v.CanarySettings, ok); err != nil {
424			return err
425		}
426	}
427
428	if v.Description != nil {
429		ok := object.Key("description")
430		ok.String(*v.Description)
431	}
432
433	if v.StageDescription != nil {
434		ok := object.Key("stageDescription")
435		ok.String(*v.StageDescription)
436	}
437
438	if v.StageName != nil {
439		ok := object.Key("stageName")
440		ok.String(*v.StageName)
441	}
442
443	if v.TracingEnabled != nil {
444		ok := object.Key("tracingEnabled")
445		ok.Boolean(*v.TracingEnabled)
446	}
447
448	if v.Variables != nil {
449		ok := object.Key("variables")
450		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Variables, ok); err != nil {
451			return err
452		}
453	}
454
455	return nil
456}
457
458type awsRestjson1_serializeOpCreateDocumentationPart struct {
459}
460
461func (*awsRestjson1_serializeOpCreateDocumentationPart) ID() string {
462	return "OperationSerializer"
463}
464
465func (m *awsRestjson1_serializeOpCreateDocumentationPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
466	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
467) {
468	request, ok := in.Request.(*smithyhttp.Request)
469	if !ok {
470		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
471	}
472
473	input, ok := in.Parameters.(*CreateDocumentationPartInput)
474	_ = input
475	if !ok {
476		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
477	}
478
479	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts")
480	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
481	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
482	request.Method = "POST"
483	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
484	if err != nil {
485		return out, metadata, &smithy.SerializationError{Err: err}
486	}
487
488	if err := awsRestjson1_serializeOpHttpBindingsCreateDocumentationPartInput(input, restEncoder); err != nil {
489		return out, metadata, &smithy.SerializationError{Err: err}
490	}
491
492	restEncoder.SetHeader("Content-Type").String("application/json")
493
494	jsonEncoder := smithyjson.NewEncoder()
495	if err := awsRestjson1_serializeOpDocumentCreateDocumentationPartInput(input, jsonEncoder.Value); err != nil {
496		return out, metadata, &smithy.SerializationError{Err: err}
497	}
498
499	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
500		return out, metadata, &smithy.SerializationError{Err: err}
501	}
502
503	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
504		return out, metadata, &smithy.SerializationError{Err: err}
505	}
506	in.Request = request
507
508	return next.HandleSerialize(ctx, in)
509}
510func awsRestjson1_serializeOpHttpBindingsCreateDocumentationPartInput(v *CreateDocumentationPartInput, encoder *httpbinding.Encoder) error {
511	if v == nil {
512		return fmt.Errorf("unsupported serialization of nil %T", v)
513	}
514
515	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
516		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
517	}
518	if v.RestApiId != nil {
519		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
520			return err
521		}
522	}
523
524	return nil
525}
526
527func awsRestjson1_serializeOpDocumentCreateDocumentationPartInput(v *CreateDocumentationPartInput, value smithyjson.Value) error {
528	object := value.Object()
529	defer object.Close()
530
531	if v.Location != nil {
532		ok := object.Key("location")
533		if err := awsRestjson1_serializeDocumentDocumentationPartLocation(v.Location, ok); err != nil {
534			return err
535		}
536	}
537
538	if v.Properties != nil {
539		ok := object.Key("properties")
540		ok.String(*v.Properties)
541	}
542
543	return nil
544}
545
546type awsRestjson1_serializeOpCreateDocumentationVersion struct {
547}
548
549func (*awsRestjson1_serializeOpCreateDocumentationVersion) ID() string {
550	return "OperationSerializer"
551}
552
553func (m *awsRestjson1_serializeOpCreateDocumentationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
554	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
555) {
556	request, ok := in.Request.(*smithyhttp.Request)
557	if !ok {
558		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
559	}
560
561	input, ok := in.Parameters.(*CreateDocumentationVersionInput)
562	_ = input
563	if !ok {
564		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
565	}
566
567	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/versions")
568	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
569	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
570	request.Method = "POST"
571	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
572	if err != nil {
573		return out, metadata, &smithy.SerializationError{Err: err}
574	}
575
576	if err := awsRestjson1_serializeOpHttpBindingsCreateDocumentationVersionInput(input, restEncoder); err != nil {
577		return out, metadata, &smithy.SerializationError{Err: err}
578	}
579
580	restEncoder.SetHeader("Content-Type").String("application/json")
581
582	jsonEncoder := smithyjson.NewEncoder()
583	if err := awsRestjson1_serializeOpDocumentCreateDocumentationVersionInput(input, jsonEncoder.Value); err != nil {
584		return out, metadata, &smithy.SerializationError{Err: err}
585	}
586
587	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
588		return out, metadata, &smithy.SerializationError{Err: err}
589	}
590
591	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
592		return out, metadata, &smithy.SerializationError{Err: err}
593	}
594	in.Request = request
595
596	return next.HandleSerialize(ctx, in)
597}
598func awsRestjson1_serializeOpHttpBindingsCreateDocumentationVersionInput(v *CreateDocumentationVersionInput, encoder *httpbinding.Encoder) error {
599	if v == nil {
600		return fmt.Errorf("unsupported serialization of nil %T", v)
601	}
602
603	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
604		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
605	}
606	if v.RestApiId != nil {
607		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
608			return err
609		}
610	}
611
612	return nil
613}
614
615func awsRestjson1_serializeOpDocumentCreateDocumentationVersionInput(v *CreateDocumentationVersionInput, value smithyjson.Value) error {
616	object := value.Object()
617	defer object.Close()
618
619	if v.Description != nil {
620		ok := object.Key("description")
621		ok.String(*v.Description)
622	}
623
624	if v.DocumentationVersion != nil {
625		ok := object.Key("documentationVersion")
626		ok.String(*v.DocumentationVersion)
627	}
628
629	if v.StageName != nil {
630		ok := object.Key("stageName")
631		ok.String(*v.StageName)
632	}
633
634	return nil
635}
636
637type awsRestjson1_serializeOpCreateDomainName struct {
638}
639
640func (*awsRestjson1_serializeOpCreateDomainName) ID() string {
641	return "OperationSerializer"
642}
643
644func (m *awsRestjson1_serializeOpCreateDomainName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
645	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
646) {
647	request, ok := in.Request.(*smithyhttp.Request)
648	if !ok {
649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
650	}
651
652	input, ok := in.Parameters.(*CreateDomainNameInput)
653	_ = input
654	if !ok {
655		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
656	}
657
658	opPath, opQuery := httpbinding.SplitURI("/domainnames")
659	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
660	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
661	request.Method = "POST"
662	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
663	if err != nil {
664		return out, metadata, &smithy.SerializationError{Err: err}
665	}
666
667	restEncoder.SetHeader("Content-Type").String("application/json")
668
669	jsonEncoder := smithyjson.NewEncoder()
670	if err := awsRestjson1_serializeOpDocumentCreateDomainNameInput(input, jsonEncoder.Value); err != nil {
671		return out, metadata, &smithy.SerializationError{Err: err}
672	}
673
674	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
675		return out, metadata, &smithy.SerializationError{Err: err}
676	}
677
678	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
679		return out, metadata, &smithy.SerializationError{Err: err}
680	}
681	in.Request = request
682
683	return next.HandleSerialize(ctx, in)
684}
685func awsRestjson1_serializeOpHttpBindingsCreateDomainNameInput(v *CreateDomainNameInput, encoder *httpbinding.Encoder) error {
686	if v == nil {
687		return fmt.Errorf("unsupported serialization of nil %T", v)
688	}
689
690	return nil
691}
692
693func awsRestjson1_serializeOpDocumentCreateDomainNameInput(v *CreateDomainNameInput, value smithyjson.Value) error {
694	object := value.Object()
695	defer object.Close()
696
697	if v.CertificateArn != nil {
698		ok := object.Key("certificateArn")
699		ok.String(*v.CertificateArn)
700	}
701
702	if v.CertificateBody != nil {
703		ok := object.Key("certificateBody")
704		ok.String(*v.CertificateBody)
705	}
706
707	if v.CertificateChain != nil {
708		ok := object.Key("certificateChain")
709		ok.String(*v.CertificateChain)
710	}
711
712	if v.CertificateName != nil {
713		ok := object.Key("certificateName")
714		ok.String(*v.CertificateName)
715	}
716
717	if v.CertificatePrivateKey != nil {
718		ok := object.Key("certificatePrivateKey")
719		ok.String(*v.CertificatePrivateKey)
720	}
721
722	if v.DomainName != nil {
723		ok := object.Key("domainName")
724		ok.String(*v.DomainName)
725	}
726
727	if v.EndpointConfiguration != nil {
728		ok := object.Key("endpointConfiguration")
729		if err := awsRestjson1_serializeDocumentEndpointConfiguration(v.EndpointConfiguration, ok); err != nil {
730			return err
731		}
732	}
733
734	if v.MutualTlsAuthentication != nil {
735		ok := object.Key("mutualTlsAuthentication")
736		if err := awsRestjson1_serializeDocumentMutualTlsAuthenticationInput(v.MutualTlsAuthentication, ok); err != nil {
737			return err
738		}
739	}
740
741	if v.RegionalCertificateArn != nil {
742		ok := object.Key("regionalCertificateArn")
743		ok.String(*v.RegionalCertificateArn)
744	}
745
746	if v.RegionalCertificateName != nil {
747		ok := object.Key("regionalCertificateName")
748		ok.String(*v.RegionalCertificateName)
749	}
750
751	if len(v.SecurityPolicy) > 0 {
752		ok := object.Key("securityPolicy")
753		ok.String(string(v.SecurityPolicy))
754	}
755
756	if v.Tags != nil {
757		ok := object.Key("tags")
758		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
759			return err
760		}
761	}
762
763	return nil
764}
765
766type awsRestjson1_serializeOpCreateModel struct {
767}
768
769func (*awsRestjson1_serializeOpCreateModel) ID() string {
770	return "OperationSerializer"
771}
772
773func (m *awsRestjson1_serializeOpCreateModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
774	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
775) {
776	request, ok := in.Request.(*smithyhttp.Request)
777	if !ok {
778		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
779	}
780
781	input, ok := in.Parameters.(*CreateModelInput)
782	_ = input
783	if !ok {
784		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
785	}
786
787	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models")
788	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
789	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
790	request.Method = "POST"
791	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
792	if err != nil {
793		return out, metadata, &smithy.SerializationError{Err: err}
794	}
795
796	if err := awsRestjson1_serializeOpHttpBindingsCreateModelInput(input, restEncoder); err != nil {
797		return out, metadata, &smithy.SerializationError{Err: err}
798	}
799
800	restEncoder.SetHeader("Content-Type").String("application/json")
801
802	jsonEncoder := smithyjson.NewEncoder()
803	if err := awsRestjson1_serializeOpDocumentCreateModelInput(input, jsonEncoder.Value); err != nil {
804		return out, metadata, &smithy.SerializationError{Err: err}
805	}
806
807	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); 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_serializeOpHttpBindingsCreateModelInput(v *CreateModelInput, encoder *httpbinding.Encoder) error {
819	if v == nil {
820		return fmt.Errorf("unsupported serialization of nil %T", v)
821	}
822
823	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
824		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
825	}
826	if v.RestApiId != nil {
827		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
828			return err
829		}
830	}
831
832	return nil
833}
834
835func awsRestjson1_serializeOpDocumentCreateModelInput(v *CreateModelInput, value smithyjson.Value) error {
836	object := value.Object()
837	defer object.Close()
838
839	if v.ContentType != nil {
840		ok := object.Key("contentType")
841		ok.String(*v.ContentType)
842	}
843
844	if v.Description != nil {
845		ok := object.Key("description")
846		ok.String(*v.Description)
847	}
848
849	if v.Name != nil {
850		ok := object.Key("name")
851		ok.String(*v.Name)
852	}
853
854	if v.Schema != nil {
855		ok := object.Key("schema")
856		ok.String(*v.Schema)
857	}
858
859	return nil
860}
861
862type awsRestjson1_serializeOpCreateRequestValidator struct {
863}
864
865func (*awsRestjson1_serializeOpCreateRequestValidator) ID() string {
866	return "OperationSerializer"
867}
868
869func (m *awsRestjson1_serializeOpCreateRequestValidator) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
870	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
871) {
872	request, ok := in.Request.(*smithyhttp.Request)
873	if !ok {
874		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
875	}
876
877	input, ok := in.Parameters.(*CreateRequestValidatorInput)
878	_ = input
879	if !ok {
880		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
881	}
882
883	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/requestvalidators")
884	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
885	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
886	request.Method = "POST"
887	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
888	if err != nil {
889		return out, metadata, &smithy.SerializationError{Err: err}
890	}
891
892	if err := awsRestjson1_serializeOpHttpBindingsCreateRequestValidatorInput(input, restEncoder); err != nil {
893		return out, metadata, &smithy.SerializationError{Err: err}
894	}
895
896	restEncoder.SetHeader("Content-Type").String("application/json")
897
898	jsonEncoder := smithyjson.NewEncoder()
899	if err := awsRestjson1_serializeOpDocumentCreateRequestValidatorInput(input, jsonEncoder.Value); err != nil {
900		return out, metadata, &smithy.SerializationError{Err: err}
901	}
902
903	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
904		return out, metadata, &smithy.SerializationError{Err: err}
905	}
906
907	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
908		return out, metadata, &smithy.SerializationError{Err: err}
909	}
910	in.Request = request
911
912	return next.HandleSerialize(ctx, in)
913}
914func awsRestjson1_serializeOpHttpBindingsCreateRequestValidatorInput(v *CreateRequestValidatorInput, encoder *httpbinding.Encoder) error {
915	if v == nil {
916		return fmt.Errorf("unsupported serialization of nil %T", v)
917	}
918
919	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
920		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
921	}
922	if v.RestApiId != nil {
923		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
924			return err
925		}
926	}
927
928	return nil
929}
930
931func awsRestjson1_serializeOpDocumentCreateRequestValidatorInput(v *CreateRequestValidatorInput, value smithyjson.Value) error {
932	object := value.Object()
933	defer object.Close()
934
935	if v.Name != nil {
936		ok := object.Key("name")
937		ok.String(*v.Name)
938	}
939
940	if v.ValidateRequestBody {
941		ok := object.Key("validateRequestBody")
942		ok.Boolean(v.ValidateRequestBody)
943	}
944
945	if v.ValidateRequestParameters {
946		ok := object.Key("validateRequestParameters")
947		ok.Boolean(v.ValidateRequestParameters)
948	}
949
950	return nil
951}
952
953type awsRestjson1_serializeOpCreateResource struct {
954}
955
956func (*awsRestjson1_serializeOpCreateResource) ID() string {
957	return "OperationSerializer"
958}
959
960func (m *awsRestjson1_serializeOpCreateResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
961	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
962) {
963	request, ok := in.Request.(*smithyhttp.Request)
964	if !ok {
965		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
966	}
967
968	input, ok := in.Parameters.(*CreateResourceInput)
969	_ = input
970	if !ok {
971		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
972	}
973
974	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{parentId}")
975	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
976	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
977	request.Method = "POST"
978	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
979	if err != nil {
980		return out, metadata, &smithy.SerializationError{Err: err}
981	}
982
983	if err := awsRestjson1_serializeOpHttpBindingsCreateResourceInput(input, restEncoder); err != nil {
984		return out, metadata, &smithy.SerializationError{Err: err}
985	}
986
987	restEncoder.SetHeader("Content-Type").String("application/json")
988
989	jsonEncoder := smithyjson.NewEncoder()
990	if err := awsRestjson1_serializeOpDocumentCreateResourceInput(input, jsonEncoder.Value); err != nil {
991		return out, metadata, &smithy.SerializationError{Err: err}
992	}
993
994	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
995		return out, metadata, &smithy.SerializationError{Err: err}
996	}
997
998	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
999		return out, metadata, &smithy.SerializationError{Err: err}
1000	}
1001	in.Request = request
1002
1003	return next.HandleSerialize(ctx, in)
1004}
1005func awsRestjson1_serializeOpHttpBindingsCreateResourceInput(v *CreateResourceInput, encoder *httpbinding.Encoder) error {
1006	if v == nil {
1007		return fmt.Errorf("unsupported serialization of nil %T", v)
1008	}
1009
1010	if v.ParentId == nil || len(*v.ParentId) == 0 {
1011		return &smithy.SerializationError{Err: fmt.Errorf("input member parentId must not be empty")}
1012	}
1013	if v.ParentId != nil {
1014		if err := encoder.SetURI("parentId").String(*v.ParentId); err != nil {
1015			return err
1016		}
1017	}
1018
1019	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
1020		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
1021	}
1022	if v.RestApiId != nil {
1023		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
1024			return err
1025		}
1026	}
1027
1028	return nil
1029}
1030
1031func awsRestjson1_serializeOpDocumentCreateResourceInput(v *CreateResourceInput, value smithyjson.Value) error {
1032	object := value.Object()
1033	defer object.Close()
1034
1035	if v.PathPart != nil {
1036		ok := object.Key("pathPart")
1037		ok.String(*v.PathPart)
1038	}
1039
1040	return nil
1041}
1042
1043type awsRestjson1_serializeOpCreateRestApi struct {
1044}
1045
1046func (*awsRestjson1_serializeOpCreateRestApi) ID() string {
1047	return "OperationSerializer"
1048}
1049
1050func (m *awsRestjson1_serializeOpCreateRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1051	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1052) {
1053	request, ok := in.Request.(*smithyhttp.Request)
1054	if !ok {
1055		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1056	}
1057
1058	input, ok := in.Parameters.(*CreateRestApiInput)
1059	_ = input
1060	if !ok {
1061		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1062	}
1063
1064	opPath, opQuery := httpbinding.SplitURI("/restapis")
1065	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1066	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1067	request.Method = "POST"
1068	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1069	if err != nil {
1070		return out, metadata, &smithy.SerializationError{Err: err}
1071	}
1072
1073	restEncoder.SetHeader("Content-Type").String("application/json")
1074
1075	jsonEncoder := smithyjson.NewEncoder()
1076	if err := awsRestjson1_serializeOpDocumentCreateRestApiInput(input, jsonEncoder.Value); err != nil {
1077		return out, metadata, &smithy.SerializationError{Err: err}
1078	}
1079
1080	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1081		return out, metadata, &smithy.SerializationError{Err: err}
1082	}
1083
1084	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1085		return out, metadata, &smithy.SerializationError{Err: err}
1086	}
1087	in.Request = request
1088
1089	return next.HandleSerialize(ctx, in)
1090}
1091func awsRestjson1_serializeOpHttpBindingsCreateRestApiInput(v *CreateRestApiInput, encoder *httpbinding.Encoder) error {
1092	if v == nil {
1093		return fmt.Errorf("unsupported serialization of nil %T", v)
1094	}
1095
1096	return nil
1097}
1098
1099func awsRestjson1_serializeOpDocumentCreateRestApiInput(v *CreateRestApiInput, value smithyjson.Value) error {
1100	object := value.Object()
1101	defer object.Close()
1102
1103	if len(v.ApiKeySource) > 0 {
1104		ok := object.Key("apiKeySource")
1105		ok.String(string(v.ApiKeySource))
1106	}
1107
1108	if v.BinaryMediaTypes != nil {
1109		ok := object.Key("binaryMediaTypes")
1110		if err := awsRestjson1_serializeDocumentListOfString(v.BinaryMediaTypes, ok); err != nil {
1111			return err
1112		}
1113	}
1114
1115	if v.CloneFrom != nil {
1116		ok := object.Key("cloneFrom")
1117		ok.String(*v.CloneFrom)
1118	}
1119
1120	if v.Description != nil {
1121		ok := object.Key("description")
1122		ok.String(*v.Description)
1123	}
1124
1125	if v.DisableExecuteApiEndpoint {
1126		ok := object.Key("disableExecuteApiEndpoint")
1127		ok.Boolean(v.DisableExecuteApiEndpoint)
1128	}
1129
1130	if v.EndpointConfiguration != nil {
1131		ok := object.Key("endpointConfiguration")
1132		if err := awsRestjson1_serializeDocumentEndpointConfiguration(v.EndpointConfiguration, ok); err != nil {
1133			return err
1134		}
1135	}
1136
1137	if v.MinimumCompressionSize != nil {
1138		ok := object.Key("minimumCompressionSize")
1139		ok.Integer(*v.MinimumCompressionSize)
1140	}
1141
1142	if v.Name != nil {
1143		ok := object.Key("name")
1144		ok.String(*v.Name)
1145	}
1146
1147	if v.Policy != nil {
1148		ok := object.Key("policy")
1149		ok.String(*v.Policy)
1150	}
1151
1152	if v.Tags != nil {
1153		ok := object.Key("tags")
1154		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
1155			return err
1156		}
1157	}
1158
1159	if v.Version != nil {
1160		ok := object.Key("version")
1161		ok.String(*v.Version)
1162	}
1163
1164	return nil
1165}
1166
1167type awsRestjson1_serializeOpCreateStage struct {
1168}
1169
1170func (*awsRestjson1_serializeOpCreateStage) ID() string {
1171	return "OperationSerializer"
1172}
1173
1174func (m *awsRestjson1_serializeOpCreateStage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1175	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1176) {
1177	request, ok := in.Request.(*smithyhttp.Request)
1178	if !ok {
1179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1180	}
1181
1182	input, ok := in.Parameters.(*CreateStageInput)
1183	_ = input
1184	if !ok {
1185		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1186	}
1187
1188	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages")
1189	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1190	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1191	request.Method = "POST"
1192	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1193	if err != nil {
1194		return out, metadata, &smithy.SerializationError{Err: err}
1195	}
1196
1197	if err := awsRestjson1_serializeOpHttpBindingsCreateStageInput(input, restEncoder); err != nil {
1198		return out, metadata, &smithy.SerializationError{Err: err}
1199	}
1200
1201	restEncoder.SetHeader("Content-Type").String("application/json")
1202
1203	jsonEncoder := smithyjson.NewEncoder()
1204	if err := awsRestjson1_serializeOpDocumentCreateStageInput(input, jsonEncoder.Value); err != nil {
1205		return out, metadata, &smithy.SerializationError{Err: err}
1206	}
1207
1208	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1209		return out, metadata, &smithy.SerializationError{Err: err}
1210	}
1211
1212	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1213		return out, metadata, &smithy.SerializationError{Err: err}
1214	}
1215	in.Request = request
1216
1217	return next.HandleSerialize(ctx, in)
1218}
1219func awsRestjson1_serializeOpHttpBindingsCreateStageInput(v *CreateStageInput, encoder *httpbinding.Encoder) error {
1220	if v == nil {
1221		return fmt.Errorf("unsupported serialization of nil %T", v)
1222	}
1223
1224	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
1225		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
1226	}
1227	if v.RestApiId != nil {
1228		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
1229			return err
1230		}
1231	}
1232
1233	return nil
1234}
1235
1236func awsRestjson1_serializeOpDocumentCreateStageInput(v *CreateStageInput, value smithyjson.Value) error {
1237	object := value.Object()
1238	defer object.Close()
1239
1240	if v.CacheClusterEnabled {
1241		ok := object.Key("cacheClusterEnabled")
1242		ok.Boolean(v.CacheClusterEnabled)
1243	}
1244
1245	if len(v.CacheClusterSize) > 0 {
1246		ok := object.Key("cacheClusterSize")
1247		ok.String(string(v.CacheClusterSize))
1248	}
1249
1250	if v.CanarySettings != nil {
1251		ok := object.Key("canarySettings")
1252		if err := awsRestjson1_serializeDocumentCanarySettings(v.CanarySettings, ok); err != nil {
1253			return err
1254		}
1255	}
1256
1257	if v.DeploymentId != nil {
1258		ok := object.Key("deploymentId")
1259		ok.String(*v.DeploymentId)
1260	}
1261
1262	if v.Description != nil {
1263		ok := object.Key("description")
1264		ok.String(*v.Description)
1265	}
1266
1267	if v.DocumentationVersion != nil {
1268		ok := object.Key("documentationVersion")
1269		ok.String(*v.DocumentationVersion)
1270	}
1271
1272	if v.StageName != nil {
1273		ok := object.Key("stageName")
1274		ok.String(*v.StageName)
1275	}
1276
1277	if v.Tags != nil {
1278		ok := object.Key("tags")
1279		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
1280			return err
1281		}
1282	}
1283
1284	if v.TracingEnabled {
1285		ok := object.Key("tracingEnabled")
1286		ok.Boolean(v.TracingEnabled)
1287	}
1288
1289	if v.Variables != nil {
1290		ok := object.Key("variables")
1291		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Variables, ok); err != nil {
1292			return err
1293		}
1294	}
1295
1296	return nil
1297}
1298
1299type awsRestjson1_serializeOpCreateUsagePlan struct {
1300}
1301
1302func (*awsRestjson1_serializeOpCreateUsagePlan) ID() string {
1303	return "OperationSerializer"
1304}
1305
1306func (m *awsRestjson1_serializeOpCreateUsagePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1308) {
1309	request, ok := in.Request.(*smithyhttp.Request)
1310	if !ok {
1311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1312	}
1313
1314	input, ok := in.Parameters.(*CreateUsagePlanInput)
1315	_ = input
1316	if !ok {
1317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1318	}
1319
1320	opPath, opQuery := httpbinding.SplitURI("/usageplans")
1321	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1322	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1323	request.Method = "POST"
1324	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1325	if err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328
1329	restEncoder.SetHeader("Content-Type").String("application/json")
1330
1331	jsonEncoder := smithyjson.NewEncoder()
1332	if err := awsRestjson1_serializeOpDocumentCreateUsagePlanInput(input, jsonEncoder.Value); err != nil {
1333		return out, metadata, &smithy.SerializationError{Err: err}
1334	}
1335
1336	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1337		return out, metadata, &smithy.SerializationError{Err: err}
1338	}
1339
1340	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1341		return out, metadata, &smithy.SerializationError{Err: err}
1342	}
1343	in.Request = request
1344
1345	return next.HandleSerialize(ctx, in)
1346}
1347func awsRestjson1_serializeOpHttpBindingsCreateUsagePlanInput(v *CreateUsagePlanInput, encoder *httpbinding.Encoder) error {
1348	if v == nil {
1349		return fmt.Errorf("unsupported serialization of nil %T", v)
1350	}
1351
1352	return nil
1353}
1354
1355func awsRestjson1_serializeOpDocumentCreateUsagePlanInput(v *CreateUsagePlanInput, value smithyjson.Value) error {
1356	object := value.Object()
1357	defer object.Close()
1358
1359	if v.ApiStages != nil {
1360		ok := object.Key("apiStages")
1361		if err := awsRestjson1_serializeDocumentListOfApiStage(v.ApiStages, ok); err != nil {
1362			return err
1363		}
1364	}
1365
1366	if v.Description != nil {
1367		ok := object.Key("description")
1368		ok.String(*v.Description)
1369	}
1370
1371	if v.Name != nil {
1372		ok := object.Key("name")
1373		ok.String(*v.Name)
1374	}
1375
1376	if v.Quota != nil {
1377		ok := object.Key("quota")
1378		if err := awsRestjson1_serializeDocumentQuotaSettings(v.Quota, ok); err != nil {
1379			return err
1380		}
1381	}
1382
1383	if v.Tags != nil {
1384		ok := object.Key("tags")
1385		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
1386			return err
1387		}
1388	}
1389
1390	if v.Throttle != nil {
1391		ok := object.Key("throttle")
1392		if err := awsRestjson1_serializeDocumentThrottleSettings(v.Throttle, ok); err != nil {
1393			return err
1394		}
1395	}
1396
1397	return nil
1398}
1399
1400type awsRestjson1_serializeOpCreateUsagePlanKey struct {
1401}
1402
1403func (*awsRestjson1_serializeOpCreateUsagePlanKey) ID() string {
1404	return "OperationSerializer"
1405}
1406
1407func (m *awsRestjson1_serializeOpCreateUsagePlanKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1408	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1409) {
1410	request, ok := in.Request.(*smithyhttp.Request)
1411	if !ok {
1412		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1413	}
1414
1415	input, ok := in.Parameters.(*CreateUsagePlanKeyInput)
1416	_ = input
1417	if !ok {
1418		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1419	}
1420
1421	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/keys")
1422	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1423	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1424	request.Method = "POST"
1425	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1426	if err != nil {
1427		return out, metadata, &smithy.SerializationError{Err: err}
1428	}
1429
1430	if err := awsRestjson1_serializeOpHttpBindingsCreateUsagePlanKeyInput(input, restEncoder); err != nil {
1431		return out, metadata, &smithy.SerializationError{Err: err}
1432	}
1433
1434	restEncoder.SetHeader("Content-Type").String("application/json")
1435
1436	jsonEncoder := smithyjson.NewEncoder()
1437	if err := awsRestjson1_serializeOpDocumentCreateUsagePlanKeyInput(input, jsonEncoder.Value); err != nil {
1438		return out, metadata, &smithy.SerializationError{Err: err}
1439	}
1440
1441	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1442		return out, metadata, &smithy.SerializationError{Err: err}
1443	}
1444
1445	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1446		return out, metadata, &smithy.SerializationError{Err: err}
1447	}
1448	in.Request = request
1449
1450	return next.HandleSerialize(ctx, in)
1451}
1452func awsRestjson1_serializeOpHttpBindingsCreateUsagePlanKeyInput(v *CreateUsagePlanKeyInput, encoder *httpbinding.Encoder) error {
1453	if v == nil {
1454		return fmt.Errorf("unsupported serialization of nil %T", v)
1455	}
1456
1457	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
1458		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
1459	}
1460	if v.UsagePlanId != nil {
1461		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
1462			return err
1463		}
1464	}
1465
1466	return nil
1467}
1468
1469func awsRestjson1_serializeOpDocumentCreateUsagePlanKeyInput(v *CreateUsagePlanKeyInput, value smithyjson.Value) error {
1470	object := value.Object()
1471	defer object.Close()
1472
1473	if v.KeyId != nil {
1474		ok := object.Key("keyId")
1475		ok.String(*v.KeyId)
1476	}
1477
1478	if v.KeyType != nil {
1479		ok := object.Key("keyType")
1480		ok.String(*v.KeyType)
1481	}
1482
1483	return nil
1484}
1485
1486type awsRestjson1_serializeOpCreateVpcLink struct {
1487}
1488
1489func (*awsRestjson1_serializeOpCreateVpcLink) ID() string {
1490	return "OperationSerializer"
1491}
1492
1493func (m *awsRestjson1_serializeOpCreateVpcLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1494	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1495) {
1496	request, ok := in.Request.(*smithyhttp.Request)
1497	if !ok {
1498		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1499	}
1500
1501	input, ok := in.Parameters.(*CreateVpcLinkInput)
1502	_ = input
1503	if !ok {
1504		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1505	}
1506
1507	opPath, opQuery := httpbinding.SplitURI("/vpclinks")
1508	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1509	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1510	request.Method = "POST"
1511	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1512	if err != nil {
1513		return out, metadata, &smithy.SerializationError{Err: err}
1514	}
1515
1516	restEncoder.SetHeader("Content-Type").String("application/json")
1517
1518	jsonEncoder := smithyjson.NewEncoder()
1519	if err := awsRestjson1_serializeOpDocumentCreateVpcLinkInput(input, jsonEncoder.Value); err != nil {
1520		return out, metadata, &smithy.SerializationError{Err: err}
1521	}
1522
1523	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1524		return out, metadata, &smithy.SerializationError{Err: err}
1525	}
1526
1527	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1528		return out, metadata, &smithy.SerializationError{Err: err}
1529	}
1530	in.Request = request
1531
1532	return next.HandleSerialize(ctx, in)
1533}
1534func awsRestjson1_serializeOpHttpBindingsCreateVpcLinkInput(v *CreateVpcLinkInput, encoder *httpbinding.Encoder) error {
1535	if v == nil {
1536		return fmt.Errorf("unsupported serialization of nil %T", v)
1537	}
1538
1539	return nil
1540}
1541
1542func awsRestjson1_serializeOpDocumentCreateVpcLinkInput(v *CreateVpcLinkInput, value smithyjson.Value) error {
1543	object := value.Object()
1544	defer object.Close()
1545
1546	if v.Description != nil {
1547		ok := object.Key("description")
1548		ok.String(*v.Description)
1549	}
1550
1551	if v.Name != nil {
1552		ok := object.Key("name")
1553		ok.String(*v.Name)
1554	}
1555
1556	if v.Tags != nil {
1557		ok := object.Key("tags")
1558		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
1559			return err
1560		}
1561	}
1562
1563	if v.TargetArns != nil {
1564		ok := object.Key("targetArns")
1565		if err := awsRestjson1_serializeDocumentListOfString(v.TargetArns, ok); err != nil {
1566			return err
1567		}
1568	}
1569
1570	return nil
1571}
1572
1573type awsRestjson1_serializeOpDeleteApiKey struct {
1574}
1575
1576func (*awsRestjson1_serializeOpDeleteApiKey) ID() string {
1577	return "OperationSerializer"
1578}
1579
1580func (m *awsRestjson1_serializeOpDeleteApiKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1581	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	request, ok := in.Request.(*smithyhttp.Request)
1584	if !ok {
1585		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1586	}
1587
1588	input, ok := in.Parameters.(*DeleteApiKeyInput)
1589	_ = input
1590	if !ok {
1591		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1592	}
1593
1594	opPath, opQuery := httpbinding.SplitURI("/apikeys/{apiKey}")
1595	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1596	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1597	request.Method = "DELETE"
1598	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1599	if err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if err := awsRestjson1_serializeOpHttpBindingsDeleteApiKeyInput(input, restEncoder); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606
1607	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1608		return out, metadata, &smithy.SerializationError{Err: err}
1609	}
1610	in.Request = request
1611
1612	return next.HandleSerialize(ctx, in)
1613}
1614func awsRestjson1_serializeOpHttpBindingsDeleteApiKeyInput(v *DeleteApiKeyInput, encoder *httpbinding.Encoder) error {
1615	if v == nil {
1616		return fmt.Errorf("unsupported serialization of nil %T", v)
1617	}
1618
1619	if v.ApiKey == nil || len(*v.ApiKey) == 0 {
1620		return &smithy.SerializationError{Err: fmt.Errorf("input member apiKey must not be empty")}
1621	}
1622	if v.ApiKey != nil {
1623		if err := encoder.SetURI("apiKey").String(*v.ApiKey); err != nil {
1624			return err
1625		}
1626	}
1627
1628	return nil
1629}
1630
1631type awsRestjson1_serializeOpDeleteAuthorizer struct {
1632}
1633
1634func (*awsRestjson1_serializeOpDeleteAuthorizer) ID() string {
1635	return "OperationSerializer"
1636}
1637
1638func (m *awsRestjson1_serializeOpDeleteAuthorizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1639	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1640) {
1641	request, ok := in.Request.(*smithyhttp.Request)
1642	if !ok {
1643		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1644	}
1645
1646	input, ok := in.Parameters.(*DeleteAuthorizerInput)
1647	_ = input
1648	if !ok {
1649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1650	}
1651
1652	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers/{authorizerId}")
1653	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1654	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1655	request.Method = "DELETE"
1656	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1657	if err != nil {
1658		return out, metadata, &smithy.SerializationError{Err: err}
1659	}
1660
1661	if err := awsRestjson1_serializeOpHttpBindingsDeleteAuthorizerInput(input, restEncoder); err != nil {
1662		return out, metadata, &smithy.SerializationError{Err: err}
1663	}
1664
1665	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1666		return out, metadata, &smithy.SerializationError{Err: err}
1667	}
1668	in.Request = request
1669
1670	return next.HandleSerialize(ctx, in)
1671}
1672func awsRestjson1_serializeOpHttpBindingsDeleteAuthorizerInput(v *DeleteAuthorizerInput, encoder *httpbinding.Encoder) error {
1673	if v == nil {
1674		return fmt.Errorf("unsupported serialization of nil %T", v)
1675	}
1676
1677	if v.AuthorizerId == nil || len(*v.AuthorizerId) == 0 {
1678		return &smithy.SerializationError{Err: fmt.Errorf("input member authorizerId must not be empty")}
1679	}
1680	if v.AuthorizerId != nil {
1681		if err := encoder.SetURI("authorizerId").String(*v.AuthorizerId); err != nil {
1682			return err
1683		}
1684	}
1685
1686	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
1687		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
1688	}
1689	if v.RestApiId != nil {
1690		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
1691			return err
1692		}
1693	}
1694
1695	return nil
1696}
1697
1698type awsRestjson1_serializeOpDeleteBasePathMapping struct {
1699}
1700
1701func (*awsRestjson1_serializeOpDeleteBasePathMapping) ID() string {
1702	return "OperationSerializer"
1703}
1704
1705func (m *awsRestjson1_serializeOpDeleteBasePathMapping) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1706	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1707) {
1708	request, ok := in.Request.(*smithyhttp.Request)
1709	if !ok {
1710		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1711	}
1712
1713	input, ok := in.Parameters.(*DeleteBasePathMappingInput)
1714	_ = input
1715	if !ok {
1716		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1717	}
1718
1719	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}/basepathmappings/{basePath}")
1720	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1721	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1722	request.Method = "DELETE"
1723	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1724	if err != nil {
1725		return out, metadata, &smithy.SerializationError{Err: err}
1726	}
1727
1728	if err := awsRestjson1_serializeOpHttpBindingsDeleteBasePathMappingInput(input, restEncoder); err != nil {
1729		return out, metadata, &smithy.SerializationError{Err: err}
1730	}
1731
1732	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1733		return out, metadata, &smithy.SerializationError{Err: err}
1734	}
1735	in.Request = request
1736
1737	return next.HandleSerialize(ctx, in)
1738}
1739func awsRestjson1_serializeOpHttpBindingsDeleteBasePathMappingInput(v *DeleteBasePathMappingInput, encoder *httpbinding.Encoder) error {
1740	if v == nil {
1741		return fmt.Errorf("unsupported serialization of nil %T", v)
1742	}
1743
1744	if v.BasePath == nil || len(*v.BasePath) == 0 {
1745		return &smithy.SerializationError{Err: fmt.Errorf("input member basePath must not be empty")}
1746	}
1747	if v.BasePath != nil {
1748		if err := encoder.SetURI("basePath").String(*v.BasePath); err != nil {
1749			return err
1750		}
1751	}
1752
1753	if v.DomainName == nil || len(*v.DomainName) == 0 {
1754		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
1755	}
1756	if v.DomainName != nil {
1757		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
1758			return err
1759		}
1760	}
1761
1762	return nil
1763}
1764
1765type awsRestjson1_serializeOpDeleteClientCertificate struct {
1766}
1767
1768func (*awsRestjson1_serializeOpDeleteClientCertificate) ID() string {
1769	return "OperationSerializer"
1770}
1771
1772func (m *awsRestjson1_serializeOpDeleteClientCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1773	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1774) {
1775	request, ok := in.Request.(*smithyhttp.Request)
1776	if !ok {
1777		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1778	}
1779
1780	input, ok := in.Parameters.(*DeleteClientCertificateInput)
1781	_ = input
1782	if !ok {
1783		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1784	}
1785
1786	opPath, opQuery := httpbinding.SplitURI("/clientcertificates/{clientCertificateId}")
1787	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1788	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1789	request.Method = "DELETE"
1790	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1791	if err != nil {
1792		return out, metadata, &smithy.SerializationError{Err: err}
1793	}
1794
1795	if err := awsRestjson1_serializeOpHttpBindingsDeleteClientCertificateInput(input, restEncoder); err != nil {
1796		return out, metadata, &smithy.SerializationError{Err: err}
1797	}
1798
1799	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1800		return out, metadata, &smithy.SerializationError{Err: err}
1801	}
1802	in.Request = request
1803
1804	return next.HandleSerialize(ctx, in)
1805}
1806func awsRestjson1_serializeOpHttpBindingsDeleteClientCertificateInput(v *DeleteClientCertificateInput, encoder *httpbinding.Encoder) error {
1807	if v == nil {
1808		return fmt.Errorf("unsupported serialization of nil %T", v)
1809	}
1810
1811	if v.ClientCertificateId == nil || len(*v.ClientCertificateId) == 0 {
1812		return &smithy.SerializationError{Err: fmt.Errorf("input member clientCertificateId must not be empty")}
1813	}
1814	if v.ClientCertificateId != nil {
1815		if err := encoder.SetURI("clientCertificateId").String(*v.ClientCertificateId); err != nil {
1816			return err
1817		}
1818	}
1819
1820	return nil
1821}
1822
1823type awsRestjson1_serializeOpDeleteDeployment struct {
1824}
1825
1826func (*awsRestjson1_serializeOpDeleteDeployment) ID() string {
1827	return "OperationSerializer"
1828}
1829
1830func (m *awsRestjson1_serializeOpDeleteDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1831	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1832) {
1833	request, ok := in.Request.(*smithyhttp.Request)
1834	if !ok {
1835		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1836	}
1837
1838	input, ok := in.Parameters.(*DeleteDeploymentInput)
1839	_ = input
1840	if !ok {
1841		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1842	}
1843
1844	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/deployments/{deploymentId}")
1845	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1846	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1847	request.Method = "DELETE"
1848	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1849	if err != nil {
1850		return out, metadata, &smithy.SerializationError{Err: err}
1851	}
1852
1853	if err := awsRestjson1_serializeOpHttpBindingsDeleteDeploymentInput(input, restEncoder); err != nil {
1854		return out, metadata, &smithy.SerializationError{Err: err}
1855	}
1856
1857	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1858		return out, metadata, &smithy.SerializationError{Err: err}
1859	}
1860	in.Request = request
1861
1862	return next.HandleSerialize(ctx, in)
1863}
1864func awsRestjson1_serializeOpHttpBindingsDeleteDeploymentInput(v *DeleteDeploymentInput, encoder *httpbinding.Encoder) error {
1865	if v == nil {
1866		return fmt.Errorf("unsupported serialization of nil %T", v)
1867	}
1868
1869	if v.DeploymentId == nil || len(*v.DeploymentId) == 0 {
1870		return &smithy.SerializationError{Err: fmt.Errorf("input member deploymentId must not be empty")}
1871	}
1872	if v.DeploymentId != nil {
1873		if err := encoder.SetURI("deploymentId").String(*v.DeploymentId); err != nil {
1874			return err
1875		}
1876	}
1877
1878	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
1879		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
1880	}
1881	if v.RestApiId != nil {
1882		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
1883			return err
1884		}
1885	}
1886
1887	return nil
1888}
1889
1890type awsRestjson1_serializeOpDeleteDocumentationPart struct {
1891}
1892
1893func (*awsRestjson1_serializeOpDeleteDocumentationPart) ID() string {
1894	return "OperationSerializer"
1895}
1896
1897func (m *awsRestjson1_serializeOpDeleteDocumentationPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1898	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1899) {
1900	request, ok := in.Request.(*smithyhttp.Request)
1901	if !ok {
1902		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1903	}
1904
1905	input, ok := in.Parameters.(*DeleteDocumentationPartInput)
1906	_ = input
1907	if !ok {
1908		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1909	}
1910
1911	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts/{documentationPartId}")
1912	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1913	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1914	request.Method = "DELETE"
1915	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1916	if err != nil {
1917		return out, metadata, &smithy.SerializationError{Err: err}
1918	}
1919
1920	if err := awsRestjson1_serializeOpHttpBindingsDeleteDocumentationPartInput(input, restEncoder); err != nil {
1921		return out, metadata, &smithy.SerializationError{Err: err}
1922	}
1923
1924	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1925		return out, metadata, &smithy.SerializationError{Err: err}
1926	}
1927	in.Request = request
1928
1929	return next.HandleSerialize(ctx, in)
1930}
1931func awsRestjson1_serializeOpHttpBindingsDeleteDocumentationPartInput(v *DeleteDocumentationPartInput, encoder *httpbinding.Encoder) error {
1932	if v == nil {
1933		return fmt.Errorf("unsupported serialization of nil %T", v)
1934	}
1935
1936	if v.DocumentationPartId == nil || len(*v.DocumentationPartId) == 0 {
1937		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationPartId must not be empty")}
1938	}
1939	if v.DocumentationPartId != nil {
1940		if err := encoder.SetURI("documentationPartId").String(*v.DocumentationPartId); err != nil {
1941			return err
1942		}
1943	}
1944
1945	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
1946		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
1947	}
1948	if v.RestApiId != nil {
1949		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
1950			return err
1951		}
1952	}
1953
1954	return nil
1955}
1956
1957type awsRestjson1_serializeOpDeleteDocumentationVersion struct {
1958}
1959
1960func (*awsRestjson1_serializeOpDeleteDocumentationVersion) ID() string {
1961	return "OperationSerializer"
1962}
1963
1964func (m *awsRestjson1_serializeOpDeleteDocumentationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1966) {
1967	request, ok := in.Request.(*smithyhttp.Request)
1968	if !ok {
1969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1970	}
1971
1972	input, ok := in.Parameters.(*DeleteDocumentationVersionInput)
1973	_ = input
1974	if !ok {
1975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1976	}
1977
1978	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/versions/{documentationVersion}")
1979	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1980	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1981	request.Method = "DELETE"
1982	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1983	if err != nil {
1984		return out, metadata, &smithy.SerializationError{Err: err}
1985	}
1986
1987	if err := awsRestjson1_serializeOpHttpBindingsDeleteDocumentationVersionInput(input, restEncoder); err != nil {
1988		return out, metadata, &smithy.SerializationError{Err: err}
1989	}
1990
1991	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1992		return out, metadata, &smithy.SerializationError{Err: err}
1993	}
1994	in.Request = request
1995
1996	return next.HandleSerialize(ctx, in)
1997}
1998func awsRestjson1_serializeOpHttpBindingsDeleteDocumentationVersionInput(v *DeleteDocumentationVersionInput, encoder *httpbinding.Encoder) error {
1999	if v == nil {
2000		return fmt.Errorf("unsupported serialization of nil %T", v)
2001	}
2002
2003	if v.DocumentationVersion == nil || len(*v.DocumentationVersion) == 0 {
2004		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationVersion must not be empty")}
2005	}
2006	if v.DocumentationVersion != nil {
2007		if err := encoder.SetURI("documentationVersion").String(*v.DocumentationVersion); err != nil {
2008			return err
2009		}
2010	}
2011
2012	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2013		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2014	}
2015	if v.RestApiId != nil {
2016		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2017			return err
2018		}
2019	}
2020
2021	return nil
2022}
2023
2024type awsRestjson1_serializeOpDeleteDomainName struct {
2025}
2026
2027func (*awsRestjson1_serializeOpDeleteDomainName) ID() string {
2028	return "OperationSerializer"
2029}
2030
2031func (m *awsRestjson1_serializeOpDeleteDomainName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2032	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2033) {
2034	request, ok := in.Request.(*smithyhttp.Request)
2035	if !ok {
2036		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2037	}
2038
2039	input, ok := in.Parameters.(*DeleteDomainNameInput)
2040	_ = input
2041	if !ok {
2042		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2043	}
2044
2045	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}")
2046	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2047	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2048	request.Method = "DELETE"
2049	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2050	if err != nil {
2051		return out, metadata, &smithy.SerializationError{Err: err}
2052	}
2053
2054	if err := awsRestjson1_serializeOpHttpBindingsDeleteDomainNameInput(input, restEncoder); err != nil {
2055		return out, metadata, &smithy.SerializationError{Err: err}
2056	}
2057
2058	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2059		return out, metadata, &smithy.SerializationError{Err: err}
2060	}
2061	in.Request = request
2062
2063	return next.HandleSerialize(ctx, in)
2064}
2065func awsRestjson1_serializeOpHttpBindingsDeleteDomainNameInput(v *DeleteDomainNameInput, encoder *httpbinding.Encoder) error {
2066	if v == nil {
2067		return fmt.Errorf("unsupported serialization of nil %T", v)
2068	}
2069
2070	if v.DomainName == nil || len(*v.DomainName) == 0 {
2071		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
2072	}
2073	if v.DomainName != nil {
2074		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
2075			return err
2076		}
2077	}
2078
2079	return nil
2080}
2081
2082type awsRestjson1_serializeOpDeleteGatewayResponse struct {
2083}
2084
2085func (*awsRestjson1_serializeOpDeleteGatewayResponse) ID() string {
2086	return "OperationSerializer"
2087}
2088
2089func (m *awsRestjson1_serializeOpDeleteGatewayResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2090	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2091) {
2092	request, ok := in.Request.(*smithyhttp.Request)
2093	if !ok {
2094		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2095	}
2096
2097	input, ok := in.Parameters.(*DeleteGatewayResponseInput)
2098	_ = input
2099	if !ok {
2100		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2101	}
2102
2103	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/gatewayresponses/{responseType}")
2104	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2105	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2106	request.Method = "DELETE"
2107	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2108	if err != nil {
2109		return out, metadata, &smithy.SerializationError{Err: err}
2110	}
2111
2112	if err := awsRestjson1_serializeOpHttpBindingsDeleteGatewayResponseInput(input, restEncoder); err != nil {
2113		return out, metadata, &smithy.SerializationError{Err: err}
2114	}
2115
2116	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2117		return out, metadata, &smithy.SerializationError{Err: err}
2118	}
2119	in.Request = request
2120
2121	return next.HandleSerialize(ctx, in)
2122}
2123func awsRestjson1_serializeOpHttpBindingsDeleteGatewayResponseInput(v *DeleteGatewayResponseInput, encoder *httpbinding.Encoder) error {
2124	if v == nil {
2125		return fmt.Errorf("unsupported serialization of nil %T", v)
2126	}
2127
2128	if len(v.ResponseType) == 0 {
2129		return &smithy.SerializationError{Err: fmt.Errorf("input member responseType must not be empty")}
2130	}
2131	if len(v.ResponseType) > 0 {
2132		if err := encoder.SetURI("responseType").String(string(v.ResponseType)); err != nil {
2133			return err
2134		}
2135	}
2136
2137	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2138		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2139	}
2140	if v.RestApiId != nil {
2141		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2142			return err
2143		}
2144	}
2145
2146	return nil
2147}
2148
2149type awsRestjson1_serializeOpDeleteIntegration struct {
2150}
2151
2152func (*awsRestjson1_serializeOpDeleteIntegration) ID() string {
2153	return "OperationSerializer"
2154}
2155
2156func (m *awsRestjson1_serializeOpDeleteIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2157	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2158) {
2159	request, ok := in.Request.(*smithyhttp.Request)
2160	if !ok {
2161		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2162	}
2163
2164	input, ok := in.Parameters.(*DeleteIntegrationInput)
2165	_ = input
2166	if !ok {
2167		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2168	}
2169
2170	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration")
2171	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2172	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2173	request.Method = "DELETE"
2174	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2175	if err != nil {
2176		return out, metadata, &smithy.SerializationError{Err: err}
2177	}
2178
2179	if err := awsRestjson1_serializeOpHttpBindingsDeleteIntegrationInput(input, restEncoder); err != nil {
2180		return out, metadata, &smithy.SerializationError{Err: err}
2181	}
2182
2183	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2184		return out, metadata, &smithy.SerializationError{Err: err}
2185	}
2186	in.Request = request
2187
2188	return next.HandleSerialize(ctx, in)
2189}
2190func awsRestjson1_serializeOpHttpBindingsDeleteIntegrationInput(v *DeleteIntegrationInput, encoder *httpbinding.Encoder) error {
2191	if v == nil {
2192		return fmt.Errorf("unsupported serialization of nil %T", v)
2193	}
2194
2195	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
2196		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
2197	}
2198	if v.HttpMethod != nil {
2199		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
2200			return err
2201		}
2202	}
2203
2204	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
2205		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
2206	}
2207	if v.ResourceId != nil {
2208		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
2209			return err
2210		}
2211	}
2212
2213	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2214		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2215	}
2216	if v.RestApiId != nil {
2217		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2218			return err
2219		}
2220	}
2221
2222	return nil
2223}
2224
2225type awsRestjson1_serializeOpDeleteIntegrationResponse struct {
2226}
2227
2228func (*awsRestjson1_serializeOpDeleteIntegrationResponse) ID() string {
2229	return "OperationSerializer"
2230}
2231
2232func (m *awsRestjson1_serializeOpDeleteIntegrationResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2233	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2234) {
2235	request, ok := in.Request.(*smithyhttp.Request)
2236	if !ok {
2237		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2238	}
2239
2240	input, ok := in.Parameters.(*DeleteIntegrationResponseInput)
2241	_ = input
2242	if !ok {
2243		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2244	}
2245
2246	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}")
2247	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2248	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2249	request.Method = "DELETE"
2250	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2251	if err != nil {
2252		return out, metadata, &smithy.SerializationError{Err: err}
2253	}
2254
2255	if err := awsRestjson1_serializeOpHttpBindingsDeleteIntegrationResponseInput(input, restEncoder); err != nil {
2256		return out, metadata, &smithy.SerializationError{Err: err}
2257	}
2258
2259	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2260		return out, metadata, &smithy.SerializationError{Err: err}
2261	}
2262	in.Request = request
2263
2264	return next.HandleSerialize(ctx, in)
2265}
2266func awsRestjson1_serializeOpHttpBindingsDeleteIntegrationResponseInput(v *DeleteIntegrationResponseInput, encoder *httpbinding.Encoder) error {
2267	if v == nil {
2268		return fmt.Errorf("unsupported serialization of nil %T", v)
2269	}
2270
2271	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
2272		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
2273	}
2274	if v.HttpMethod != nil {
2275		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
2276			return err
2277		}
2278	}
2279
2280	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
2281		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
2282	}
2283	if v.ResourceId != nil {
2284		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
2285			return err
2286		}
2287	}
2288
2289	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2290		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2291	}
2292	if v.RestApiId != nil {
2293		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2294			return err
2295		}
2296	}
2297
2298	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
2299		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
2300	}
2301	if v.StatusCode != nil {
2302		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
2303			return err
2304		}
2305	}
2306
2307	return nil
2308}
2309
2310type awsRestjson1_serializeOpDeleteMethod struct {
2311}
2312
2313func (*awsRestjson1_serializeOpDeleteMethod) ID() string {
2314	return "OperationSerializer"
2315}
2316
2317func (m *awsRestjson1_serializeOpDeleteMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2318	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2319) {
2320	request, ok := in.Request.(*smithyhttp.Request)
2321	if !ok {
2322		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2323	}
2324
2325	input, ok := in.Parameters.(*DeleteMethodInput)
2326	_ = input
2327	if !ok {
2328		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2329	}
2330
2331	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}")
2332	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2333	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2334	request.Method = "DELETE"
2335	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2336	if err != nil {
2337		return out, metadata, &smithy.SerializationError{Err: err}
2338	}
2339
2340	if err := awsRestjson1_serializeOpHttpBindingsDeleteMethodInput(input, restEncoder); err != nil {
2341		return out, metadata, &smithy.SerializationError{Err: err}
2342	}
2343
2344	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2345		return out, metadata, &smithy.SerializationError{Err: err}
2346	}
2347	in.Request = request
2348
2349	return next.HandleSerialize(ctx, in)
2350}
2351func awsRestjson1_serializeOpHttpBindingsDeleteMethodInput(v *DeleteMethodInput, encoder *httpbinding.Encoder) error {
2352	if v == nil {
2353		return fmt.Errorf("unsupported serialization of nil %T", v)
2354	}
2355
2356	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
2357		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
2358	}
2359	if v.HttpMethod != nil {
2360		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
2361			return err
2362		}
2363	}
2364
2365	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
2366		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
2367	}
2368	if v.ResourceId != nil {
2369		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
2370			return err
2371		}
2372	}
2373
2374	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2375		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2376	}
2377	if v.RestApiId != nil {
2378		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2379			return err
2380		}
2381	}
2382
2383	return nil
2384}
2385
2386type awsRestjson1_serializeOpDeleteMethodResponse struct {
2387}
2388
2389func (*awsRestjson1_serializeOpDeleteMethodResponse) ID() string {
2390	return "OperationSerializer"
2391}
2392
2393func (m *awsRestjson1_serializeOpDeleteMethodResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2394	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2395) {
2396	request, ok := in.Request.(*smithyhttp.Request)
2397	if !ok {
2398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2399	}
2400
2401	input, ok := in.Parameters.(*DeleteMethodResponseInput)
2402	_ = input
2403	if !ok {
2404		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2405	}
2406
2407	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}")
2408	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2409	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2410	request.Method = "DELETE"
2411	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2412	if err != nil {
2413		return out, metadata, &smithy.SerializationError{Err: err}
2414	}
2415
2416	if err := awsRestjson1_serializeOpHttpBindingsDeleteMethodResponseInput(input, restEncoder); err != nil {
2417		return out, metadata, &smithy.SerializationError{Err: err}
2418	}
2419
2420	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2421		return out, metadata, &smithy.SerializationError{Err: err}
2422	}
2423	in.Request = request
2424
2425	return next.HandleSerialize(ctx, in)
2426}
2427func awsRestjson1_serializeOpHttpBindingsDeleteMethodResponseInput(v *DeleteMethodResponseInput, encoder *httpbinding.Encoder) error {
2428	if v == nil {
2429		return fmt.Errorf("unsupported serialization of nil %T", v)
2430	}
2431
2432	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
2433		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
2434	}
2435	if v.HttpMethod != nil {
2436		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
2437			return err
2438		}
2439	}
2440
2441	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
2442		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
2443	}
2444	if v.ResourceId != nil {
2445		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
2446			return err
2447		}
2448	}
2449
2450	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2451		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2452	}
2453	if v.RestApiId != nil {
2454		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2455			return err
2456		}
2457	}
2458
2459	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
2460		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
2461	}
2462	if v.StatusCode != nil {
2463		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
2464			return err
2465		}
2466	}
2467
2468	return nil
2469}
2470
2471type awsRestjson1_serializeOpDeleteModel struct {
2472}
2473
2474func (*awsRestjson1_serializeOpDeleteModel) ID() string {
2475	return "OperationSerializer"
2476}
2477
2478func (m *awsRestjson1_serializeOpDeleteModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2479	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2480) {
2481	request, ok := in.Request.(*smithyhttp.Request)
2482	if !ok {
2483		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2484	}
2485
2486	input, ok := in.Parameters.(*DeleteModelInput)
2487	_ = input
2488	if !ok {
2489		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2490	}
2491
2492	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models/{modelName}")
2493	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2494	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2495	request.Method = "DELETE"
2496	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2497	if err != nil {
2498		return out, metadata, &smithy.SerializationError{Err: err}
2499	}
2500
2501	if err := awsRestjson1_serializeOpHttpBindingsDeleteModelInput(input, restEncoder); err != nil {
2502		return out, metadata, &smithy.SerializationError{Err: err}
2503	}
2504
2505	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2506		return out, metadata, &smithy.SerializationError{Err: err}
2507	}
2508	in.Request = request
2509
2510	return next.HandleSerialize(ctx, in)
2511}
2512func awsRestjson1_serializeOpHttpBindingsDeleteModelInput(v *DeleteModelInput, encoder *httpbinding.Encoder) error {
2513	if v == nil {
2514		return fmt.Errorf("unsupported serialization of nil %T", v)
2515	}
2516
2517	if v.ModelName == nil || len(*v.ModelName) == 0 {
2518		return &smithy.SerializationError{Err: fmt.Errorf("input member modelName must not be empty")}
2519	}
2520	if v.ModelName != nil {
2521		if err := encoder.SetURI("modelName").String(*v.ModelName); err != nil {
2522			return err
2523		}
2524	}
2525
2526	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2527		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2528	}
2529	if v.RestApiId != nil {
2530		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2531			return err
2532		}
2533	}
2534
2535	return nil
2536}
2537
2538type awsRestjson1_serializeOpDeleteRequestValidator struct {
2539}
2540
2541func (*awsRestjson1_serializeOpDeleteRequestValidator) ID() string {
2542	return "OperationSerializer"
2543}
2544
2545func (m *awsRestjson1_serializeOpDeleteRequestValidator) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2546	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2547) {
2548	request, ok := in.Request.(*smithyhttp.Request)
2549	if !ok {
2550		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2551	}
2552
2553	input, ok := in.Parameters.(*DeleteRequestValidatorInput)
2554	_ = input
2555	if !ok {
2556		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2557	}
2558
2559	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/requestvalidators/{requestValidatorId}")
2560	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2561	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2562	request.Method = "DELETE"
2563	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2564	if err != nil {
2565		return out, metadata, &smithy.SerializationError{Err: err}
2566	}
2567
2568	if err := awsRestjson1_serializeOpHttpBindingsDeleteRequestValidatorInput(input, restEncoder); err != nil {
2569		return out, metadata, &smithy.SerializationError{Err: err}
2570	}
2571
2572	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2573		return out, metadata, &smithy.SerializationError{Err: err}
2574	}
2575	in.Request = request
2576
2577	return next.HandleSerialize(ctx, in)
2578}
2579func awsRestjson1_serializeOpHttpBindingsDeleteRequestValidatorInput(v *DeleteRequestValidatorInput, encoder *httpbinding.Encoder) error {
2580	if v == nil {
2581		return fmt.Errorf("unsupported serialization of nil %T", v)
2582	}
2583
2584	if v.RequestValidatorId == nil || len(*v.RequestValidatorId) == 0 {
2585		return &smithy.SerializationError{Err: fmt.Errorf("input member requestValidatorId must not be empty")}
2586	}
2587	if v.RequestValidatorId != nil {
2588		if err := encoder.SetURI("requestValidatorId").String(*v.RequestValidatorId); err != nil {
2589			return err
2590		}
2591	}
2592
2593	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2594		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2595	}
2596	if v.RestApiId != nil {
2597		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2598			return err
2599		}
2600	}
2601
2602	return nil
2603}
2604
2605type awsRestjson1_serializeOpDeleteResource struct {
2606}
2607
2608func (*awsRestjson1_serializeOpDeleteResource) ID() string {
2609	return "OperationSerializer"
2610}
2611
2612func (m *awsRestjson1_serializeOpDeleteResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2613	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2614) {
2615	request, ok := in.Request.(*smithyhttp.Request)
2616	if !ok {
2617		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2618	}
2619
2620	input, ok := in.Parameters.(*DeleteResourceInput)
2621	_ = input
2622	if !ok {
2623		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2624	}
2625
2626	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}")
2627	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2628	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2629	request.Method = "DELETE"
2630	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2631	if err != nil {
2632		return out, metadata, &smithy.SerializationError{Err: err}
2633	}
2634
2635	if err := awsRestjson1_serializeOpHttpBindingsDeleteResourceInput(input, restEncoder); err != nil {
2636		return out, metadata, &smithy.SerializationError{Err: err}
2637	}
2638
2639	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2640		return out, metadata, &smithy.SerializationError{Err: err}
2641	}
2642	in.Request = request
2643
2644	return next.HandleSerialize(ctx, in)
2645}
2646func awsRestjson1_serializeOpHttpBindingsDeleteResourceInput(v *DeleteResourceInput, encoder *httpbinding.Encoder) error {
2647	if v == nil {
2648		return fmt.Errorf("unsupported serialization of nil %T", v)
2649	}
2650
2651	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
2652		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
2653	}
2654	if v.ResourceId != nil {
2655		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
2656			return err
2657		}
2658	}
2659
2660	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2661		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2662	}
2663	if v.RestApiId != nil {
2664		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2665			return err
2666		}
2667	}
2668
2669	return nil
2670}
2671
2672type awsRestjson1_serializeOpDeleteRestApi struct {
2673}
2674
2675func (*awsRestjson1_serializeOpDeleteRestApi) ID() string {
2676	return "OperationSerializer"
2677}
2678
2679func (m *awsRestjson1_serializeOpDeleteRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2680	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2681) {
2682	request, ok := in.Request.(*smithyhttp.Request)
2683	if !ok {
2684		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2685	}
2686
2687	input, ok := in.Parameters.(*DeleteRestApiInput)
2688	_ = input
2689	if !ok {
2690		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2691	}
2692
2693	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}")
2694	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2695	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2696	request.Method = "DELETE"
2697	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2698	if err != nil {
2699		return out, metadata, &smithy.SerializationError{Err: err}
2700	}
2701
2702	if err := awsRestjson1_serializeOpHttpBindingsDeleteRestApiInput(input, restEncoder); err != nil {
2703		return out, metadata, &smithy.SerializationError{Err: err}
2704	}
2705
2706	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2707		return out, metadata, &smithy.SerializationError{Err: err}
2708	}
2709	in.Request = request
2710
2711	return next.HandleSerialize(ctx, in)
2712}
2713func awsRestjson1_serializeOpHttpBindingsDeleteRestApiInput(v *DeleteRestApiInput, encoder *httpbinding.Encoder) error {
2714	if v == nil {
2715		return fmt.Errorf("unsupported serialization of nil %T", v)
2716	}
2717
2718	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2719		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2720	}
2721	if v.RestApiId != nil {
2722		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2723			return err
2724		}
2725	}
2726
2727	return nil
2728}
2729
2730type awsRestjson1_serializeOpDeleteStage struct {
2731}
2732
2733func (*awsRestjson1_serializeOpDeleteStage) ID() string {
2734	return "OperationSerializer"
2735}
2736
2737func (m *awsRestjson1_serializeOpDeleteStage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2738	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2739) {
2740	request, ok := in.Request.(*smithyhttp.Request)
2741	if !ok {
2742		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2743	}
2744
2745	input, ok := in.Parameters.(*DeleteStageInput)
2746	_ = input
2747	if !ok {
2748		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2749	}
2750
2751	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}")
2752	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2753	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2754	request.Method = "DELETE"
2755	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2756	if err != nil {
2757		return out, metadata, &smithy.SerializationError{Err: err}
2758	}
2759
2760	if err := awsRestjson1_serializeOpHttpBindingsDeleteStageInput(input, restEncoder); err != nil {
2761		return out, metadata, &smithy.SerializationError{Err: err}
2762	}
2763
2764	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2765		return out, metadata, &smithy.SerializationError{Err: err}
2766	}
2767	in.Request = request
2768
2769	return next.HandleSerialize(ctx, in)
2770}
2771func awsRestjson1_serializeOpHttpBindingsDeleteStageInput(v *DeleteStageInput, encoder *httpbinding.Encoder) error {
2772	if v == nil {
2773		return fmt.Errorf("unsupported serialization of nil %T", v)
2774	}
2775
2776	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
2777		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
2778	}
2779	if v.RestApiId != nil {
2780		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
2781			return err
2782		}
2783	}
2784
2785	if v.StageName == nil || len(*v.StageName) == 0 {
2786		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
2787	}
2788	if v.StageName != nil {
2789		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
2790			return err
2791		}
2792	}
2793
2794	return nil
2795}
2796
2797type awsRestjson1_serializeOpDeleteUsagePlan struct {
2798}
2799
2800func (*awsRestjson1_serializeOpDeleteUsagePlan) ID() string {
2801	return "OperationSerializer"
2802}
2803
2804func (m *awsRestjson1_serializeOpDeleteUsagePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2805	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2806) {
2807	request, ok := in.Request.(*smithyhttp.Request)
2808	if !ok {
2809		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2810	}
2811
2812	input, ok := in.Parameters.(*DeleteUsagePlanInput)
2813	_ = input
2814	if !ok {
2815		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2816	}
2817
2818	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}")
2819	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2820	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2821	request.Method = "DELETE"
2822	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2823	if err != nil {
2824		return out, metadata, &smithy.SerializationError{Err: err}
2825	}
2826
2827	if err := awsRestjson1_serializeOpHttpBindingsDeleteUsagePlanInput(input, restEncoder); err != nil {
2828		return out, metadata, &smithy.SerializationError{Err: err}
2829	}
2830
2831	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2832		return out, metadata, &smithy.SerializationError{Err: err}
2833	}
2834	in.Request = request
2835
2836	return next.HandleSerialize(ctx, in)
2837}
2838func awsRestjson1_serializeOpHttpBindingsDeleteUsagePlanInput(v *DeleteUsagePlanInput, encoder *httpbinding.Encoder) error {
2839	if v == nil {
2840		return fmt.Errorf("unsupported serialization of nil %T", v)
2841	}
2842
2843	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
2844		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
2845	}
2846	if v.UsagePlanId != nil {
2847		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
2848			return err
2849		}
2850	}
2851
2852	return nil
2853}
2854
2855type awsRestjson1_serializeOpDeleteUsagePlanKey struct {
2856}
2857
2858func (*awsRestjson1_serializeOpDeleteUsagePlanKey) ID() string {
2859	return "OperationSerializer"
2860}
2861
2862func (m *awsRestjson1_serializeOpDeleteUsagePlanKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2863	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2864) {
2865	request, ok := in.Request.(*smithyhttp.Request)
2866	if !ok {
2867		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2868	}
2869
2870	input, ok := in.Parameters.(*DeleteUsagePlanKeyInput)
2871	_ = input
2872	if !ok {
2873		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2874	}
2875
2876	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/keys/{keyId}")
2877	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2878	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2879	request.Method = "DELETE"
2880	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2881	if err != nil {
2882		return out, metadata, &smithy.SerializationError{Err: err}
2883	}
2884
2885	if err := awsRestjson1_serializeOpHttpBindingsDeleteUsagePlanKeyInput(input, restEncoder); err != nil {
2886		return out, metadata, &smithy.SerializationError{Err: err}
2887	}
2888
2889	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2890		return out, metadata, &smithy.SerializationError{Err: err}
2891	}
2892	in.Request = request
2893
2894	return next.HandleSerialize(ctx, in)
2895}
2896func awsRestjson1_serializeOpHttpBindingsDeleteUsagePlanKeyInput(v *DeleteUsagePlanKeyInput, encoder *httpbinding.Encoder) error {
2897	if v == nil {
2898		return fmt.Errorf("unsupported serialization of nil %T", v)
2899	}
2900
2901	if v.KeyId == nil || len(*v.KeyId) == 0 {
2902		return &smithy.SerializationError{Err: fmt.Errorf("input member keyId must not be empty")}
2903	}
2904	if v.KeyId != nil {
2905		if err := encoder.SetURI("keyId").String(*v.KeyId); err != nil {
2906			return err
2907		}
2908	}
2909
2910	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
2911		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
2912	}
2913	if v.UsagePlanId != nil {
2914		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
2915			return err
2916		}
2917	}
2918
2919	return nil
2920}
2921
2922type awsRestjson1_serializeOpDeleteVpcLink struct {
2923}
2924
2925func (*awsRestjson1_serializeOpDeleteVpcLink) ID() string {
2926	return "OperationSerializer"
2927}
2928
2929func (m *awsRestjson1_serializeOpDeleteVpcLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2930	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2931) {
2932	request, ok := in.Request.(*smithyhttp.Request)
2933	if !ok {
2934		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2935	}
2936
2937	input, ok := in.Parameters.(*DeleteVpcLinkInput)
2938	_ = input
2939	if !ok {
2940		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2941	}
2942
2943	opPath, opQuery := httpbinding.SplitURI("/vpclinks/{vpcLinkId}")
2944	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2945	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2946	request.Method = "DELETE"
2947	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2948	if err != nil {
2949		return out, metadata, &smithy.SerializationError{Err: err}
2950	}
2951
2952	if err := awsRestjson1_serializeOpHttpBindingsDeleteVpcLinkInput(input, restEncoder); err != nil {
2953		return out, metadata, &smithy.SerializationError{Err: err}
2954	}
2955
2956	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2957		return out, metadata, &smithy.SerializationError{Err: err}
2958	}
2959	in.Request = request
2960
2961	return next.HandleSerialize(ctx, in)
2962}
2963func awsRestjson1_serializeOpHttpBindingsDeleteVpcLinkInput(v *DeleteVpcLinkInput, encoder *httpbinding.Encoder) error {
2964	if v == nil {
2965		return fmt.Errorf("unsupported serialization of nil %T", v)
2966	}
2967
2968	if v.VpcLinkId == nil || len(*v.VpcLinkId) == 0 {
2969		return &smithy.SerializationError{Err: fmt.Errorf("input member vpcLinkId must not be empty")}
2970	}
2971	if v.VpcLinkId != nil {
2972		if err := encoder.SetURI("vpcLinkId").String(*v.VpcLinkId); err != nil {
2973			return err
2974		}
2975	}
2976
2977	return nil
2978}
2979
2980type awsRestjson1_serializeOpFlushStageAuthorizersCache struct {
2981}
2982
2983func (*awsRestjson1_serializeOpFlushStageAuthorizersCache) ID() string {
2984	return "OperationSerializer"
2985}
2986
2987func (m *awsRestjson1_serializeOpFlushStageAuthorizersCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2988	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2989) {
2990	request, ok := in.Request.(*smithyhttp.Request)
2991	if !ok {
2992		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2993	}
2994
2995	input, ok := in.Parameters.(*FlushStageAuthorizersCacheInput)
2996	_ = input
2997	if !ok {
2998		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2999	}
3000
3001	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}/cache/authorizers")
3002	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3003	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3004	request.Method = "DELETE"
3005	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3006	if err != nil {
3007		return out, metadata, &smithy.SerializationError{Err: err}
3008	}
3009
3010	if err := awsRestjson1_serializeOpHttpBindingsFlushStageAuthorizersCacheInput(input, restEncoder); err != nil {
3011		return out, metadata, &smithy.SerializationError{Err: err}
3012	}
3013
3014	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3015		return out, metadata, &smithy.SerializationError{Err: err}
3016	}
3017	in.Request = request
3018
3019	return next.HandleSerialize(ctx, in)
3020}
3021func awsRestjson1_serializeOpHttpBindingsFlushStageAuthorizersCacheInput(v *FlushStageAuthorizersCacheInput, encoder *httpbinding.Encoder) error {
3022	if v == nil {
3023		return fmt.Errorf("unsupported serialization of nil %T", v)
3024	}
3025
3026	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3027		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3028	}
3029	if v.RestApiId != nil {
3030		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3031			return err
3032		}
3033	}
3034
3035	if v.StageName == nil || len(*v.StageName) == 0 {
3036		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
3037	}
3038	if v.StageName != nil {
3039		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
3040			return err
3041		}
3042	}
3043
3044	return nil
3045}
3046
3047type awsRestjson1_serializeOpFlushStageCache struct {
3048}
3049
3050func (*awsRestjson1_serializeOpFlushStageCache) ID() string {
3051	return "OperationSerializer"
3052}
3053
3054func (m *awsRestjson1_serializeOpFlushStageCache) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3055	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3056) {
3057	request, ok := in.Request.(*smithyhttp.Request)
3058	if !ok {
3059		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3060	}
3061
3062	input, ok := in.Parameters.(*FlushStageCacheInput)
3063	_ = input
3064	if !ok {
3065		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3066	}
3067
3068	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}/cache/data")
3069	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3070	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3071	request.Method = "DELETE"
3072	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3073	if err != nil {
3074		return out, metadata, &smithy.SerializationError{Err: err}
3075	}
3076
3077	if err := awsRestjson1_serializeOpHttpBindingsFlushStageCacheInput(input, restEncoder); err != nil {
3078		return out, metadata, &smithy.SerializationError{Err: err}
3079	}
3080
3081	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3082		return out, metadata, &smithy.SerializationError{Err: err}
3083	}
3084	in.Request = request
3085
3086	return next.HandleSerialize(ctx, in)
3087}
3088func awsRestjson1_serializeOpHttpBindingsFlushStageCacheInput(v *FlushStageCacheInput, encoder *httpbinding.Encoder) error {
3089	if v == nil {
3090		return fmt.Errorf("unsupported serialization of nil %T", v)
3091	}
3092
3093	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3094		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3095	}
3096	if v.RestApiId != nil {
3097		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3098			return err
3099		}
3100	}
3101
3102	if v.StageName == nil || len(*v.StageName) == 0 {
3103		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
3104	}
3105	if v.StageName != nil {
3106		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
3107			return err
3108		}
3109	}
3110
3111	return nil
3112}
3113
3114type awsRestjson1_serializeOpGenerateClientCertificate struct {
3115}
3116
3117func (*awsRestjson1_serializeOpGenerateClientCertificate) ID() string {
3118	return "OperationSerializer"
3119}
3120
3121func (m *awsRestjson1_serializeOpGenerateClientCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3122	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3123) {
3124	request, ok := in.Request.(*smithyhttp.Request)
3125	if !ok {
3126		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3127	}
3128
3129	input, ok := in.Parameters.(*GenerateClientCertificateInput)
3130	_ = input
3131	if !ok {
3132		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3133	}
3134
3135	opPath, opQuery := httpbinding.SplitURI("/clientcertificates")
3136	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3137	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3138	request.Method = "POST"
3139	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3140	if err != nil {
3141		return out, metadata, &smithy.SerializationError{Err: err}
3142	}
3143
3144	restEncoder.SetHeader("Content-Type").String("application/json")
3145
3146	jsonEncoder := smithyjson.NewEncoder()
3147	if err := awsRestjson1_serializeOpDocumentGenerateClientCertificateInput(input, jsonEncoder.Value); err != nil {
3148		return out, metadata, &smithy.SerializationError{Err: err}
3149	}
3150
3151	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
3152		return out, metadata, &smithy.SerializationError{Err: err}
3153	}
3154
3155	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3156		return out, metadata, &smithy.SerializationError{Err: err}
3157	}
3158	in.Request = request
3159
3160	return next.HandleSerialize(ctx, in)
3161}
3162func awsRestjson1_serializeOpHttpBindingsGenerateClientCertificateInput(v *GenerateClientCertificateInput, encoder *httpbinding.Encoder) error {
3163	if v == nil {
3164		return fmt.Errorf("unsupported serialization of nil %T", v)
3165	}
3166
3167	return nil
3168}
3169
3170func awsRestjson1_serializeOpDocumentGenerateClientCertificateInput(v *GenerateClientCertificateInput, value smithyjson.Value) error {
3171	object := value.Object()
3172	defer object.Close()
3173
3174	if v.Description != nil {
3175		ok := object.Key("description")
3176		ok.String(*v.Description)
3177	}
3178
3179	if v.Tags != nil {
3180		ok := object.Key("tags")
3181		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
3182			return err
3183		}
3184	}
3185
3186	return nil
3187}
3188
3189type awsRestjson1_serializeOpGetAccount struct {
3190}
3191
3192func (*awsRestjson1_serializeOpGetAccount) ID() string {
3193	return "OperationSerializer"
3194}
3195
3196func (m *awsRestjson1_serializeOpGetAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3197	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3198) {
3199	request, ok := in.Request.(*smithyhttp.Request)
3200	if !ok {
3201		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3202	}
3203
3204	input, ok := in.Parameters.(*GetAccountInput)
3205	_ = input
3206	if !ok {
3207		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3208	}
3209
3210	opPath, opQuery := httpbinding.SplitURI("/account")
3211	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3212	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3213	request.Method = "GET"
3214	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3215	if err != nil {
3216		return out, metadata, &smithy.SerializationError{Err: err}
3217	}
3218
3219	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3220		return out, metadata, &smithy.SerializationError{Err: err}
3221	}
3222	in.Request = request
3223
3224	return next.HandleSerialize(ctx, in)
3225}
3226func awsRestjson1_serializeOpHttpBindingsGetAccountInput(v *GetAccountInput, encoder *httpbinding.Encoder) error {
3227	if v == nil {
3228		return fmt.Errorf("unsupported serialization of nil %T", v)
3229	}
3230
3231	return nil
3232}
3233
3234type awsRestjson1_serializeOpGetApiKey struct {
3235}
3236
3237func (*awsRestjson1_serializeOpGetApiKey) ID() string {
3238	return "OperationSerializer"
3239}
3240
3241func (m *awsRestjson1_serializeOpGetApiKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3242	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3243) {
3244	request, ok := in.Request.(*smithyhttp.Request)
3245	if !ok {
3246		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3247	}
3248
3249	input, ok := in.Parameters.(*GetApiKeyInput)
3250	_ = input
3251	if !ok {
3252		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3253	}
3254
3255	opPath, opQuery := httpbinding.SplitURI("/apikeys/{apiKey}")
3256	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3257	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3258	request.Method = "GET"
3259	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3260	if err != nil {
3261		return out, metadata, &smithy.SerializationError{Err: err}
3262	}
3263
3264	if err := awsRestjson1_serializeOpHttpBindingsGetApiKeyInput(input, restEncoder); err != nil {
3265		return out, metadata, &smithy.SerializationError{Err: err}
3266	}
3267
3268	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3269		return out, metadata, &smithy.SerializationError{Err: err}
3270	}
3271	in.Request = request
3272
3273	return next.HandleSerialize(ctx, in)
3274}
3275func awsRestjson1_serializeOpHttpBindingsGetApiKeyInput(v *GetApiKeyInput, encoder *httpbinding.Encoder) error {
3276	if v == nil {
3277		return fmt.Errorf("unsupported serialization of nil %T", v)
3278	}
3279
3280	if v.ApiKey == nil || len(*v.ApiKey) == 0 {
3281		return &smithy.SerializationError{Err: fmt.Errorf("input member apiKey must not be empty")}
3282	}
3283	if v.ApiKey != nil {
3284		if err := encoder.SetURI("apiKey").String(*v.ApiKey); err != nil {
3285			return err
3286		}
3287	}
3288
3289	if v.IncludeValue != nil {
3290		encoder.SetQuery("includeValue").Boolean(*v.IncludeValue)
3291	}
3292
3293	return nil
3294}
3295
3296type awsRestjson1_serializeOpGetApiKeys struct {
3297}
3298
3299func (*awsRestjson1_serializeOpGetApiKeys) ID() string {
3300	return "OperationSerializer"
3301}
3302
3303func (m *awsRestjson1_serializeOpGetApiKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3304	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3305) {
3306	request, ok := in.Request.(*smithyhttp.Request)
3307	if !ok {
3308		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3309	}
3310
3311	input, ok := in.Parameters.(*GetApiKeysInput)
3312	_ = input
3313	if !ok {
3314		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3315	}
3316
3317	opPath, opQuery := httpbinding.SplitURI("/apikeys")
3318	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3319	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3320	request.Method = "GET"
3321	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3322	if err != nil {
3323		return out, metadata, &smithy.SerializationError{Err: err}
3324	}
3325
3326	if err := awsRestjson1_serializeOpHttpBindingsGetApiKeysInput(input, restEncoder); err != nil {
3327		return out, metadata, &smithy.SerializationError{Err: err}
3328	}
3329
3330	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3331		return out, metadata, &smithy.SerializationError{Err: err}
3332	}
3333	in.Request = request
3334
3335	return next.HandleSerialize(ctx, in)
3336}
3337func awsRestjson1_serializeOpHttpBindingsGetApiKeysInput(v *GetApiKeysInput, encoder *httpbinding.Encoder) error {
3338	if v == nil {
3339		return fmt.Errorf("unsupported serialization of nil %T", v)
3340	}
3341
3342	if v.CustomerId != nil {
3343		encoder.SetQuery("customerId").String(*v.CustomerId)
3344	}
3345
3346	if v.IncludeValues != nil {
3347		encoder.SetQuery("includeValues").Boolean(*v.IncludeValues)
3348	}
3349
3350	if v.Limit != nil {
3351		encoder.SetQuery("limit").Integer(*v.Limit)
3352	}
3353
3354	if v.NameQuery != nil {
3355		encoder.SetQuery("name").String(*v.NameQuery)
3356	}
3357
3358	if v.Position != nil {
3359		encoder.SetQuery("position").String(*v.Position)
3360	}
3361
3362	return nil
3363}
3364
3365type awsRestjson1_serializeOpGetAuthorizer struct {
3366}
3367
3368func (*awsRestjson1_serializeOpGetAuthorizer) ID() string {
3369	return "OperationSerializer"
3370}
3371
3372func (m *awsRestjson1_serializeOpGetAuthorizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3373	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3374) {
3375	request, ok := in.Request.(*smithyhttp.Request)
3376	if !ok {
3377		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3378	}
3379
3380	input, ok := in.Parameters.(*GetAuthorizerInput)
3381	_ = input
3382	if !ok {
3383		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3384	}
3385
3386	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers/{authorizerId}")
3387	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3388	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3389	request.Method = "GET"
3390	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3391	if err != nil {
3392		return out, metadata, &smithy.SerializationError{Err: err}
3393	}
3394
3395	if err := awsRestjson1_serializeOpHttpBindingsGetAuthorizerInput(input, restEncoder); err != nil {
3396		return out, metadata, &smithy.SerializationError{Err: err}
3397	}
3398
3399	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3400		return out, metadata, &smithy.SerializationError{Err: err}
3401	}
3402	in.Request = request
3403
3404	return next.HandleSerialize(ctx, in)
3405}
3406func awsRestjson1_serializeOpHttpBindingsGetAuthorizerInput(v *GetAuthorizerInput, encoder *httpbinding.Encoder) error {
3407	if v == nil {
3408		return fmt.Errorf("unsupported serialization of nil %T", v)
3409	}
3410
3411	if v.AuthorizerId == nil || len(*v.AuthorizerId) == 0 {
3412		return &smithy.SerializationError{Err: fmt.Errorf("input member authorizerId must not be empty")}
3413	}
3414	if v.AuthorizerId != nil {
3415		if err := encoder.SetURI("authorizerId").String(*v.AuthorizerId); err != nil {
3416			return err
3417		}
3418	}
3419
3420	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3421		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3422	}
3423	if v.RestApiId != nil {
3424		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3425			return err
3426		}
3427	}
3428
3429	return nil
3430}
3431
3432type awsRestjson1_serializeOpGetAuthorizers struct {
3433}
3434
3435func (*awsRestjson1_serializeOpGetAuthorizers) ID() string {
3436	return "OperationSerializer"
3437}
3438
3439func (m *awsRestjson1_serializeOpGetAuthorizers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3440	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3441) {
3442	request, ok := in.Request.(*smithyhttp.Request)
3443	if !ok {
3444		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3445	}
3446
3447	input, ok := in.Parameters.(*GetAuthorizersInput)
3448	_ = input
3449	if !ok {
3450		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3451	}
3452
3453	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers")
3454	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3455	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3456	request.Method = "GET"
3457	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3458	if err != nil {
3459		return out, metadata, &smithy.SerializationError{Err: err}
3460	}
3461
3462	if err := awsRestjson1_serializeOpHttpBindingsGetAuthorizersInput(input, restEncoder); err != nil {
3463		return out, metadata, &smithy.SerializationError{Err: err}
3464	}
3465
3466	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3467		return out, metadata, &smithy.SerializationError{Err: err}
3468	}
3469	in.Request = request
3470
3471	return next.HandleSerialize(ctx, in)
3472}
3473func awsRestjson1_serializeOpHttpBindingsGetAuthorizersInput(v *GetAuthorizersInput, encoder *httpbinding.Encoder) error {
3474	if v == nil {
3475		return fmt.Errorf("unsupported serialization of nil %T", v)
3476	}
3477
3478	if v.Limit != nil {
3479		encoder.SetQuery("limit").Integer(*v.Limit)
3480	}
3481
3482	if v.Position != nil {
3483		encoder.SetQuery("position").String(*v.Position)
3484	}
3485
3486	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3487		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3488	}
3489	if v.RestApiId != nil {
3490		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3491			return err
3492		}
3493	}
3494
3495	return nil
3496}
3497
3498type awsRestjson1_serializeOpGetBasePathMapping struct {
3499}
3500
3501func (*awsRestjson1_serializeOpGetBasePathMapping) ID() string {
3502	return "OperationSerializer"
3503}
3504
3505func (m *awsRestjson1_serializeOpGetBasePathMapping) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3506	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3507) {
3508	request, ok := in.Request.(*smithyhttp.Request)
3509	if !ok {
3510		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3511	}
3512
3513	input, ok := in.Parameters.(*GetBasePathMappingInput)
3514	_ = input
3515	if !ok {
3516		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3517	}
3518
3519	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}/basepathmappings/{basePath}")
3520	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3521	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3522	request.Method = "GET"
3523	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3524	if err != nil {
3525		return out, metadata, &smithy.SerializationError{Err: err}
3526	}
3527
3528	if err := awsRestjson1_serializeOpHttpBindingsGetBasePathMappingInput(input, restEncoder); err != nil {
3529		return out, metadata, &smithy.SerializationError{Err: err}
3530	}
3531
3532	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3533		return out, metadata, &smithy.SerializationError{Err: err}
3534	}
3535	in.Request = request
3536
3537	return next.HandleSerialize(ctx, in)
3538}
3539func awsRestjson1_serializeOpHttpBindingsGetBasePathMappingInput(v *GetBasePathMappingInput, encoder *httpbinding.Encoder) error {
3540	if v == nil {
3541		return fmt.Errorf("unsupported serialization of nil %T", v)
3542	}
3543
3544	if v.BasePath == nil || len(*v.BasePath) == 0 {
3545		return &smithy.SerializationError{Err: fmt.Errorf("input member basePath must not be empty")}
3546	}
3547	if v.BasePath != nil {
3548		if err := encoder.SetURI("basePath").String(*v.BasePath); err != nil {
3549			return err
3550		}
3551	}
3552
3553	if v.DomainName == nil || len(*v.DomainName) == 0 {
3554		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
3555	}
3556	if v.DomainName != nil {
3557		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
3558			return err
3559		}
3560	}
3561
3562	return nil
3563}
3564
3565type awsRestjson1_serializeOpGetBasePathMappings struct {
3566}
3567
3568func (*awsRestjson1_serializeOpGetBasePathMappings) ID() string {
3569	return "OperationSerializer"
3570}
3571
3572func (m *awsRestjson1_serializeOpGetBasePathMappings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3573	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3574) {
3575	request, ok := in.Request.(*smithyhttp.Request)
3576	if !ok {
3577		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3578	}
3579
3580	input, ok := in.Parameters.(*GetBasePathMappingsInput)
3581	_ = input
3582	if !ok {
3583		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3584	}
3585
3586	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}/basepathmappings")
3587	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3588	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3589	request.Method = "GET"
3590	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3591	if err != nil {
3592		return out, metadata, &smithy.SerializationError{Err: err}
3593	}
3594
3595	if err := awsRestjson1_serializeOpHttpBindingsGetBasePathMappingsInput(input, restEncoder); err != nil {
3596		return out, metadata, &smithy.SerializationError{Err: err}
3597	}
3598
3599	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3600		return out, metadata, &smithy.SerializationError{Err: err}
3601	}
3602	in.Request = request
3603
3604	return next.HandleSerialize(ctx, in)
3605}
3606func awsRestjson1_serializeOpHttpBindingsGetBasePathMappingsInput(v *GetBasePathMappingsInput, encoder *httpbinding.Encoder) error {
3607	if v == nil {
3608		return fmt.Errorf("unsupported serialization of nil %T", v)
3609	}
3610
3611	if v.DomainName == nil || len(*v.DomainName) == 0 {
3612		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
3613	}
3614	if v.DomainName != nil {
3615		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
3616			return err
3617		}
3618	}
3619
3620	if v.Limit != nil {
3621		encoder.SetQuery("limit").Integer(*v.Limit)
3622	}
3623
3624	if v.Position != nil {
3625		encoder.SetQuery("position").String(*v.Position)
3626	}
3627
3628	return nil
3629}
3630
3631type awsRestjson1_serializeOpGetClientCertificate struct {
3632}
3633
3634func (*awsRestjson1_serializeOpGetClientCertificate) ID() string {
3635	return "OperationSerializer"
3636}
3637
3638func (m *awsRestjson1_serializeOpGetClientCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3639	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3640) {
3641	request, ok := in.Request.(*smithyhttp.Request)
3642	if !ok {
3643		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3644	}
3645
3646	input, ok := in.Parameters.(*GetClientCertificateInput)
3647	_ = input
3648	if !ok {
3649		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3650	}
3651
3652	opPath, opQuery := httpbinding.SplitURI("/clientcertificates/{clientCertificateId}")
3653	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3654	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3655	request.Method = "GET"
3656	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3657	if err != nil {
3658		return out, metadata, &smithy.SerializationError{Err: err}
3659	}
3660
3661	if err := awsRestjson1_serializeOpHttpBindingsGetClientCertificateInput(input, restEncoder); err != nil {
3662		return out, metadata, &smithy.SerializationError{Err: err}
3663	}
3664
3665	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3666		return out, metadata, &smithy.SerializationError{Err: err}
3667	}
3668	in.Request = request
3669
3670	return next.HandleSerialize(ctx, in)
3671}
3672func awsRestjson1_serializeOpHttpBindingsGetClientCertificateInput(v *GetClientCertificateInput, encoder *httpbinding.Encoder) error {
3673	if v == nil {
3674		return fmt.Errorf("unsupported serialization of nil %T", v)
3675	}
3676
3677	if v.ClientCertificateId == nil || len(*v.ClientCertificateId) == 0 {
3678		return &smithy.SerializationError{Err: fmt.Errorf("input member clientCertificateId must not be empty")}
3679	}
3680	if v.ClientCertificateId != nil {
3681		if err := encoder.SetURI("clientCertificateId").String(*v.ClientCertificateId); err != nil {
3682			return err
3683		}
3684	}
3685
3686	return nil
3687}
3688
3689type awsRestjson1_serializeOpGetClientCertificates struct {
3690}
3691
3692func (*awsRestjson1_serializeOpGetClientCertificates) ID() string {
3693	return "OperationSerializer"
3694}
3695
3696func (m *awsRestjson1_serializeOpGetClientCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3697	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3698) {
3699	request, ok := in.Request.(*smithyhttp.Request)
3700	if !ok {
3701		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3702	}
3703
3704	input, ok := in.Parameters.(*GetClientCertificatesInput)
3705	_ = input
3706	if !ok {
3707		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3708	}
3709
3710	opPath, opQuery := httpbinding.SplitURI("/clientcertificates")
3711	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3712	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3713	request.Method = "GET"
3714	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3715	if err != nil {
3716		return out, metadata, &smithy.SerializationError{Err: err}
3717	}
3718
3719	if err := awsRestjson1_serializeOpHttpBindingsGetClientCertificatesInput(input, restEncoder); err != nil {
3720		return out, metadata, &smithy.SerializationError{Err: err}
3721	}
3722
3723	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3724		return out, metadata, &smithy.SerializationError{Err: err}
3725	}
3726	in.Request = request
3727
3728	return next.HandleSerialize(ctx, in)
3729}
3730func awsRestjson1_serializeOpHttpBindingsGetClientCertificatesInput(v *GetClientCertificatesInput, encoder *httpbinding.Encoder) error {
3731	if v == nil {
3732		return fmt.Errorf("unsupported serialization of nil %T", v)
3733	}
3734
3735	if v.Limit != nil {
3736		encoder.SetQuery("limit").Integer(*v.Limit)
3737	}
3738
3739	if v.Position != nil {
3740		encoder.SetQuery("position").String(*v.Position)
3741	}
3742
3743	return nil
3744}
3745
3746type awsRestjson1_serializeOpGetDeployment struct {
3747}
3748
3749func (*awsRestjson1_serializeOpGetDeployment) ID() string {
3750	return "OperationSerializer"
3751}
3752
3753func (m *awsRestjson1_serializeOpGetDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3754	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3755) {
3756	request, ok := in.Request.(*smithyhttp.Request)
3757	if !ok {
3758		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3759	}
3760
3761	input, ok := in.Parameters.(*GetDeploymentInput)
3762	_ = input
3763	if !ok {
3764		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3765	}
3766
3767	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/deployments/{deploymentId}")
3768	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3769	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3770	request.Method = "GET"
3771	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3772	if err != nil {
3773		return out, metadata, &smithy.SerializationError{Err: err}
3774	}
3775
3776	if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(input, restEncoder); err != nil {
3777		return out, metadata, &smithy.SerializationError{Err: err}
3778	}
3779
3780	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3781		return out, metadata, &smithy.SerializationError{Err: err}
3782	}
3783	in.Request = request
3784
3785	return next.HandleSerialize(ctx, in)
3786}
3787func awsRestjson1_serializeOpHttpBindingsGetDeploymentInput(v *GetDeploymentInput, encoder *httpbinding.Encoder) error {
3788	if v == nil {
3789		return fmt.Errorf("unsupported serialization of nil %T", v)
3790	}
3791
3792	if v.DeploymentId == nil || len(*v.DeploymentId) == 0 {
3793		return &smithy.SerializationError{Err: fmt.Errorf("input member deploymentId must not be empty")}
3794	}
3795	if v.DeploymentId != nil {
3796		if err := encoder.SetURI("deploymentId").String(*v.DeploymentId); err != nil {
3797			return err
3798		}
3799	}
3800
3801	if v.Embed != nil {
3802		for i := range v.Embed {
3803			encoder.AddQuery("embed").String(v.Embed[i])
3804		}
3805	}
3806
3807	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3808		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3809	}
3810	if v.RestApiId != nil {
3811		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3812			return err
3813		}
3814	}
3815
3816	return nil
3817}
3818
3819type awsRestjson1_serializeOpGetDeployments struct {
3820}
3821
3822func (*awsRestjson1_serializeOpGetDeployments) ID() string {
3823	return "OperationSerializer"
3824}
3825
3826func (m *awsRestjson1_serializeOpGetDeployments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3827	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3828) {
3829	request, ok := in.Request.(*smithyhttp.Request)
3830	if !ok {
3831		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3832	}
3833
3834	input, ok := in.Parameters.(*GetDeploymentsInput)
3835	_ = input
3836	if !ok {
3837		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3838	}
3839
3840	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/deployments")
3841	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3842	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3843	request.Method = "GET"
3844	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3845	if err != nil {
3846		return out, metadata, &smithy.SerializationError{Err: err}
3847	}
3848
3849	if err := awsRestjson1_serializeOpHttpBindingsGetDeploymentsInput(input, restEncoder); err != nil {
3850		return out, metadata, &smithy.SerializationError{Err: err}
3851	}
3852
3853	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3854		return out, metadata, &smithy.SerializationError{Err: err}
3855	}
3856	in.Request = request
3857
3858	return next.HandleSerialize(ctx, in)
3859}
3860func awsRestjson1_serializeOpHttpBindingsGetDeploymentsInput(v *GetDeploymentsInput, encoder *httpbinding.Encoder) error {
3861	if v == nil {
3862		return fmt.Errorf("unsupported serialization of nil %T", v)
3863	}
3864
3865	if v.Limit != nil {
3866		encoder.SetQuery("limit").Integer(*v.Limit)
3867	}
3868
3869	if v.Position != nil {
3870		encoder.SetQuery("position").String(*v.Position)
3871	}
3872
3873	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3874		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3875	}
3876	if v.RestApiId != nil {
3877		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3878			return err
3879		}
3880	}
3881
3882	return nil
3883}
3884
3885type awsRestjson1_serializeOpGetDocumentationPart struct {
3886}
3887
3888func (*awsRestjson1_serializeOpGetDocumentationPart) ID() string {
3889	return "OperationSerializer"
3890}
3891
3892func (m *awsRestjson1_serializeOpGetDocumentationPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3893	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3894) {
3895	request, ok := in.Request.(*smithyhttp.Request)
3896	if !ok {
3897		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3898	}
3899
3900	input, ok := in.Parameters.(*GetDocumentationPartInput)
3901	_ = input
3902	if !ok {
3903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3904	}
3905
3906	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts/{documentationPartId}")
3907	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3908	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3909	request.Method = "GET"
3910	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3911	if err != nil {
3912		return out, metadata, &smithy.SerializationError{Err: err}
3913	}
3914
3915	if err := awsRestjson1_serializeOpHttpBindingsGetDocumentationPartInput(input, restEncoder); err != nil {
3916		return out, metadata, &smithy.SerializationError{Err: err}
3917	}
3918
3919	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3920		return out, metadata, &smithy.SerializationError{Err: err}
3921	}
3922	in.Request = request
3923
3924	return next.HandleSerialize(ctx, in)
3925}
3926func awsRestjson1_serializeOpHttpBindingsGetDocumentationPartInput(v *GetDocumentationPartInput, encoder *httpbinding.Encoder) error {
3927	if v == nil {
3928		return fmt.Errorf("unsupported serialization of nil %T", v)
3929	}
3930
3931	if v.DocumentationPartId == nil || len(*v.DocumentationPartId) == 0 {
3932		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationPartId must not be empty")}
3933	}
3934	if v.DocumentationPartId != nil {
3935		if err := encoder.SetURI("documentationPartId").String(*v.DocumentationPartId); err != nil {
3936			return err
3937		}
3938	}
3939
3940	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
3941		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
3942	}
3943	if v.RestApiId != nil {
3944		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
3945			return err
3946		}
3947	}
3948
3949	return nil
3950}
3951
3952type awsRestjson1_serializeOpGetDocumentationParts struct {
3953}
3954
3955func (*awsRestjson1_serializeOpGetDocumentationParts) ID() string {
3956	return "OperationSerializer"
3957}
3958
3959func (m *awsRestjson1_serializeOpGetDocumentationParts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3960	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3961) {
3962	request, ok := in.Request.(*smithyhttp.Request)
3963	if !ok {
3964		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3965	}
3966
3967	input, ok := in.Parameters.(*GetDocumentationPartsInput)
3968	_ = input
3969	if !ok {
3970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3971	}
3972
3973	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts")
3974	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3975	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3976	request.Method = "GET"
3977	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3978	if err != nil {
3979		return out, metadata, &smithy.SerializationError{Err: err}
3980	}
3981
3982	if err := awsRestjson1_serializeOpHttpBindingsGetDocumentationPartsInput(input, restEncoder); err != nil {
3983		return out, metadata, &smithy.SerializationError{Err: err}
3984	}
3985
3986	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3987		return out, metadata, &smithy.SerializationError{Err: err}
3988	}
3989	in.Request = request
3990
3991	return next.HandleSerialize(ctx, in)
3992}
3993func awsRestjson1_serializeOpHttpBindingsGetDocumentationPartsInput(v *GetDocumentationPartsInput, encoder *httpbinding.Encoder) error {
3994	if v == nil {
3995		return fmt.Errorf("unsupported serialization of nil %T", v)
3996	}
3997
3998	if v.Limit != nil {
3999		encoder.SetQuery("limit").Integer(*v.Limit)
4000	}
4001
4002	if len(v.LocationStatus) > 0 {
4003		encoder.SetQuery("locationStatus").String(string(v.LocationStatus))
4004	}
4005
4006	if v.NameQuery != nil {
4007		encoder.SetQuery("name").String(*v.NameQuery)
4008	}
4009
4010	if v.Path != nil {
4011		encoder.SetQuery("path").String(*v.Path)
4012	}
4013
4014	if v.Position != nil {
4015		encoder.SetQuery("position").String(*v.Position)
4016	}
4017
4018	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4019		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4020	}
4021	if v.RestApiId != nil {
4022		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4023			return err
4024		}
4025	}
4026
4027	if len(v.Type) > 0 {
4028		encoder.SetQuery("type").String(string(v.Type))
4029	}
4030
4031	return nil
4032}
4033
4034type awsRestjson1_serializeOpGetDocumentationVersion struct {
4035}
4036
4037func (*awsRestjson1_serializeOpGetDocumentationVersion) ID() string {
4038	return "OperationSerializer"
4039}
4040
4041func (m *awsRestjson1_serializeOpGetDocumentationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4042	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4043) {
4044	request, ok := in.Request.(*smithyhttp.Request)
4045	if !ok {
4046		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4047	}
4048
4049	input, ok := in.Parameters.(*GetDocumentationVersionInput)
4050	_ = input
4051	if !ok {
4052		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4053	}
4054
4055	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/versions/{documentationVersion}")
4056	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4057	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4058	request.Method = "GET"
4059	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4060	if err != nil {
4061		return out, metadata, &smithy.SerializationError{Err: err}
4062	}
4063
4064	if err := awsRestjson1_serializeOpHttpBindingsGetDocumentationVersionInput(input, restEncoder); err != nil {
4065		return out, metadata, &smithy.SerializationError{Err: err}
4066	}
4067
4068	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4069		return out, metadata, &smithy.SerializationError{Err: err}
4070	}
4071	in.Request = request
4072
4073	return next.HandleSerialize(ctx, in)
4074}
4075func awsRestjson1_serializeOpHttpBindingsGetDocumentationVersionInput(v *GetDocumentationVersionInput, encoder *httpbinding.Encoder) error {
4076	if v == nil {
4077		return fmt.Errorf("unsupported serialization of nil %T", v)
4078	}
4079
4080	if v.DocumentationVersion == nil || len(*v.DocumentationVersion) == 0 {
4081		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationVersion must not be empty")}
4082	}
4083	if v.DocumentationVersion != nil {
4084		if err := encoder.SetURI("documentationVersion").String(*v.DocumentationVersion); err != nil {
4085			return err
4086		}
4087	}
4088
4089	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4090		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4091	}
4092	if v.RestApiId != nil {
4093		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4094			return err
4095		}
4096	}
4097
4098	return nil
4099}
4100
4101type awsRestjson1_serializeOpGetDocumentationVersions struct {
4102}
4103
4104func (*awsRestjson1_serializeOpGetDocumentationVersions) ID() string {
4105	return "OperationSerializer"
4106}
4107
4108func (m *awsRestjson1_serializeOpGetDocumentationVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4109	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4110) {
4111	request, ok := in.Request.(*smithyhttp.Request)
4112	if !ok {
4113		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4114	}
4115
4116	input, ok := in.Parameters.(*GetDocumentationVersionsInput)
4117	_ = input
4118	if !ok {
4119		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4120	}
4121
4122	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/versions")
4123	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4124	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4125	request.Method = "GET"
4126	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4127	if err != nil {
4128		return out, metadata, &smithy.SerializationError{Err: err}
4129	}
4130
4131	if err := awsRestjson1_serializeOpHttpBindingsGetDocumentationVersionsInput(input, restEncoder); err != nil {
4132		return out, metadata, &smithy.SerializationError{Err: err}
4133	}
4134
4135	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4136		return out, metadata, &smithy.SerializationError{Err: err}
4137	}
4138	in.Request = request
4139
4140	return next.HandleSerialize(ctx, in)
4141}
4142func awsRestjson1_serializeOpHttpBindingsGetDocumentationVersionsInput(v *GetDocumentationVersionsInput, encoder *httpbinding.Encoder) error {
4143	if v == nil {
4144		return fmt.Errorf("unsupported serialization of nil %T", v)
4145	}
4146
4147	if v.Limit != nil {
4148		encoder.SetQuery("limit").Integer(*v.Limit)
4149	}
4150
4151	if v.Position != nil {
4152		encoder.SetQuery("position").String(*v.Position)
4153	}
4154
4155	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4156		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4157	}
4158	if v.RestApiId != nil {
4159		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4160			return err
4161		}
4162	}
4163
4164	return nil
4165}
4166
4167type awsRestjson1_serializeOpGetDomainName struct {
4168}
4169
4170func (*awsRestjson1_serializeOpGetDomainName) ID() string {
4171	return "OperationSerializer"
4172}
4173
4174func (m *awsRestjson1_serializeOpGetDomainName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4175	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4176) {
4177	request, ok := in.Request.(*smithyhttp.Request)
4178	if !ok {
4179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4180	}
4181
4182	input, ok := in.Parameters.(*GetDomainNameInput)
4183	_ = input
4184	if !ok {
4185		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4186	}
4187
4188	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}")
4189	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4190	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4191	request.Method = "GET"
4192	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4193	if err != nil {
4194		return out, metadata, &smithy.SerializationError{Err: err}
4195	}
4196
4197	if err := awsRestjson1_serializeOpHttpBindingsGetDomainNameInput(input, restEncoder); err != nil {
4198		return out, metadata, &smithy.SerializationError{Err: err}
4199	}
4200
4201	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4202		return out, metadata, &smithy.SerializationError{Err: err}
4203	}
4204	in.Request = request
4205
4206	return next.HandleSerialize(ctx, in)
4207}
4208func awsRestjson1_serializeOpHttpBindingsGetDomainNameInput(v *GetDomainNameInput, encoder *httpbinding.Encoder) error {
4209	if v == nil {
4210		return fmt.Errorf("unsupported serialization of nil %T", v)
4211	}
4212
4213	if v.DomainName == nil || len(*v.DomainName) == 0 {
4214		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
4215	}
4216	if v.DomainName != nil {
4217		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
4218			return err
4219		}
4220	}
4221
4222	return nil
4223}
4224
4225type awsRestjson1_serializeOpGetDomainNames struct {
4226}
4227
4228func (*awsRestjson1_serializeOpGetDomainNames) ID() string {
4229	return "OperationSerializer"
4230}
4231
4232func (m *awsRestjson1_serializeOpGetDomainNames) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4233	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4234) {
4235	request, ok := in.Request.(*smithyhttp.Request)
4236	if !ok {
4237		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4238	}
4239
4240	input, ok := in.Parameters.(*GetDomainNamesInput)
4241	_ = input
4242	if !ok {
4243		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4244	}
4245
4246	opPath, opQuery := httpbinding.SplitURI("/domainnames")
4247	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4248	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4249	request.Method = "GET"
4250	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4251	if err != nil {
4252		return out, metadata, &smithy.SerializationError{Err: err}
4253	}
4254
4255	if err := awsRestjson1_serializeOpHttpBindingsGetDomainNamesInput(input, restEncoder); err != nil {
4256		return out, metadata, &smithy.SerializationError{Err: err}
4257	}
4258
4259	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4260		return out, metadata, &smithy.SerializationError{Err: err}
4261	}
4262	in.Request = request
4263
4264	return next.HandleSerialize(ctx, in)
4265}
4266func awsRestjson1_serializeOpHttpBindingsGetDomainNamesInput(v *GetDomainNamesInput, encoder *httpbinding.Encoder) error {
4267	if v == nil {
4268		return fmt.Errorf("unsupported serialization of nil %T", v)
4269	}
4270
4271	if v.Limit != nil {
4272		encoder.SetQuery("limit").Integer(*v.Limit)
4273	}
4274
4275	if v.Position != nil {
4276		encoder.SetQuery("position").String(*v.Position)
4277	}
4278
4279	return nil
4280}
4281
4282type awsRestjson1_serializeOpGetExport struct {
4283}
4284
4285func (*awsRestjson1_serializeOpGetExport) ID() string {
4286	return "OperationSerializer"
4287}
4288
4289func (m *awsRestjson1_serializeOpGetExport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4290	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4291) {
4292	request, ok := in.Request.(*smithyhttp.Request)
4293	if !ok {
4294		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4295	}
4296
4297	input, ok := in.Parameters.(*GetExportInput)
4298	_ = input
4299	if !ok {
4300		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4301	}
4302
4303	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}/exports/{exportType}")
4304	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4305	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4306	request.Method = "GET"
4307	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4308	if err != nil {
4309		return out, metadata, &smithy.SerializationError{Err: err}
4310	}
4311
4312	if err := awsRestjson1_serializeOpHttpBindingsGetExportInput(input, restEncoder); err != nil {
4313		return out, metadata, &smithy.SerializationError{Err: err}
4314	}
4315
4316	restEncoder.SetHeader("Content-Type").String("application/json")
4317
4318	jsonEncoder := smithyjson.NewEncoder()
4319	if err := awsRestjson1_serializeOpDocumentGetExportInput(input, jsonEncoder.Value); err != nil {
4320		return out, metadata, &smithy.SerializationError{Err: err}
4321	}
4322
4323	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4324		return out, metadata, &smithy.SerializationError{Err: err}
4325	}
4326
4327	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4328		return out, metadata, &smithy.SerializationError{Err: err}
4329	}
4330	in.Request = request
4331
4332	return next.HandleSerialize(ctx, in)
4333}
4334func awsRestjson1_serializeOpHttpBindingsGetExportInput(v *GetExportInput, encoder *httpbinding.Encoder) error {
4335	if v == nil {
4336		return fmt.Errorf("unsupported serialization of nil %T", v)
4337	}
4338
4339	if v.Accepts != nil && len(*v.Accepts) > 0 {
4340		locationName := "Accept"
4341		encoder.SetHeader(locationName).String(*v.Accepts)
4342	}
4343
4344	if v.ExportType == nil || len(*v.ExportType) == 0 {
4345		return &smithy.SerializationError{Err: fmt.Errorf("input member exportType must not be empty")}
4346	}
4347	if v.ExportType != nil {
4348		if err := encoder.SetURI("exportType").String(*v.ExportType); err != nil {
4349			return err
4350		}
4351	}
4352
4353	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4354		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4355	}
4356	if v.RestApiId != nil {
4357		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4358			return err
4359		}
4360	}
4361
4362	if v.StageName == nil || len(*v.StageName) == 0 {
4363		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
4364	}
4365	if v.StageName != nil {
4366		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
4367			return err
4368		}
4369	}
4370
4371	return nil
4372}
4373
4374func awsRestjson1_serializeOpDocumentGetExportInput(v *GetExportInput, value smithyjson.Value) error {
4375	object := value.Object()
4376	defer object.Close()
4377
4378	if v.Parameters != nil {
4379		ok := object.Key("parameters")
4380		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Parameters, ok); err != nil {
4381			return err
4382		}
4383	}
4384
4385	return nil
4386}
4387
4388type awsRestjson1_serializeOpGetGatewayResponse struct {
4389}
4390
4391func (*awsRestjson1_serializeOpGetGatewayResponse) ID() string {
4392	return "OperationSerializer"
4393}
4394
4395func (m *awsRestjson1_serializeOpGetGatewayResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4396	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4397) {
4398	request, ok := in.Request.(*smithyhttp.Request)
4399	if !ok {
4400		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4401	}
4402
4403	input, ok := in.Parameters.(*GetGatewayResponseInput)
4404	_ = input
4405	if !ok {
4406		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4407	}
4408
4409	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/gatewayresponses/{responseType}")
4410	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4411	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4412	request.Method = "GET"
4413	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4414	if err != nil {
4415		return out, metadata, &smithy.SerializationError{Err: err}
4416	}
4417
4418	if err := awsRestjson1_serializeOpHttpBindingsGetGatewayResponseInput(input, restEncoder); err != nil {
4419		return out, metadata, &smithy.SerializationError{Err: err}
4420	}
4421
4422	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4423		return out, metadata, &smithy.SerializationError{Err: err}
4424	}
4425	in.Request = request
4426
4427	return next.HandleSerialize(ctx, in)
4428}
4429func awsRestjson1_serializeOpHttpBindingsGetGatewayResponseInput(v *GetGatewayResponseInput, encoder *httpbinding.Encoder) error {
4430	if v == nil {
4431		return fmt.Errorf("unsupported serialization of nil %T", v)
4432	}
4433
4434	if len(v.ResponseType) == 0 {
4435		return &smithy.SerializationError{Err: fmt.Errorf("input member responseType must not be empty")}
4436	}
4437	if len(v.ResponseType) > 0 {
4438		if err := encoder.SetURI("responseType").String(string(v.ResponseType)); err != nil {
4439			return err
4440		}
4441	}
4442
4443	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4444		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4445	}
4446	if v.RestApiId != nil {
4447		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4448			return err
4449		}
4450	}
4451
4452	return nil
4453}
4454
4455type awsRestjson1_serializeOpGetGatewayResponses struct {
4456}
4457
4458func (*awsRestjson1_serializeOpGetGatewayResponses) ID() string {
4459	return "OperationSerializer"
4460}
4461
4462func (m *awsRestjson1_serializeOpGetGatewayResponses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4463	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4464) {
4465	request, ok := in.Request.(*smithyhttp.Request)
4466	if !ok {
4467		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4468	}
4469
4470	input, ok := in.Parameters.(*GetGatewayResponsesInput)
4471	_ = input
4472	if !ok {
4473		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4474	}
4475
4476	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/gatewayresponses")
4477	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4478	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4479	request.Method = "GET"
4480	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4481	if err != nil {
4482		return out, metadata, &smithy.SerializationError{Err: err}
4483	}
4484
4485	if err := awsRestjson1_serializeOpHttpBindingsGetGatewayResponsesInput(input, restEncoder); err != nil {
4486		return out, metadata, &smithy.SerializationError{Err: err}
4487	}
4488
4489	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4490		return out, metadata, &smithy.SerializationError{Err: err}
4491	}
4492	in.Request = request
4493
4494	return next.HandleSerialize(ctx, in)
4495}
4496func awsRestjson1_serializeOpHttpBindingsGetGatewayResponsesInput(v *GetGatewayResponsesInput, encoder *httpbinding.Encoder) error {
4497	if v == nil {
4498		return fmt.Errorf("unsupported serialization of nil %T", v)
4499	}
4500
4501	if v.Limit != nil {
4502		encoder.SetQuery("limit").Integer(*v.Limit)
4503	}
4504
4505	if v.Position != nil {
4506		encoder.SetQuery("position").String(*v.Position)
4507	}
4508
4509	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4510		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4511	}
4512	if v.RestApiId != nil {
4513		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4514			return err
4515		}
4516	}
4517
4518	return nil
4519}
4520
4521type awsRestjson1_serializeOpGetIntegration struct {
4522}
4523
4524func (*awsRestjson1_serializeOpGetIntegration) ID() string {
4525	return "OperationSerializer"
4526}
4527
4528func (m *awsRestjson1_serializeOpGetIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4530) {
4531	request, ok := in.Request.(*smithyhttp.Request)
4532	if !ok {
4533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4534	}
4535
4536	input, ok := in.Parameters.(*GetIntegrationInput)
4537	_ = input
4538	if !ok {
4539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4540	}
4541
4542	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration")
4543	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4544	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4545	request.Method = "GET"
4546	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4547	if err != nil {
4548		return out, metadata, &smithy.SerializationError{Err: err}
4549	}
4550
4551	if err := awsRestjson1_serializeOpHttpBindingsGetIntegrationInput(input, restEncoder); err != nil {
4552		return out, metadata, &smithy.SerializationError{Err: err}
4553	}
4554
4555	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4556		return out, metadata, &smithy.SerializationError{Err: err}
4557	}
4558	in.Request = request
4559
4560	return next.HandleSerialize(ctx, in)
4561}
4562func awsRestjson1_serializeOpHttpBindingsGetIntegrationInput(v *GetIntegrationInput, encoder *httpbinding.Encoder) error {
4563	if v == nil {
4564		return fmt.Errorf("unsupported serialization of nil %T", v)
4565	}
4566
4567	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
4568		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
4569	}
4570	if v.HttpMethod != nil {
4571		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
4572			return err
4573		}
4574	}
4575
4576	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
4577		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
4578	}
4579	if v.ResourceId != nil {
4580		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
4581			return err
4582		}
4583	}
4584
4585	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4586		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4587	}
4588	if v.RestApiId != nil {
4589		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4590			return err
4591		}
4592	}
4593
4594	return nil
4595}
4596
4597type awsRestjson1_serializeOpGetIntegrationResponse struct {
4598}
4599
4600func (*awsRestjson1_serializeOpGetIntegrationResponse) ID() string {
4601	return "OperationSerializer"
4602}
4603
4604func (m *awsRestjson1_serializeOpGetIntegrationResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4605	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4606) {
4607	request, ok := in.Request.(*smithyhttp.Request)
4608	if !ok {
4609		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4610	}
4611
4612	input, ok := in.Parameters.(*GetIntegrationResponseInput)
4613	_ = input
4614	if !ok {
4615		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4616	}
4617
4618	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}")
4619	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4620	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4621	request.Method = "GET"
4622	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4623	if err != nil {
4624		return out, metadata, &smithy.SerializationError{Err: err}
4625	}
4626
4627	if err := awsRestjson1_serializeOpHttpBindingsGetIntegrationResponseInput(input, restEncoder); err != nil {
4628		return out, metadata, &smithy.SerializationError{Err: err}
4629	}
4630
4631	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4632		return out, metadata, &smithy.SerializationError{Err: err}
4633	}
4634	in.Request = request
4635
4636	return next.HandleSerialize(ctx, in)
4637}
4638func awsRestjson1_serializeOpHttpBindingsGetIntegrationResponseInput(v *GetIntegrationResponseInput, encoder *httpbinding.Encoder) error {
4639	if v == nil {
4640		return fmt.Errorf("unsupported serialization of nil %T", v)
4641	}
4642
4643	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
4644		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
4645	}
4646	if v.HttpMethod != nil {
4647		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
4648			return err
4649		}
4650	}
4651
4652	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
4653		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
4654	}
4655	if v.ResourceId != nil {
4656		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
4657			return err
4658		}
4659	}
4660
4661	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4662		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4663	}
4664	if v.RestApiId != nil {
4665		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4666			return err
4667		}
4668	}
4669
4670	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
4671		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
4672	}
4673	if v.StatusCode != nil {
4674		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
4675			return err
4676		}
4677	}
4678
4679	return nil
4680}
4681
4682type awsRestjson1_serializeOpGetMethod struct {
4683}
4684
4685func (*awsRestjson1_serializeOpGetMethod) ID() string {
4686	return "OperationSerializer"
4687}
4688
4689func (m *awsRestjson1_serializeOpGetMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4690	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4691) {
4692	request, ok := in.Request.(*smithyhttp.Request)
4693	if !ok {
4694		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4695	}
4696
4697	input, ok := in.Parameters.(*GetMethodInput)
4698	_ = input
4699	if !ok {
4700		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4701	}
4702
4703	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}")
4704	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4705	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4706	request.Method = "GET"
4707	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4708	if err != nil {
4709		return out, metadata, &smithy.SerializationError{Err: err}
4710	}
4711
4712	if err := awsRestjson1_serializeOpHttpBindingsGetMethodInput(input, restEncoder); err != nil {
4713		return out, metadata, &smithy.SerializationError{Err: err}
4714	}
4715
4716	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4717		return out, metadata, &smithy.SerializationError{Err: err}
4718	}
4719	in.Request = request
4720
4721	return next.HandleSerialize(ctx, in)
4722}
4723func awsRestjson1_serializeOpHttpBindingsGetMethodInput(v *GetMethodInput, encoder *httpbinding.Encoder) error {
4724	if v == nil {
4725		return fmt.Errorf("unsupported serialization of nil %T", v)
4726	}
4727
4728	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
4729		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
4730	}
4731	if v.HttpMethod != nil {
4732		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
4733			return err
4734		}
4735	}
4736
4737	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
4738		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
4739	}
4740	if v.ResourceId != nil {
4741		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
4742			return err
4743		}
4744	}
4745
4746	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4747		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4748	}
4749	if v.RestApiId != nil {
4750		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4751			return err
4752		}
4753	}
4754
4755	return nil
4756}
4757
4758type awsRestjson1_serializeOpGetMethodResponse struct {
4759}
4760
4761func (*awsRestjson1_serializeOpGetMethodResponse) ID() string {
4762	return "OperationSerializer"
4763}
4764
4765func (m *awsRestjson1_serializeOpGetMethodResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4766	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4767) {
4768	request, ok := in.Request.(*smithyhttp.Request)
4769	if !ok {
4770		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4771	}
4772
4773	input, ok := in.Parameters.(*GetMethodResponseInput)
4774	_ = input
4775	if !ok {
4776		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4777	}
4778
4779	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}")
4780	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4781	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4782	request.Method = "GET"
4783	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4784	if err != nil {
4785		return out, metadata, &smithy.SerializationError{Err: err}
4786	}
4787
4788	if err := awsRestjson1_serializeOpHttpBindingsGetMethodResponseInput(input, restEncoder); err != nil {
4789		return out, metadata, &smithy.SerializationError{Err: err}
4790	}
4791
4792	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4793		return out, metadata, &smithy.SerializationError{Err: err}
4794	}
4795	in.Request = request
4796
4797	return next.HandleSerialize(ctx, in)
4798}
4799func awsRestjson1_serializeOpHttpBindingsGetMethodResponseInput(v *GetMethodResponseInput, encoder *httpbinding.Encoder) error {
4800	if v == nil {
4801		return fmt.Errorf("unsupported serialization of nil %T", v)
4802	}
4803
4804	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
4805		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
4806	}
4807	if v.HttpMethod != nil {
4808		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
4809			return err
4810		}
4811	}
4812
4813	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
4814		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
4815	}
4816	if v.ResourceId != nil {
4817		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
4818			return err
4819		}
4820	}
4821
4822	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4823		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4824	}
4825	if v.RestApiId != nil {
4826		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4827			return err
4828		}
4829	}
4830
4831	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
4832		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
4833	}
4834	if v.StatusCode != nil {
4835		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
4836			return err
4837		}
4838	}
4839
4840	return nil
4841}
4842
4843type awsRestjson1_serializeOpGetModel struct {
4844}
4845
4846func (*awsRestjson1_serializeOpGetModel) ID() string {
4847	return "OperationSerializer"
4848}
4849
4850func (m *awsRestjson1_serializeOpGetModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4851	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4852) {
4853	request, ok := in.Request.(*smithyhttp.Request)
4854	if !ok {
4855		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4856	}
4857
4858	input, ok := in.Parameters.(*GetModelInput)
4859	_ = input
4860	if !ok {
4861		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4862	}
4863
4864	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models/{modelName}")
4865	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4866	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4867	request.Method = "GET"
4868	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4869	if err != nil {
4870		return out, metadata, &smithy.SerializationError{Err: err}
4871	}
4872
4873	if err := awsRestjson1_serializeOpHttpBindingsGetModelInput(input, restEncoder); err != nil {
4874		return out, metadata, &smithy.SerializationError{Err: err}
4875	}
4876
4877	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4878		return out, metadata, &smithy.SerializationError{Err: err}
4879	}
4880	in.Request = request
4881
4882	return next.HandleSerialize(ctx, in)
4883}
4884func awsRestjson1_serializeOpHttpBindingsGetModelInput(v *GetModelInput, encoder *httpbinding.Encoder) error {
4885	if v == nil {
4886		return fmt.Errorf("unsupported serialization of nil %T", v)
4887	}
4888
4889	if v.Flatten {
4890		encoder.SetQuery("flatten").Boolean(v.Flatten)
4891	}
4892
4893	if v.ModelName == nil || len(*v.ModelName) == 0 {
4894		return &smithy.SerializationError{Err: fmt.Errorf("input member modelName must not be empty")}
4895	}
4896	if v.ModelName != nil {
4897		if err := encoder.SetURI("modelName").String(*v.ModelName); err != nil {
4898			return err
4899		}
4900	}
4901
4902	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4903		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4904	}
4905	if v.RestApiId != nil {
4906		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4907			return err
4908		}
4909	}
4910
4911	return nil
4912}
4913
4914type awsRestjson1_serializeOpGetModels struct {
4915}
4916
4917func (*awsRestjson1_serializeOpGetModels) ID() string {
4918	return "OperationSerializer"
4919}
4920
4921func (m *awsRestjson1_serializeOpGetModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4922	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4923) {
4924	request, ok := in.Request.(*smithyhttp.Request)
4925	if !ok {
4926		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4927	}
4928
4929	input, ok := in.Parameters.(*GetModelsInput)
4930	_ = input
4931	if !ok {
4932		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4933	}
4934
4935	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models")
4936	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4937	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4938	request.Method = "GET"
4939	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4940	if err != nil {
4941		return out, metadata, &smithy.SerializationError{Err: err}
4942	}
4943
4944	if err := awsRestjson1_serializeOpHttpBindingsGetModelsInput(input, restEncoder); err != nil {
4945		return out, metadata, &smithy.SerializationError{Err: err}
4946	}
4947
4948	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4949		return out, metadata, &smithy.SerializationError{Err: err}
4950	}
4951	in.Request = request
4952
4953	return next.HandleSerialize(ctx, in)
4954}
4955func awsRestjson1_serializeOpHttpBindingsGetModelsInput(v *GetModelsInput, encoder *httpbinding.Encoder) error {
4956	if v == nil {
4957		return fmt.Errorf("unsupported serialization of nil %T", v)
4958	}
4959
4960	if v.Limit != nil {
4961		encoder.SetQuery("limit").Integer(*v.Limit)
4962	}
4963
4964	if v.Position != nil {
4965		encoder.SetQuery("position").String(*v.Position)
4966	}
4967
4968	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
4969		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
4970	}
4971	if v.RestApiId != nil {
4972		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
4973			return err
4974		}
4975	}
4976
4977	return nil
4978}
4979
4980type awsRestjson1_serializeOpGetModelTemplate struct {
4981}
4982
4983func (*awsRestjson1_serializeOpGetModelTemplate) ID() string {
4984	return "OperationSerializer"
4985}
4986
4987func (m *awsRestjson1_serializeOpGetModelTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4988	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4989) {
4990	request, ok := in.Request.(*smithyhttp.Request)
4991	if !ok {
4992		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4993	}
4994
4995	input, ok := in.Parameters.(*GetModelTemplateInput)
4996	_ = input
4997	if !ok {
4998		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4999	}
5000
5001	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models/{modelName}/default_template")
5002	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5003	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5004	request.Method = "GET"
5005	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5006	if err != nil {
5007		return out, metadata, &smithy.SerializationError{Err: err}
5008	}
5009
5010	if err := awsRestjson1_serializeOpHttpBindingsGetModelTemplateInput(input, restEncoder); err != nil {
5011		return out, metadata, &smithy.SerializationError{Err: err}
5012	}
5013
5014	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5015		return out, metadata, &smithy.SerializationError{Err: err}
5016	}
5017	in.Request = request
5018
5019	return next.HandleSerialize(ctx, in)
5020}
5021func awsRestjson1_serializeOpHttpBindingsGetModelTemplateInput(v *GetModelTemplateInput, encoder *httpbinding.Encoder) error {
5022	if v == nil {
5023		return fmt.Errorf("unsupported serialization of nil %T", v)
5024	}
5025
5026	if v.ModelName == nil || len(*v.ModelName) == 0 {
5027		return &smithy.SerializationError{Err: fmt.Errorf("input member modelName must not be empty")}
5028	}
5029	if v.ModelName != nil {
5030		if err := encoder.SetURI("modelName").String(*v.ModelName); err != nil {
5031			return err
5032		}
5033	}
5034
5035	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5036		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5037	}
5038	if v.RestApiId != nil {
5039		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5040			return err
5041		}
5042	}
5043
5044	return nil
5045}
5046
5047type awsRestjson1_serializeOpGetRequestValidator struct {
5048}
5049
5050func (*awsRestjson1_serializeOpGetRequestValidator) ID() string {
5051	return "OperationSerializer"
5052}
5053
5054func (m *awsRestjson1_serializeOpGetRequestValidator) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5055	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5056) {
5057	request, ok := in.Request.(*smithyhttp.Request)
5058	if !ok {
5059		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5060	}
5061
5062	input, ok := in.Parameters.(*GetRequestValidatorInput)
5063	_ = input
5064	if !ok {
5065		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5066	}
5067
5068	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/requestvalidators/{requestValidatorId}")
5069	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5070	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5071	request.Method = "GET"
5072	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5073	if err != nil {
5074		return out, metadata, &smithy.SerializationError{Err: err}
5075	}
5076
5077	if err := awsRestjson1_serializeOpHttpBindingsGetRequestValidatorInput(input, restEncoder); err != nil {
5078		return out, metadata, &smithy.SerializationError{Err: err}
5079	}
5080
5081	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5082		return out, metadata, &smithy.SerializationError{Err: err}
5083	}
5084	in.Request = request
5085
5086	return next.HandleSerialize(ctx, in)
5087}
5088func awsRestjson1_serializeOpHttpBindingsGetRequestValidatorInput(v *GetRequestValidatorInput, encoder *httpbinding.Encoder) error {
5089	if v == nil {
5090		return fmt.Errorf("unsupported serialization of nil %T", v)
5091	}
5092
5093	if v.RequestValidatorId == nil || len(*v.RequestValidatorId) == 0 {
5094		return &smithy.SerializationError{Err: fmt.Errorf("input member requestValidatorId must not be empty")}
5095	}
5096	if v.RequestValidatorId != nil {
5097		if err := encoder.SetURI("requestValidatorId").String(*v.RequestValidatorId); err != nil {
5098			return err
5099		}
5100	}
5101
5102	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5103		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5104	}
5105	if v.RestApiId != nil {
5106		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5107			return err
5108		}
5109	}
5110
5111	return nil
5112}
5113
5114type awsRestjson1_serializeOpGetRequestValidators struct {
5115}
5116
5117func (*awsRestjson1_serializeOpGetRequestValidators) ID() string {
5118	return "OperationSerializer"
5119}
5120
5121func (m *awsRestjson1_serializeOpGetRequestValidators) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5122	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5123) {
5124	request, ok := in.Request.(*smithyhttp.Request)
5125	if !ok {
5126		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5127	}
5128
5129	input, ok := in.Parameters.(*GetRequestValidatorsInput)
5130	_ = input
5131	if !ok {
5132		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5133	}
5134
5135	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/requestvalidators")
5136	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5137	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5138	request.Method = "GET"
5139	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5140	if err != nil {
5141		return out, metadata, &smithy.SerializationError{Err: err}
5142	}
5143
5144	if err := awsRestjson1_serializeOpHttpBindingsGetRequestValidatorsInput(input, restEncoder); err != nil {
5145		return out, metadata, &smithy.SerializationError{Err: err}
5146	}
5147
5148	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5149		return out, metadata, &smithy.SerializationError{Err: err}
5150	}
5151	in.Request = request
5152
5153	return next.HandleSerialize(ctx, in)
5154}
5155func awsRestjson1_serializeOpHttpBindingsGetRequestValidatorsInput(v *GetRequestValidatorsInput, encoder *httpbinding.Encoder) error {
5156	if v == nil {
5157		return fmt.Errorf("unsupported serialization of nil %T", v)
5158	}
5159
5160	if v.Limit != nil {
5161		encoder.SetQuery("limit").Integer(*v.Limit)
5162	}
5163
5164	if v.Position != nil {
5165		encoder.SetQuery("position").String(*v.Position)
5166	}
5167
5168	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5169		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5170	}
5171	if v.RestApiId != nil {
5172		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5173			return err
5174		}
5175	}
5176
5177	return nil
5178}
5179
5180type awsRestjson1_serializeOpGetResource struct {
5181}
5182
5183func (*awsRestjson1_serializeOpGetResource) ID() string {
5184	return "OperationSerializer"
5185}
5186
5187func (m *awsRestjson1_serializeOpGetResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5188	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5189) {
5190	request, ok := in.Request.(*smithyhttp.Request)
5191	if !ok {
5192		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5193	}
5194
5195	input, ok := in.Parameters.(*GetResourceInput)
5196	_ = input
5197	if !ok {
5198		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5199	}
5200
5201	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}")
5202	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5203	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5204	request.Method = "GET"
5205	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5206	if err != nil {
5207		return out, metadata, &smithy.SerializationError{Err: err}
5208	}
5209
5210	if err := awsRestjson1_serializeOpHttpBindingsGetResourceInput(input, restEncoder); err != nil {
5211		return out, metadata, &smithy.SerializationError{Err: err}
5212	}
5213
5214	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5215		return out, metadata, &smithy.SerializationError{Err: err}
5216	}
5217	in.Request = request
5218
5219	return next.HandleSerialize(ctx, in)
5220}
5221func awsRestjson1_serializeOpHttpBindingsGetResourceInput(v *GetResourceInput, encoder *httpbinding.Encoder) error {
5222	if v == nil {
5223		return fmt.Errorf("unsupported serialization of nil %T", v)
5224	}
5225
5226	if v.Embed != nil {
5227		for i := range v.Embed {
5228			encoder.AddQuery("embed").String(v.Embed[i])
5229		}
5230	}
5231
5232	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
5233		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
5234	}
5235	if v.ResourceId != nil {
5236		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
5237			return err
5238		}
5239	}
5240
5241	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5242		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5243	}
5244	if v.RestApiId != nil {
5245		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5246			return err
5247		}
5248	}
5249
5250	return nil
5251}
5252
5253type awsRestjson1_serializeOpGetResources struct {
5254}
5255
5256func (*awsRestjson1_serializeOpGetResources) ID() string {
5257	return "OperationSerializer"
5258}
5259
5260func (m *awsRestjson1_serializeOpGetResources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5261	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5262) {
5263	request, ok := in.Request.(*smithyhttp.Request)
5264	if !ok {
5265		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5266	}
5267
5268	input, ok := in.Parameters.(*GetResourcesInput)
5269	_ = input
5270	if !ok {
5271		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5272	}
5273
5274	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources")
5275	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5276	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5277	request.Method = "GET"
5278	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5279	if err != nil {
5280		return out, metadata, &smithy.SerializationError{Err: err}
5281	}
5282
5283	if err := awsRestjson1_serializeOpHttpBindingsGetResourcesInput(input, restEncoder); err != nil {
5284		return out, metadata, &smithy.SerializationError{Err: err}
5285	}
5286
5287	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5288		return out, metadata, &smithy.SerializationError{Err: err}
5289	}
5290	in.Request = request
5291
5292	return next.HandleSerialize(ctx, in)
5293}
5294func awsRestjson1_serializeOpHttpBindingsGetResourcesInput(v *GetResourcesInput, encoder *httpbinding.Encoder) error {
5295	if v == nil {
5296		return fmt.Errorf("unsupported serialization of nil %T", v)
5297	}
5298
5299	if v.Embed != nil {
5300		for i := range v.Embed {
5301			encoder.AddQuery("embed").String(v.Embed[i])
5302		}
5303	}
5304
5305	if v.Limit != nil {
5306		encoder.SetQuery("limit").Integer(*v.Limit)
5307	}
5308
5309	if v.Position != nil {
5310		encoder.SetQuery("position").String(*v.Position)
5311	}
5312
5313	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5314		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5315	}
5316	if v.RestApiId != nil {
5317		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5318			return err
5319		}
5320	}
5321
5322	return nil
5323}
5324
5325type awsRestjson1_serializeOpGetRestApi struct {
5326}
5327
5328func (*awsRestjson1_serializeOpGetRestApi) ID() string {
5329	return "OperationSerializer"
5330}
5331
5332func (m *awsRestjson1_serializeOpGetRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5333	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5334) {
5335	request, ok := in.Request.(*smithyhttp.Request)
5336	if !ok {
5337		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5338	}
5339
5340	input, ok := in.Parameters.(*GetRestApiInput)
5341	_ = input
5342	if !ok {
5343		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5344	}
5345
5346	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}")
5347	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5348	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5349	request.Method = "GET"
5350	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5351	if err != nil {
5352		return out, metadata, &smithy.SerializationError{Err: err}
5353	}
5354
5355	if err := awsRestjson1_serializeOpHttpBindingsGetRestApiInput(input, restEncoder); err != nil {
5356		return out, metadata, &smithy.SerializationError{Err: err}
5357	}
5358
5359	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5360		return out, metadata, &smithy.SerializationError{Err: err}
5361	}
5362	in.Request = request
5363
5364	return next.HandleSerialize(ctx, in)
5365}
5366func awsRestjson1_serializeOpHttpBindingsGetRestApiInput(v *GetRestApiInput, encoder *httpbinding.Encoder) error {
5367	if v == nil {
5368		return fmt.Errorf("unsupported serialization of nil %T", v)
5369	}
5370
5371	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5372		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5373	}
5374	if v.RestApiId != nil {
5375		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5376			return err
5377		}
5378	}
5379
5380	return nil
5381}
5382
5383type awsRestjson1_serializeOpGetRestApis struct {
5384}
5385
5386func (*awsRestjson1_serializeOpGetRestApis) ID() string {
5387	return "OperationSerializer"
5388}
5389
5390func (m *awsRestjson1_serializeOpGetRestApis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5391	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5392) {
5393	request, ok := in.Request.(*smithyhttp.Request)
5394	if !ok {
5395		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5396	}
5397
5398	input, ok := in.Parameters.(*GetRestApisInput)
5399	_ = input
5400	if !ok {
5401		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5402	}
5403
5404	opPath, opQuery := httpbinding.SplitURI("/restapis")
5405	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5406	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5407	request.Method = "GET"
5408	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5409	if err != nil {
5410		return out, metadata, &smithy.SerializationError{Err: err}
5411	}
5412
5413	if err := awsRestjson1_serializeOpHttpBindingsGetRestApisInput(input, restEncoder); err != nil {
5414		return out, metadata, &smithy.SerializationError{Err: err}
5415	}
5416
5417	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5418		return out, metadata, &smithy.SerializationError{Err: err}
5419	}
5420	in.Request = request
5421
5422	return next.HandleSerialize(ctx, in)
5423}
5424func awsRestjson1_serializeOpHttpBindingsGetRestApisInput(v *GetRestApisInput, encoder *httpbinding.Encoder) error {
5425	if v == nil {
5426		return fmt.Errorf("unsupported serialization of nil %T", v)
5427	}
5428
5429	if v.Limit != nil {
5430		encoder.SetQuery("limit").Integer(*v.Limit)
5431	}
5432
5433	if v.Position != nil {
5434		encoder.SetQuery("position").String(*v.Position)
5435	}
5436
5437	return nil
5438}
5439
5440type awsRestjson1_serializeOpGetSdk struct {
5441}
5442
5443func (*awsRestjson1_serializeOpGetSdk) ID() string {
5444	return "OperationSerializer"
5445}
5446
5447func (m *awsRestjson1_serializeOpGetSdk) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5448	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5449) {
5450	request, ok := in.Request.(*smithyhttp.Request)
5451	if !ok {
5452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5453	}
5454
5455	input, ok := in.Parameters.(*GetSdkInput)
5456	_ = input
5457	if !ok {
5458		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5459	}
5460
5461	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}")
5462	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5463	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5464	request.Method = "GET"
5465	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5466	if err != nil {
5467		return out, metadata, &smithy.SerializationError{Err: err}
5468	}
5469
5470	if err := awsRestjson1_serializeOpHttpBindingsGetSdkInput(input, restEncoder); err != nil {
5471		return out, metadata, &smithy.SerializationError{Err: err}
5472	}
5473
5474	restEncoder.SetHeader("Content-Type").String("application/json")
5475
5476	jsonEncoder := smithyjson.NewEncoder()
5477	if err := awsRestjson1_serializeOpDocumentGetSdkInput(input, jsonEncoder.Value); err != nil {
5478		return out, metadata, &smithy.SerializationError{Err: err}
5479	}
5480
5481	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5482		return out, metadata, &smithy.SerializationError{Err: err}
5483	}
5484
5485	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5486		return out, metadata, &smithy.SerializationError{Err: err}
5487	}
5488	in.Request = request
5489
5490	return next.HandleSerialize(ctx, in)
5491}
5492func awsRestjson1_serializeOpHttpBindingsGetSdkInput(v *GetSdkInput, encoder *httpbinding.Encoder) error {
5493	if v == nil {
5494		return fmt.Errorf("unsupported serialization of nil %T", v)
5495	}
5496
5497	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5498		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5499	}
5500	if v.RestApiId != nil {
5501		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5502			return err
5503		}
5504	}
5505
5506	if v.SdkType == nil || len(*v.SdkType) == 0 {
5507		return &smithy.SerializationError{Err: fmt.Errorf("input member sdkType must not be empty")}
5508	}
5509	if v.SdkType != nil {
5510		if err := encoder.SetURI("sdkType").String(*v.SdkType); err != nil {
5511			return err
5512		}
5513	}
5514
5515	if v.StageName == nil || len(*v.StageName) == 0 {
5516		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
5517	}
5518	if v.StageName != nil {
5519		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
5520			return err
5521		}
5522	}
5523
5524	return nil
5525}
5526
5527func awsRestjson1_serializeOpDocumentGetSdkInput(v *GetSdkInput, value smithyjson.Value) error {
5528	object := value.Object()
5529	defer object.Close()
5530
5531	if v.Parameters != nil {
5532		ok := object.Key("parameters")
5533		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Parameters, ok); err != nil {
5534			return err
5535		}
5536	}
5537
5538	return nil
5539}
5540
5541type awsRestjson1_serializeOpGetSdkType struct {
5542}
5543
5544func (*awsRestjson1_serializeOpGetSdkType) ID() string {
5545	return "OperationSerializer"
5546}
5547
5548func (m *awsRestjson1_serializeOpGetSdkType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5549	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5550) {
5551	request, ok := in.Request.(*smithyhttp.Request)
5552	if !ok {
5553		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5554	}
5555
5556	input, ok := in.Parameters.(*GetSdkTypeInput)
5557	_ = input
5558	if !ok {
5559		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5560	}
5561
5562	opPath, opQuery := httpbinding.SplitURI("/sdktypes/{id}")
5563	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5564	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5565	request.Method = "GET"
5566	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5567	if err != nil {
5568		return out, metadata, &smithy.SerializationError{Err: err}
5569	}
5570
5571	if err := awsRestjson1_serializeOpHttpBindingsGetSdkTypeInput(input, restEncoder); err != nil {
5572		return out, metadata, &smithy.SerializationError{Err: err}
5573	}
5574
5575	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5576		return out, metadata, &smithy.SerializationError{Err: err}
5577	}
5578	in.Request = request
5579
5580	return next.HandleSerialize(ctx, in)
5581}
5582func awsRestjson1_serializeOpHttpBindingsGetSdkTypeInput(v *GetSdkTypeInput, encoder *httpbinding.Encoder) error {
5583	if v == nil {
5584		return fmt.Errorf("unsupported serialization of nil %T", v)
5585	}
5586
5587	if v.Id == nil || len(*v.Id) == 0 {
5588		return &smithy.SerializationError{Err: fmt.Errorf("input member id must not be empty")}
5589	}
5590	if v.Id != nil {
5591		if err := encoder.SetURI("id").String(*v.Id); err != nil {
5592			return err
5593		}
5594	}
5595
5596	return nil
5597}
5598
5599type awsRestjson1_serializeOpGetSdkTypes struct {
5600}
5601
5602func (*awsRestjson1_serializeOpGetSdkTypes) ID() string {
5603	return "OperationSerializer"
5604}
5605
5606func (m *awsRestjson1_serializeOpGetSdkTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5607	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5608) {
5609	request, ok := in.Request.(*smithyhttp.Request)
5610	if !ok {
5611		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5612	}
5613
5614	input, ok := in.Parameters.(*GetSdkTypesInput)
5615	_ = input
5616	if !ok {
5617		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5618	}
5619
5620	opPath, opQuery := httpbinding.SplitURI("/sdktypes")
5621	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5622	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5623	request.Method = "GET"
5624	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5625	if err != nil {
5626		return out, metadata, &smithy.SerializationError{Err: err}
5627	}
5628
5629	if err := awsRestjson1_serializeOpHttpBindingsGetSdkTypesInput(input, restEncoder); err != nil {
5630		return out, metadata, &smithy.SerializationError{Err: err}
5631	}
5632
5633	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5634		return out, metadata, &smithy.SerializationError{Err: err}
5635	}
5636	in.Request = request
5637
5638	return next.HandleSerialize(ctx, in)
5639}
5640func awsRestjson1_serializeOpHttpBindingsGetSdkTypesInput(v *GetSdkTypesInput, encoder *httpbinding.Encoder) error {
5641	if v == nil {
5642		return fmt.Errorf("unsupported serialization of nil %T", v)
5643	}
5644
5645	if v.Limit != nil {
5646		encoder.SetQuery("limit").Integer(*v.Limit)
5647	}
5648
5649	if v.Position != nil {
5650		encoder.SetQuery("position").String(*v.Position)
5651	}
5652
5653	return nil
5654}
5655
5656type awsRestjson1_serializeOpGetStage struct {
5657}
5658
5659func (*awsRestjson1_serializeOpGetStage) ID() string {
5660	return "OperationSerializer"
5661}
5662
5663func (m *awsRestjson1_serializeOpGetStage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5664	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5665) {
5666	request, ok := in.Request.(*smithyhttp.Request)
5667	if !ok {
5668		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5669	}
5670
5671	input, ok := in.Parameters.(*GetStageInput)
5672	_ = input
5673	if !ok {
5674		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5675	}
5676
5677	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}")
5678	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5679	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5680	request.Method = "GET"
5681	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5682	if err != nil {
5683		return out, metadata, &smithy.SerializationError{Err: err}
5684	}
5685
5686	if err := awsRestjson1_serializeOpHttpBindingsGetStageInput(input, restEncoder); err != nil {
5687		return out, metadata, &smithy.SerializationError{Err: err}
5688	}
5689
5690	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5691		return out, metadata, &smithy.SerializationError{Err: err}
5692	}
5693	in.Request = request
5694
5695	return next.HandleSerialize(ctx, in)
5696}
5697func awsRestjson1_serializeOpHttpBindingsGetStageInput(v *GetStageInput, encoder *httpbinding.Encoder) error {
5698	if v == nil {
5699		return fmt.Errorf("unsupported serialization of nil %T", v)
5700	}
5701
5702	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5703		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5704	}
5705	if v.RestApiId != nil {
5706		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5707			return err
5708		}
5709	}
5710
5711	if v.StageName == nil || len(*v.StageName) == 0 {
5712		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
5713	}
5714	if v.StageName != nil {
5715		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
5716			return err
5717		}
5718	}
5719
5720	return nil
5721}
5722
5723type awsRestjson1_serializeOpGetStages struct {
5724}
5725
5726func (*awsRestjson1_serializeOpGetStages) ID() string {
5727	return "OperationSerializer"
5728}
5729
5730func (m *awsRestjson1_serializeOpGetStages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5731	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5732) {
5733	request, ok := in.Request.(*smithyhttp.Request)
5734	if !ok {
5735		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5736	}
5737
5738	input, ok := in.Parameters.(*GetStagesInput)
5739	_ = input
5740	if !ok {
5741		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5742	}
5743
5744	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages")
5745	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5746	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5747	request.Method = "GET"
5748	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5749	if err != nil {
5750		return out, metadata, &smithy.SerializationError{Err: err}
5751	}
5752
5753	if err := awsRestjson1_serializeOpHttpBindingsGetStagesInput(input, restEncoder); err != nil {
5754		return out, metadata, &smithy.SerializationError{Err: err}
5755	}
5756
5757	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5758		return out, metadata, &smithy.SerializationError{Err: err}
5759	}
5760	in.Request = request
5761
5762	return next.HandleSerialize(ctx, in)
5763}
5764func awsRestjson1_serializeOpHttpBindingsGetStagesInput(v *GetStagesInput, encoder *httpbinding.Encoder) error {
5765	if v == nil {
5766		return fmt.Errorf("unsupported serialization of nil %T", v)
5767	}
5768
5769	if v.DeploymentId != nil {
5770		encoder.SetQuery("deploymentId").String(*v.DeploymentId)
5771	}
5772
5773	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
5774		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
5775	}
5776	if v.RestApiId != nil {
5777		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
5778			return err
5779		}
5780	}
5781
5782	return nil
5783}
5784
5785type awsRestjson1_serializeOpGetTags struct {
5786}
5787
5788func (*awsRestjson1_serializeOpGetTags) ID() string {
5789	return "OperationSerializer"
5790}
5791
5792func (m *awsRestjson1_serializeOpGetTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5793	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5794) {
5795	request, ok := in.Request.(*smithyhttp.Request)
5796	if !ok {
5797		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5798	}
5799
5800	input, ok := in.Parameters.(*GetTagsInput)
5801	_ = input
5802	if !ok {
5803		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5804	}
5805
5806	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
5807	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5808	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5809	request.Method = "GET"
5810	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5811	if err != nil {
5812		return out, metadata, &smithy.SerializationError{Err: err}
5813	}
5814
5815	if err := awsRestjson1_serializeOpHttpBindingsGetTagsInput(input, restEncoder); err != nil {
5816		return out, metadata, &smithy.SerializationError{Err: err}
5817	}
5818
5819	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5820		return out, metadata, &smithy.SerializationError{Err: err}
5821	}
5822	in.Request = request
5823
5824	return next.HandleSerialize(ctx, in)
5825}
5826func awsRestjson1_serializeOpHttpBindingsGetTagsInput(v *GetTagsInput, encoder *httpbinding.Encoder) error {
5827	if v == nil {
5828		return fmt.Errorf("unsupported serialization of nil %T", v)
5829	}
5830
5831	if v.Limit != nil {
5832		encoder.SetQuery("limit").Integer(*v.Limit)
5833	}
5834
5835	if v.Position != nil {
5836		encoder.SetQuery("position").String(*v.Position)
5837	}
5838
5839	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
5840		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
5841	}
5842	if v.ResourceArn != nil {
5843		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
5844			return err
5845		}
5846	}
5847
5848	return nil
5849}
5850
5851type awsRestjson1_serializeOpGetUsage struct {
5852}
5853
5854func (*awsRestjson1_serializeOpGetUsage) ID() string {
5855	return "OperationSerializer"
5856}
5857
5858func (m *awsRestjson1_serializeOpGetUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5859	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5860) {
5861	request, ok := in.Request.(*smithyhttp.Request)
5862	if !ok {
5863		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5864	}
5865
5866	input, ok := in.Parameters.(*GetUsageInput)
5867	_ = input
5868	if !ok {
5869		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5870	}
5871
5872	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/usage")
5873	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5874	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5875	request.Method = "GET"
5876	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5877	if err != nil {
5878		return out, metadata, &smithy.SerializationError{Err: err}
5879	}
5880
5881	if err := awsRestjson1_serializeOpHttpBindingsGetUsageInput(input, restEncoder); err != nil {
5882		return out, metadata, &smithy.SerializationError{Err: err}
5883	}
5884
5885	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5886		return out, metadata, &smithy.SerializationError{Err: err}
5887	}
5888	in.Request = request
5889
5890	return next.HandleSerialize(ctx, in)
5891}
5892func awsRestjson1_serializeOpHttpBindingsGetUsageInput(v *GetUsageInput, encoder *httpbinding.Encoder) error {
5893	if v == nil {
5894		return fmt.Errorf("unsupported serialization of nil %T", v)
5895	}
5896
5897	if v.EndDate != nil {
5898		encoder.SetQuery("endDate").String(*v.EndDate)
5899	}
5900
5901	if v.KeyId != nil {
5902		encoder.SetQuery("keyId").String(*v.KeyId)
5903	}
5904
5905	if v.Limit != nil {
5906		encoder.SetQuery("limit").Integer(*v.Limit)
5907	}
5908
5909	if v.Position != nil {
5910		encoder.SetQuery("position").String(*v.Position)
5911	}
5912
5913	if v.StartDate != nil {
5914		encoder.SetQuery("startDate").String(*v.StartDate)
5915	}
5916
5917	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
5918		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
5919	}
5920	if v.UsagePlanId != nil {
5921		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
5922			return err
5923		}
5924	}
5925
5926	return nil
5927}
5928
5929type awsRestjson1_serializeOpGetUsagePlan struct {
5930}
5931
5932func (*awsRestjson1_serializeOpGetUsagePlan) ID() string {
5933	return "OperationSerializer"
5934}
5935
5936func (m *awsRestjson1_serializeOpGetUsagePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5937	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5938) {
5939	request, ok := in.Request.(*smithyhttp.Request)
5940	if !ok {
5941		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5942	}
5943
5944	input, ok := in.Parameters.(*GetUsagePlanInput)
5945	_ = input
5946	if !ok {
5947		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5948	}
5949
5950	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}")
5951	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5952	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5953	request.Method = "GET"
5954	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5955	if err != nil {
5956		return out, metadata, &smithy.SerializationError{Err: err}
5957	}
5958
5959	if err := awsRestjson1_serializeOpHttpBindingsGetUsagePlanInput(input, restEncoder); err != nil {
5960		return out, metadata, &smithy.SerializationError{Err: err}
5961	}
5962
5963	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5964		return out, metadata, &smithy.SerializationError{Err: err}
5965	}
5966	in.Request = request
5967
5968	return next.HandleSerialize(ctx, in)
5969}
5970func awsRestjson1_serializeOpHttpBindingsGetUsagePlanInput(v *GetUsagePlanInput, encoder *httpbinding.Encoder) error {
5971	if v == nil {
5972		return fmt.Errorf("unsupported serialization of nil %T", v)
5973	}
5974
5975	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
5976		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
5977	}
5978	if v.UsagePlanId != nil {
5979		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
5980			return err
5981		}
5982	}
5983
5984	return nil
5985}
5986
5987type awsRestjson1_serializeOpGetUsagePlanKey struct {
5988}
5989
5990func (*awsRestjson1_serializeOpGetUsagePlanKey) ID() string {
5991	return "OperationSerializer"
5992}
5993
5994func (m *awsRestjson1_serializeOpGetUsagePlanKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5995	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5996) {
5997	request, ok := in.Request.(*smithyhttp.Request)
5998	if !ok {
5999		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6000	}
6001
6002	input, ok := in.Parameters.(*GetUsagePlanKeyInput)
6003	_ = input
6004	if !ok {
6005		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6006	}
6007
6008	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/keys/{keyId}")
6009	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6010	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6011	request.Method = "GET"
6012	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6013	if err != nil {
6014		return out, metadata, &smithy.SerializationError{Err: err}
6015	}
6016
6017	if err := awsRestjson1_serializeOpHttpBindingsGetUsagePlanKeyInput(input, restEncoder); err != nil {
6018		return out, metadata, &smithy.SerializationError{Err: err}
6019	}
6020
6021	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6022		return out, metadata, &smithy.SerializationError{Err: err}
6023	}
6024	in.Request = request
6025
6026	return next.HandleSerialize(ctx, in)
6027}
6028func awsRestjson1_serializeOpHttpBindingsGetUsagePlanKeyInput(v *GetUsagePlanKeyInput, encoder *httpbinding.Encoder) error {
6029	if v == nil {
6030		return fmt.Errorf("unsupported serialization of nil %T", v)
6031	}
6032
6033	if v.KeyId == nil || len(*v.KeyId) == 0 {
6034		return &smithy.SerializationError{Err: fmt.Errorf("input member keyId must not be empty")}
6035	}
6036	if v.KeyId != nil {
6037		if err := encoder.SetURI("keyId").String(*v.KeyId); err != nil {
6038			return err
6039		}
6040	}
6041
6042	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
6043		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
6044	}
6045	if v.UsagePlanId != nil {
6046		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
6047			return err
6048		}
6049	}
6050
6051	return nil
6052}
6053
6054type awsRestjson1_serializeOpGetUsagePlanKeys struct {
6055}
6056
6057func (*awsRestjson1_serializeOpGetUsagePlanKeys) ID() string {
6058	return "OperationSerializer"
6059}
6060
6061func (m *awsRestjson1_serializeOpGetUsagePlanKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6062	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6063) {
6064	request, ok := in.Request.(*smithyhttp.Request)
6065	if !ok {
6066		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6067	}
6068
6069	input, ok := in.Parameters.(*GetUsagePlanKeysInput)
6070	_ = input
6071	if !ok {
6072		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6073	}
6074
6075	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/keys")
6076	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6077	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6078	request.Method = "GET"
6079	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6080	if err != nil {
6081		return out, metadata, &smithy.SerializationError{Err: err}
6082	}
6083
6084	if err := awsRestjson1_serializeOpHttpBindingsGetUsagePlanKeysInput(input, restEncoder); err != nil {
6085		return out, metadata, &smithy.SerializationError{Err: err}
6086	}
6087
6088	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6089		return out, metadata, &smithy.SerializationError{Err: err}
6090	}
6091	in.Request = request
6092
6093	return next.HandleSerialize(ctx, in)
6094}
6095func awsRestjson1_serializeOpHttpBindingsGetUsagePlanKeysInput(v *GetUsagePlanKeysInput, encoder *httpbinding.Encoder) error {
6096	if v == nil {
6097		return fmt.Errorf("unsupported serialization of nil %T", v)
6098	}
6099
6100	if v.Limit != nil {
6101		encoder.SetQuery("limit").Integer(*v.Limit)
6102	}
6103
6104	if v.NameQuery != nil {
6105		encoder.SetQuery("name").String(*v.NameQuery)
6106	}
6107
6108	if v.Position != nil {
6109		encoder.SetQuery("position").String(*v.Position)
6110	}
6111
6112	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
6113		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
6114	}
6115	if v.UsagePlanId != nil {
6116		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
6117			return err
6118		}
6119	}
6120
6121	return nil
6122}
6123
6124type awsRestjson1_serializeOpGetUsagePlans struct {
6125}
6126
6127func (*awsRestjson1_serializeOpGetUsagePlans) ID() string {
6128	return "OperationSerializer"
6129}
6130
6131func (m *awsRestjson1_serializeOpGetUsagePlans) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6132	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6133) {
6134	request, ok := in.Request.(*smithyhttp.Request)
6135	if !ok {
6136		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6137	}
6138
6139	input, ok := in.Parameters.(*GetUsagePlansInput)
6140	_ = input
6141	if !ok {
6142		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6143	}
6144
6145	opPath, opQuery := httpbinding.SplitURI("/usageplans")
6146	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6147	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6148	request.Method = "GET"
6149	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6150	if err != nil {
6151		return out, metadata, &smithy.SerializationError{Err: err}
6152	}
6153
6154	if err := awsRestjson1_serializeOpHttpBindingsGetUsagePlansInput(input, restEncoder); err != nil {
6155		return out, metadata, &smithy.SerializationError{Err: err}
6156	}
6157
6158	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6159		return out, metadata, &smithy.SerializationError{Err: err}
6160	}
6161	in.Request = request
6162
6163	return next.HandleSerialize(ctx, in)
6164}
6165func awsRestjson1_serializeOpHttpBindingsGetUsagePlansInput(v *GetUsagePlansInput, encoder *httpbinding.Encoder) error {
6166	if v == nil {
6167		return fmt.Errorf("unsupported serialization of nil %T", v)
6168	}
6169
6170	if v.KeyId != nil {
6171		encoder.SetQuery("keyId").String(*v.KeyId)
6172	}
6173
6174	if v.Limit != nil {
6175		encoder.SetQuery("limit").Integer(*v.Limit)
6176	}
6177
6178	if v.Position != nil {
6179		encoder.SetQuery("position").String(*v.Position)
6180	}
6181
6182	return nil
6183}
6184
6185type awsRestjson1_serializeOpGetVpcLink struct {
6186}
6187
6188func (*awsRestjson1_serializeOpGetVpcLink) ID() string {
6189	return "OperationSerializer"
6190}
6191
6192func (m *awsRestjson1_serializeOpGetVpcLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6193	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6194) {
6195	request, ok := in.Request.(*smithyhttp.Request)
6196	if !ok {
6197		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6198	}
6199
6200	input, ok := in.Parameters.(*GetVpcLinkInput)
6201	_ = input
6202	if !ok {
6203		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6204	}
6205
6206	opPath, opQuery := httpbinding.SplitURI("/vpclinks/{vpcLinkId}")
6207	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6208	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6209	request.Method = "GET"
6210	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6211	if err != nil {
6212		return out, metadata, &smithy.SerializationError{Err: err}
6213	}
6214
6215	if err := awsRestjson1_serializeOpHttpBindingsGetVpcLinkInput(input, restEncoder); err != nil {
6216		return out, metadata, &smithy.SerializationError{Err: err}
6217	}
6218
6219	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6220		return out, metadata, &smithy.SerializationError{Err: err}
6221	}
6222	in.Request = request
6223
6224	return next.HandleSerialize(ctx, in)
6225}
6226func awsRestjson1_serializeOpHttpBindingsGetVpcLinkInput(v *GetVpcLinkInput, encoder *httpbinding.Encoder) error {
6227	if v == nil {
6228		return fmt.Errorf("unsupported serialization of nil %T", v)
6229	}
6230
6231	if v.VpcLinkId == nil || len(*v.VpcLinkId) == 0 {
6232		return &smithy.SerializationError{Err: fmt.Errorf("input member vpcLinkId must not be empty")}
6233	}
6234	if v.VpcLinkId != nil {
6235		if err := encoder.SetURI("vpcLinkId").String(*v.VpcLinkId); err != nil {
6236			return err
6237		}
6238	}
6239
6240	return nil
6241}
6242
6243type awsRestjson1_serializeOpGetVpcLinks struct {
6244}
6245
6246func (*awsRestjson1_serializeOpGetVpcLinks) ID() string {
6247	return "OperationSerializer"
6248}
6249
6250func (m *awsRestjson1_serializeOpGetVpcLinks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6251	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6252) {
6253	request, ok := in.Request.(*smithyhttp.Request)
6254	if !ok {
6255		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6256	}
6257
6258	input, ok := in.Parameters.(*GetVpcLinksInput)
6259	_ = input
6260	if !ok {
6261		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6262	}
6263
6264	opPath, opQuery := httpbinding.SplitURI("/vpclinks")
6265	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6266	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6267	request.Method = "GET"
6268	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6269	if err != nil {
6270		return out, metadata, &smithy.SerializationError{Err: err}
6271	}
6272
6273	if err := awsRestjson1_serializeOpHttpBindingsGetVpcLinksInput(input, restEncoder); err != nil {
6274		return out, metadata, &smithy.SerializationError{Err: err}
6275	}
6276
6277	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6278		return out, metadata, &smithy.SerializationError{Err: err}
6279	}
6280	in.Request = request
6281
6282	return next.HandleSerialize(ctx, in)
6283}
6284func awsRestjson1_serializeOpHttpBindingsGetVpcLinksInput(v *GetVpcLinksInput, encoder *httpbinding.Encoder) error {
6285	if v == nil {
6286		return fmt.Errorf("unsupported serialization of nil %T", v)
6287	}
6288
6289	if v.Limit != nil {
6290		encoder.SetQuery("limit").Integer(*v.Limit)
6291	}
6292
6293	if v.Position != nil {
6294		encoder.SetQuery("position").String(*v.Position)
6295	}
6296
6297	return nil
6298}
6299
6300type awsRestjson1_serializeOpImportApiKeys struct {
6301}
6302
6303func (*awsRestjson1_serializeOpImportApiKeys) ID() string {
6304	return "OperationSerializer"
6305}
6306
6307func (m *awsRestjson1_serializeOpImportApiKeys) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6308	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6309) {
6310	request, ok := in.Request.(*smithyhttp.Request)
6311	if !ok {
6312		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6313	}
6314
6315	input, ok := in.Parameters.(*ImportApiKeysInput)
6316	_ = input
6317	if !ok {
6318		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6319	}
6320
6321	opPath, opQuery := httpbinding.SplitURI("/apikeys?mode=import")
6322	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6323	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6324	request.Method = "POST"
6325	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6326	if err != nil {
6327		return out, metadata, &smithy.SerializationError{Err: err}
6328	}
6329
6330	if err := awsRestjson1_serializeOpHttpBindingsImportApiKeysInput(input, restEncoder); err != nil {
6331		return out, metadata, &smithy.SerializationError{Err: err}
6332	}
6333
6334	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6335		return out, metadata, &smithy.SerializationError{Err: err}
6336	}
6337	in.Request = request
6338
6339	return next.HandleSerialize(ctx, in)
6340}
6341func awsRestjson1_serializeOpHttpBindingsImportApiKeysInput(v *ImportApiKeysInput, encoder *httpbinding.Encoder) error {
6342	if v == nil {
6343		return fmt.Errorf("unsupported serialization of nil %T", v)
6344	}
6345
6346	if v.FailOnWarnings {
6347		encoder.SetQuery("failonwarnings").Boolean(v.FailOnWarnings)
6348	}
6349
6350	if len(v.Format) > 0 {
6351		encoder.SetQuery("format").String(string(v.Format))
6352	}
6353
6354	return nil
6355}
6356
6357type awsRestjson1_serializeOpImportDocumentationParts struct {
6358}
6359
6360func (*awsRestjson1_serializeOpImportDocumentationParts) ID() string {
6361	return "OperationSerializer"
6362}
6363
6364func (m *awsRestjson1_serializeOpImportDocumentationParts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6365	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6366) {
6367	request, ok := in.Request.(*smithyhttp.Request)
6368	if !ok {
6369		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6370	}
6371
6372	input, ok := in.Parameters.(*ImportDocumentationPartsInput)
6373	_ = input
6374	if !ok {
6375		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6376	}
6377
6378	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts")
6379	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6380	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6381	request.Method = "PUT"
6382	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6383	if err != nil {
6384		return out, metadata, &smithy.SerializationError{Err: err}
6385	}
6386
6387	if err := awsRestjson1_serializeOpHttpBindingsImportDocumentationPartsInput(input, restEncoder); err != nil {
6388		return out, metadata, &smithy.SerializationError{Err: err}
6389	}
6390
6391	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6392		return out, metadata, &smithy.SerializationError{Err: err}
6393	}
6394	in.Request = request
6395
6396	return next.HandleSerialize(ctx, in)
6397}
6398func awsRestjson1_serializeOpHttpBindingsImportDocumentationPartsInput(v *ImportDocumentationPartsInput, encoder *httpbinding.Encoder) error {
6399	if v == nil {
6400		return fmt.Errorf("unsupported serialization of nil %T", v)
6401	}
6402
6403	if v.FailOnWarnings {
6404		encoder.SetQuery("failonwarnings").Boolean(v.FailOnWarnings)
6405	}
6406
6407	if len(v.Mode) > 0 {
6408		encoder.SetQuery("mode").String(string(v.Mode))
6409	}
6410
6411	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
6412		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
6413	}
6414	if v.RestApiId != nil {
6415		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
6416			return err
6417		}
6418	}
6419
6420	return nil
6421}
6422
6423type awsRestjson1_serializeOpImportRestApi struct {
6424}
6425
6426func (*awsRestjson1_serializeOpImportRestApi) ID() string {
6427	return "OperationSerializer"
6428}
6429
6430func (m *awsRestjson1_serializeOpImportRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6431	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6432) {
6433	request, ok := in.Request.(*smithyhttp.Request)
6434	if !ok {
6435		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6436	}
6437
6438	input, ok := in.Parameters.(*ImportRestApiInput)
6439	_ = input
6440	if !ok {
6441		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6442	}
6443
6444	opPath, opQuery := httpbinding.SplitURI("/restapis?mode=import")
6445	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6446	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6447	request.Method = "POST"
6448	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6449	if err != nil {
6450		return out, metadata, &smithy.SerializationError{Err: err}
6451	}
6452
6453	if err := awsRestjson1_serializeOpHttpBindingsImportRestApiInput(input, restEncoder); err != nil {
6454		return out, metadata, &smithy.SerializationError{Err: err}
6455	}
6456
6457	restEncoder.SetHeader("Content-Type").String("application/json")
6458
6459	jsonEncoder := smithyjson.NewEncoder()
6460	if err := awsRestjson1_serializeOpDocumentImportRestApiInput(input, jsonEncoder.Value); err != nil {
6461		return out, metadata, &smithy.SerializationError{Err: err}
6462	}
6463
6464	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6465		return out, metadata, &smithy.SerializationError{Err: err}
6466	}
6467
6468	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6469		return out, metadata, &smithy.SerializationError{Err: err}
6470	}
6471	in.Request = request
6472
6473	return next.HandleSerialize(ctx, in)
6474}
6475func awsRestjson1_serializeOpHttpBindingsImportRestApiInput(v *ImportRestApiInput, encoder *httpbinding.Encoder) error {
6476	if v == nil {
6477		return fmt.Errorf("unsupported serialization of nil %T", v)
6478	}
6479
6480	if v.FailOnWarnings {
6481		encoder.SetQuery("failonwarnings").Boolean(v.FailOnWarnings)
6482	}
6483
6484	return nil
6485}
6486
6487func awsRestjson1_serializeOpDocumentImportRestApiInput(v *ImportRestApiInput, value smithyjson.Value) error {
6488	object := value.Object()
6489	defer object.Close()
6490
6491	if v.Parameters != nil {
6492		ok := object.Key("parameters")
6493		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Parameters, ok); err != nil {
6494			return err
6495		}
6496	}
6497
6498	return nil
6499}
6500
6501type awsRestjson1_serializeOpPutGatewayResponse struct {
6502}
6503
6504func (*awsRestjson1_serializeOpPutGatewayResponse) ID() string {
6505	return "OperationSerializer"
6506}
6507
6508func (m *awsRestjson1_serializeOpPutGatewayResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6509	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6510) {
6511	request, ok := in.Request.(*smithyhttp.Request)
6512	if !ok {
6513		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6514	}
6515
6516	input, ok := in.Parameters.(*PutGatewayResponseInput)
6517	_ = input
6518	if !ok {
6519		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6520	}
6521
6522	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/gatewayresponses/{responseType}")
6523	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6524	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6525	request.Method = "PUT"
6526	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6527	if err != nil {
6528		return out, metadata, &smithy.SerializationError{Err: err}
6529	}
6530
6531	if err := awsRestjson1_serializeOpHttpBindingsPutGatewayResponseInput(input, restEncoder); err != nil {
6532		return out, metadata, &smithy.SerializationError{Err: err}
6533	}
6534
6535	restEncoder.SetHeader("Content-Type").String("application/json")
6536
6537	jsonEncoder := smithyjson.NewEncoder()
6538	if err := awsRestjson1_serializeOpDocumentPutGatewayResponseInput(input, jsonEncoder.Value); err != nil {
6539		return out, metadata, &smithy.SerializationError{Err: err}
6540	}
6541
6542	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6543		return out, metadata, &smithy.SerializationError{Err: err}
6544	}
6545
6546	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6547		return out, metadata, &smithy.SerializationError{Err: err}
6548	}
6549	in.Request = request
6550
6551	return next.HandleSerialize(ctx, in)
6552}
6553func awsRestjson1_serializeOpHttpBindingsPutGatewayResponseInput(v *PutGatewayResponseInput, encoder *httpbinding.Encoder) error {
6554	if v == nil {
6555		return fmt.Errorf("unsupported serialization of nil %T", v)
6556	}
6557
6558	if len(v.ResponseType) == 0 {
6559		return &smithy.SerializationError{Err: fmt.Errorf("input member responseType must not be empty")}
6560	}
6561	if len(v.ResponseType) > 0 {
6562		if err := encoder.SetURI("responseType").String(string(v.ResponseType)); err != nil {
6563			return err
6564		}
6565	}
6566
6567	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
6568		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
6569	}
6570	if v.RestApiId != nil {
6571		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
6572			return err
6573		}
6574	}
6575
6576	return nil
6577}
6578
6579func awsRestjson1_serializeOpDocumentPutGatewayResponseInput(v *PutGatewayResponseInput, value smithyjson.Value) error {
6580	object := value.Object()
6581	defer object.Close()
6582
6583	if v.ResponseParameters != nil {
6584		ok := object.Key("responseParameters")
6585		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.ResponseParameters, ok); err != nil {
6586			return err
6587		}
6588	}
6589
6590	if v.ResponseTemplates != nil {
6591		ok := object.Key("responseTemplates")
6592		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.ResponseTemplates, ok); err != nil {
6593			return err
6594		}
6595	}
6596
6597	if v.StatusCode != nil {
6598		ok := object.Key("statusCode")
6599		ok.String(*v.StatusCode)
6600	}
6601
6602	return nil
6603}
6604
6605type awsRestjson1_serializeOpPutIntegration struct {
6606}
6607
6608func (*awsRestjson1_serializeOpPutIntegration) ID() string {
6609	return "OperationSerializer"
6610}
6611
6612func (m *awsRestjson1_serializeOpPutIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6613	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6614) {
6615	request, ok := in.Request.(*smithyhttp.Request)
6616	if !ok {
6617		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6618	}
6619
6620	input, ok := in.Parameters.(*PutIntegrationInput)
6621	_ = input
6622	if !ok {
6623		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6624	}
6625
6626	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration")
6627	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6628	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6629	request.Method = "PUT"
6630	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6631	if err != nil {
6632		return out, metadata, &smithy.SerializationError{Err: err}
6633	}
6634
6635	if err := awsRestjson1_serializeOpHttpBindingsPutIntegrationInput(input, restEncoder); err != nil {
6636		return out, metadata, &smithy.SerializationError{Err: err}
6637	}
6638
6639	restEncoder.SetHeader("Content-Type").String("application/json")
6640
6641	jsonEncoder := smithyjson.NewEncoder()
6642	if err := awsRestjson1_serializeOpDocumentPutIntegrationInput(input, jsonEncoder.Value); err != nil {
6643		return out, metadata, &smithy.SerializationError{Err: err}
6644	}
6645
6646	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6647		return out, metadata, &smithy.SerializationError{Err: err}
6648	}
6649
6650	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6651		return out, metadata, &smithy.SerializationError{Err: err}
6652	}
6653	in.Request = request
6654
6655	return next.HandleSerialize(ctx, in)
6656}
6657func awsRestjson1_serializeOpHttpBindingsPutIntegrationInput(v *PutIntegrationInput, encoder *httpbinding.Encoder) error {
6658	if v == nil {
6659		return fmt.Errorf("unsupported serialization of nil %T", v)
6660	}
6661
6662	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
6663		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
6664	}
6665	if v.HttpMethod != nil {
6666		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
6667			return err
6668		}
6669	}
6670
6671	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
6672		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
6673	}
6674	if v.ResourceId != nil {
6675		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
6676			return err
6677		}
6678	}
6679
6680	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
6681		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
6682	}
6683	if v.RestApiId != nil {
6684		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
6685			return err
6686		}
6687	}
6688
6689	return nil
6690}
6691
6692func awsRestjson1_serializeOpDocumentPutIntegrationInput(v *PutIntegrationInput, value smithyjson.Value) error {
6693	object := value.Object()
6694	defer object.Close()
6695
6696	if v.CacheKeyParameters != nil {
6697		ok := object.Key("cacheKeyParameters")
6698		if err := awsRestjson1_serializeDocumentListOfString(v.CacheKeyParameters, ok); err != nil {
6699			return err
6700		}
6701	}
6702
6703	if v.CacheNamespace != nil {
6704		ok := object.Key("cacheNamespace")
6705		ok.String(*v.CacheNamespace)
6706	}
6707
6708	if v.ConnectionId != nil {
6709		ok := object.Key("connectionId")
6710		ok.String(*v.ConnectionId)
6711	}
6712
6713	if len(v.ConnectionType) > 0 {
6714		ok := object.Key("connectionType")
6715		ok.String(string(v.ConnectionType))
6716	}
6717
6718	if len(v.ContentHandling) > 0 {
6719		ok := object.Key("contentHandling")
6720		ok.String(string(v.ContentHandling))
6721	}
6722
6723	if v.Credentials != nil {
6724		ok := object.Key("credentials")
6725		ok.String(*v.Credentials)
6726	}
6727
6728	if v.IntegrationHttpMethod != nil {
6729		ok := object.Key("httpMethod")
6730		ok.String(*v.IntegrationHttpMethod)
6731	}
6732
6733	if v.PassthroughBehavior != nil {
6734		ok := object.Key("passthroughBehavior")
6735		ok.String(*v.PassthroughBehavior)
6736	}
6737
6738	if v.RequestParameters != nil {
6739		ok := object.Key("requestParameters")
6740		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.RequestParameters, ok); err != nil {
6741			return err
6742		}
6743	}
6744
6745	if v.RequestTemplates != nil {
6746		ok := object.Key("requestTemplates")
6747		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.RequestTemplates, ok); err != nil {
6748			return err
6749		}
6750	}
6751
6752	if v.TimeoutInMillis != nil {
6753		ok := object.Key("timeoutInMillis")
6754		ok.Integer(*v.TimeoutInMillis)
6755	}
6756
6757	if v.TlsConfig != nil {
6758		ok := object.Key("tlsConfig")
6759		if err := awsRestjson1_serializeDocumentTlsConfig(v.TlsConfig, ok); err != nil {
6760			return err
6761		}
6762	}
6763
6764	if len(v.Type) > 0 {
6765		ok := object.Key("type")
6766		ok.String(string(v.Type))
6767	}
6768
6769	if v.Uri != nil {
6770		ok := object.Key("uri")
6771		ok.String(*v.Uri)
6772	}
6773
6774	return nil
6775}
6776
6777type awsRestjson1_serializeOpPutIntegrationResponse struct {
6778}
6779
6780func (*awsRestjson1_serializeOpPutIntegrationResponse) ID() string {
6781	return "OperationSerializer"
6782}
6783
6784func (m *awsRestjson1_serializeOpPutIntegrationResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6785	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6786) {
6787	request, ok := in.Request.(*smithyhttp.Request)
6788	if !ok {
6789		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6790	}
6791
6792	input, ok := in.Parameters.(*PutIntegrationResponseInput)
6793	_ = input
6794	if !ok {
6795		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6796	}
6797
6798	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}")
6799	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6800	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6801	request.Method = "PUT"
6802	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6803	if err != nil {
6804		return out, metadata, &smithy.SerializationError{Err: err}
6805	}
6806
6807	if err := awsRestjson1_serializeOpHttpBindingsPutIntegrationResponseInput(input, restEncoder); err != nil {
6808		return out, metadata, &smithy.SerializationError{Err: err}
6809	}
6810
6811	restEncoder.SetHeader("Content-Type").String("application/json")
6812
6813	jsonEncoder := smithyjson.NewEncoder()
6814	if err := awsRestjson1_serializeOpDocumentPutIntegrationResponseInput(input, jsonEncoder.Value); err != nil {
6815		return out, metadata, &smithy.SerializationError{Err: err}
6816	}
6817
6818	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6819		return out, metadata, &smithy.SerializationError{Err: err}
6820	}
6821
6822	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6823		return out, metadata, &smithy.SerializationError{Err: err}
6824	}
6825	in.Request = request
6826
6827	return next.HandleSerialize(ctx, in)
6828}
6829func awsRestjson1_serializeOpHttpBindingsPutIntegrationResponseInput(v *PutIntegrationResponseInput, encoder *httpbinding.Encoder) error {
6830	if v == nil {
6831		return fmt.Errorf("unsupported serialization of nil %T", v)
6832	}
6833
6834	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
6835		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
6836	}
6837	if v.HttpMethod != nil {
6838		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
6839			return err
6840		}
6841	}
6842
6843	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
6844		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
6845	}
6846	if v.ResourceId != nil {
6847		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
6848			return err
6849		}
6850	}
6851
6852	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
6853		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
6854	}
6855	if v.RestApiId != nil {
6856		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
6857			return err
6858		}
6859	}
6860
6861	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
6862		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
6863	}
6864	if v.StatusCode != nil {
6865		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
6866			return err
6867		}
6868	}
6869
6870	return nil
6871}
6872
6873func awsRestjson1_serializeOpDocumentPutIntegrationResponseInput(v *PutIntegrationResponseInput, value smithyjson.Value) error {
6874	object := value.Object()
6875	defer object.Close()
6876
6877	if len(v.ContentHandling) > 0 {
6878		ok := object.Key("contentHandling")
6879		ok.String(string(v.ContentHandling))
6880	}
6881
6882	if v.ResponseParameters != nil {
6883		ok := object.Key("responseParameters")
6884		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.ResponseParameters, ok); err != nil {
6885			return err
6886		}
6887	}
6888
6889	if v.ResponseTemplates != nil {
6890		ok := object.Key("responseTemplates")
6891		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.ResponseTemplates, ok); err != nil {
6892			return err
6893		}
6894	}
6895
6896	if v.SelectionPattern != nil {
6897		ok := object.Key("selectionPattern")
6898		ok.String(*v.SelectionPattern)
6899	}
6900
6901	return nil
6902}
6903
6904type awsRestjson1_serializeOpPutMethod struct {
6905}
6906
6907func (*awsRestjson1_serializeOpPutMethod) ID() string {
6908	return "OperationSerializer"
6909}
6910
6911func (m *awsRestjson1_serializeOpPutMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6912	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6913) {
6914	request, ok := in.Request.(*smithyhttp.Request)
6915	if !ok {
6916		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6917	}
6918
6919	input, ok := in.Parameters.(*PutMethodInput)
6920	_ = input
6921	if !ok {
6922		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6923	}
6924
6925	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}")
6926	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6927	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6928	request.Method = "PUT"
6929	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6930	if err != nil {
6931		return out, metadata, &smithy.SerializationError{Err: err}
6932	}
6933
6934	if err := awsRestjson1_serializeOpHttpBindingsPutMethodInput(input, restEncoder); err != nil {
6935		return out, metadata, &smithy.SerializationError{Err: err}
6936	}
6937
6938	restEncoder.SetHeader("Content-Type").String("application/json")
6939
6940	jsonEncoder := smithyjson.NewEncoder()
6941	if err := awsRestjson1_serializeOpDocumentPutMethodInput(input, jsonEncoder.Value); err != nil {
6942		return out, metadata, &smithy.SerializationError{Err: err}
6943	}
6944
6945	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6946		return out, metadata, &smithy.SerializationError{Err: err}
6947	}
6948
6949	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6950		return out, metadata, &smithy.SerializationError{Err: err}
6951	}
6952	in.Request = request
6953
6954	return next.HandleSerialize(ctx, in)
6955}
6956func awsRestjson1_serializeOpHttpBindingsPutMethodInput(v *PutMethodInput, encoder *httpbinding.Encoder) error {
6957	if v == nil {
6958		return fmt.Errorf("unsupported serialization of nil %T", v)
6959	}
6960
6961	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
6962		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
6963	}
6964	if v.HttpMethod != nil {
6965		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
6966			return err
6967		}
6968	}
6969
6970	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
6971		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
6972	}
6973	if v.ResourceId != nil {
6974		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
6975			return err
6976		}
6977	}
6978
6979	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
6980		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
6981	}
6982	if v.RestApiId != nil {
6983		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
6984			return err
6985		}
6986	}
6987
6988	return nil
6989}
6990
6991func awsRestjson1_serializeOpDocumentPutMethodInput(v *PutMethodInput, value smithyjson.Value) error {
6992	object := value.Object()
6993	defer object.Close()
6994
6995	if v.ApiKeyRequired {
6996		ok := object.Key("apiKeyRequired")
6997		ok.Boolean(v.ApiKeyRequired)
6998	}
6999
7000	if v.AuthorizationScopes != nil {
7001		ok := object.Key("authorizationScopes")
7002		if err := awsRestjson1_serializeDocumentListOfString(v.AuthorizationScopes, ok); err != nil {
7003			return err
7004		}
7005	}
7006
7007	if v.AuthorizationType != nil {
7008		ok := object.Key("authorizationType")
7009		ok.String(*v.AuthorizationType)
7010	}
7011
7012	if v.AuthorizerId != nil {
7013		ok := object.Key("authorizerId")
7014		ok.String(*v.AuthorizerId)
7015	}
7016
7017	if v.OperationName != nil {
7018		ok := object.Key("operationName")
7019		ok.String(*v.OperationName)
7020	}
7021
7022	if v.RequestModels != nil {
7023		ok := object.Key("requestModels")
7024		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.RequestModels, ok); err != nil {
7025			return err
7026		}
7027	}
7028
7029	if v.RequestParameters != nil {
7030		ok := object.Key("requestParameters")
7031		if err := awsRestjson1_serializeDocumentMapOfStringToBoolean(v.RequestParameters, ok); err != nil {
7032			return err
7033		}
7034	}
7035
7036	if v.RequestValidatorId != nil {
7037		ok := object.Key("requestValidatorId")
7038		ok.String(*v.RequestValidatorId)
7039	}
7040
7041	return nil
7042}
7043
7044type awsRestjson1_serializeOpPutMethodResponse struct {
7045}
7046
7047func (*awsRestjson1_serializeOpPutMethodResponse) ID() string {
7048	return "OperationSerializer"
7049}
7050
7051func (m *awsRestjson1_serializeOpPutMethodResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7052	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7053) {
7054	request, ok := in.Request.(*smithyhttp.Request)
7055	if !ok {
7056		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7057	}
7058
7059	input, ok := in.Parameters.(*PutMethodResponseInput)
7060	_ = input
7061	if !ok {
7062		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7063	}
7064
7065	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}")
7066	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7067	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7068	request.Method = "PUT"
7069	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7070	if err != nil {
7071		return out, metadata, &smithy.SerializationError{Err: err}
7072	}
7073
7074	if err := awsRestjson1_serializeOpHttpBindingsPutMethodResponseInput(input, restEncoder); err != nil {
7075		return out, metadata, &smithy.SerializationError{Err: err}
7076	}
7077
7078	restEncoder.SetHeader("Content-Type").String("application/json")
7079
7080	jsonEncoder := smithyjson.NewEncoder()
7081	if err := awsRestjson1_serializeOpDocumentPutMethodResponseInput(input, jsonEncoder.Value); err != nil {
7082		return out, metadata, &smithy.SerializationError{Err: err}
7083	}
7084
7085	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7086		return out, metadata, &smithy.SerializationError{Err: err}
7087	}
7088
7089	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7090		return out, metadata, &smithy.SerializationError{Err: err}
7091	}
7092	in.Request = request
7093
7094	return next.HandleSerialize(ctx, in)
7095}
7096func awsRestjson1_serializeOpHttpBindingsPutMethodResponseInput(v *PutMethodResponseInput, encoder *httpbinding.Encoder) error {
7097	if v == nil {
7098		return fmt.Errorf("unsupported serialization of nil %T", v)
7099	}
7100
7101	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
7102		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
7103	}
7104	if v.HttpMethod != nil {
7105		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
7106			return err
7107		}
7108	}
7109
7110	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
7111		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
7112	}
7113	if v.ResourceId != nil {
7114		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
7115			return err
7116		}
7117	}
7118
7119	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
7120		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
7121	}
7122	if v.RestApiId != nil {
7123		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
7124			return err
7125		}
7126	}
7127
7128	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
7129		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
7130	}
7131	if v.StatusCode != nil {
7132		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
7133			return err
7134		}
7135	}
7136
7137	return nil
7138}
7139
7140func awsRestjson1_serializeOpDocumentPutMethodResponseInput(v *PutMethodResponseInput, value smithyjson.Value) error {
7141	object := value.Object()
7142	defer object.Close()
7143
7144	if v.ResponseModels != nil {
7145		ok := object.Key("responseModels")
7146		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.ResponseModels, ok); err != nil {
7147			return err
7148		}
7149	}
7150
7151	if v.ResponseParameters != nil {
7152		ok := object.Key("responseParameters")
7153		if err := awsRestjson1_serializeDocumentMapOfStringToBoolean(v.ResponseParameters, ok); err != nil {
7154			return err
7155		}
7156	}
7157
7158	return nil
7159}
7160
7161type awsRestjson1_serializeOpPutRestApi struct {
7162}
7163
7164func (*awsRestjson1_serializeOpPutRestApi) ID() string {
7165	return "OperationSerializer"
7166}
7167
7168func (m *awsRestjson1_serializeOpPutRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7169	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7170) {
7171	request, ok := in.Request.(*smithyhttp.Request)
7172	if !ok {
7173		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7174	}
7175
7176	input, ok := in.Parameters.(*PutRestApiInput)
7177	_ = input
7178	if !ok {
7179		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7180	}
7181
7182	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}")
7183	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7184	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7185	request.Method = "PUT"
7186	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7187	if err != nil {
7188		return out, metadata, &smithy.SerializationError{Err: err}
7189	}
7190
7191	if err := awsRestjson1_serializeOpHttpBindingsPutRestApiInput(input, restEncoder); err != nil {
7192		return out, metadata, &smithy.SerializationError{Err: err}
7193	}
7194
7195	restEncoder.SetHeader("Content-Type").String("application/json")
7196
7197	jsonEncoder := smithyjson.NewEncoder()
7198	if err := awsRestjson1_serializeOpDocumentPutRestApiInput(input, jsonEncoder.Value); err != nil {
7199		return out, metadata, &smithy.SerializationError{Err: err}
7200	}
7201
7202	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7203		return out, metadata, &smithy.SerializationError{Err: err}
7204	}
7205
7206	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7207		return out, metadata, &smithy.SerializationError{Err: err}
7208	}
7209	in.Request = request
7210
7211	return next.HandleSerialize(ctx, in)
7212}
7213func awsRestjson1_serializeOpHttpBindingsPutRestApiInput(v *PutRestApiInput, encoder *httpbinding.Encoder) error {
7214	if v == nil {
7215		return fmt.Errorf("unsupported serialization of nil %T", v)
7216	}
7217
7218	if v.FailOnWarnings {
7219		encoder.SetQuery("failonwarnings").Boolean(v.FailOnWarnings)
7220	}
7221
7222	if len(v.Mode) > 0 {
7223		encoder.SetQuery("mode").String(string(v.Mode))
7224	}
7225
7226	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
7227		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
7228	}
7229	if v.RestApiId != nil {
7230		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
7231			return err
7232		}
7233	}
7234
7235	return nil
7236}
7237
7238func awsRestjson1_serializeOpDocumentPutRestApiInput(v *PutRestApiInput, value smithyjson.Value) error {
7239	object := value.Object()
7240	defer object.Close()
7241
7242	if v.Parameters != nil {
7243		ok := object.Key("parameters")
7244		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Parameters, ok); err != nil {
7245			return err
7246		}
7247	}
7248
7249	return nil
7250}
7251
7252type awsRestjson1_serializeOpTagResource struct {
7253}
7254
7255func (*awsRestjson1_serializeOpTagResource) ID() string {
7256	return "OperationSerializer"
7257}
7258
7259func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7260	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7261) {
7262	request, ok := in.Request.(*smithyhttp.Request)
7263	if !ok {
7264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7265	}
7266
7267	input, ok := in.Parameters.(*TagResourceInput)
7268	_ = input
7269	if !ok {
7270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7271	}
7272
7273	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
7274	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7275	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7276	request.Method = "PUT"
7277	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7278	if err != nil {
7279		return out, metadata, &smithy.SerializationError{Err: err}
7280	}
7281
7282	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
7283		return out, metadata, &smithy.SerializationError{Err: err}
7284	}
7285
7286	restEncoder.SetHeader("Content-Type").String("application/json")
7287
7288	jsonEncoder := smithyjson.NewEncoder()
7289	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
7290		return out, metadata, &smithy.SerializationError{Err: err}
7291	}
7292
7293	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7294		return out, metadata, &smithy.SerializationError{Err: err}
7295	}
7296
7297	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7298		return out, metadata, &smithy.SerializationError{Err: err}
7299	}
7300	in.Request = request
7301
7302	return next.HandleSerialize(ctx, in)
7303}
7304func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
7305	if v == nil {
7306		return fmt.Errorf("unsupported serialization of nil %T", v)
7307	}
7308
7309	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
7310		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
7311	}
7312	if v.ResourceArn != nil {
7313		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
7314			return err
7315		}
7316	}
7317
7318	return nil
7319}
7320
7321func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
7322	object := value.Object()
7323	defer object.Close()
7324
7325	if v.Tags != nil {
7326		ok := object.Key("tags")
7327		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Tags, ok); err != nil {
7328			return err
7329		}
7330	}
7331
7332	return nil
7333}
7334
7335type awsRestjson1_serializeOpTestInvokeAuthorizer struct {
7336}
7337
7338func (*awsRestjson1_serializeOpTestInvokeAuthorizer) ID() string {
7339	return "OperationSerializer"
7340}
7341
7342func (m *awsRestjson1_serializeOpTestInvokeAuthorizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7343	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7344) {
7345	request, ok := in.Request.(*smithyhttp.Request)
7346	if !ok {
7347		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7348	}
7349
7350	input, ok := in.Parameters.(*TestInvokeAuthorizerInput)
7351	_ = input
7352	if !ok {
7353		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7354	}
7355
7356	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers/{authorizerId}")
7357	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7358	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7359	request.Method = "POST"
7360	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7361	if err != nil {
7362		return out, metadata, &smithy.SerializationError{Err: err}
7363	}
7364
7365	if err := awsRestjson1_serializeOpHttpBindingsTestInvokeAuthorizerInput(input, restEncoder); err != nil {
7366		return out, metadata, &smithy.SerializationError{Err: err}
7367	}
7368
7369	restEncoder.SetHeader("Content-Type").String("application/json")
7370
7371	jsonEncoder := smithyjson.NewEncoder()
7372	if err := awsRestjson1_serializeOpDocumentTestInvokeAuthorizerInput(input, jsonEncoder.Value); err != nil {
7373		return out, metadata, &smithy.SerializationError{Err: err}
7374	}
7375
7376	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7377		return out, metadata, &smithy.SerializationError{Err: err}
7378	}
7379
7380	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7381		return out, metadata, &smithy.SerializationError{Err: err}
7382	}
7383	in.Request = request
7384
7385	return next.HandleSerialize(ctx, in)
7386}
7387func awsRestjson1_serializeOpHttpBindingsTestInvokeAuthorizerInput(v *TestInvokeAuthorizerInput, encoder *httpbinding.Encoder) error {
7388	if v == nil {
7389		return fmt.Errorf("unsupported serialization of nil %T", v)
7390	}
7391
7392	if v.AuthorizerId == nil || len(*v.AuthorizerId) == 0 {
7393		return &smithy.SerializationError{Err: fmt.Errorf("input member authorizerId must not be empty")}
7394	}
7395	if v.AuthorizerId != nil {
7396		if err := encoder.SetURI("authorizerId").String(*v.AuthorizerId); err != nil {
7397			return err
7398		}
7399	}
7400
7401	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
7402		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
7403	}
7404	if v.RestApiId != nil {
7405		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
7406			return err
7407		}
7408	}
7409
7410	return nil
7411}
7412
7413func awsRestjson1_serializeOpDocumentTestInvokeAuthorizerInput(v *TestInvokeAuthorizerInput, value smithyjson.Value) error {
7414	object := value.Object()
7415	defer object.Close()
7416
7417	if v.AdditionalContext != nil {
7418		ok := object.Key("additionalContext")
7419		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.AdditionalContext, ok); err != nil {
7420			return err
7421		}
7422	}
7423
7424	if v.Body != nil {
7425		ok := object.Key("body")
7426		ok.String(*v.Body)
7427	}
7428
7429	if v.Headers != nil {
7430		ok := object.Key("headers")
7431		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Headers, ok); err != nil {
7432			return err
7433		}
7434	}
7435
7436	if v.MultiValueHeaders != nil {
7437		ok := object.Key("multiValueHeaders")
7438		if err := awsRestjson1_serializeDocumentMapOfStringToList(v.MultiValueHeaders, ok); err != nil {
7439			return err
7440		}
7441	}
7442
7443	if v.PathWithQueryString != nil {
7444		ok := object.Key("pathWithQueryString")
7445		ok.String(*v.PathWithQueryString)
7446	}
7447
7448	if v.StageVariables != nil {
7449		ok := object.Key("stageVariables")
7450		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.StageVariables, ok); err != nil {
7451			return err
7452		}
7453	}
7454
7455	return nil
7456}
7457
7458type awsRestjson1_serializeOpTestInvokeMethod struct {
7459}
7460
7461func (*awsRestjson1_serializeOpTestInvokeMethod) ID() string {
7462	return "OperationSerializer"
7463}
7464
7465func (m *awsRestjson1_serializeOpTestInvokeMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7466	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7467) {
7468	request, ok := in.Request.(*smithyhttp.Request)
7469	if !ok {
7470		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7471	}
7472
7473	input, ok := in.Parameters.(*TestInvokeMethodInput)
7474	_ = input
7475	if !ok {
7476		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7477	}
7478
7479	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}")
7480	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7481	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7482	request.Method = "POST"
7483	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7484	if err != nil {
7485		return out, metadata, &smithy.SerializationError{Err: err}
7486	}
7487
7488	if err := awsRestjson1_serializeOpHttpBindingsTestInvokeMethodInput(input, restEncoder); err != nil {
7489		return out, metadata, &smithy.SerializationError{Err: err}
7490	}
7491
7492	restEncoder.SetHeader("Content-Type").String("application/json")
7493
7494	jsonEncoder := smithyjson.NewEncoder()
7495	if err := awsRestjson1_serializeOpDocumentTestInvokeMethodInput(input, jsonEncoder.Value); err != nil {
7496		return out, metadata, &smithy.SerializationError{Err: err}
7497	}
7498
7499	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7500		return out, metadata, &smithy.SerializationError{Err: err}
7501	}
7502
7503	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7504		return out, metadata, &smithy.SerializationError{Err: err}
7505	}
7506	in.Request = request
7507
7508	return next.HandleSerialize(ctx, in)
7509}
7510func awsRestjson1_serializeOpHttpBindingsTestInvokeMethodInput(v *TestInvokeMethodInput, encoder *httpbinding.Encoder) error {
7511	if v == nil {
7512		return fmt.Errorf("unsupported serialization of nil %T", v)
7513	}
7514
7515	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
7516		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
7517	}
7518	if v.HttpMethod != nil {
7519		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
7520			return err
7521		}
7522	}
7523
7524	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
7525		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
7526	}
7527	if v.ResourceId != nil {
7528		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
7529			return err
7530		}
7531	}
7532
7533	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
7534		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
7535	}
7536	if v.RestApiId != nil {
7537		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
7538			return err
7539		}
7540	}
7541
7542	return nil
7543}
7544
7545func awsRestjson1_serializeOpDocumentTestInvokeMethodInput(v *TestInvokeMethodInput, value smithyjson.Value) error {
7546	object := value.Object()
7547	defer object.Close()
7548
7549	if v.Body != nil {
7550		ok := object.Key("body")
7551		ok.String(*v.Body)
7552	}
7553
7554	if v.ClientCertificateId != nil {
7555		ok := object.Key("clientCertificateId")
7556		ok.String(*v.ClientCertificateId)
7557	}
7558
7559	if v.Headers != nil {
7560		ok := object.Key("headers")
7561		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.Headers, ok); err != nil {
7562			return err
7563		}
7564	}
7565
7566	if v.MultiValueHeaders != nil {
7567		ok := object.Key("multiValueHeaders")
7568		if err := awsRestjson1_serializeDocumentMapOfStringToList(v.MultiValueHeaders, ok); err != nil {
7569			return err
7570		}
7571	}
7572
7573	if v.PathWithQueryString != nil {
7574		ok := object.Key("pathWithQueryString")
7575		ok.String(*v.PathWithQueryString)
7576	}
7577
7578	if v.StageVariables != nil {
7579		ok := object.Key("stageVariables")
7580		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.StageVariables, ok); err != nil {
7581			return err
7582		}
7583	}
7584
7585	return nil
7586}
7587
7588type awsRestjson1_serializeOpUntagResource struct {
7589}
7590
7591func (*awsRestjson1_serializeOpUntagResource) ID() string {
7592	return "OperationSerializer"
7593}
7594
7595func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7596	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7597) {
7598	request, ok := in.Request.(*smithyhttp.Request)
7599	if !ok {
7600		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7601	}
7602
7603	input, ok := in.Parameters.(*UntagResourceInput)
7604	_ = input
7605	if !ok {
7606		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7607	}
7608
7609	opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
7610	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7611	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7612	request.Method = "DELETE"
7613	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7614	if err != nil {
7615		return out, metadata, &smithy.SerializationError{Err: err}
7616	}
7617
7618	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
7619		return out, metadata, &smithy.SerializationError{Err: err}
7620	}
7621
7622	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7623		return out, metadata, &smithy.SerializationError{Err: err}
7624	}
7625	in.Request = request
7626
7627	return next.HandleSerialize(ctx, in)
7628}
7629func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
7630	if v == nil {
7631		return fmt.Errorf("unsupported serialization of nil %T", v)
7632	}
7633
7634	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
7635		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
7636	}
7637	if v.ResourceArn != nil {
7638		if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
7639			return err
7640		}
7641	}
7642
7643	if v.TagKeys != nil {
7644		for i := range v.TagKeys {
7645			encoder.AddQuery("tagKeys").String(v.TagKeys[i])
7646		}
7647	}
7648
7649	return nil
7650}
7651
7652type awsRestjson1_serializeOpUpdateAccount struct {
7653}
7654
7655func (*awsRestjson1_serializeOpUpdateAccount) ID() string {
7656	return "OperationSerializer"
7657}
7658
7659func (m *awsRestjson1_serializeOpUpdateAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7660	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7661) {
7662	request, ok := in.Request.(*smithyhttp.Request)
7663	if !ok {
7664		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7665	}
7666
7667	input, ok := in.Parameters.(*UpdateAccountInput)
7668	_ = input
7669	if !ok {
7670		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7671	}
7672
7673	opPath, opQuery := httpbinding.SplitURI("/account")
7674	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7675	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7676	request.Method = "PATCH"
7677	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7678	if err != nil {
7679		return out, metadata, &smithy.SerializationError{Err: err}
7680	}
7681
7682	restEncoder.SetHeader("Content-Type").String("application/json")
7683
7684	jsonEncoder := smithyjson.NewEncoder()
7685	if err := awsRestjson1_serializeOpDocumentUpdateAccountInput(input, jsonEncoder.Value); err != nil {
7686		return out, metadata, &smithy.SerializationError{Err: err}
7687	}
7688
7689	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7690		return out, metadata, &smithy.SerializationError{Err: err}
7691	}
7692
7693	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7694		return out, metadata, &smithy.SerializationError{Err: err}
7695	}
7696	in.Request = request
7697
7698	return next.HandleSerialize(ctx, in)
7699}
7700func awsRestjson1_serializeOpHttpBindingsUpdateAccountInput(v *UpdateAccountInput, encoder *httpbinding.Encoder) error {
7701	if v == nil {
7702		return fmt.Errorf("unsupported serialization of nil %T", v)
7703	}
7704
7705	return nil
7706}
7707
7708func awsRestjson1_serializeOpDocumentUpdateAccountInput(v *UpdateAccountInput, value smithyjson.Value) error {
7709	object := value.Object()
7710	defer object.Close()
7711
7712	if v.PatchOperations != nil {
7713		ok := object.Key("patchOperations")
7714		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
7715			return err
7716		}
7717	}
7718
7719	return nil
7720}
7721
7722type awsRestjson1_serializeOpUpdateApiKey struct {
7723}
7724
7725func (*awsRestjson1_serializeOpUpdateApiKey) ID() string {
7726	return "OperationSerializer"
7727}
7728
7729func (m *awsRestjson1_serializeOpUpdateApiKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7730	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7731) {
7732	request, ok := in.Request.(*smithyhttp.Request)
7733	if !ok {
7734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7735	}
7736
7737	input, ok := in.Parameters.(*UpdateApiKeyInput)
7738	_ = input
7739	if !ok {
7740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7741	}
7742
7743	opPath, opQuery := httpbinding.SplitURI("/apikeys/{apiKey}")
7744	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7745	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7746	request.Method = "PATCH"
7747	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7748	if err != nil {
7749		return out, metadata, &smithy.SerializationError{Err: err}
7750	}
7751
7752	if err := awsRestjson1_serializeOpHttpBindingsUpdateApiKeyInput(input, restEncoder); err != nil {
7753		return out, metadata, &smithy.SerializationError{Err: err}
7754	}
7755
7756	restEncoder.SetHeader("Content-Type").String("application/json")
7757
7758	jsonEncoder := smithyjson.NewEncoder()
7759	if err := awsRestjson1_serializeOpDocumentUpdateApiKeyInput(input, jsonEncoder.Value); err != nil {
7760		return out, metadata, &smithy.SerializationError{Err: err}
7761	}
7762
7763	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7764		return out, metadata, &smithy.SerializationError{Err: err}
7765	}
7766
7767	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7768		return out, metadata, &smithy.SerializationError{Err: err}
7769	}
7770	in.Request = request
7771
7772	return next.HandleSerialize(ctx, in)
7773}
7774func awsRestjson1_serializeOpHttpBindingsUpdateApiKeyInput(v *UpdateApiKeyInput, encoder *httpbinding.Encoder) error {
7775	if v == nil {
7776		return fmt.Errorf("unsupported serialization of nil %T", v)
7777	}
7778
7779	if v.ApiKey == nil || len(*v.ApiKey) == 0 {
7780		return &smithy.SerializationError{Err: fmt.Errorf("input member apiKey must not be empty")}
7781	}
7782	if v.ApiKey != nil {
7783		if err := encoder.SetURI("apiKey").String(*v.ApiKey); err != nil {
7784			return err
7785		}
7786	}
7787
7788	return nil
7789}
7790
7791func awsRestjson1_serializeOpDocumentUpdateApiKeyInput(v *UpdateApiKeyInput, value smithyjson.Value) error {
7792	object := value.Object()
7793	defer object.Close()
7794
7795	if v.PatchOperations != nil {
7796		ok := object.Key("patchOperations")
7797		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
7798			return err
7799		}
7800	}
7801
7802	return nil
7803}
7804
7805type awsRestjson1_serializeOpUpdateAuthorizer struct {
7806}
7807
7808func (*awsRestjson1_serializeOpUpdateAuthorizer) ID() string {
7809	return "OperationSerializer"
7810}
7811
7812func (m *awsRestjson1_serializeOpUpdateAuthorizer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7813	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7814) {
7815	request, ok := in.Request.(*smithyhttp.Request)
7816	if !ok {
7817		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7818	}
7819
7820	input, ok := in.Parameters.(*UpdateAuthorizerInput)
7821	_ = input
7822	if !ok {
7823		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7824	}
7825
7826	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/authorizers/{authorizerId}")
7827	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7828	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7829	request.Method = "PATCH"
7830	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7831	if err != nil {
7832		return out, metadata, &smithy.SerializationError{Err: err}
7833	}
7834
7835	if err := awsRestjson1_serializeOpHttpBindingsUpdateAuthorizerInput(input, restEncoder); err != nil {
7836		return out, metadata, &smithy.SerializationError{Err: err}
7837	}
7838
7839	restEncoder.SetHeader("Content-Type").String("application/json")
7840
7841	jsonEncoder := smithyjson.NewEncoder()
7842	if err := awsRestjson1_serializeOpDocumentUpdateAuthorizerInput(input, jsonEncoder.Value); err != nil {
7843		return out, metadata, &smithy.SerializationError{Err: err}
7844	}
7845
7846	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7847		return out, metadata, &smithy.SerializationError{Err: err}
7848	}
7849
7850	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7851		return out, metadata, &smithy.SerializationError{Err: err}
7852	}
7853	in.Request = request
7854
7855	return next.HandleSerialize(ctx, in)
7856}
7857func awsRestjson1_serializeOpHttpBindingsUpdateAuthorizerInput(v *UpdateAuthorizerInput, encoder *httpbinding.Encoder) error {
7858	if v == nil {
7859		return fmt.Errorf("unsupported serialization of nil %T", v)
7860	}
7861
7862	if v.AuthorizerId == nil || len(*v.AuthorizerId) == 0 {
7863		return &smithy.SerializationError{Err: fmt.Errorf("input member authorizerId must not be empty")}
7864	}
7865	if v.AuthorizerId != nil {
7866		if err := encoder.SetURI("authorizerId").String(*v.AuthorizerId); err != nil {
7867			return err
7868		}
7869	}
7870
7871	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
7872		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
7873	}
7874	if v.RestApiId != nil {
7875		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
7876			return err
7877		}
7878	}
7879
7880	return nil
7881}
7882
7883func awsRestjson1_serializeOpDocumentUpdateAuthorizerInput(v *UpdateAuthorizerInput, value smithyjson.Value) error {
7884	object := value.Object()
7885	defer object.Close()
7886
7887	if v.PatchOperations != nil {
7888		ok := object.Key("patchOperations")
7889		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
7890			return err
7891		}
7892	}
7893
7894	return nil
7895}
7896
7897type awsRestjson1_serializeOpUpdateBasePathMapping struct {
7898}
7899
7900func (*awsRestjson1_serializeOpUpdateBasePathMapping) ID() string {
7901	return "OperationSerializer"
7902}
7903
7904func (m *awsRestjson1_serializeOpUpdateBasePathMapping) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7905	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7906) {
7907	request, ok := in.Request.(*smithyhttp.Request)
7908	if !ok {
7909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7910	}
7911
7912	input, ok := in.Parameters.(*UpdateBasePathMappingInput)
7913	_ = input
7914	if !ok {
7915		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7916	}
7917
7918	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}/basepathmappings/{basePath}")
7919	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7920	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7921	request.Method = "PATCH"
7922	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7923	if err != nil {
7924		return out, metadata, &smithy.SerializationError{Err: err}
7925	}
7926
7927	if err := awsRestjson1_serializeOpHttpBindingsUpdateBasePathMappingInput(input, restEncoder); err != nil {
7928		return out, metadata, &smithy.SerializationError{Err: err}
7929	}
7930
7931	restEncoder.SetHeader("Content-Type").String("application/json")
7932
7933	jsonEncoder := smithyjson.NewEncoder()
7934	if err := awsRestjson1_serializeOpDocumentUpdateBasePathMappingInput(input, jsonEncoder.Value); err != nil {
7935		return out, metadata, &smithy.SerializationError{Err: err}
7936	}
7937
7938	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7939		return out, metadata, &smithy.SerializationError{Err: err}
7940	}
7941
7942	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7943		return out, metadata, &smithy.SerializationError{Err: err}
7944	}
7945	in.Request = request
7946
7947	return next.HandleSerialize(ctx, in)
7948}
7949func awsRestjson1_serializeOpHttpBindingsUpdateBasePathMappingInput(v *UpdateBasePathMappingInput, encoder *httpbinding.Encoder) error {
7950	if v == nil {
7951		return fmt.Errorf("unsupported serialization of nil %T", v)
7952	}
7953
7954	if v.BasePath == nil || len(*v.BasePath) == 0 {
7955		return &smithy.SerializationError{Err: fmt.Errorf("input member basePath must not be empty")}
7956	}
7957	if v.BasePath != nil {
7958		if err := encoder.SetURI("basePath").String(*v.BasePath); err != nil {
7959			return err
7960		}
7961	}
7962
7963	if v.DomainName == nil || len(*v.DomainName) == 0 {
7964		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
7965	}
7966	if v.DomainName != nil {
7967		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
7968			return err
7969		}
7970	}
7971
7972	return nil
7973}
7974
7975func awsRestjson1_serializeOpDocumentUpdateBasePathMappingInput(v *UpdateBasePathMappingInput, value smithyjson.Value) error {
7976	object := value.Object()
7977	defer object.Close()
7978
7979	if v.PatchOperations != nil {
7980		ok := object.Key("patchOperations")
7981		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
7982			return err
7983		}
7984	}
7985
7986	return nil
7987}
7988
7989type awsRestjson1_serializeOpUpdateClientCertificate struct {
7990}
7991
7992func (*awsRestjson1_serializeOpUpdateClientCertificate) ID() string {
7993	return "OperationSerializer"
7994}
7995
7996func (m *awsRestjson1_serializeOpUpdateClientCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7997	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7998) {
7999	request, ok := in.Request.(*smithyhttp.Request)
8000	if !ok {
8001		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8002	}
8003
8004	input, ok := in.Parameters.(*UpdateClientCertificateInput)
8005	_ = input
8006	if !ok {
8007		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8008	}
8009
8010	opPath, opQuery := httpbinding.SplitURI("/clientcertificates/{clientCertificateId}")
8011	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8012	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8013	request.Method = "PATCH"
8014	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8015	if err != nil {
8016		return out, metadata, &smithy.SerializationError{Err: err}
8017	}
8018
8019	if err := awsRestjson1_serializeOpHttpBindingsUpdateClientCertificateInput(input, restEncoder); err != nil {
8020		return out, metadata, &smithy.SerializationError{Err: err}
8021	}
8022
8023	restEncoder.SetHeader("Content-Type").String("application/json")
8024
8025	jsonEncoder := smithyjson.NewEncoder()
8026	if err := awsRestjson1_serializeOpDocumentUpdateClientCertificateInput(input, jsonEncoder.Value); err != nil {
8027		return out, metadata, &smithy.SerializationError{Err: err}
8028	}
8029
8030	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8031		return out, metadata, &smithy.SerializationError{Err: err}
8032	}
8033
8034	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8035		return out, metadata, &smithy.SerializationError{Err: err}
8036	}
8037	in.Request = request
8038
8039	return next.HandleSerialize(ctx, in)
8040}
8041func awsRestjson1_serializeOpHttpBindingsUpdateClientCertificateInput(v *UpdateClientCertificateInput, encoder *httpbinding.Encoder) error {
8042	if v == nil {
8043		return fmt.Errorf("unsupported serialization of nil %T", v)
8044	}
8045
8046	if v.ClientCertificateId == nil || len(*v.ClientCertificateId) == 0 {
8047		return &smithy.SerializationError{Err: fmt.Errorf("input member clientCertificateId must not be empty")}
8048	}
8049	if v.ClientCertificateId != nil {
8050		if err := encoder.SetURI("clientCertificateId").String(*v.ClientCertificateId); err != nil {
8051			return err
8052		}
8053	}
8054
8055	return nil
8056}
8057
8058func awsRestjson1_serializeOpDocumentUpdateClientCertificateInput(v *UpdateClientCertificateInput, value smithyjson.Value) error {
8059	object := value.Object()
8060	defer object.Close()
8061
8062	if v.PatchOperations != nil {
8063		ok := object.Key("patchOperations")
8064		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8065			return err
8066		}
8067	}
8068
8069	return nil
8070}
8071
8072type awsRestjson1_serializeOpUpdateDeployment struct {
8073}
8074
8075func (*awsRestjson1_serializeOpUpdateDeployment) ID() string {
8076	return "OperationSerializer"
8077}
8078
8079func (m *awsRestjson1_serializeOpUpdateDeployment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8080	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8081) {
8082	request, ok := in.Request.(*smithyhttp.Request)
8083	if !ok {
8084		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8085	}
8086
8087	input, ok := in.Parameters.(*UpdateDeploymentInput)
8088	_ = input
8089	if !ok {
8090		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8091	}
8092
8093	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/deployments/{deploymentId}")
8094	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8095	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8096	request.Method = "PATCH"
8097	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8098	if err != nil {
8099		return out, metadata, &smithy.SerializationError{Err: err}
8100	}
8101
8102	if err := awsRestjson1_serializeOpHttpBindingsUpdateDeploymentInput(input, restEncoder); err != nil {
8103		return out, metadata, &smithy.SerializationError{Err: err}
8104	}
8105
8106	restEncoder.SetHeader("Content-Type").String("application/json")
8107
8108	jsonEncoder := smithyjson.NewEncoder()
8109	if err := awsRestjson1_serializeOpDocumentUpdateDeploymentInput(input, jsonEncoder.Value); err != nil {
8110		return out, metadata, &smithy.SerializationError{Err: err}
8111	}
8112
8113	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8114		return out, metadata, &smithy.SerializationError{Err: err}
8115	}
8116
8117	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8118		return out, metadata, &smithy.SerializationError{Err: err}
8119	}
8120	in.Request = request
8121
8122	return next.HandleSerialize(ctx, in)
8123}
8124func awsRestjson1_serializeOpHttpBindingsUpdateDeploymentInput(v *UpdateDeploymentInput, encoder *httpbinding.Encoder) error {
8125	if v == nil {
8126		return fmt.Errorf("unsupported serialization of nil %T", v)
8127	}
8128
8129	if v.DeploymentId == nil || len(*v.DeploymentId) == 0 {
8130		return &smithy.SerializationError{Err: fmt.Errorf("input member deploymentId must not be empty")}
8131	}
8132	if v.DeploymentId != nil {
8133		if err := encoder.SetURI("deploymentId").String(*v.DeploymentId); err != nil {
8134			return err
8135		}
8136	}
8137
8138	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8139		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8140	}
8141	if v.RestApiId != nil {
8142		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8143			return err
8144		}
8145	}
8146
8147	return nil
8148}
8149
8150func awsRestjson1_serializeOpDocumentUpdateDeploymentInput(v *UpdateDeploymentInput, value smithyjson.Value) error {
8151	object := value.Object()
8152	defer object.Close()
8153
8154	if v.PatchOperations != nil {
8155		ok := object.Key("patchOperations")
8156		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8157			return err
8158		}
8159	}
8160
8161	return nil
8162}
8163
8164type awsRestjson1_serializeOpUpdateDocumentationPart struct {
8165}
8166
8167func (*awsRestjson1_serializeOpUpdateDocumentationPart) ID() string {
8168	return "OperationSerializer"
8169}
8170
8171func (m *awsRestjson1_serializeOpUpdateDocumentationPart) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8172	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8173) {
8174	request, ok := in.Request.(*smithyhttp.Request)
8175	if !ok {
8176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8177	}
8178
8179	input, ok := in.Parameters.(*UpdateDocumentationPartInput)
8180	_ = input
8181	if !ok {
8182		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8183	}
8184
8185	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/parts/{documentationPartId}")
8186	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8187	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8188	request.Method = "PATCH"
8189	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8190	if err != nil {
8191		return out, metadata, &smithy.SerializationError{Err: err}
8192	}
8193
8194	if err := awsRestjson1_serializeOpHttpBindingsUpdateDocumentationPartInput(input, restEncoder); err != nil {
8195		return out, metadata, &smithy.SerializationError{Err: err}
8196	}
8197
8198	restEncoder.SetHeader("Content-Type").String("application/json")
8199
8200	jsonEncoder := smithyjson.NewEncoder()
8201	if err := awsRestjson1_serializeOpDocumentUpdateDocumentationPartInput(input, jsonEncoder.Value); err != nil {
8202		return out, metadata, &smithy.SerializationError{Err: err}
8203	}
8204
8205	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8206		return out, metadata, &smithy.SerializationError{Err: err}
8207	}
8208
8209	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8210		return out, metadata, &smithy.SerializationError{Err: err}
8211	}
8212	in.Request = request
8213
8214	return next.HandleSerialize(ctx, in)
8215}
8216func awsRestjson1_serializeOpHttpBindingsUpdateDocumentationPartInput(v *UpdateDocumentationPartInput, encoder *httpbinding.Encoder) error {
8217	if v == nil {
8218		return fmt.Errorf("unsupported serialization of nil %T", v)
8219	}
8220
8221	if v.DocumentationPartId == nil || len(*v.DocumentationPartId) == 0 {
8222		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationPartId must not be empty")}
8223	}
8224	if v.DocumentationPartId != nil {
8225		if err := encoder.SetURI("documentationPartId").String(*v.DocumentationPartId); err != nil {
8226			return err
8227		}
8228	}
8229
8230	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8231		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8232	}
8233	if v.RestApiId != nil {
8234		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8235			return err
8236		}
8237	}
8238
8239	return nil
8240}
8241
8242func awsRestjson1_serializeOpDocumentUpdateDocumentationPartInput(v *UpdateDocumentationPartInput, value smithyjson.Value) error {
8243	object := value.Object()
8244	defer object.Close()
8245
8246	if v.PatchOperations != nil {
8247		ok := object.Key("patchOperations")
8248		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8249			return err
8250		}
8251	}
8252
8253	return nil
8254}
8255
8256type awsRestjson1_serializeOpUpdateDocumentationVersion struct {
8257}
8258
8259func (*awsRestjson1_serializeOpUpdateDocumentationVersion) ID() string {
8260	return "OperationSerializer"
8261}
8262
8263func (m *awsRestjson1_serializeOpUpdateDocumentationVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8264	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8265) {
8266	request, ok := in.Request.(*smithyhttp.Request)
8267	if !ok {
8268		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8269	}
8270
8271	input, ok := in.Parameters.(*UpdateDocumentationVersionInput)
8272	_ = input
8273	if !ok {
8274		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8275	}
8276
8277	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/documentation/versions/{documentationVersion}")
8278	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8279	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8280	request.Method = "PATCH"
8281	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8282	if err != nil {
8283		return out, metadata, &smithy.SerializationError{Err: err}
8284	}
8285
8286	if err := awsRestjson1_serializeOpHttpBindingsUpdateDocumentationVersionInput(input, restEncoder); err != nil {
8287		return out, metadata, &smithy.SerializationError{Err: err}
8288	}
8289
8290	restEncoder.SetHeader("Content-Type").String("application/json")
8291
8292	jsonEncoder := smithyjson.NewEncoder()
8293	if err := awsRestjson1_serializeOpDocumentUpdateDocumentationVersionInput(input, jsonEncoder.Value); err != nil {
8294		return out, metadata, &smithy.SerializationError{Err: err}
8295	}
8296
8297	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8298		return out, metadata, &smithy.SerializationError{Err: err}
8299	}
8300
8301	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8302		return out, metadata, &smithy.SerializationError{Err: err}
8303	}
8304	in.Request = request
8305
8306	return next.HandleSerialize(ctx, in)
8307}
8308func awsRestjson1_serializeOpHttpBindingsUpdateDocumentationVersionInput(v *UpdateDocumentationVersionInput, encoder *httpbinding.Encoder) error {
8309	if v == nil {
8310		return fmt.Errorf("unsupported serialization of nil %T", v)
8311	}
8312
8313	if v.DocumentationVersion == nil || len(*v.DocumentationVersion) == 0 {
8314		return &smithy.SerializationError{Err: fmt.Errorf("input member documentationVersion must not be empty")}
8315	}
8316	if v.DocumentationVersion != nil {
8317		if err := encoder.SetURI("documentationVersion").String(*v.DocumentationVersion); err != nil {
8318			return err
8319		}
8320	}
8321
8322	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8323		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8324	}
8325	if v.RestApiId != nil {
8326		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8327			return err
8328		}
8329	}
8330
8331	return nil
8332}
8333
8334func awsRestjson1_serializeOpDocumentUpdateDocumentationVersionInput(v *UpdateDocumentationVersionInput, value smithyjson.Value) error {
8335	object := value.Object()
8336	defer object.Close()
8337
8338	if v.PatchOperations != nil {
8339		ok := object.Key("patchOperations")
8340		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8341			return err
8342		}
8343	}
8344
8345	return nil
8346}
8347
8348type awsRestjson1_serializeOpUpdateDomainName struct {
8349}
8350
8351func (*awsRestjson1_serializeOpUpdateDomainName) ID() string {
8352	return "OperationSerializer"
8353}
8354
8355func (m *awsRestjson1_serializeOpUpdateDomainName) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8356	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8357) {
8358	request, ok := in.Request.(*smithyhttp.Request)
8359	if !ok {
8360		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8361	}
8362
8363	input, ok := in.Parameters.(*UpdateDomainNameInput)
8364	_ = input
8365	if !ok {
8366		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8367	}
8368
8369	opPath, opQuery := httpbinding.SplitURI("/domainnames/{domainName}")
8370	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8371	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8372	request.Method = "PATCH"
8373	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8374	if err != nil {
8375		return out, metadata, &smithy.SerializationError{Err: err}
8376	}
8377
8378	if err := awsRestjson1_serializeOpHttpBindingsUpdateDomainNameInput(input, restEncoder); err != nil {
8379		return out, metadata, &smithy.SerializationError{Err: err}
8380	}
8381
8382	restEncoder.SetHeader("Content-Type").String("application/json")
8383
8384	jsonEncoder := smithyjson.NewEncoder()
8385	if err := awsRestjson1_serializeOpDocumentUpdateDomainNameInput(input, jsonEncoder.Value); err != nil {
8386		return out, metadata, &smithy.SerializationError{Err: err}
8387	}
8388
8389	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8390		return out, metadata, &smithy.SerializationError{Err: err}
8391	}
8392
8393	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8394		return out, metadata, &smithy.SerializationError{Err: err}
8395	}
8396	in.Request = request
8397
8398	return next.HandleSerialize(ctx, in)
8399}
8400func awsRestjson1_serializeOpHttpBindingsUpdateDomainNameInput(v *UpdateDomainNameInput, encoder *httpbinding.Encoder) error {
8401	if v == nil {
8402		return fmt.Errorf("unsupported serialization of nil %T", v)
8403	}
8404
8405	if v.DomainName == nil || len(*v.DomainName) == 0 {
8406		return &smithy.SerializationError{Err: fmt.Errorf("input member domainName must not be empty")}
8407	}
8408	if v.DomainName != nil {
8409		if err := encoder.SetURI("domainName").String(*v.DomainName); err != nil {
8410			return err
8411		}
8412	}
8413
8414	return nil
8415}
8416
8417func awsRestjson1_serializeOpDocumentUpdateDomainNameInput(v *UpdateDomainNameInput, value smithyjson.Value) error {
8418	object := value.Object()
8419	defer object.Close()
8420
8421	if v.PatchOperations != nil {
8422		ok := object.Key("patchOperations")
8423		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8424			return err
8425		}
8426	}
8427
8428	return nil
8429}
8430
8431type awsRestjson1_serializeOpUpdateGatewayResponse struct {
8432}
8433
8434func (*awsRestjson1_serializeOpUpdateGatewayResponse) ID() string {
8435	return "OperationSerializer"
8436}
8437
8438func (m *awsRestjson1_serializeOpUpdateGatewayResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8439	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8440) {
8441	request, ok := in.Request.(*smithyhttp.Request)
8442	if !ok {
8443		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8444	}
8445
8446	input, ok := in.Parameters.(*UpdateGatewayResponseInput)
8447	_ = input
8448	if !ok {
8449		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8450	}
8451
8452	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/gatewayresponses/{responseType}")
8453	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8454	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8455	request.Method = "PATCH"
8456	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8457	if err != nil {
8458		return out, metadata, &smithy.SerializationError{Err: err}
8459	}
8460
8461	if err := awsRestjson1_serializeOpHttpBindingsUpdateGatewayResponseInput(input, restEncoder); err != nil {
8462		return out, metadata, &smithy.SerializationError{Err: err}
8463	}
8464
8465	restEncoder.SetHeader("Content-Type").String("application/json")
8466
8467	jsonEncoder := smithyjson.NewEncoder()
8468	if err := awsRestjson1_serializeOpDocumentUpdateGatewayResponseInput(input, jsonEncoder.Value); err != nil {
8469		return out, metadata, &smithy.SerializationError{Err: err}
8470	}
8471
8472	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8473		return out, metadata, &smithy.SerializationError{Err: err}
8474	}
8475
8476	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8477		return out, metadata, &smithy.SerializationError{Err: err}
8478	}
8479	in.Request = request
8480
8481	return next.HandleSerialize(ctx, in)
8482}
8483func awsRestjson1_serializeOpHttpBindingsUpdateGatewayResponseInput(v *UpdateGatewayResponseInput, encoder *httpbinding.Encoder) error {
8484	if v == nil {
8485		return fmt.Errorf("unsupported serialization of nil %T", v)
8486	}
8487
8488	if len(v.ResponseType) == 0 {
8489		return &smithy.SerializationError{Err: fmt.Errorf("input member responseType must not be empty")}
8490	}
8491	if len(v.ResponseType) > 0 {
8492		if err := encoder.SetURI("responseType").String(string(v.ResponseType)); err != nil {
8493			return err
8494		}
8495	}
8496
8497	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8498		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8499	}
8500	if v.RestApiId != nil {
8501		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8502			return err
8503		}
8504	}
8505
8506	return nil
8507}
8508
8509func awsRestjson1_serializeOpDocumentUpdateGatewayResponseInput(v *UpdateGatewayResponseInput, value smithyjson.Value) error {
8510	object := value.Object()
8511	defer object.Close()
8512
8513	if v.PatchOperations != nil {
8514		ok := object.Key("patchOperations")
8515		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8516			return err
8517		}
8518	}
8519
8520	return nil
8521}
8522
8523type awsRestjson1_serializeOpUpdateIntegration struct {
8524}
8525
8526func (*awsRestjson1_serializeOpUpdateIntegration) ID() string {
8527	return "OperationSerializer"
8528}
8529
8530func (m *awsRestjson1_serializeOpUpdateIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8531	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8532) {
8533	request, ok := in.Request.(*smithyhttp.Request)
8534	if !ok {
8535		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8536	}
8537
8538	input, ok := in.Parameters.(*UpdateIntegrationInput)
8539	_ = input
8540	if !ok {
8541		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8542	}
8543
8544	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration")
8545	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8546	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8547	request.Method = "PATCH"
8548	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8549	if err != nil {
8550		return out, metadata, &smithy.SerializationError{Err: err}
8551	}
8552
8553	if err := awsRestjson1_serializeOpHttpBindingsUpdateIntegrationInput(input, restEncoder); err != nil {
8554		return out, metadata, &smithy.SerializationError{Err: err}
8555	}
8556
8557	restEncoder.SetHeader("Content-Type").String("application/json")
8558
8559	jsonEncoder := smithyjson.NewEncoder()
8560	if err := awsRestjson1_serializeOpDocumentUpdateIntegrationInput(input, jsonEncoder.Value); err != nil {
8561		return out, metadata, &smithy.SerializationError{Err: err}
8562	}
8563
8564	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8565		return out, metadata, &smithy.SerializationError{Err: err}
8566	}
8567
8568	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8569		return out, metadata, &smithy.SerializationError{Err: err}
8570	}
8571	in.Request = request
8572
8573	return next.HandleSerialize(ctx, in)
8574}
8575func awsRestjson1_serializeOpHttpBindingsUpdateIntegrationInput(v *UpdateIntegrationInput, encoder *httpbinding.Encoder) error {
8576	if v == nil {
8577		return fmt.Errorf("unsupported serialization of nil %T", v)
8578	}
8579
8580	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
8581		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
8582	}
8583	if v.HttpMethod != nil {
8584		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
8585			return err
8586		}
8587	}
8588
8589	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
8590		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
8591	}
8592	if v.ResourceId != nil {
8593		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
8594			return err
8595		}
8596	}
8597
8598	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8599		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8600	}
8601	if v.RestApiId != nil {
8602		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8603			return err
8604		}
8605	}
8606
8607	return nil
8608}
8609
8610func awsRestjson1_serializeOpDocumentUpdateIntegrationInput(v *UpdateIntegrationInput, value smithyjson.Value) error {
8611	object := value.Object()
8612	defer object.Close()
8613
8614	if v.PatchOperations != nil {
8615		ok := object.Key("patchOperations")
8616		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8617			return err
8618		}
8619	}
8620
8621	return nil
8622}
8623
8624type awsRestjson1_serializeOpUpdateIntegrationResponse struct {
8625}
8626
8627func (*awsRestjson1_serializeOpUpdateIntegrationResponse) ID() string {
8628	return "OperationSerializer"
8629}
8630
8631func (m *awsRestjson1_serializeOpUpdateIntegrationResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8632	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8633) {
8634	request, ok := in.Request.(*smithyhttp.Request)
8635	if !ok {
8636		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8637	}
8638
8639	input, ok := in.Parameters.(*UpdateIntegrationResponseInput)
8640	_ = input
8641	if !ok {
8642		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8643	}
8644
8645	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}")
8646	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8647	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8648	request.Method = "PATCH"
8649	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8650	if err != nil {
8651		return out, metadata, &smithy.SerializationError{Err: err}
8652	}
8653
8654	if err := awsRestjson1_serializeOpHttpBindingsUpdateIntegrationResponseInput(input, restEncoder); err != nil {
8655		return out, metadata, &smithy.SerializationError{Err: err}
8656	}
8657
8658	restEncoder.SetHeader("Content-Type").String("application/json")
8659
8660	jsonEncoder := smithyjson.NewEncoder()
8661	if err := awsRestjson1_serializeOpDocumentUpdateIntegrationResponseInput(input, jsonEncoder.Value); err != nil {
8662		return out, metadata, &smithy.SerializationError{Err: err}
8663	}
8664
8665	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8666		return out, metadata, &smithy.SerializationError{Err: err}
8667	}
8668
8669	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8670		return out, metadata, &smithy.SerializationError{Err: err}
8671	}
8672	in.Request = request
8673
8674	return next.HandleSerialize(ctx, in)
8675}
8676func awsRestjson1_serializeOpHttpBindingsUpdateIntegrationResponseInput(v *UpdateIntegrationResponseInput, encoder *httpbinding.Encoder) error {
8677	if v == nil {
8678		return fmt.Errorf("unsupported serialization of nil %T", v)
8679	}
8680
8681	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
8682		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
8683	}
8684	if v.HttpMethod != nil {
8685		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
8686			return err
8687		}
8688	}
8689
8690	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
8691		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
8692	}
8693	if v.ResourceId != nil {
8694		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
8695			return err
8696		}
8697	}
8698
8699	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8700		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8701	}
8702	if v.RestApiId != nil {
8703		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8704			return err
8705		}
8706	}
8707
8708	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
8709		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
8710	}
8711	if v.StatusCode != nil {
8712		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
8713			return err
8714		}
8715	}
8716
8717	return nil
8718}
8719
8720func awsRestjson1_serializeOpDocumentUpdateIntegrationResponseInput(v *UpdateIntegrationResponseInput, value smithyjson.Value) error {
8721	object := value.Object()
8722	defer object.Close()
8723
8724	if v.PatchOperations != nil {
8725		ok := object.Key("patchOperations")
8726		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8727			return err
8728		}
8729	}
8730
8731	return nil
8732}
8733
8734type awsRestjson1_serializeOpUpdateMethod struct {
8735}
8736
8737func (*awsRestjson1_serializeOpUpdateMethod) ID() string {
8738	return "OperationSerializer"
8739}
8740
8741func (m *awsRestjson1_serializeOpUpdateMethod) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8742	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8743) {
8744	request, ok := in.Request.(*smithyhttp.Request)
8745	if !ok {
8746		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8747	}
8748
8749	input, ok := in.Parameters.(*UpdateMethodInput)
8750	_ = input
8751	if !ok {
8752		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8753	}
8754
8755	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}")
8756	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8757	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8758	request.Method = "PATCH"
8759	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8760	if err != nil {
8761		return out, metadata, &smithy.SerializationError{Err: err}
8762	}
8763
8764	if err := awsRestjson1_serializeOpHttpBindingsUpdateMethodInput(input, restEncoder); err != nil {
8765		return out, metadata, &smithy.SerializationError{Err: err}
8766	}
8767
8768	restEncoder.SetHeader("Content-Type").String("application/json")
8769
8770	jsonEncoder := smithyjson.NewEncoder()
8771	if err := awsRestjson1_serializeOpDocumentUpdateMethodInput(input, jsonEncoder.Value); err != nil {
8772		return out, metadata, &smithy.SerializationError{Err: err}
8773	}
8774
8775	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8776		return out, metadata, &smithy.SerializationError{Err: err}
8777	}
8778
8779	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8780		return out, metadata, &smithy.SerializationError{Err: err}
8781	}
8782	in.Request = request
8783
8784	return next.HandleSerialize(ctx, in)
8785}
8786func awsRestjson1_serializeOpHttpBindingsUpdateMethodInput(v *UpdateMethodInput, encoder *httpbinding.Encoder) error {
8787	if v == nil {
8788		return fmt.Errorf("unsupported serialization of nil %T", v)
8789	}
8790
8791	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
8792		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
8793	}
8794	if v.HttpMethod != nil {
8795		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
8796			return err
8797		}
8798	}
8799
8800	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
8801		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
8802	}
8803	if v.ResourceId != nil {
8804		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
8805			return err
8806		}
8807	}
8808
8809	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8810		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8811	}
8812	if v.RestApiId != nil {
8813		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8814			return err
8815		}
8816	}
8817
8818	return nil
8819}
8820
8821func awsRestjson1_serializeOpDocumentUpdateMethodInput(v *UpdateMethodInput, value smithyjson.Value) error {
8822	object := value.Object()
8823	defer object.Close()
8824
8825	if v.PatchOperations != nil {
8826		ok := object.Key("patchOperations")
8827		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8828			return err
8829		}
8830	}
8831
8832	return nil
8833}
8834
8835type awsRestjson1_serializeOpUpdateMethodResponse struct {
8836}
8837
8838func (*awsRestjson1_serializeOpUpdateMethodResponse) ID() string {
8839	return "OperationSerializer"
8840}
8841
8842func (m *awsRestjson1_serializeOpUpdateMethodResponse) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8843	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8844) {
8845	request, ok := in.Request.(*smithyhttp.Request)
8846	if !ok {
8847		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8848	}
8849
8850	input, ok := in.Parameters.(*UpdateMethodResponseInput)
8851	_ = input
8852	if !ok {
8853		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8854	}
8855
8856	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}")
8857	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8858	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8859	request.Method = "PATCH"
8860	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8861	if err != nil {
8862		return out, metadata, &smithy.SerializationError{Err: err}
8863	}
8864
8865	if err := awsRestjson1_serializeOpHttpBindingsUpdateMethodResponseInput(input, restEncoder); err != nil {
8866		return out, metadata, &smithy.SerializationError{Err: err}
8867	}
8868
8869	restEncoder.SetHeader("Content-Type").String("application/json")
8870
8871	jsonEncoder := smithyjson.NewEncoder()
8872	if err := awsRestjson1_serializeOpDocumentUpdateMethodResponseInput(input, jsonEncoder.Value); err != nil {
8873		return out, metadata, &smithy.SerializationError{Err: err}
8874	}
8875
8876	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8877		return out, metadata, &smithy.SerializationError{Err: err}
8878	}
8879
8880	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8881		return out, metadata, &smithy.SerializationError{Err: err}
8882	}
8883	in.Request = request
8884
8885	return next.HandleSerialize(ctx, in)
8886}
8887func awsRestjson1_serializeOpHttpBindingsUpdateMethodResponseInput(v *UpdateMethodResponseInput, encoder *httpbinding.Encoder) error {
8888	if v == nil {
8889		return fmt.Errorf("unsupported serialization of nil %T", v)
8890	}
8891
8892	if v.HttpMethod == nil || len(*v.HttpMethod) == 0 {
8893		return &smithy.SerializationError{Err: fmt.Errorf("input member httpMethod must not be empty")}
8894	}
8895	if v.HttpMethod != nil {
8896		if err := encoder.SetURI("httpMethod").String(*v.HttpMethod); err != nil {
8897			return err
8898		}
8899	}
8900
8901	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
8902		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
8903	}
8904	if v.ResourceId != nil {
8905		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
8906			return err
8907		}
8908	}
8909
8910	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
8911		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
8912	}
8913	if v.RestApiId != nil {
8914		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
8915			return err
8916		}
8917	}
8918
8919	if v.StatusCode == nil || len(*v.StatusCode) == 0 {
8920		return &smithy.SerializationError{Err: fmt.Errorf("input member statusCode must not be empty")}
8921	}
8922	if v.StatusCode != nil {
8923		if err := encoder.SetURI("statusCode").String(*v.StatusCode); err != nil {
8924			return err
8925		}
8926	}
8927
8928	return nil
8929}
8930
8931func awsRestjson1_serializeOpDocumentUpdateMethodResponseInput(v *UpdateMethodResponseInput, value smithyjson.Value) error {
8932	object := value.Object()
8933	defer object.Close()
8934
8935	if v.PatchOperations != nil {
8936		ok := object.Key("patchOperations")
8937		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
8938			return err
8939		}
8940	}
8941
8942	return nil
8943}
8944
8945type awsRestjson1_serializeOpUpdateModel struct {
8946}
8947
8948func (*awsRestjson1_serializeOpUpdateModel) ID() string {
8949	return "OperationSerializer"
8950}
8951
8952func (m *awsRestjson1_serializeOpUpdateModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8953	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8954) {
8955	request, ok := in.Request.(*smithyhttp.Request)
8956	if !ok {
8957		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8958	}
8959
8960	input, ok := in.Parameters.(*UpdateModelInput)
8961	_ = input
8962	if !ok {
8963		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8964	}
8965
8966	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/models/{modelName}")
8967	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8968	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8969	request.Method = "PATCH"
8970	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8971	if err != nil {
8972		return out, metadata, &smithy.SerializationError{Err: err}
8973	}
8974
8975	if err := awsRestjson1_serializeOpHttpBindingsUpdateModelInput(input, restEncoder); err != nil {
8976		return out, metadata, &smithy.SerializationError{Err: err}
8977	}
8978
8979	restEncoder.SetHeader("Content-Type").String("application/json")
8980
8981	jsonEncoder := smithyjson.NewEncoder()
8982	if err := awsRestjson1_serializeOpDocumentUpdateModelInput(input, jsonEncoder.Value); err != nil {
8983		return out, metadata, &smithy.SerializationError{Err: err}
8984	}
8985
8986	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8987		return out, metadata, &smithy.SerializationError{Err: err}
8988	}
8989
8990	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8991		return out, metadata, &smithy.SerializationError{Err: err}
8992	}
8993	in.Request = request
8994
8995	return next.HandleSerialize(ctx, in)
8996}
8997func awsRestjson1_serializeOpHttpBindingsUpdateModelInput(v *UpdateModelInput, encoder *httpbinding.Encoder) error {
8998	if v == nil {
8999		return fmt.Errorf("unsupported serialization of nil %T", v)
9000	}
9001
9002	if v.ModelName == nil || len(*v.ModelName) == 0 {
9003		return &smithy.SerializationError{Err: fmt.Errorf("input member modelName must not be empty")}
9004	}
9005	if v.ModelName != nil {
9006		if err := encoder.SetURI("modelName").String(*v.ModelName); err != nil {
9007			return err
9008		}
9009	}
9010
9011	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
9012		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
9013	}
9014	if v.RestApiId != nil {
9015		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
9016			return err
9017		}
9018	}
9019
9020	return nil
9021}
9022
9023func awsRestjson1_serializeOpDocumentUpdateModelInput(v *UpdateModelInput, value smithyjson.Value) error {
9024	object := value.Object()
9025	defer object.Close()
9026
9027	if v.PatchOperations != nil {
9028		ok := object.Key("patchOperations")
9029		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9030			return err
9031		}
9032	}
9033
9034	return nil
9035}
9036
9037type awsRestjson1_serializeOpUpdateRequestValidator struct {
9038}
9039
9040func (*awsRestjson1_serializeOpUpdateRequestValidator) ID() string {
9041	return "OperationSerializer"
9042}
9043
9044func (m *awsRestjson1_serializeOpUpdateRequestValidator) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9045	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9046) {
9047	request, ok := in.Request.(*smithyhttp.Request)
9048	if !ok {
9049		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9050	}
9051
9052	input, ok := in.Parameters.(*UpdateRequestValidatorInput)
9053	_ = input
9054	if !ok {
9055		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9056	}
9057
9058	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/requestvalidators/{requestValidatorId}")
9059	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9060	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9061	request.Method = "PATCH"
9062	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9063	if err != nil {
9064		return out, metadata, &smithy.SerializationError{Err: err}
9065	}
9066
9067	if err := awsRestjson1_serializeOpHttpBindingsUpdateRequestValidatorInput(input, restEncoder); err != nil {
9068		return out, metadata, &smithy.SerializationError{Err: err}
9069	}
9070
9071	restEncoder.SetHeader("Content-Type").String("application/json")
9072
9073	jsonEncoder := smithyjson.NewEncoder()
9074	if err := awsRestjson1_serializeOpDocumentUpdateRequestValidatorInput(input, jsonEncoder.Value); err != nil {
9075		return out, metadata, &smithy.SerializationError{Err: err}
9076	}
9077
9078	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9079		return out, metadata, &smithy.SerializationError{Err: err}
9080	}
9081
9082	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9083		return out, metadata, &smithy.SerializationError{Err: err}
9084	}
9085	in.Request = request
9086
9087	return next.HandleSerialize(ctx, in)
9088}
9089func awsRestjson1_serializeOpHttpBindingsUpdateRequestValidatorInput(v *UpdateRequestValidatorInput, encoder *httpbinding.Encoder) error {
9090	if v == nil {
9091		return fmt.Errorf("unsupported serialization of nil %T", v)
9092	}
9093
9094	if v.RequestValidatorId == nil || len(*v.RequestValidatorId) == 0 {
9095		return &smithy.SerializationError{Err: fmt.Errorf("input member requestValidatorId must not be empty")}
9096	}
9097	if v.RequestValidatorId != nil {
9098		if err := encoder.SetURI("requestValidatorId").String(*v.RequestValidatorId); err != nil {
9099			return err
9100		}
9101	}
9102
9103	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
9104		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
9105	}
9106	if v.RestApiId != nil {
9107		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
9108			return err
9109		}
9110	}
9111
9112	return nil
9113}
9114
9115func awsRestjson1_serializeOpDocumentUpdateRequestValidatorInput(v *UpdateRequestValidatorInput, value smithyjson.Value) error {
9116	object := value.Object()
9117	defer object.Close()
9118
9119	if v.PatchOperations != nil {
9120		ok := object.Key("patchOperations")
9121		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9122			return err
9123		}
9124	}
9125
9126	return nil
9127}
9128
9129type awsRestjson1_serializeOpUpdateResource struct {
9130}
9131
9132func (*awsRestjson1_serializeOpUpdateResource) ID() string {
9133	return "OperationSerializer"
9134}
9135
9136func (m *awsRestjson1_serializeOpUpdateResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9137	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9138) {
9139	request, ok := in.Request.(*smithyhttp.Request)
9140	if !ok {
9141		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9142	}
9143
9144	input, ok := in.Parameters.(*UpdateResourceInput)
9145	_ = input
9146	if !ok {
9147		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9148	}
9149
9150	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/resources/{resourceId}")
9151	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9152	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9153	request.Method = "PATCH"
9154	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9155	if err != nil {
9156		return out, metadata, &smithy.SerializationError{Err: err}
9157	}
9158
9159	if err := awsRestjson1_serializeOpHttpBindingsUpdateResourceInput(input, restEncoder); err != nil {
9160		return out, metadata, &smithy.SerializationError{Err: err}
9161	}
9162
9163	restEncoder.SetHeader("Content-Type").String("application/json")
9164
9165	jsonEncoder := smithyjson.NewEncoder()
9166	if err := awsRestjson1_serializeOpDocumentUpdateResourceInput(input, jsonEncoder.Value); err != nil {
9167		return out, metadata, &smithy.SerializationError{Err: err}
9168	}
9169
9170	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9171		return out, metadata, &smithy.SerializationError{Err: err}
9172	}
9173
9174	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9175		return out, metadata, &smithy.SerializationError{Err: err}
9176	}
9177	in.Request = request
9178
9179	return next.HandleSerialize(ctx, in)
9180}
9181func awsRestjson1_serializeOpHttpBindingsUpdateResourceInput(v *UpdateResourceInput, encoder *httpbinding.Encoder) error {
9182	if v == nil {
9183		return fmt.Errorf("unsupported serialization of nil %T", v)
9184	}
9185
9186	if v.ResourceId == nil || len(*v.ResourceId) == 0 {
9187		return &smithy.SerializationError{Err: fmt.Errorf("input member resourceId must not be empty")}
9188	}
9189	if v.ResourceId != nil {
9190		if err := encoder.SetURI("resourceId").String(*v.ResourceId); err != nil {
9191			return err
9192		}
9193	}
9194
9195	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
9196		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
9197	}
9198	if v.RestApiId != nil {
9199		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
9200			return err
9201		}
9202	}
9203
9204	return nil
9205}
9206
9207func awsRestjson1_serializeOpDocumentUpdateResourceInput(v *UpdateResourceInput, value smithyjson.Value) error {
9208	object := value.Object()
9209	defer object.Close()
9210
9211	if v.PatchOperations != nil {
9212		ok := object.Key("patchOperations")
9213		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9214			return err
9215		}
9216	}
9217
9218	return nil
9219}
9220
9221type awsRestjson1_serializeOpUpdateRestApi struct {
9222}
9223
9224func (*awsRestjson1_serializeOpUpdateRestApi) ID() string {
9225	return "OperationSerializer"
9226}
9227
9228func (m *awsRestjson1_serializeOpUpdateRestApi) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9229	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9230) {
9231	request, ok := in.Request.(*smithyhttp.Request)
9232	if !ok {
9233		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9234	}
9235
9236	input, ok := in.Parameters.(*UpdateRestApiInput)
9237	_ = input
9238	if !ok {
9239		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9240	}
9241
9242	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}")
9243	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9244	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9245	request.Method = "PATCH"
9246	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9247	if err != nil {
9248		return out, metadata, &smithy.SerializationError{Err: err}
9249	}
9250
9251	if err := awsRestjson1_serializeOpHttpBindingsUpdateRestApiInput(input, restEncoder); err != nil {
9252		return out, metadata, &smithy.SerializationError{Err: err}
9253	}
9254
9255	restEncoder.SetHeader("Content-Type").String("application/json")
9256
9257	jsonEncoder := smithyjson.NewEncoder()
9258	if err := awsRestjson1_serializeOpDocumentUpdateRestApiInput(input, jsonEncoder.Value); err != nil {
9259		return out, metadata, &smithy.SerializationError{Err: err}
9260	}
9261
9262	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9263		return out, metadata, &smithy.SerializationError{Err: err}
9264	}
9265
9266	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9267		return out, metadata, &smithy.SerializationError{Err: err}
9268	}
9269	in.Request = request
9270
9271	return next.HandleSerialize(ctx, in)
9272}
9273func awsRestjson1_serializeOpHttpBindingsUpdateRestApiInput(v *UpdateRestApiInput, encoder *httpbinding.Encoder) error {
9274	if v == nil {
9275		return fmt.Errorf("unsupported serialization of nil %T", v)
9276	}
9277
9278	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
9279		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
9280	}
9281	if v.RestApiId != nil {
9282		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
9283			return err
9284		}
9285	}
9286
9287	return nil
9288}
9289
9290func awsRestjson1_serializeOpDocumentUpdateRestApiInput(v *UpdateRestApiInput, value smithyjson.Value) error {
9291	object := value.Object()
9292	defer object.Close()
9293
9294	if v.PatchOperations != nil {
9295		ok := object.Key("patchOperations")
9296		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9297			return err
9298		}
9299	}
9300
9301	return nil
9302}
9303
9304type awsRestjson1_serializeOpUpdateStage struct {
9305}
9306
9307func (*awsRestjson1_serializeOpUpdateStage) ID() string {
9308	return "OperationSerializer"
9309}
9310
9311func (m *awsRestjson1_serializeOpUpdateStage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9312	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9313) {
9314	request, ok := in.Request.(*smithyhttp.Request)
9315	if !ok {
9316		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9317	}
9318
9319	input, ok := in.Parameters.(*UpdateStageInput)
9320	_ = input
9321	if !ok {
9322		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9323	}
9324
9325	opPath, opQuery := httpbinding.SplitURI("/restapis/{restApiId}/stages/{stageName}")
9326	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9327	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9328	request.Method = "PATCH"
9329	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9330	if err != nil {
9331		return out, metadata, &smithy.SerializationError{Err: err}
9332	}
9333
9334	if err := awsRestjson1_serializeOpHttpBindingsUpdateStageInput(input, restEncoder); err != nil {
9335		return out, metadata, &smithy.SerializationError{Err: err}
9336	}
9337
9338	restEncoder.SetHeader("Content-Type").String("application/json")
9339
9340	jsonEncoder := smithyjson.NewEncoder()
9341	if err := awsRestjson1_serializeOpDocumentUpdateStageInput(input, jsonEncoder.Value); err != nil {
9342		return out, metadata, &smithy.SerializationError{Err: err}
9343	}
9344
9345	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9346		return out, metadata, &smithy.SerializationError{Err: err}
9347	}
9348
9349	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9350		return out, metadata, &smithy.SerializationError{Err: err}
9351	}
9352	in.Request = request
9353
9354	return next.HandleSerialize(ctx, in)
9355}
9356func awsRestjson1_serializeOpHttpBindingsUpdateStageInput(v *UpdateStageInput, encoder *httpbinding.Encoder) error {
9357	if v == nil {
9358		return fmt.Errorf("unsupported serialization of nil %T", v)
9359	}
9360
9361	if v.RestApiId == nil || len(*v.RestApiId) == 0 {
9362		return &smithy.SerializationError{Err: fmt.Errorf("input member restApiId must not be empty")}
9363	}
9364	if v.RestApiId != nil {
9365		if err := encoder.SetURI("restApiId").String(*v.RestApiId); err != nil {
9366			return err
9367		}
9368	}
9369
9370	if v.StageName == nil || len(*v.StageName) == 0 {
9371		return &smithy.SerializationError{Err: fmt.Errorf("input member stageName must not be empty")}
9372	}
9373	if v.StageName != nil {
9374		if err := encoder.SetURI("stageName").String(*v.StageName); err != nil {
9375			return err
9376		}
9377	}
9378
9379	return nil
9380}
9381
9382func awsRestjson1_serializeOpDocumentUpdateStageInput(v *UpdateStageInput, value smithyjson.Value) error {
9383	object := value.Object()
9384	defer object.Close()
9385
9386	if v.PatchOperations != nil {
9387		ok := object.Key("patchOperations")
9388		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9389			return err
9390		}
9391	}
9392
9393	return nil
9394}
9395
9396type awsRestjson1_serializeOpUpdateUsage struct {
9397}
9398
9399func (*awsRestjson1_serializeOpUpdateUsage) ID() string {
9400	return "OperationSerializer"
9401}
9402
9403func (m *awsRestjson1_serializeOpUpdateUsage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9404	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9405) {
9406	request, ok := in.Request.(*smithyhttp.Request)
9407	if !ok {
9408		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9409	}
9410
9411	input, ok := in.Parameters.(*UpdateUsageInput)
9412	_ = input
9413	if !ok {
9414		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9415	}
9416
9417	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}/keys/{keyId}/usage")
9418	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9419	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9420	request.Method = "PATCH"
9421	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9422	if err != nil {
9423		return out, metadata, &smithy.SerializationError{Err: err}
9424	}
9425
9426	if err := awsRestjson1_serializeOpHttpBindingsUpdateUsageInput(input, restEncoder); err != nil {
9427		return out, metadata, &smithy.SerializationError{Err: err}
9428	}
9429
9430	restEncoder.SetHeader("Content-Type").String("application/json")
9431
9432	jsonEncoder := smithyjson.NewEncoder()
9433	if err := awsRestjson1_serializeOpDocumentUpdateUsageInput(input, jsonEncoder.Value); err != nil {
9434		return out, metadata, &smithy.SerializationError{Err: err}
9435	}
9436
9437	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9438		return out, metadata, &smithy.SerializationError{Err: err}
9439	}
9440
9441	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9442		return out, metadata, &smithy.SerializationError{Err: err}
9443	}
9444	in.Request = request
9445
9446	return next.HandleSerialize(ctx, in)
9447}
9448func awsRestjson1_serializeOpHttpBindingsUpdateUsageInput(v *UpdateUsageInput, encoder *httpbinding.Encoder) error {
9449	if v == nil {
9450		return fmt.Errorf("unsupported serialization of nil %T", v)
9451	}
9452
9453	if v.KeyId == nil || len(*v.KeyId) == 0 {
9454		return &smithy.SerializationError{Err: fmt.Errorf("input member keyId must not be empty")}
9455	}
9456	if v.KeyId != nil {
9457		if err := encoder.SetURI("keyId").String(*v.KeyId); err != nil {
9458			return err
9459		}
9460	}
9461
9462	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
9463		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
9464	}
9465	if v.UsagePlanId != nil {
9466		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
9467			return err
9468		}
9469	}
9470
9471	return nil
9472}
9473
9474func awsRestjson1_serializeOpDocumentUpdateUsageInput(v *UpdateUsageInput, value smithyjson.Value) error {
9475	object := value.Object()
9476	defer object.Close()
9477
9478	if v.PatchOperations != nil {
9479		ok := object.Key("patchOperations")
9480		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9481			return err
9482		}
9483	}
9484
9485	return nil
9486}
9487
9488type awsRestjson1_serializeOpUpdateUsagePlan struct {
9489}
9490
9491func (*awsRestjson1_serializeOpUpdateUsagePlan) ID() string {
9492	return "OperationSerializer"
9493}
9494
9495func (m *awsRestjson1_serializeOpUpdateUsagePlan) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9497) {
9498	request, ok := in.Request.(*smithyhttp.Request)
9499	if !ok {
9500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9501	}
9502
9503	input, ok := in.Parameters.(*UpdateUsagePlanInput)
9504	_ = input
9505	if !ok {
9506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9507	}
9508
9509	opPath, opQuery := httpbinding.SplitURI("/usageplans/{usagePlanId}")
9510	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9511	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9512	request.Method = "PATCH"
9513	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9514	if err != nil {
9515		return out, metadata, &smithy.SerializationError{Err: err}
9516	}
9517
9518	if err := awsRestjson1_serializeOpHttpBindingsUpdateUsagePlanInput(input, restEncoder); err != nil {
9519		return out, metadata, &smithy.SerializationError{Err: err}
9520	}
9521
9522	restEncoder.SetHeader("Content-Type").String("application/json")
9523
9524	jsonEncoder := smithyjson.NewEncoder()
9525	if err := awsRestjson1_serializeOpDocumentUpdateUsagePlanInput(input, jsonEncoder.Value); err != nil {
9526		return out, metadata, &smithy.SerializationError{Err: err}
9527	}
9528
9529	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9530		return out, metadata, &smithy.SerializationError{Err: err}
9531	}
9532
9533	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9534		return out, metadata, &smithy.SerializationError{Err: err}
9535	}
9536	in.Request = request
9537
9538	return next.HandleSerialize(ctx, in)
9539}
9540func awsRestjson1_serializeOpHttpBindingsUpdateUsagePlanInput(v *UpdateUsagePlanInput, encoder *httpbinding.Encoder) error {
9541	if v == nil {
9542		return fmt.Errorf("unsupported serialization of nil %T", v)
9543	}
9544
9545	if v.UsagePlanId == nil || len(*v.UsagePlanId) == 0 {
9546		return &smithy.SerializationError{Err: fmt.Errorf("input member usagePlanId must not be empty")}
9547	}
9548	if v.UsagePlanId != nil {
9549		if err := encoder.SetURI("usagePlanId").String(*v.UsagePlanId); err != nil {
9550			return err
9551		}
9552	}
9553
9554	return nil
9555}
9556
9557func awsRestjson1_serializeOpDocumentUpdateUsagePlanInput(v *UpdateUsagePlanInput, value smithyjson.Value) error {
9558	object := value.Object()
9559	defer object.Close()
9560
9561	if v.PatchOperations != nil {
9562		ok := object.Key("patchOperations")
9563		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9564			return err
9565		}
9566	}
9567
9568	return nil
9569}
9570
9571type awsRestjson1_serializeOpUpdateVpcLink struct {
9572}
9573
9574func (*awsRestjson1_serializeOpUpdateVpcLink) ID() string {
9575	return "OperationSerializer"
9576}
9577
9578func (m *awsRestjson1_serializeOpUpdateVpcLink) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
9579	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
9580) {
9581	request, ok := in.Request.(*smithyhttp.Request)
9582	if !ok {
9583		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
9584	}
9585
9586	input, ok := in.Parameters.(*UpdateVpcLinkInput)
9587	_ = input
9588	if !ok {
9589		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
9590	}
9591
9592	opPath, opQuery := httpbinding.SplitURI("/vpclinks/{vpcLinkId}")
9593	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
9594	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
9595	request.Method = "PATCH"
9596	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
9597	if err != nil {
9598		return out, metadata, &smithy.SerializationError{Err: err}
9599	}
9600
9601	if err := awsRestjson1_serializeOpHttpBindingsUpdateVpcLinkInput(input, restEncoder); err != nil {
9602		return out, metadata, &smithy.SerializationError{Err: err}
9603	}
9604
9605	restEncoder.SetHeader("Content-Type").String("application/json")
9606
9607	jsonEncoder := smithyjson.NewEncoder()
9608	if err := awsRestjson1_serializeOpDocumentUpdateVpcLinkInput(input, jsonEncoder.Value); err != nil {
9609		return out, metadata, &smithy.SerializationError{Err: err}
9610	}
9611
9612	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
9613		return out, metadata, &smithy.SerializationError{Err: err}
9614	}
9615
9616	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
9617		return out, metadata, &smithy.SerializationError{Err: err}
9618	}
9619	in.Request = request
9620
9621	return next.HandleSerialize(ctx, in)
9622}
9623func awsRestjson1_serializeOpHttpBindingsUpdateVpcLinkInput(v *UpdateVpcLinkInput, encoder *httpbinding.Encoder) error {
9624	if v == nil {
9625		return fmt.Errorf("unsupported serialization of nil %T", v)
9626	}
9627
9628	if v.VpcLinkId == nil || len(*v.VpcLinkId) == 0 {
9629		return &smithy.SerializationError{Err: fmt.Errorf("input member vpcLinkId must not be empty")}
9630	}
9631	if v.VpcLinkId != nil {
9632		if err := encoder.SetURI("vpcLinkId").String(*v.VpcLinkId); err != nil {
9633			return err
9634		}
9635	}
9636
9637	return nil
9638}
9639
9640func awsRestjson1_serializeOpDocumentUpdateVpcLinkInput(v *UpdateVpcLinkInput, value smithyjson.Value) error {
9641	object := value.Object()
9642	defer object.Close()
9643
9644	if v.PatchOperations != nil {
9645		ok := object.Key("patchOperations")
9646		if err := awsRestjson1_serializeDocumentListOfPatchOperation(v.PatchOperations, ok); err != nil {
9647			return err
9648		}
9649	}
9650
9651	return nil
9652}
9653
9654func awsRestjson1_serializeDocumentApiStage(v *types.ApiStage, value smithyjson.Value) error {
9655	object := value.Object()
9656	defer object.Close()
9657
9658	if v.ApiId != nil {
9659		ok := object.Key("apiId")
9660		ok.String(*v.ApiId)
9661	}
9662
9663	if v.Stage != nil {
9664		ok := object.Key("stage")
9665		ok.String(*v.Stage)
9666	}
9667
9668	if v.Throttle != nil {
9669		ok := object.Key("throttle")
9670		if err := awsRestjson1_serializeDocumentMapOfApiStageThrottleSettings(v.Throttle, ok); err != nil {
9671			return err
9672		}
9673	}
9674
9675	return nil
9676}
9677
9678func awsRestjson1_serializeDocumentCanarySettings(v *types.CanarySettings, value smithyjson.Value) error {
9679	object := value.Object()
9680	defer object.Close()
9681
9682	if v.DeploymentId != nil {
9683		ok := object.Key("deploymentId")
9684		ok.String(*v.DeploymentId)
9685	}
9686
9687	if v.PercentTraffic != 0 {
9688		ok := object.Key("percentTraffic")
9689		ok.Double(v.PercentTraffic)
9690	}
9691
9692	if v.StageVariableOverrides != nil {
9693		ok := object.Key("stageVariableOverrides")
9694		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.StageVariableOverrides, ok); err != nil {
9695			return err
9696		}
9697	}
9698
9699	if v.UseStageCache {
9700		ok := object.Key("useStageCache")
9701		ok.Boolean(v.UseStageCache)
9702	}
9703
9704	return nil
9705}
9706
9707func awsRestjson1_serializeDocumentDeploymentCanarySettings(v *types.DeploymentCanarySettings, value smithyjson.Value) error {
9708	object := value.Object()
9709	defer object.Close()
9710
9711	if v.PercentTraffic != 0 {
9712		ok := object.Key("percentTraffic")
9713		ok.Double(v.PercentTraffic)
9714	}
9715
9716	if v.StageVariableOverrides != nil {
9717		ok := object.Key("stageVariableOverrides")
9718		if err := awsRestjson1_serializeDocumentMapOfStringToString(v.StageVariableOverrides, ok); err != nil {
9719			return err
9720		}
9721	}
9722
9723	if v.UseStageCache {
9724		ok := object.Key("useStageCache")
9725		ok.Boolean(v.UseStageCache)
9726	}
9727
9728	return nil
9729}
9730
9731func awsRestjson1_serializeDocumentDocumentationPartLocation(v *types.DocumentationPartLocation, value smithyjson.Value) error {
9732	object := value.Object()
9733	defer object.Close()
9734
9735	if v.Method != nil {
9736		ok := object.Key("method")
9737		ok.String(*v.Method)
9738	}
9739
9740	if v.Name != nil {
9741		ok := object.Key("name")
9742		ok.String(*v.Name)
9743	}
9744
9745	if v.Path != nil {
9746		ok := object.Key("path")
9747		ok.String(*v.Path)
9748	}
9749
9750	if v.StatusCode != nil {
9751		ok := object.Key("statusCode")
9752		ok.String(*v.StatusCode)
9753	}
9754
9755	if len(v.Type) > 0 {
9756		ok := object.Key("type")
9757		ok.String(string(v.Type))
9758	}
9759
9760	return nil
9761}
9762
9763func awsRestjson1_serializeDocumentEndpointConfiguration(v *types.EndpointConfiguration, value smithyjson.Value) error {
9764	object := value.Object()
9765	defer object.Close()
9766
9767	if v.Types != nil {
9768		ok := object.Key("types")
9769		if err := awsRestjson1_serializeDocumentListOfEndpointType(v.Types, ok); err != nil {
9770			return err
9771		}
9772	}
9773
9774	if v.VpcEndpointIds != nil {
9775		ok := object.Key("vpcEndpointIds")
9776		if err := awsRestjson1_serializeDocumentListOfString(v.VpcEndpointIds, ok); err != nil {
9777			return err
9778		}
9779	}
9780
9781	return nil
9782}
9783
9784func awsRestjson1_serializeDocumentListOfApiStage(v []types.ApiStage, value smithyjson.Value) error {
9785	array := value.Array()
9786	defer array.Close()
9787
9788	for i := range v {
9789		av := array.Value()
9790		if err := awsRestjson1_serializeDocumentApiStage(&v[i], av); err != nil {
9791			return err
9792		}
9793	}
9794	return nil
9795}
9796
9797func awsRestjson1_serializeDocumentListOfARNs(v []string, value smithyjson.Value) error {
9798	array := value.Array()
9799	defer array.Close()
9800
9801	for i := range v {
9802		av := array.Value()
9803		av.String(v[i])
9804	}
9805	return nil
9806}
9807
9808func awsRestjson1_serializeDocumentListOfEndpointType(v []types.EndpointType, value smithyjson.Value) error {
9809	array := value.Array()
9810	defer array.Close()
9811
9812	for i := range v {
9813		av := array.Value()
9814		av.String(string(v[i]))
9815	}
9816	return nil
9817}
9818
9819func awsRestjson1_serializeDocumentListOfPatchOperation(v []types.PatchOperation, value smithyjson.Value) error {
9820	array := value.Array()
9821	defer array.Close()
9822
9823	for i := range v {
9824		av := array.Value()
9825		if err := awsRestjson1_serializeDocumentPatchOperation(&v[i], av); err != nil {
9826			return err
9827		}
9828	}
9829	return nil
9830}
9831
9832func awsRestjson1_serializeDocumentListOfStageKeys(v []types.StageKey, value smithyjson.Value) error {
9833	array := value.Array()
9834	defer array.Close()
9835
9836	for i := range v {
9837		av := array.Value()
9838		if err := awsRestjson1_serializeDocumentStageKey(&v[i], av); err != nil {
9839			return err
9840		}
9841	}
9842	return nil
9843}
9844
9845func awsRestjson1_serializeDocumentListOfString(v []string, value smithyjson.Value) error {
9846	array := value.Array()
9847	defer array.Close()
9848
9849	for i := range v {
9850		av := array.Value()
9851		av.String(v[i])
9852	}
9853	return nil
9854}
9855
9856func awsRestjson1_serializeDocumentMapOfApiStageThrottleSettings(v map[string]types.ThrottleSettings, value smithyjson.Value) error {
9857	object := value.Object()
9858	defer object.Close()
9859
9860	for key := range v {
9861		om := object.Key(key)
9862		mapVar := v[key]
9863		if err := awsRestjson1_serializeDocumentThrottleSettings(&mapVar, om); err != nil {
9864			return err
9865		}
9866	}
9867	return nil
9868}
9869
9870func awsRestjson1_serializeDocumentMapOfStringToBoolean(v map[string]bool, value smithyjson.Value) error {
9871	object := value.Object()
9872	defer object.Close()
9873
9874	for key := range v {
9875		om := object.Key(key)
9876		om.Boolean(v[key])
9877	}
9878	return nil
9879}
9880
9881func awsRestjson1_serializeDocumentMapOfStringToList(v map[string][]string, value smithyjson.Value) error {
9882	object := value.Object()
9883	defer object.Close()
9884
9885	for key := range v {
9886		om := object.Key(key)
9887		if vv := v[key]; vv == nil {
9888			continue
9889		}
9890		if err := awsRestjson1_serializeDocumentListOfString(v[key], om); err != nil {
9891			return err
9892		}
9893	}
9894	return nil
9895}
9896
9897func awsRestjson1_serializeDocumentMapOfStringToString(v map[string]string, value smithyjson.Value) error {
9898	object := value.Object()
9899	defer object.Close()
9900
9901	for key := range v {
9902		om := object.Key(key)
9903		om.String(v[key])
9904	}
9905	return nil
9906}
9907
9908func awsRestjson1_serializeDocumentMutualTlsAuthenticationInput(v *types.MutualTlsAuthenticationInput, value smithyjson.Value) error {
9909	object := value.Object()
9910	defer object.Close()
9911
9912	if v.TruststoreUri != nil {
9913		ok := object.Key("truststoreUri")
9914		ok.String(*v.TruststoreUri)
9915	}
9916
9917	if v.TruststoreVersion != nil {
9918		ok := object.Key("truststoreVersion")
9919		ok.String(*v.TruststoreVersion)
9920	}
9921
9922	return nil
9923}
9924
9925func awsRestjson1_serializeDocumentPatchOperation(v *types.PatchOperation, value smithyjson.Value) error {
9926	object := value.Object()
9927	defer object.Close()
9928
9929	if v.From != nil {
9930		ok := object.Key("from")
9931		ok.String(*v.From)
9932	}
9933
9934	if len(v.Op) > 0 {
9935		ok := object.Key("op")
9936		ok.String(string(v.Op))
9937	}
9938
9939	if v.Path != nil {
9940		ok := object.Key("path")
9941		ok.String(*v.Path)
9942	}
9943
9944	if v.Value != nil {
9945		ok := object.Key("value")
9946		ok.String(*v.Value)
9947	}
9948
9949	return nil
9950}
9951
9952func awsRestjson1_serializeDocumentQuotaSettings(v *types.QuotaSettings, value smithyjson.Value) error {
9953	object := value.Object()
9954	defer object.Close()
9955
9956	if v.Limit != 0 {
9957		ok := object.Key("limit")
9958		ok.Integer(v.Limit)
9959	}
9960
9961	if v.Offset != 0 {
9962		ok := object.Key("offset")
9963		ok.Integer(v.Offset)
9964	}
9965
9966	if len(v.Period) > 0 {
9967		ok := object.Key("period")
9968		ok.String(string(v.Period))
9969	}
9970
9971	return nil
9972}
9973
9974func awsRestjson1_serializeDocumentStageKey(v *types.StageKey, value smithyjson.Value) error {
9975	object := value.Object()
9976	defer object.Close()
9977
9978	if v.RestApiId != nil {
9979		ok := object.Key("restApiId")
9980		ok.String(*v.RestApiId)
9981	}
9982
9983	if v.StageName != nil {
9984		ok := object.Key("stageName")
9985		ok.String(*v.StageName)
9986	}
9987
9988	return nil
9989}
9990
9991func awsRestjson1_serializeDocumentThrottleSettings(v *types.ThrottleSettings, value smithyjson.Value) error {
9992	object := value.Object()
9993	defer object.Close()
9994
9995	if v.BurstLimit != 0 {
9996		ok := object.Key("burstLimit")
9997		ok.Integer(v.BurstLimit)
9998	}
9999
10000	if v.RateLimit != 0 {
10001		ok := object.Key("rateLimit")
10002		ok.Double(v.RateLimit)
10003	}
10004
10005	return nil
10006}
10007
10008func awsRestjson1_serializeDocumentTlsConfig(v *types.TlsConfig, value smithyjson.Value) error {
10009	object := value.Object()
10010	defer object.Close()
10011
10012	if v.InsecureSkipVerification {
10013		ok := object.Key("insecureSkipVerification")
10014		ok.Boolean(v.InsecureSkipVerification)
10015	}
10016
10017	return nil
10018}
10019