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