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