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