1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package managedblockchain 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/managedblockchain/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_serializeOpCreateMember struct { 18} 19 20func (*awsRestjson1_serializeOpCreateMember) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpCreateMember) 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.(*CreateMemberInput) 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("/networks/{NetworkId}/members") 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_serializeOpHttpBindingsCreateMemberInput(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_serializeOpDocumentCreateMemberInput(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_serializeOpHttpBindingsCreateMemberInput(v *CreateMemberInput, encoder *httpbinding.Encoder) error { 75 if v == nil { 76 return fmt.Errorf("unsupported serialization of nil %T", v) 77 } 78 79 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 80 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 81 } 82 if v.NetworkId != nil { 83 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 84 return err 85 } 86 } 87 88 return nil 89} 90 91func awsRestjson1_serializeOpDocumentCreateMemberInput(v *CreateMemberInput, value smithyjson.Value) error { 92 object := value.Object() 93 defer object.Close() 94 95 if v.ClientRequestToken != nil { 96 ok := object.Key("ClientRequestToken") 97 ok.String(*v.ClientRequestToken) 98 } 99 100 if v.InvitationId != nil { 101 ok := object.Key("InvitationId") 102 ok.String(*v.InvitationId) 103 } 104 105 if v.MemberConfiguration != nil { 106 ok := object.Key("MemberConfiguration") 107 if err := awsRestjson1_serializeDocumentMemberConfiguration(v.MemberConfiguration, ok); err != nil { 108 return err 109 } 110 } 111 112 return nil 113} 114 115type awsRestjson1_serializeOpCreateNetwork struct { 116} 117 118func (*awsRestjson1_serializeOpCreateNetwork) ID() string { 119 return "OperationSerializer" 120} 121 122func (m *awsRestjson1_serializeOpCreateNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 123 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 124) { 125 request, ok := in.Request.(*smithyhttp.Request) 126 if !ok { 127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 128 } 129 130 input, ok := in.Parameters.(*CreateNetworkInput) 131 _ = input 132 if !ok { 133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 134 } 135 136 opPath, opQuery := httpbinding.SplitURI("/networks") 137 request.URL.Path = opPath 138 if len(request.URL.RawQuery) > 0 { 139 request.URL.RawQuery = "&" + opQuery 140 } else { 141 request.URL.RawQuery = opQuery 142 } 143 144 request.Method = "POST" 145 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 146 if err != nil { 147 return out, metadata, &smithy.SerializationError{Err: err} 148 } 149 150 restEncoder.SetHeader("Content-Type").String("application/json") 151 152 jsonEncoder := smithyjson.NewEncoder() 153 if err := awsRestjson1_serializeOpDocumentCreateNetworkInput(input, jsonEncoder.Value); err != nil { 154 return out, metadata, &smithy.SerializationError{Err: err} 155 } 156 157 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 158 return out, metadata, &smithy.SerializationError{Err: err} 159 } 160 161 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 162 return out, metadata, &smithy.SerializationError{Err: err} 163 } 164 in.Request = request 165 166 return next.HandleSerialize(ctx, in) 167} 168func awsRestjson1_serializeOpHttpBindingsCreateNetworkInput(v *CreateNetworkInput, encoder *httpbinding.Encoder) error { 169 if v == nil { 170 return fmt.Errorf("unsupported serialization of nil %T", v) 171 } 172 173 return nil 174} 175 176func awsRestjson1_serializeOpDocumentCreateNetworkInput(v *CreateNetworkInput, value smithyjson.Value) error { 177 object := value.Object() 178 defer object.Close() 179 180 if v.ClientRequestToken != nil { 181 ok := object.Key("ClientRequestToken") 182 ok.String(*v.ClientRequestToken) 183 } 184 185 if v.Description != nil { 186 ok := object.Key("Description") 187 ok.String(*v.Description) 188 } 189 190 if len(v.Framework) > 0 { 191 ok := object.Key("Framework") 192 ok.String(string(v.Framework)) 193 } 194 195 if v.FrameworkConfiguration != nil { 196 ok := object.Key("FrameworkConfiguration") 197 if err := awsRestjson1_serializeDocumentNetworkFrameworkConfiguration(v.FrameworkConfiguration, ok); err != nil { 198 return err 199 } 200 } 201 202 if v.FrameworkVersion != nil { 203 ok := object.Key("FrameworkVersion") 204 ok.String(*v.FrameworkVersion) 205 } 206 207 if v.MemberConfiguration != nil { 208 ok := object.Key("MemberConfiguration") 209 if err := awsRestjson1_serializeDocumentMemberConfiguration(v.MemberConfiguration, ok); err != nil { 210 return err 211 } 212 } 213 214 if v.Name != nil { 215 ok := object.Key("Name") 216 ok.String(*v.Name) 217 } 218 219 if v.VotingPolicy != nil { 220 ok := object.Key("VotingPolicy") 221 if err := awsRestjson1_serializeDocumentVotingPolicy(v.VotingPolicy, ok); err != nil { 222 return err 223 } 224 } 225 226 return nil 227} 228 229type awsRestjson1_serializeOpCreateNode struct { 230} 231 232func (*awsRestjson1_serializeOpCreateNode) ID() string { 233 return "OperationSerializer" 234} 235 236func (m *awsRestjson1_serializeOpCreateNode) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 237 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 238) { 239 request, ok := in.Request.(*smithyhttp.Request) 240 if !ok { 241 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 242 } 243 244 input, ok := in.Parameters.(*CreateNodeInput) 245 _ = input 246 if !ok { 247 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 248 } 249 250 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/nodes") 251 request.URL.Path = opPath 252 if len(request.URL.RawQuery) > 0 { 253 request.URL.RawQuery = "&" + opQuery 254 } else { 255 request.URL.RawQuery = opQuery 256 } 257 258 request.Method = "POST" 259 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 260 if err != nil { 261 return out, metadata, &smithy.SerializationError{Err: err} 262 } 263 264 if err := awsRestjson1_serializeOpHttpBindingsCreateNodeInput(input, restEncoder); err != nil { 265 return out, metadata, &smithy.SerializationError{Err: err} 266 } 267 268 restEncoder.SetHeader("Content-Type").String("application/json") 269 270 jsonEncoder := smithyjson.NewEncoder() 271 if err := awsRestjson1_serializeOpDocumentCreateNodeInput(input, jsonEncoder.Value); err != nil { 272 return out, metadata, &smithy.SerializationError{Err: err} 273 } 274 275 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 276 return out, metadata, &smithy.SerializationError{Err: err} 277 } 278 279 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 280 return out, metadata, &smithy.SerializationError{Err: err} 281 } 282 in.Request = request 283 284 return next.HandleSerialize(ctx, in) 285} 286func awsRestjson1_serializeOpHttpBindingsCreateNodeInput(v *CreateNodeInput, encoder *httpbinding.Encoder) error { 287 if v == nil { 288 return fmt.Errorf("unsupported serialization of nil %T", v) 289 } 290 291 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 292 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 293 } 294 if v.NetworkId != nil { 295 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 296 return err 297 } 298 } 299 300 return nil 301} 302 303func awsRestjson1_serializeOpDocumentCreateNodeInput(v *CreateNodeInput, value smithyjson.Value) error { 304 object := value.Object() 305 defer object.Close() 306 307 if v.ClientRequestToken != nil { 308 ok := object.Key("ClientRequestToken") 309 ok.String(*v.ClientRequestToken) 310 } 311 312 if v.MemberId != nil { 313 ok := object.Key("MemberId") 314 ok.String(*v.MemberId) 315 } 316 317 if v.NodeConfiguration != nil { 318 ok := object.Key("NodeConfiguration") 319 if err := awsRestjson1_serializeDocumentNodeConfiguration(v.NodeConfiguration, ok); err != nil { 320 return err 321 } 322 } 323 324 return nil 325} 326 327type awsRestjson1_serializeOpCreateProposal struct { 328} 329 330func (*awsRestjson1_serializeOpCreateProposal) ID() string { 331 return "OperationSerializer" 332} 333 334func (m *awsRestjson1_serializeOpCreateProposal) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 335 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 336) { 337 request, ok := in.Request.(*smithyhttp.Request) 338 if !ok { 339 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 340 } 341 342 input, ok := in.Parameters.(*CreateProposalInput) 343 _ = input 344 if !ok { 345 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 346 } 347 348 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/proposals") 349 request.URL.Path = opPath 350 if len(request.URL.RawQuery) > 0 { 351 request.URL.RawQuery = "&" + opQuery 352 } else { 353 request.URL.RawQuery = opQuery 354 } 355 356 request.Method = "POST" 357 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 358 if err != nil { 359 return out, metadata, &smithy.SerializationError{Err: err} 360 } 361 362 if err := awsRestjson1_serializeOpHttpBindingsCreateProposalInput(input, restEncoder); err != nil { 363 return out, metadata, &smithy.SerializationError{Err: err} 364 } 365 366 restEncoder.SetHeader("Content-Type").String("application/json") 367 368 jsonEncoder := smithyjson.NewEncoder() 369 if err := awsRestjson1_serializeOpDocumentCreateProposalInput(input, jsonEncoder.Value); err != nil { 370 return out, metadata, &smithy.SerializationError{Err: err} 371 } 372 373 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 374 return out, metadata, &smithy.SerializationError{Err: err} 375 } 376 377 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 378 return out, metadata, &smithy.SerializationError{Err: err} 379 } 380 in.Request = request 381 382 return next.HandleSerialize(ctx, in) 383} 384func awsRestjson1_serializeOpHttpBindingsCreateProposalInput(v *CreateProposalInput, encoder *httpbinding.Encoder) error { 385 if v == nil { 386 return fmt.Errorf("unsupported serialization of nil %T", v) 387 } 388 389 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 390 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 391 } 392 if v.NetworkId != nil { 393 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 394 return err 395 } 396 } 397 398 return nil 399} 400 401func awsRestjson1_serializeOpDocumentCreateProposalInput(v *CreateProposalInput, value smithyjson.Value) error { 402 object := value.Object() 403 defer object.Close() 404 405 if v.Actions != nil { 406 ok := object.Key("Actions") 407 if err := awsRestjson1_serializeDocumentProposalActions(v.Actions, ok); err != nil { 408 return err 409 } 410 } 411 412 if v.ClientRequestToken != nil { 413 ok := object.Key("ClientRequestToken") 414 ok.String(*v.ClientRequestToken) 415 } 416 417 if v.Description != nil { 418 ok := object.Key("Description") 419 ok.String(*v.Description) 420 } 421 422 if v.MemberId != nil { 423 ok := object.Key("MemberId") 424 ok.String(*v.MemberId) 425 } 426 427 return nil 428} 429 430type awsRestjson1_serializeOpDeleteMember struct { 431} 432 433func (*awsRestjson1_serializeOpDeleteMember) ID() string { 434 return "OperationSerializer" 435} 436 437func (m *awsRestjson1_serializeOpDeleteMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 438 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 439) { 440 request, ok := in.Request.(*smithyhttp.Request) 441 if !ok { 442 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 443 } 444 445 input, ok := in.Parameters.(*DeleteMemberInput) 446 _ = input 447 if !ok { 448 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 449 } 450 451 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/members/{MemberId}") 452 request.URL.Path = opPath 453 if len(request.URL.RawQuery) > 0 { 454 request.URL.RawQuery = "&" + opQuery 455 } else { 456 request.URL.RawQuery = opQuery 457 } 458 459 request.Method = "DELETE" 460 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 461 if err != nil { 462 return out, metadata, &smithy.SerializationError{Err: err} 463 } 464 465 if err := awsRestjson1_serializeOpHttpBindingsDeleteMemberInput(input, restEncoder); err != nil { 466 return out, metadata, &smithy.SerializationError{Err: err} 467 } 468 469 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 470 return out, metadata, &smithy.SerializationError{Err: err} 471 } 472 in.Request = request 473 474 return next.HandleSerialize(ctx, in) 475} 476func awsRestjson1_serializeOpHttpBindingsDeleteMemberInput(v *DeleteMemberInput, encoder *httpbinding.Encoder) error { 477 if v == nil { 478 return fmt.Errorf("unsupported serialization of nil %T", v) 479 } 480 481 if v.MemberId == nil || len(*v.MemberId) == 0 { 482 return &smithy.SerializationError{Err: fmt.Errorf("input member MemberId must not be empty")} 483 } 484 if v.MemberId != nil { 485 if err := encoder.SetURI("MemberId").String(*v.MemberId); err != nil { 486 return err 487 } 488 } 489 490 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 491 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 492 } 493 if v.NetworkId != nil { 494 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 495 return err 496 } 497 } 498 499 return nil 500} 501 502type awsRestjson1_serializeOpDeleteNode struct { 503} 504 505func (*awsRestjson1_serializeOpDeleteNode) ID() string { 506 return "OperationSerializer" 507} 508 509func (m *awsRestjson1_serializeOpDeleteNode) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 510 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 511) { 512 request, ok := in.Request.(*smithyhttp.Request) 513 if !ok { 514 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 515 } 516 517 input, ok := in.Parameters.(*DeleteNodeInput) 518 _ = input 519 if !ok { 520 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 521 } 522 523 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/nodes/{NodeId}") 524 request.URL.Path = opPath 525 if len(request.URL.RawQuery) > 0 { 526 request.URL.RawQuery = "&" + opQuery 527 } else { 528 request.URL.RawQuery = opQuery 529 } 530 531 request.Method = "DELETE" 532 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 533 if err != nil { 534 return out, metadata, &smithy.SerializationError{Err: err} 535 } 536 537 if err := awsRestjson1_serializeOpHttpBindingsDeleteNodeInput(input, restEncoder); err != nil { 538 return out, metadata, &smithy.SerializationError{Err: err} 539 } 540 541 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 542 return out, metadata, &smithy.SerializationError{Err: err} 543 } 544 in.Request = request 545 546 return next.HandleSerialize(ctx, in) 547} 548func awsRestjson1_serializeOpHttpBindingsDeleteNodeInput(v *DeleteNodeInput, encoder *httpbinding.Encoder) error { 549 if v == nil { 550 return fmt.Errorf("unsupported serialization of nil %T", v) 551 } 552 553 if v.MemberId != nil { 554 encoder.SetQuery("memberId").String(*v.MemberId) 555 } 556 557 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 558 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 559 } 560 if v.NetworkId != nil { 561 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 562 return err 563 } 564 } 565 566 if v.NodeId == nil || len(*v.NodeId) == 0 { 567 return &smithy.SerializationError{Err: fmt.Errorf("input member NodeId must not be empty")} 568 } 569 if v.NodeId != nil { 570 if err := encoder.SetURI("NodeId").String(*v.NodeId); err != nil { 571 return err 572 } 573 } 574 575 return nil 576} 577 578type awsRestjson1_serializeOpGetMember struct { 579} 580 581func (*awsRestjson1_serializeOpGetMember) ID() string { 582 return "OperationSerializer" 583} 584 585func (m *awsRestjson1_serializeOpGetMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 586 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 587) { 588 request, ok := in.Request.(*smithyhttp.Request) 589 if !ok { 590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 591 } 592 593 input, ok := in.Parameters.(*GetMemberInput) 594 _ = input 595 if !ok { 596 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 597 } 598 599 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/members/{MemberId}") 600 request.URL.Path = opPath 601 if len(request.URL.RawQuery) > 0 { 602 request.URL.RawQuery = "&" + opQuery 603 } else { 604 request.URL.RawQuery = opQuery 605 } 606 607 request.Method = "GET" 608 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 609 if err != nil { 610 return out, metadata, &smithy.SerializationError{Err: err} 611 } 612 613 if err := awsRestjson1_serializeOpHttpBindingsGetMemberInput(input, restEncoder); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 618 return out, metadata, &smithy.SerializationError{Err: err} 619 } 620 in.Request = request 621 622 return next.HandleSerialize(ctx, in) 623} 624func awsRestjson1_serializeOpHttpBindingsGetMemberInput(v *GetMemberInput, encoder *httpbinding.Encoder) error { 625 if v == nil { 626 return fmt.Errorf("unsupported serialization of nil %T", v) 627 } 628 629 if v.MemberId == nil || len(*v.MemberId) == 0 { 630 return &smithy.SerializationError{Err: fmt.Errorf("input member MemberId must not be empty")} 631 } 632 if v.MemberId != nil { 633 if err := encoder.SetURI("MemberId").String(*v.MemberId); err != nil { 634 return err 635 } 636 } 637 638 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 639 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 640 } 641 if v.NetworkId != nil { 642 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 643 return err 644 } 645 } 646 647 return nil 648} 649 650type awsRestjson1_serializeOpGetNetwork struct { 651} 652 653func (*awsRestjson1_serializeOpGetNetwork) ID() string { 654 return "OperationSerializer" 655} 656 657func (m *awsRestjson1_serializeOpGetNetwork) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 658 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 659) { 660 request, ok := in.Request.(*smithyhttp.Request) 661 if !ok { 662 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 663 } 664 665 input, ok := in.Parameters.(*GetNetworkInput) 666 _ = input 667 if !ok { 668 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 669 } 670 671 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}") 672 request.URL.Path = opPath 673 if len(request.URL.RawQuery) > 0 { 674 request.URL.RawQuery = "&" + opQuery 675 } else { 676 request.URL.RawQuery = opQuery 677 } 678 679 request.Method = "GET" 680 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 681 if err != nil { 682 return out, metadata, &smithy.SerializationError{Err: err} 683 } 684 685 if err := awsRestjson1_serializeOpHttpBindingsGetNetworkInput(input, restEncoder); err != nil { 686 return out, metadata, &smithy.SerializationError{Err: err} 687 } 688 689 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 690 return out, metadata, &smithy.SerializationError{Err: err} 691 } 692 in.Request = request 693 694 return next.HandleSerialize(ctx, in) 695} 696func awsRestjson1_serializeOpHttpBindingsGetNetworkInput(v *GetNetworkInput, encoder *httpbinding.Encoder) error { 697 if v == nil { 698 return fmt.Errorf("unsupported serialization of nil %T", v) 699 } 700 701 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 702 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 703 } 704 if v.NetworkId != nil { 705 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 706 return err 707 } 708 } 709 710 return nil 711} 712 713type awsRestjson1_serializeOpGetNode struct { 714} 715 716func (*awsRestjson1_serializeOpGetNode) ID() string { 717 return "OperationSerializer" 718} 719 720func (m *awsRestjson1_serializeOpGetNode) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 721 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 722) { 723 request, ok := in.Request.(*smithyhttp.Request) 724 if !ok { 725 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 726 } 727 728 input, ok := in.Parameters.(*GetNodeInput) 729 _ = input 730 if !ok { 731 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 732 } 733 734 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/nodes/{NodeId}") 735 request.URL.Path = opPath 736 if len(request.URL.RawQuery) > 0 { 737 request.URL.RawQuery = "&" + opQuery 738 } else { 739 request.URL.RawQuery = opQuery 740 } 741 742 request.Method = "GET" 743 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 744 if err != nil { 745 return out, metadata, &smithy.SerializationError{Err: err} 746 } 747 748 if err := awsRestjson1_serializeOpHttpBindingsGetNodeInput(input, restEncoder); err != nil { 749 return out, metadata, &smithy.SerializationError{Err: err} 750 } 751 752 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 753 return out, metadata, &smithy.SerializationError{Err: err} 754 } 755 in.Request = request 756 757 return next.HandleSerialize(ctx, in) 758} 759func awsRestjson1_serializeOpHttpBindingsGetNodeInput(v *GetNodeInput, encoder *httpbinding.Encoder) error { 760 if v == nil { 761 return fmt.Errorf("unsupported serialization of nil %T", v) 762 } 763 764 if v.MemberId != nil { 765 encoder.SetQuery("memberId").String(*v.MemberId) 766 } 767 768 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 769 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 770 } 771 if v.NetworkId != nil { 772 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 773 return err 774 } 775 } 776 777 if v.NodeId == nil || len(*v.NodeId) == 0 { 778 return &smithy.SerializationError{Err: fmt.Errorf("input member NodeId must not be empty")} 779 } 780 if v.NodeId != nil { 781 if err := encoder.SetURI("NodeId").String(*v.NodeId); err != nil { 782 return err 783 } 784 } 785 786 return nil 787} 788 789type awsRestjson1_serializeOpGetProposal struct { 790} 791 792func (*awsRestjson1_serializeOpGetProposal) ID() string { 793 return "OperationSerializer" 794} 795 796func (m *awsRestjson1_serializeOpGetProposal) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 797 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 798) { 799 request, ok := in.Request.(*smithyhttp.Request) 800 if !ok { 801 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 802 } 803 804 input, ok := in.Parameters.(*GetProposalInput) 805 _ = input 806 if !ok { 807 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 808 } 809 810 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/proposals/{ProposalId}") 811 request.URL.Path = opPath 812 if len(request.URL.RawQuery) > 0 { 813 request.URL.RawQuery = "&" + opQuery 814 } else { 815 request.URL.RawQuery = opQuery 816 } 817 818 request.Method = "GET" 819 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 820 if err != nil { 821 return out, metadata, &smithy.SerializationError{Err: err} 822 } 823 824 if err := awsRestjson1_serializeOpHttpBindingsGetProposalInput(input, restEncoder); err != nil { 825 return out, metadata, &smithy.SerializationError{Err: err} 826 } 827 828 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 829 return out, metadata, &smithy.SerializationError{Err: err} 830 } 831 in.Request = request 832 833 return next.HandleSerialize(ctx, in) 834} 835func awsRestjson1_serializeOpHttpBindingsGetProposalInput(v *GetProposalInput, encoder *httpbinding.Encoder) error { 836 if v == nil { 837 return fmt.Errorf("unsupported serialization of nil %T", v) 838 } 839 840 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 841 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 842 } 843 if v.NetworkId != nil { 844 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 845 return err 846 } 847 } 848 849 if v.ProposalId == nil || len(*v.ProposalId) == 0 { 850 return &smithy.SerializationError{Err: fmt.Errorf("input member ProposalId must not be empty")} 851 } 852 if v.ProposalId != nil { 853 if err := encoder.SetURI("ProposalId").String(*v.ProposalId); err != nil { 854 return err 855 } 856 } 857 858 return nil 859} 860 861type awsRestjson1_serializeOpListInvitations struct { 862} 863 864func (*awsRestjson1_serializeOpListInvitations) ID() string { 865 return "OperationSerializer" 866} 867 868func (m *awsRestjson1_serializeOpListInvitations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 869 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 870) { 871 request, ok := in.Request.(*smithyhttp.Request) 872 if !ok { 873 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 874 } 875 876 input, ok := in.Parameters.(*ListInvitationsInput) 877 _ = input 878 if !ok { 879 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 880 } 881 882 opPath, opQuery := httpbinding.SplitURI("/invitations") 883 request.URL.Path = opPath 884 if len(request.URL.RawQuery) > 0 { 885 request.URL.RawQuery = "&" + opQuery 886 } else { 887 request.URL.RawQuery = opQuery 888 } 889 890 request.Method = "GET" 891 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 892 if err != nil { 893 return out, metadata, &smithy.SerializationError{Err: err} 894 } 895 896 if err := awsRestjson1_serializeOpHttpBindingsListInvitationsInput(input, restEncoder); err != nil { 897 return out, metadata, &smithy.SerializationError{Err: err} 898 } 899 900 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 901 return out, metadata, &smithy.SerializationError{Err: err} 902 } 903 in.Request = request 904 905 return next.HandleSerialize(ctx, in) 906} 907func awsRestjson1_serializeOpHttpBindingsListInvitationsInput(v *ListInvitationsInput, encoder *httpbinding.Encoder) error { 908 if v == nil { 909 return fmt.Errorf("unsupported serialization of nil %T", v) 910 } 911 912 if v.MaxResults != nil { 913 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 914 } 915 916 if v.NextToken != nil { 917 encoder.SetQuery("nextToken").String(*v.NextToken) 918 } 919 920 return nil 921} 922 923type awsRestjson1_serializeOpListMembers struct { 924} 925 926func (*awsRestjson1_serializeOpListMembers) ID() string { 927 return "OperationSerializer" 928} 929 930func (m *awsRestjson1_serializeOpListMembers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 931 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 932) { 933 request, ok := in.Request.(*smithyhttp.Request) 934 if !ok { 935 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 936 } 937 938 input, ok := in.Parameters.(*ListMembersInput) 939 _ = input 940 if !ok { 941 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 942 } 943 944 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/members") 945 request.URL.Path = opPath 946 if len(request.URL.RawQuery) > 0 { 947 request.URL.RawQuery = "&" + opQuery 948 } else { 949 request.URL.RawQuery = opQuery 950 } 951 952 request.Method = "GET" 953 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 954 if err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 958 if err := awsRestjson1_serializeOpHttpBindingsListMembersInput(input, restEncoder); err != nil { 959 return out, metadata, &smithy.SerializationError{Err: err} 960 } 961 962 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 963 return out, metadata, &smithy.SerializationError{Err: err} 964 } 965 in.Request = request 966 967 return next.HandleSerialize(ctx, in) 968} 969func awsRestjson1_serializeOpHttpBindingsListMembersInput(v *ListMembersInput, encoder *httpbinding.Encoder) error { 970 if v == nil { 971 return fmt.Errorf("unsupported serialization of nil %T", v) 972 } 973 974 if v.IsOwned != nil { 975 encoder.SetQuery("isOwned").Boolean(*v.IsOwned) 976 } 977 978 if v.MaxResults != nil { 979 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 980 } 981 982 if v.Name != nil { 983 encoder.SetQuery("name").String(*v.Name) 984 } 985 986 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 987 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 988 } 989 if v.NetworkId != nil { 990 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 991 return err 992 } 993 } 994 995 if v.NextToken != nil { 996 encoder.SetQuery("nextToken").String(*v.NextToken) 997 } 998 999 if len(v.Status) > 0 { 1000 encoder.SetQuery("status").String(string(v.Status)) 1001 } 1002 1003 return nil 1004} 1005 1006type awsRestjson1_serializeOpListNetworks struct { 1007} 1008 1009func (*awsRestjson1_serializeOpListNetworks) ID() string { 1010 return "OperationSerializer" 1011} 1012 1013func (m *awsRestjson1_serializeOpListNetworks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1014 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1015) { 1016 request, ok := in.Request.(*smithyhttp.Request) 1017 if !ok { 1018 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1019 } 1020 1021 input, ok := in.Parameters.(*ListNetworksInput) 1022 _ = input 1023 if !ok { 1024 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1025 } 1026 1027 opPath, opQuery := httpbinding.SplitURI("/networks") 1028 request.URL.Path = opPath 1029 if len(request.URL.RawQuery) > 0 { 1030 request.URL.RawQuery = "&" + opQuery 1031 } else { 1032 request.URL.RawQuery = opQuery 1033 } 1034 1035 request.Method = "GET" 1036 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1037 if err != nil { 1038 return out, metadata, &smithy.SerializationError{Err: err} 1039 } 1040 1041 if err := awsRestjson1_serializeOpHttpBindingsListNetworksInput(input, restEncoder); err != nil { 1042 return out, metadata, &smithy.SerializationError{Err: err} 1043 } 1044 1045 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1046 return out, metadata, &smithy.SerializationError{Err: err} 1047 } 1048 in.Request = request 1049 1050 return next.HandleSerialize(ctx, in) 1051} 1052func awsRestjson1_serializeOpHttpBindingsListNetworksInput(v *ListNetworksInput, encoder *httpbinding.Encoder) error { 1053 if v == nil { 1054 return fmt.Errorf("unsupported serialization of nil %T", v) 1055 } 1056 1057 if len(v.Framework) > 0 { 1058 encoder.SetQuery("framework").String(string(v.Framework)) 1059 } 1060 1061 if v.MaxResults != nil { 1062 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1063 } 1064 1065 if v.Name != nil { 1066 encoder.SetQuery("name").String(*v.Name) 1067 } 1068 1069 if v.NextToken != nil { 1070 encoder.SetQuery("nextToken").String(*v.NextToken) 1071 } 1072 1073 if len(v.Status) > 0 { 1074 encoder.SetQuery("status").String(string(v.Status)) 1075 } 1076 1077 return nil 1078} 1079 1080type awsRestjson1_serializeOpListNodes struct { 1081} 1082 1083func (*awsRestjson1_serializeOpListNodes) ID() string { 1084 return "OperationSerializer" 1085} 1086 1087func (m *awsRestjson1_serializeOpListNodes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1088 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1089) { 1090 request, ok := in.Request.(*smithyhttp.Request) 1091 if !ok { 1092 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1093 } 1094 1095 input, ok := in.Parameters.(*ListNodesInput) 1096 _ = input 1097 if !ok { 1098 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1099 } 1100 1101 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/nodes") 1102 request.URL.Path = opPath 1103 if len(request.URL.RawQuery) > 0 { 1104 request.URL.RawQuery = "&" + opQuery 1105 } else { 1106 request.URL.RawQuery = opQuery 1107 } 1108 1109 request.Method = "GET" 1110 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1111 if err != nil { 1112 return out, metadata, &smithy.SerializationError{Err: err} 1113 } 1114 1115 if err := awsRestjson1_serializeOpHttpBindingsListNodesInput(input, restEncoder); err != nil { 1116 return out, metadata, &smithy.SerializationError{Err: err} 1117 } 1118 1119 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1120 return out, metadata, &smithy.SerializationError{Err: err} 1121 } 1122 in.Request = request 1123 1124 return next.HandleSerialize(ctx, in) 1125} 1126func awsRestjson1_serializeOpHttpBindingsListNodesInput(v *ListNodesInput, encoder *httpbinding.Encoder) error { 1127 if v == nil { 1128 return fmt.Errorf("unsupported serialization of nil %T", v) 1129 } 1130 1131 if v.MaxResults != nil { 1132 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1133 } 1134 1135 if v.MemberId != nil { 1136 encoder.SetQuery("memberId").String(*v.MemberId) 1137 } 1138 1139 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1140 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1141 } 1142 if v.NetworkId != nil { 1143 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1144 return err 1145 } 1146 } 1147 1148 if v.NextToken != nil { 1149 encoder.SetQuery("nextToken").String(*v.NextToken) 1150 } 1151 1152 if len(v.Status) > 0 { 1153 encoder.SetQuery("status").String(string(v.Status)) 1154 } 1155 1156 return nil 1157} 1158 1159type awsRestjson1_serializeOpListProposals struct { 1160} 1161 1162func (*awsRestjson1_serializeOpListProposals) ID() string { 1163 return "OperationSerializer" 1164} 1165 1166func (m *awsRestjson1_serializeOpListProposals) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1167 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1168) { 1169 request, ok := in.Request.(*smithyhttp.Request) 1170 if !ok { 1171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1172 } 1173 1174 input, ok := in.Parameters.(*ListProposalsInput) 1175 _ = input 1176 if !ok { 1177 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1178 } 1179 1180 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/proposals") 1181 request.URL.Path = opPath 1182 if len(request.URL.RawQuery) > 0 { 1183 request.URL.RawQuery = "&" + opQuery 1184 } else { 1185 request.URL.RawQuery = opQuery 1186 } 1187 1188 request.Method = "GET" 1189 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1190 if err != nil { 1191 return out, metadata, &smithy.SerializationError{Err: err} 1192 } 1193 1194 if err := awsRestjson1_serializeOpHttpBindingsListProposalsInput(input, restEncoder); err != nil { 1195 return out, metadata, &smithy.SerializationError{Err: err} 1196 } 1197 1198 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1199 return out, metadata, &smithy.SerializationError{Err: err} 1200 } 1201 in.Request = request 1202 1203 return next.HandleSerialize(ctx, in) 1204} 1205func awsRestjson1_serializeOpHttpBindingsListProposalsInput(v *ListProposalsInput, encoder *httpbinding.Encoder) error { 1206 if v == nil { 1207 return fmt.Errorf("unsupported serialization of nil %T", v) 1208 } 1209 1210 if v.MaxResults != nil { 1211 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1212 } 1213 1214 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1215 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1216 } 1217 if v.NetworkId != nil { 1218 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1219 return err 1220 } 1221 } 1222 1223 if v.NextToken != nil { 1224 encoder.SetQuery("nextToken").String(*v.NextToken) 1225 } 1226 1227 return nil 1228} 1229 1230type awsRestjson1_serializeOpListProposalVotes struct { 1231} 1232 1233func (*awsRestjson1_serializeOpListProposalVotes) ID() string { 1234 return "OperationSerializer" 1235} 1236 1237func (m *awsRestjson1_serializeOpListProposalVotes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1238 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1239) { 1240 request, ok := in.Request.(*smithyhttp.Request) 1241 if !ok { 1242 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1243 } 1244 1245 input, ok := in.Parameters.(*ListProposalVotesInput) 1246 _ = input 1247 if !ok { 1248 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1249 } 1250 1251 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/proposals/{ProposalId}/votes") 1252 request.URL.Path = opPath 1253 if len(request.URL.RawQuery) > 0 { 1254 request.URL.RawQuery = "&" + opQuery 1255 } else { 1256 request.URL.RawQuery = opQuery 1257 } 1258 1259 request.Method = "GET" 1260 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1261 if err != nil { 1262 return out, metadata, &smithy.SerializationError{Err: err} 1263 } 1264 1265 if err := awsRestjson1_serializeOpHttpBindingsListProposalVotesInput(input, restEncoder); err != nil { 1266 return out, metadata, &smithy.SerializationError{Err: err} 1267 } 1268 1269 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1270 return out, metadata, &smithy.SerializationError{Err: err} 1271 } 1272 in.Request = request 1273 1274 return next.HandleSerialize(ctx, in) 1275} 1276func awsRestjson1_serializeOpHttpBindingsListProposalVotesInput(v *ListProposalVotesInput, encoder *httpbinding.Encoder) error { 1277 if v == nil { 1278 return fmt.Errorf("unsupported serialization of nil %T", v) 1279 } 1280 1281 if v.MaxResults != nil { 1282 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1283 } 1284 1285 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1286 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1287 } 1288 if v.NetworkId != nil { 1289 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1290 return err 1291 } 1292 } 1293 1294 if v.NextToken != nil { 1295 encoder.SetQuery("nextToken").String(*v.NextToken) 1296 } 1297 1298 if v.ProposalId == nil || len(*v.ProposalId) == 0 { 1299 return &smithy.SerializationError{Err: fmt.Errorf("input member ProposalId must not be empty")} 1300 } 1301 if v.ProposalId != nil { 1302 if err := encoder.SetURI("ProposalId").String(*v.ProposalId); err != nil { 1303 return err 1304 } 1305 } 1306 1307 return nil 1308} 1309 1310type awsRestjson1_serializeOpRejectInvitation struct { 1311} 1312 1313func (*awsRestjson1_serializeOpRejectInvitation) ID() string { 1314 return "OperationSerializer" 1315} 1316 1317func (m *awsRestjson1_serializeOpRejectInvitation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1318 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1319) { 1320 request, ok := in.Request.(*smithyhttp.Request) 1321 if !ok { 1322 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1323 } 1324 1325 input, ok := in.Parameters.(*RejectInvitationInput) 1326 _ = input 1327 if !ok { 1328 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1329 } 1330 1331 opPath, opQuery := httpbinding.SplitURI("/invitations/{InvitationId}") 1332 request.URL.Path = opPath 1333 if len(request.URL.RawQuery) > 0 { 1334 request.URL.RawQuery = "&" + opQuery 1335 } else { 1336 request.URL.RawQuery = opQuery 1337 } 1338 1339 request.Method = "DELETE" 1340 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1341 if err != nil { 1342 return out, metadata, &smithy.SerializationError{Err: err} 1343 } 1344 1345 if err := awsRestjson1_serializeOpHttpBindingsRejectInvitationInput(input, restEncoder); err != nil { 1346 return out, metadata, &smithy.SerializationError{Err: err} 1347 } 1348 1349 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1350 return out, metadata, &smithy.SerializationError{Err: err} 1351 } 1352 in.Request = request 1353 1354 return next.HandleSerialize(ctx, in) 1355} 1356func awsRestjson1_serializeOpHttpBindingsRejectInvitationInput(v *RejectInvitationInput, encoder *httpbinding.Encoder) error { 1357 if v == nil { 1358 return fmt.Errorf("unsupported serialization of nil %T", v) 1359 } 1360 1361 if v.InvitationId == nil || len(*v.InvitationId) == 0 { 1362 return &smithy.SerializationError{Err: fmt.Errorf("input member InvitationId must not be empty")} 1363 } 1364 if v.InvitationId != nil { 1365 if err := encoder.SetURI("InvitationId").String(*v.InvitationId); err != nil { 1366 return err 1367 } 1368 } 1369 1370 return nil 1371} 1372 1373type awsRestjson1_serializeOpUpdateMember struct { 1374} 1375 1376func (*awsRestjson1_serializeOpUpdateMember) ID() string { 1377 return "OperationSerializer" 1378} 1379 1380func (m *awsRestjson1_serializeOpUpdateMember) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1381 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1382) { 1383 request, ok := in.Request.(*smithyhttp.Request) 1384 if !ok { 1385 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1386 } 1387 1388 input, ok := in.Parameters.(*UpdateMemberInput) 1389 _ = input 1390 if !ok { 1391 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1392 } 1393 1394 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/members/{MemberId}") 1395 request.URL.Path = opPath 1396 if len(request.URL.RawQuery) > 0 { 1397 request.URL.RawQuery = "&" + opQuery 1398 } else { 1399 request.URL.RawQuery = opQuery 1400 } 1401 1402 request.Method = "PATCH" 1403 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1404 if err != nil { 1405 return out, metadata, &smithy.SerializationError{Err: err} 1406 } 1407 1408 if err := awsRestjson1_serializeOpHttpBindingsUpdateMemberInput(input, restEncoder); err != nil { 1409 return out, metadata, &smithy.SerializationError{Err: err} 1410 } 1411 1412 restEncoder.SetHeader("Content-Type").String("application/json") 1413 1414 jsonEncoder := smithyjson.NewEncoder() 1415 if err := awsRestjson1_serializeOpDocumentUpdateMemberInput(input, jsonEncoder.Value); err != nil { 1416 return out, metadata, &smithy.SerializationError{Err: err} 1417 } 1418 1419 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1420 return out, metadata, &smithy.SerializationError{Err: err} 1421 } 1422 1423 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1424 return out, metadata, &smithy.SerializationError{Err: err} 1425 } 1426 in.Request = request 1427 1428 return next.HandleSerialize(ctx, in) 1429} 1430func awsRestjson1_serializeOpHttpBindingsUpdateMemberInput(v *UpdateMemberInput, encoder *httpbinding.Encoder) error { 1431 if v == nil { 1432 return fmt.Errorf("unsupported serialization of nil %T", v) 1433 } 1434 1435 if v.MemberId == nil || len(*v.MemberId) == 0 { 1436 return &smithy.SerializationError{Err: fmt.Errorf("input member MemberId must not be empty")} 1437 } 1438 if v.MemberId != nil { 1439 if err := encoder.SetURI("MemberId").String(*v.MemberId); err != nil { 1440 return err 1441 } 1442 } 1443 1444 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1445 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1446 } 1447 if v.NetworkId != nil { 1448 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1449 return err 1450 } 1451 } 1452 1453 return nil 1454} 1455 1456func awsRestjson1_serializeOpDocumentUpdateMemberInput(v *UpdateMemberInput, value smithyjson.Value) error { 1457 object := value.Object() 1458 defer object.Close() 1459 1460 if v.LogPublishingConfiguration != nil { 1461 ok := object.Key("LogPublishingConfiguration") 1462 if err := awsRestjson1_serializeDocumentMemberLogPublishingConfiguration(v.LogPublishingConfiguration, ok); err != nil { 1463 return err 1464 } 1465 } 1466 1467 return nil 1468} 1469 1470type awsRestjson1_serializeOpUpdateNode struct { 1471} 1472 1473func (*awsRestjson1_serializeOpUpdateNode) ID() string { 1474 return "OperationSerializer" 1475} 1476 1477func (m *awsRestjson1_serializeOpUpdateNode) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1478 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1479) { 1480 request, ok := in.Request.(*smithyhttp.Request) 1481 if !ok { 1482 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1483 } 1484 1485 input, ok := in.Parameters.(*UpdateNodeInput) 1486 _ = input 1487 if !ok { 1488 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1489 } 1490 1491 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/nodes/{NodeId}") 1492 request.URL.Path = opPath 1493 if len(request.URL.RawQuery) > 0 { 1494 request.URL.RawQuery = "&" + opQuery 1495 } else { 1496 request.URL.RawQuery = opQuery 1497 } 1498 1499 request.Method = "PATCH" 1500 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1501 if err != nil { 1502 return out, metadata, &smithy.SerializationError{Err: err} 1503 } 1504 1505 if err := awsRestjson1_serializeOpHttpBindingsUpdateNodeInput(input, restEncoder); err != nil { 1506 return out, metadata, &smithy.SerializationError{Err: err} 1507 } 1508 1509 restEncoder.SetHeader("Content-Type").String("application/json") 1510 1511 jsonEncoder := smithyjson.NewEncoder() 1512 if err := awsRestjson1_serializeOpDocumentUpdateNodeInput(input, jsonEncoder.Value); err != nil { 1513 return out, metadata, &smithy.SerializationError{Err: err} 1514 } 1515 1516 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1517 return out, metadata, &smithy.SerializationError{Err: err} 1518 } 1519 1520 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1521 return out, metadata, &smithy.SerializationError{Err: err} 1522 } 1523 in.Request = request 1524 1525 return next.HandleSerialize(ctx, in) 1526} 1527func awsRestjson1_serializeOpHttpBindingsUpdateNodeInput(v *UpdateNodeInput, encoder *httpbinding.Encoder) error { 1528 if v == nil { 1529 return fmt.Errorf("unsupported serialization of nil %T", v) 1530 } 1531 1532 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1533 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1534 } 1535 if v.NetworkId != nil { 1536 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1537 return err 1538 } 1539 } 1540 1541 if v.NodeId == nil || len(*v.NodeId) == 0 { 1542 return &smithy.SerializationError{Err: fmt.Errorf("input member NodeId must not be empty")} 1543 } 1544 if v.NodeId != nil { 1545 if err := encoder.SetURI("NodeId").String(*v.NodeId); err != nil { 1546 return err 1547 } 1548 } 1549 1550 return nil 1551} 1552 1553func awsRestjson1_serializeOpDocumentUpdateNodeInput(v *UpdateNodeInput, value smithyjson.Value) error { 1554 object := value.Object() 1555 defer object.Close() 1556 1557 if v.LogPublishingConfiguration != nil { 1558 ok := object.Key("LogPublishingConfiguration") 1559 if err := awsRestjson1_serializeDocumentNodeLogPublishingConfiguration(v.LogPublishingConfiguration, ok); err != nil { 1560 return err 1561 } 1562 } 1563 1564 if v.MemberId != nil { 1565 ok := object.Key("MemberId") 1566 ok.String(*v.MemberId) 1567 } 1568 1569 return nil 1570} 1571 1572type awsRestjson1_serializeOpVoteOnProposal struct { 1573} 1574 1575func (*awsRestjson1_serializeOpVoteOnProposal) ID() string { 1576 return "OperationSerializer" 1577} 1578 1579func (m *awsRestjson1_serializeOpVoteOnProposal) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1580 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1581) { 1582 request, ok := in.Request.(*smithyhttp.Request) 1583 if !ok { 1584 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1585 } 1586 1587 input, ok := in.Parameters.(*VoteOnProposalInput) 1588 _ = input 1589 if !ok { 1590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1591 } 1592 1593 opPath, opQuery := httpbinding.SplitURI("/networks/{NetworkId}/proposals/{ProposalId}/votes") 1594 request.URL.Path = opPath 1595 if len(request.URL.RawQuery) > 0 { 1596 request.URL.RawQuery = "&" + opQuery 1597 } else { 1598 request.URL.RawQuery = opQuery 1599 } 1600 1601 request.Method = "POST" 1602 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1603 if err != nil { 1604 return out, metadata, &smithy.SerializationError{Err: err} 1605 } 1606 1607 if err := awsRestjson1_serializeOpHttpBindingsVoteOnProposalInput(input, restEncoder); err != nil { 1608 return out, metadata, &smithy.SerializationError{Err: err} 1609 } 1610 1611 restEncoder.SetHeader("Content-Type").String("application/json") 1612 1613 jsonEncoder := smithyjson.NewEncoder() 1614 if err := awsRestjson1_serializeOpDocumentVoteOnProposalInput(input, jsonEncoder.Value); err != nil { 1615 return out, metadata, &smithy.SerializationError{Err: err} 1616 } 1617 1618 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1619 return out, metadata, &smithy.SerializationError{Err: err} 1620 } 1621 1622 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1623 return out, metadata, &smithy.SerializationError{Err: err} 1624 } 1625 in.Request = request 1626 1627 return next.HandleSerialize(ctx, in) 1628} 1629func awsRestjson1_serializeOpHttpBindingsVoteOnProposalInput(v *VoteOnProposalInput, encoder *httpbinding.Encoder) error { 1630 if v == nil { 1631 return fmt.Errorf("unsupported serialization of nil %T", v) 1632 } 1633 1634 if v.NetworkId == nil || len(*v.NetworkId) == 0 { 1635 return &smithy.SerializationError{Err: fmt.Errorf("input member NetworkId must not be empty")} 1636 } 1637 if v.NetworkId != nil { 1638 if err := encoder.SetURI("NetworkId").String(*v.NetworkId); err != nil { 1639 return err 1640 } 1641 } 1642 1643 if v.ProposalId == nil || len(*v.ProposalId) == 0 { 1644 return &smithy.SerializationError{Err: fmt.Errorf("input member ProposalId must not be empty")} 1645 } 1646 if v.ProposalId != nil { 1647 if err := encoder.SetURI("ProposalId").String(*v.ProposalId); err != nil { 1648 return err 1649 } 1650 } 1651 1652 return nil 1653} 1654 1655func awsRestjson1_serializeOpDocumentVoteOnProposalInput(v *VoteOnProposalInput, value smithyjson.Value) error { 1656 object := value.Object() 1657 defer object.Close() 1658 1659 if len(v.Vote) > 0 { 1660 ok := object.Key("Vote") 1661 ok.String(string(v.Vote)) 1662 } 1663 1664 if v.VoterMemberId != nil { 1665 ok := object.Key("VoterMemberId") 1666 ok.String(*v.VoterMemberId) 1667 } 1668 1669 return nil 1670} 1671 1672func awsRestjson1_serializeDocumentApprovalThresholdPolicy(v *types.ApprovalThresholdPolicy, value smithyjson.Value) error { 1673 object := value.Object() 1674 defer object.Close() 1675 1676 if v.ProposalDurationInHours != nil { 1677 ok := object.Key("ProposalDurationInHours") 1678 ok.Integer(*v.ProposalDurationInHours) 1679 } 1680 1681 if len(v.ThresholdComparator) > 0 { 1682 ok := object.Key("ThresholdComparator") 1683 ok.String(string(v.ThresholdComparator)) 1684 } 1685 1686 if v.ThresholdPercentage != nil { 1687 ok := object.Key("ThresholdPercentage") 1688 ok.Integer(*v.ThresholdPercentage) 1689 } 1690 1691 return nil 1692} 1693 1694func awsRestjson1_serializeDocumentInviteAction(v *types.InviteAction, value smithyjson.Value) error { 1695 object := value.Object() 1696 defer object.Close() 1697 1698 if v.Principal != nil { 1699 ok := object.Key("Principal") 1700 ok.String(*v.Principal) 1701 } 1702 1703 return nil 1704} 1705 1706func awsRestjson1_serializeDocumentInviteActionList(v []types.InviteAction, value smithyjson.Value) error { 1707 array := value.Array() 1708 defer array.Close() 1709 1710 for i := range v { 1711 av := array.Value() 1712 if err := awsRestjson1_serializeDocumentInviteAction(&v[i], av); err != nil { 1713 return err 1714 } 1715 } 1716 return nil 1717} 1718 1719func awsRestjson1_serializeDocumentLogConfiguration(v *types.LogConfiguration, value smithyjson.Value) error { 1720 object := value.Object() 1721 defer object.Close() 1722 1723 if v.Enabled != nil { 1724 ok := object.Key("Enabled") 1725 ok.Boolean(*v.Enabled) 1726 } 1727 1728 return nil 1729} 1730 1731func awsRestjson1_serializeDocumentLogConfigurations(v *types.LogConfigurations, value smithyjson.Value) error { 1732 object := value.Object() 1733 defer object.Close() 1734 1735 if v.Cloudwatch != nil { 1736 ok := object.Key("Cloudwatch") 1737 if err := awsRestjson1_serializeDocumentLogConfiguration(v.Cloudwatch, ok); err != nil { 1738 return err 1739 } 1740 } 1741 1742 return nil 1743} 1744 1745func awsRestjson1_serializeDocumentMemberConfiguration(v *types.MemberConfiguration, value smithyjson.Value) error { 1746 object := value.Object() 1747 defer object.Close() 1748 1749 if v.Description != nil { 1750 ok := object.Key("Description") 1751 ok.String(*v.Description) 1752 } 1753 1754 if v.FrameworkConfiguration != nil { 1755 ok := object.Key("FrameworkConfiguration") 1756 if err := awsRestjson1_serializeDocumentMemberFrameworkConfiguration(v.FrameworkConfiguration, ok); err != nil { 1757 return err 1758 } 1759 } 1760 1761 if v.LogPublishingConfiguration != nil { 1762 ok := object.Key("LogPublishingConfiguration") 1763 if err := awsRestjson1_serializeDocumentMemberLogPublishingConfiguration(v.LogPublishingConfiguration, ok); err != nil { 1764 return err 1765 } 1766 } 1767 1768 if v.Name != nil { 1769 ok := object.Key("Name") 1770 ok.String(*v.Name) 1771 } 1772 1773 return nil 1774} 1775 1776func awsRestjson1_serializeDocumentMemberFabricConfiguration(v *types.MemberFabricConfiguration, value smithyjson.Value) error { 1777 object := value.Object() 1778 defer object.Close() 1779 1780 if v.AdminPassword != nil { 1781 ok := object.Key("AdminPassword") 1782 ok.String(*v.AdminPassword) 1783 } 1784 1785 if v.AdminUsername != nil { 1786 ok := object.Key("AdminUsername") 1787 ok.String(*v.AdminUsername) 1788 } 1789 1790 return nil 1791} 1792 1793func awsRestjson1_serializeDocumentMemberFabricLogPublishingConfiguration(v *types.MemberFabricLogPublishingConfiguration, value smithyjson.Value) error { 1794 object := value.Object() 1795 defer object.Close() 1796 1797 if v.CaLogs != nil { 1798 ok := object.Key("CaLogs") 1799 if err := awsRestjson1_serializeDocumentLogConfigurations(v.CaLogs, ok); err != nil { 1800 return err 1801 } 1802 } 1803 1804 return nil 1805} 1806 1807func awsRestjson1_serializeDocumentMemberFrameworkConfiguration(v *types.MemberFrameworkConfiguration, value smithyjson.Value) error { 1808 object := value.Object() 1809 defer object.Close() 1810 1811 if v.Fabric != nil { 1812 ok := object.Key("Fabric") 1813 if err := awsRestjson1_serializeDocumentMemberFabricConfiguration(v.Fabric, ok); err != nil { 1814 return err 1815 } 1816 } 1817 1818 return nil 1819} 1820 1821func awsRestjson1_serializeDocumentMemberLogPublishingConfiguration(v *types.MemberLogPublishingConfiguration, value smithyjson.Value) error { 1822 object := value.Object() 1823 defer object.Close() 1824 1825 if v.Fabric != nil { 1826 ok := object.Key("Fabric") 1827 if err := awsRestjson1_serializeDocumentMemberFabricLogPublishingConfiguration(v.Fabric, ok); err != nil { 1828 return err 1829 } 1830 } 1831 1832 return nil 1833} 1834 1835func awsRestjson1_serializeDocumentNetworkFabricConfiguration(v *types.NetworkFabricConfiguration, value smithyjson.Value) error { 1836 object := value.Object() 1837 defer object.Close() 1838 1839 if len(v.Edition) > 0 { 1840 ok := object.Key("Edition") 1841 ok.String(string(v.Edition)) 1842 } 1843 1844 return nil 1845} 1846 1847func awsRestjson1_serializeDocumentNetworkFrameworkConfiguration(v *types.NetworkFrameworkConfiguration, value smithyjson.Value) error { 1848 object := value.Object() 1849 defer object.Close() 1850 1851 if v.Fabric != nil { 1852 ok := object.Key("Fabric") 1853 if err := awsRestjson1_serializeDocumentNetworkFabricConfiguration(v.Fabric, ok); err != nil { 1854 return err 1855 } 1856 } 1857 1858 return nil 1859} 1860 1861func awsRestjson1_serializeDocumentNodeConfiguration(v *types.NodeConfiguration, value smithyjson.Value) error { 1862 object := value.Object() 1863 defer object.Close() 1864 1865 if v.AvailabilityZone != nil { 1866 ok := object.Key("AvailabilityZone") 1867 ok.String(*v.AvailabilityZone) 1868 } 1869 1870 if v.InstanceType != nil { 1871 ok := object.Key("InstanceType") 1872 ok.String(*v.InstanceType) 1873 } 1874 1875 if v.LogPublishingConfiguration != nil { 1876 ok := object.Key("LogPublishingConfiguration") 1877 if err := awsRestjson1_serializeDocumentNodeLogPublishingConfiguration(v.LogPublishingConfiguration, ok); err != nil { 1878 return err 1879 } 1880 } 1881 1882 if len(v.StateDB) > 0 { 1883 ok := object.Key("StateDB") 1884 ok.String(string(v.StateDB)) 1885 } 1886 1887 return nil 1888} 1889 1890func awsRestjson1_serializeDocumentNodeFabricLogPublishingConfiguration(v *types.NodeFabricLogPublishingConfiguration, value smithyjson.Value) error { 1891 object := value.Object() 1892 defer object.Close() 1893 1894 if v.ChaincodeLogs != nil { 1895 ok := object.Key("ChaincodeLogs") 1896 if err := awsRestjson1_serializeDocumentLogConfigurations(v.ChaincodeLogs, ok); err != nil { 1897 return err 1898 } 1899 } 1900 1901 if v.PeerLogs != nil { 1902 ok := object.Key("PeerLogs") 1903 if err := awsRestjson1_serializeDocumentLogConfigurations(v.PeerLogs, ok); err != nil { 1904 return err 1905 } 1906 } 1907 1908 return nil 1909} 1910 1911func awsRestjson1_serializeDocumentNodeLogPublishingConfiguration(v *types.NodeLogPublishingConfiguration, value smithyjson.Value) error { 1912 object := value.Object() 1913 defer object.Close() 1914 1915 if v.Fabric != nil { 1916 ok := object.Key("Fabric") 1917 if err := awsRestjson1_serializeDocumentNodeFabricLogPublishingConfiguration(v.Fabric, ok); err != nil { 1918 return err 1919 } 1920 } 1921 1922 return nil 1923} 1924 1925func awsRestjson1_serializeDocumentProposalActions(v *types.ProposalActions, value smithyjson.Value) error { 1926 object := value.Object() 1927 defer object.Close() 1928 1929 if v.Invitations != nil { 1930 ok := object.Key("Invitations") 1931 if err := awsRestjson1_serializeDocumentInviteActionList(v.Invitations, ok); err != nil { 1932 return err 1933 } 1934 } 1935 1936 if v.Removals != nil { 1937 ok := object.Key("Removals") 1938 if err := awsRestjson1_serializeDocumentRemoveActionList(v.Removals, ok); err != nil { 1939 return err 1940 } 1941 } 1942 1943 return nil 1944} 1945 1946func awsRestjson1_serializeDocumentRemoveAction(v *types.RemoveAction, value smithyjson.Value) error { 1947 object := value.Object() 1948 defer object.Close() 1949 1950 if v.MemberId != nil { 1951 ok := object.Key("MemberId") 1952 ok.String(*v.MemberId) 1953 } 1954 1955 return nil 1956} 1957 1958func awsRestjson1_serializeDocumentRemoveActionList(v []types.RemoveAction, value smithyjson.Value) error { 1959 array := value.Array() 1960 defer array.Close() 1961 1962 for i := range v { 1963 av := array.Value() 1964 if err := awsRestjson1_serializeDocumentRemoveAction(&v[i], av); err != nil { 1965 return err 1966 } 1967 } 1968 return nil 1969} 1970 1971func awsRestjson1_serializeDocumentVotingPolicy(v *types.VotingPolicy, value smithyjson.Value) error { 1972 object := value.Object() 1973 defer object.Close() 1974 1975 if v.ApprovalThresholdPolicy != nil { 1976 ok := object.Key("ApprovalThresholdPolicy") 1977 if err := awsRestjson1_serializeDocumentApprovalThresholdPolicy(v.ApprovalThresholdPolicy, ok); err != nil { 1978 return err 1979 } 1980 } 1981 1982 return nil 1983} 1984