1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appmesh 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/appmesh/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateGatewayRoute struct { 14} 15 16func (*validateOpCreateGatewayRoute) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 21 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 22) { 23 input, ok := in.Parameters.(*CreateGatewayRouteInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateGatewayRouteInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateMesh struct { 34} 35 36func (*validateOpCreateMesh) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 41 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 42) { 43 input, ok := in.Parameters.(*CreateMeshInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateMeshInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateRoute struct { 54} 55 56func (*validateOpCreateRoute) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 61 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 62) { 63 input, ok := in.Parameters.(*CreateRouteInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateRouteInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateVirtualGateway struct { 74} 75 76func (*validateOpCreateVirtualGateway) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 81 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 82) { 83 input, ok := in.Parameters.(*CreateVirtualGatewayInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateVirtualGatewayInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateVirtualNode struct { 94} 95 96func (*validateOpCreateVirtualNode) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 102) { 103 input, ok := in.Parameters.(*CreateVirtualNodeInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateVirtualNodeInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateVirtualRouter struct { 114} 115 116func (*validateOpCreateVirtualRouter) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 122) { 123 input, ok := in.Parameters.(*CreateVirtualRouterInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateVirtualRouterInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateVirtualService struct { 134} 135 136func (*validateOpCreateVirtualService) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 142) { 143 input, ok := in.Parameters.(*CreateVirtualServiceInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateVirtualServiceInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteGatewayRoute struct { 154} 155 156func (*validateOpDeleteGatewayRoute) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 162) { 163 input, ok := in.Parameters.(*DeleteGatewayRouteInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteGatewayRouteInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteMesh struct { 174} 175 176func (*validateOpDeleteMesh) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 182) { 183 input, ok := in.Parameters.(*DeleteMeshInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteMeshInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteRoute struct { 194} 195 196func (*validateOpDeleteRoute) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 202) { 203 input, ok := in.Parameters.(*DeleteRouteInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteRouteInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteVirtualGateway struct { 214} 215 216func (*validateOpDeleteVirtualGateway) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 222) { 223 input, ok := in.Parameters.(*DeleteVirtualGatewayInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteVirtualGatewayInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteVirtualNode struct { 234} 235 236func (*validateOpDeleteVirtualNode) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 242) { 243 input, ok := in.Parameters.(*DeleteVirtualNodeInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteVirtualNodeInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteVirtualRouter struct { 254} 255 256func (*validateOpDeleteVirtualRouter) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 262) { 263 input, ok := in.Parameters.(*DeleteVirtualRouterInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteVirtualRouterInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteVirtualService struct { 274} 275 276func (*validateOpDeleteVirtualService) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 282) { 283 input, ok := in.Parameters.(*DeleteVirtualServiceInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteVirtualServiceInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeGatewayRoute struct { 294} 295 296func (*validateOpDescribeGatewayRoute) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 302) { 303 input, ok := in.Parameters.(*DescribeGatewayRouteInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeGatewayRouteInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeMesh struct { 314} 315 316func (*validateOpDescribeMesh) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 322) { 323 input, ok := in.Parameters.(*DescribeMeshInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeMeshInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeRoute struct { 334} 335 336func (*validateOpDescribeRoute) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 342) { 343 input, ok := in.Parameters.(*DescribeRouteInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeRouteInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeVirtualGateway struct { 354} 355 356func (*validateOpDescribeVirtualGateway) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 362) { 363 input, ok := in.Parameters.(*DescribeVirtualGatewayInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeVirtualGatewayInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeVirtualNode struct { 374} 375 376func (*validateOpDescribeVirtualNode) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 382) { 383 input, ok := in.Parameters.(*DescribeVirtualNodeInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeVirtualNodeInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeVirtualRouter struct { 394} 395 396func (*validateOpDescribeVirtualRouter) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 402) { 403 input, ok := in.Parameters.(*DescribeVirtualRouterInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeVirtualRouterInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeVirtualService struct { 414} 415 416func (*validateOpDescribeVirtualService) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 422) { 423 input, ok := in.Parameters.(*DescribeVirtualServiceInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeVirtualServiceInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpListGatewayRoutes struct { 434} 435 436func (*validateOpListGatewayRoutes) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpListGatewayRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 442) { 443 input, ok := in.Parameters.(*ListGatewayRoutesInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpListGatewayRoutesInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpListRoutes struct { 454} 455 456func (*validateOpListRoutes) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpListRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 462) { 463 input, ok := in.Parameters.(*ListRoutesInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpListRoutesInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpListTagsForResource struct { 474} 475 476func (*validateOpListTagsForResource) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 482) { 483 input, ok := in.Parameters.(*ListTagsForResourceInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpListTagsForResourceInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListVirtualGateways struct { 494} 495 496func (*validateOpListVirtualGateways) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListVirtualGateways) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 502) { 503 input, ok := in.Parameters.(*ListVirtualGatewaysInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListVirtualGatewaysInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListVirtualNodes struct { 514} 515 516func (*validateOpListVirtualNodes) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListVirtualNodes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 522) { 523 input, ok := in.Parameters.(*ListVirtualNodesInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListVirtualNodesInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListVirtualRouters struct { 534} 535 536func (*validateOpListVirtualRouters) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListVirtualRouters) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 542) { 543 input, ok := in.Parameters.(*ListVirtualRoutersInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListVirtualRoutersInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListVirtualServices struct { 554} 555 556func (*validateOpListVirtualServices) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListVirtualServices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 562) { 563 input, ok := in.Parameters.(*ListVirtualServicesInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListVirtualServicesInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpTagResource struct { 574} 575 576func (*validateOpTagResource) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 582) { 583 input, ok := in.Parameters.(*TagResourceInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpTagResourceInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpUntagResource struct { 594} 595 596func (*validateOpUntagResource) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*UntagResourceInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpUntagResourceInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpUpdateGatewayRoute struct { 614} 615 616func (*validateOpUpdateGatewayRoute) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpUpdateGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 622) { 623 input, ok := in.Parameters.(*UpdateGatewayRouteInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpUpdateGatewayRouteInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpUpdateMesh struct { 634} 635 636func (*validateOpUpdateMesh) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpUpdateMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 642) { 643 input, ok := in.Parameters.(*UpdateMeshInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpUpdateMeshInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpUpdateRoute struct { 654} 655 656func (*validateOpUpdateRoute) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpUpdateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 662) { 663 input, ok := in.Parameters.(*UpdateRouteInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpUpdateRouteInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpUpdateVirtualGateway struct { 674} 675 676func (*validateOpUpdateVirtualGateway) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpUpdateVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 682) { 683 input, ok := in.Parameters.(*UpdateVirtualGatewayInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpUpdateVirtualGatewayInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpUpdateVirtualNode struct { 694} 695 696func (*validateOpUpdateVirtualNode) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpUpdateVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 702) { 703 input, ok := in.Parameters.(*UpdateVirtualNodeInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpUpdateVirtualNodeInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpUpdateVirtualRouter struct { 714} 715 716func (*validateOpUpdateVirtualRouter) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpUpdateVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 722) { 723 input, ok := in.Parameters.(*UpdateVirtualRouterInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpUpdateVirtualRouterInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUpdateVirtualService struct { 734} 735 736func (*validateOpUpdateVirtualService) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUpdateVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 742) { 743 input, ok := in.Parameters.(*UpdateVirtualServiceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUpdateVirtualServiceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753func addOpCreateGatewayRouteValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpCreateGatewayRoute{}, middleware.After) 755} 756 757func addOpCreateMeshValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpCreateMesh{}, middleware.After) 759} 760 761func addOpCreateRouteValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpCreateRoute{}, middleware.After) 763} 764 765func addOpCreateVirtualGatewayValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpCreateVirtualGateway{}, middleware.After) 767} 768 769func addOpCreateVirtualNodeValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpCreateVirtualNode{}, middleware.After) 771} 772 773func addOpCreateVirtualRouterValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpCreateVirtualRouter{}, middleware.After) 775} 776 777func addOpCreateVirtualServiceValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpCreateVirtualService{}, middleware.After) 779} 780 781func addOpDeleteGatewayRouteValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpDeleteGatewayRoute{}, middleware.After) 783} 784 785func addOpDeleteMeshValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpDeleteMesh{}, middleware.After) 787} 788 789func addOpDeleteRouteValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpDeleteRoute{}, middleware.After) 791} 792 793func addOpDeleteVirtualGatewayValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpDeleteVirtualGateway{}, middleware.After) 795} 796 797func addOpDeleteVirtualNodeValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpDeleteVirtualNode{}, middleware.After) 799} 800 801func addOpDeleteVirtualRouterValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpDeleteVirtualRouter{}, middleware.After) 803} 804 805func addOpDeleteVirtualServiceValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpDeleteVirtualService{}, middleware.After) 807} 808 809func addOpDescribeGatewayRouteValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpDescribeGatewayRoute{}, middleware.After) 811} 812 813func addOpDescribeMeshValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpDescribeMesh{}, middleware.After) 815} 816 817func addOpDescribeRouteValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpDescribeRoute{}, middleware.After) 819} 820 821func addOpDescribeVirtualGatewayValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpDescribeVirtualGateway{}, middleware.After) 823} 824 825func addOpDescribeVirtualNodeValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpDescribeVirtualNode{}, middleware.After) 827} 828 829func addOpDescribeVirtualRouterValidationMiddleware(stack *middleware.Stack) error { 830 return stack.Initialize.Add(&validateOpDescribeVirtualRouter{}, middleware.After) 831} 832 833func addOpDescribeVirtualServiceValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpDescribeVirtualService{}, middleware.After) 835} 836 837func addOpListGatewayRoutesValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpListGatewayRoutes{}, middleware.After) 839} 840 841func addOpListRoutesValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpListRoutes{}, middleware.After) 843} 844 845func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 847} 848 849func addOpListVirtualGatewaysValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpListVirtualGateways{}, middleware.After) 851} 852 853func addOpListVirtualNodesValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpListVirtualNodes{}, middleware.After) 855} 856 857func addOpListVirtualRoutersValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpListVirtualRouters{}, middleware.After) 859} 860 861func addOpListVirtualServicesValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpListVirtualServices{}, middleware.After) 863} 864 865func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 867} 868 869func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 871} 872 873func addOpUpdateGatewayRouteValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpUpdateGatewayRoute{}, middleware.After) 875} 876 877func addOpUpdateMeshValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpUpdateMesh{}, middleware.After) 879} 880 881func addOpUpdateRouteValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpUpdateRoute{}, middleware.After) 883} 884 885func addOpUpdateVirtualGatewayValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpUpdateVirtualGateway{}, middleware.After) 887} 888 889func addOpUpdateVirtualNodeValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpUpdateVirtualNode{}, middleware.After) 891} 892 893func addOpUpdateVirtualRouterValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpUpdateVirtualRouter{}, middleware.After) 895} 896 897func addOpUpdateVirtualServiceValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpUpdateVirtualService{}, middleware.After) 899} 900 901func validateAccessLog(v types.AccessLog) error { 902 if v == nil { 903 return nil 904 } 905 invalidParams := smithy.InvalidParamsError{Context: "AccessLog"} 906 switch uv := v.(type) { 907 case *types.AccessLogMemberFile: 908 if err := validateFileAccessLog(&uv.Value); err != nil { 909 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 910 } 911 912 } 913 if invalidParams.Len() > 0 { 914 return invalidParams 915 } else { 916 return nil 917 } 918} 919 920func validateAwsCloudMapInstanceAttribute(v *types.AwsCloudMapInstanceAttribute) error { 921 if v == nil { 922 return nil 923 } 924 invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapInstanceAttribute"} 925 if v.Key == nil { 926 invalidParams.Add(smithy.NewErrParamRequired("Key")) 927 } 928 if v.Value == nil { 929 invalidParams.Add(smithy.NewErrParamRequired("Value")) 930 } 931 if invalidParams.Len() > 0 { 932 return invalidParams 933 } else { 934 return nil 935 } 936} 937 938func validateAwsCloudMapInstanceAttributes(v []types.AwsCloudMapInstanceAttribute) error { 939 if v == nil { 940 return nil 941 } 942 invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapInstanceAttributes"} 943 for i := range v { 944 if err := validateAwsCloudMapInstanceAttribute(&v[i]); err != nil { 945 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 946 } 947 } 948 if invalidParams.Len() > 0 { 949 return invalidParams 950 } else { 951 return nil 952 } 953} 954 955func validateAwsCloudMapServiceDiscovery(v *types.AwsCloudMapServiceDiscovery) error { 956 if v == nil { 957 return nil 958 } 959 invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapServiceDiscovery"} 960 if v.NamespaceName == nil { 961 invalidParams.Add(smithy.NewErrParamRequired("NamespaceName")) 962 } 963 if v.ServiceName == nil { 964 invalidParams.Add(smithy.NewErrParamRequired("ServiceName")) 965 } 966 if v.Attributes != nil { 967 if err := validateAwsCloudMapInstanceAttributes(v.Attributes); err != nil { 968 invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError)) 969 } 970 } 971 if invalidParams.Len() > 0 { 972 return invalidParams 973 } else { 974 return nil 975 } 976} 977 978func validateBackend(v types.Backend) error { 979 if v == nil { 980 return nil 981 } 982 invalidParams := smithy.InvalidParamsError{Context: "Backend"} 983 switch uv := v.(type) { 984 case *types.BackendMemberVirtualService: 985 if err := validateVirtualServiceBackend(&uv.Value); err != nil { 986 invalidParams.AddNested("[virtualService]", err.(smithy.InvalidParamsError)) 987 } 988 989 } 990 if invalidParams.Len() > 0 { 991 return invalidParams 992 } else { 993 return nil 994 } 995} 996 997func validateBackendDefaults(v *types.BackendDefaults) error { 998 if v == nil { 999 return nil 1000 } 1001 invalidParams := smithy.InvalidParamsError{Context: "BackendDefaults"} 1002 if v.ClientPolicy != nil { 1003 if err := validateClientPolicy(v.ClientPolicy); err != nil { 1004 invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError)) 1005 } 1006 } 1007 if invalidParams.Len() > 0 { 1008 return invalidParams 1009 } else { 1010 return nil 1011 } 1012} 1013 1014func validateBackends(v []types.Backend) error { 1015 if v == nil { 1016 return nil 1017 } 1018 invalidParams := smithy.InvalidParamsError{Context: "Backends"} 1019 for i := range v { 1020 if err := validateBackend(v[i]); err != nil { 1021 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1022 } 1023 } 1024 if invalidParams.Len() > 0 { 1025 return invalidParams 1026 } else { 1027 return nil 1028 } 1029} 1030 1031func validateClientPolicy(v *types.ClientPolicy) error { 1032 if v == nil { 1033 return nil 1034 } 1035 invalidParams := smithy.InvalidParamsError{Context: "ClientPolicy"} 1036 if v.Tls != nil { 1037 if err := validateClientPolicyTls(v.Tls); err != nil { 1038 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 1039 } 1040 } 1041 if invalidParams.Len() > 0 { 1042 return invalidParams 1043 } else { 1044 return nil 1045 } 1046} 1047 1048func validateClientPolicyTls(v *types.ClientPolicyTls) error { 1049 if v == nil { 1050 return nil 1051 } 1052 invalidParams := smithy.InvalidParamsError{Context: "ClientPolicyTls"} 1053 if v.Certificate != nil { 1054 if err := validateClientTlsCertificate(v.Certificate); err != nil { 1055 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 1056 } 1057 } 1058 if v.Validation == nil { 1059 invalidParams.Add(smithy.NewErrParamRequired("Validation")) 1060 } else if v.Validation != nil { 1061 if err := validateTlsValidationContext(v.Validation); err != nil { 1062 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 1063 } 1064 } 1065 if invalidParams.Len() > 0 { 1066 return invalidParams 1067 } else { 1068 return nil 1069 } 1070} 1071 1072func validateClientTlsCertificate(v types.ClientTlsCertificate) error { 1073 if v == nil { 1074 return nil 1075 } 1076 invalidParams := smithy.InvalidParamsError{Context: "ClientTlsCertificate"} 1077 switch uv := v.(type) { 1078 case *types.ClientTlsCertificateMemberFile: 1079 if err := validateListenerTlsFileCertificate(&uv.Value); err != nil { 1080 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1081 } 1082 1083 case *types.ClientTlsCertificateMemberSds: 1084 if err := validateListenerTlsSdsCertificate(&uv.Value); err != nil { 1085 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 1086 } 1087 1088 } 1089 if invalidParams.Len() > 0 { 1090 return invalidParams 1091 } else { 1092 return nil 1093 } 1094} 1095 1096func validateDnsServiceDiscovery(v *types.DnsServiceDiscovery) error { 1097 if v == nil { 1098 return nil 1099 } 1100 invalidParams := smithy.InvalidParamsError{Context: "DnsServiceDiscovery"} 1101 if v.Hostname == nil { 1102 invalidParams.Add(smithy.NewErrParamRequired("Hostname")) 1103 } 1104 if invalidParams.Len() > 0 { 1105 return invalidParams 1106 } else { 1107 return nil 1108 } 1109} 1110 1111func validateEgressFilter(v *types.EgressFilter) error { 1112 if v == nil { 1113 return nil 1114 } 1115 invalidParams := smithy.InvalidParamsError{Context: "EgressFilter"} 1116 if len(v.Type) == 0 { 1117 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1118 } 1119 if invalidParams.Len() > 0 { 1120 return invalidParams 1121 } else { 1122 return nil 1123 } 1124} 1125 1126func validateFileAccessLog(v *types.FileAccessLog) error { 1127 if v == nil { 1128 return nil 1129 } 1130 invalidParams := smithy.InvalidParamsError{Context: "FileAccessLog"} 1131 if v.Path == nil { 1132 invalidParams.Add(smithy.NewErrParamRequired("Path")) 1133 } 1134 if invalidParams.Len() > 0 { 1135 return invalidParams 1136 } else { 1137 return nil 1138 } 1139} 1140 1141func validateGatewayRouteSpec(v *types.GatewayRouteSpec) error { 1142 if v == nil { 1143 return nil 1144 } 1145 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteSpec"} 1146 if v.HttpRoute != nil { 1147 if err := validateHttpGatewayRoute(v.HttpRoute); err != nil { 1148 invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError)) 1149 } 1150 } 1151 if v.Http2Route != nil { 1152 if err := validateHttpGatewayRoute(v.Http2Route); err != nil { 1153 invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError)) 1154 } 1155 } 1156 if v.GrpcRoute != nil { 1157 if err := validateGrpcGatewayRoute(v.GrpcRoute); err != nil { 1158 invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError)) 1159 } 1160 } 1161 if invalidParams.Len() > 0 { 1162 return invalidParams 1163 } else { 1164 return nil 1165 } 1166} 1167 1168func validateGatewayRouteTarget(v *types.GatewayRouteTarget) error { 1169 if v == nil { 1170 return nil 1171 } 1172 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteTarget"} 1173 if v.VirtualService == nil { 1174 invalidParams.Add(smithy.NewErrParamRequired("VirtualService")) 1175 } else if v.VirtualService != nil { 1176 if err := validateGatewayRouteVirtualService(v.VirtualService); err != nil { 1177 invalidParams.AddNested("VirtualService", err.(smithy.InvalidParamsError)) 1178 } 1179 } 1180 if invalidParams.Len() > 0 { 1181 return invalidParams 1182 } else { 1183 return nil 1184 } 1185} 1186 1187func validateGatewayRouteVirtualService(v *types.GatewayRouteVirtualService) error { 1188 if v == nil { 1189 return nil 1190 } 1191 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteVirtualService"} 1192 if v.VirtualServiceName == nil { 1193 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 1194 } 1195 if invalidParams.Len() > 0 { 1196 return invalidParams 1197 } else { 1198 return nil 1199 } 1200} 1201 1202func validateGrpcGatewayRoute(v *types.GrpcGatewayRoute) error { 1203 if v == nil { 1204 return nil 1205 } 1206 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRoute"} 1207 if v.Match == nil { 1208 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1209 } else if v.Match != nil { 1210 if err := validateGrpcGatewayRouteMatch(v.Match); err != nil { 1211 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1212 } 1213 } 1214 if v.Action == nil { 1215 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1216 } else if v.Action != nil { 1217 if err := validateGrpcGatewayRouteAction(v.Action); err != nil { 1218 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1219 } 1220 } 1221 if invalidParams.Len() > 0 { 1222 return invalidParams 1223 } else { 1224 return nil 1225 } 1226} 1227 1228func validateGrpcGatewayRouteAction(v *types.GrpcGatewayRouteAction) error { 1229 if v == nil { 1230 return nil 1231 } 1232 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteAction"} 1233 if v.Target == nil { 1234 invalidParams.Add(smithy.NewErrParamRequired("Target")) 1235 } else if v.Target != nil { 1236 if err := validateGatewayRouteTarget(v.Target); err != nil { 1237 invalidParams.AddNested("Target", err.(smithy.InvalidParamsError)) 1238 } 1239 } 1240 if invalidParams.Len() > 0 { 1241 return invalidParams 1242 } else { 1243 return nil 1244 } 1245} 1246 1247func validateGrpcGatewayRouteMatch(v *types.GrpcGatewayRouteMatch) error { 1248 if v == nil { 1249 return nil 1250 } 1251 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMatch"} 1252 if v.Metadata != nil { 1253 if err := validateGrpcGatewayRouteMetadataList(v.Metadata); err != nil { 1254 invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError)) 1255 } 1256 } 1257 if invalidParams.Len() > 0 { 1258 return invalidParams 1259 } else { 1260 return nil 1261 } 1262} 1263 1264func validateGrpcGatewayRouteMetadata(v *types.GrpcGatewayRouteMetadata) error { 1265 if v == nil { 1266 return nil 1267 } 1268 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMetadata"} 1269 if v.Name == nil { 1270 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1271 } 1272 if v.Match != nil { 1273 if err := validateGrpcMetadataMatchMethod(v.Match); err != nil { 1274 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1275 } 1276 } 1277 if invalidParams.Len() > 0 { 1278 return invalidParams 1279 } else { 1280 return nil 1281 } 1282} 1283 1284func validateGrpcGatewayRouteMetadataList(v []types.GrpcGatewayRouteMetadata) error { 1285 if v == nil { 1286 return nil 1287 } 1288 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMetadataList"} 1289 for i := range v { 1290 if err := validateGrpcGatewayRouteMetadata(&v[i]); err != nil { 1291 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1292 } 1293 } 1294 if invalidParams.Len() > 0 { 1295 return invalidParams 1296 } else { 1297 return nil 1298 } 1299} 1300 1301func validateGrpcMetadataMatchMethod(v types.GrpcMetadataMatchMethod) error { 1302 if v == nil { 1303 return nil 1304 } 1305 invalidParams := smithy.InvalidParamsError{Context: "GrpcMetadataMatchMethod"} 1306 switch uv := v.(type) { 1307 case *types.GrpcMetadataMatchMethodMemberRange: 1308 if err := validateMatchRange(&uv.Value); err != nil { 1309 invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError)) 1310 } 1311 1312 } 1313 if invalidParams.Len() > 0 { 1314 return invalidParams 1315 } else { 1316 return nil 1317 } 1318} 1319 1320func validateGrpcRetryPolicy(v *types.GrpcRetryPolicy) error { 1321 if v == nil { 1322 return nil 1323 } 1324 invalidParams := smithy.InvalidParamsError{Context: "GrpcRetryPolicy"} 1325 if v.PerRetryTimeout == nil { 1326 invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout")) 1327 } 1328 if v.MaxRetries == nil { 1329 invalidParams.Add(smithy.NewErrParamRequired("MaxRetries")) 1330 } 1331 if invalidParams.Len() > 0 { 1332 return invalidParams 1333 } else { 1334 return nil 1335 } 1336} 1337 1338func validateGrpcRoute(v *types.GrpcRoute) error { 1339 if v == nil { 1340 return nil 1341 } 1342 invalidParams := smithy.InvalidParamsError{Context: "GrpcRoute"} 1343 if v.Action == nil { 1344 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1345 } else if v.Action != nil { 1346 if err := validateGrpcRouteAction(v.Action); err != nil { 1347 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1348 } 1349 } 1350 if v.Match == nil { 1351 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1352 } else if v.Match != nil { 1353 if err := validateGrpcRouteMatch(v.Match); err != nil { 1354 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1355 } 1356 } 1357 if v.RetryPolicy != nil { 1358 if err := validateGrpcRetryPolicy(v.RetryPolicy); err != nil { 1359 invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError)) 1360 } 1361 } 1362 if invalidParams.Len() > 0 { 1363 return invalidParams 1364 } else { 1365 return nil 1366 } 1367} 1368 1369func validateGrpcRouteAction(v *types.GrpcRouteAction) error { 1370 if v == nil { 1371 return nil 1372 } 1373 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteAction"} 1374 if v.WeightedTargets == nil { 1375 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 1376 } else if v.WeightedTargets != nil { 1377 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 1378 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 1379 } 1380 } 1381 if invalidParams.Len() > 0 { 1382 return invalidParams 1383 } else { 1384 return nil 1385 } 1386} 1387 1388func validateGrpcRouteMatch(v *types.GrpcRouteMatch) error { 1389 if v == nil { 1390 return nil 1391 } 1392 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMatch"} 1393 if v.Metadata != nil { 1394 if err := validateGrpcRouteMetadataList(v.Metadata); err != nil { 1395 invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError)) 1396 } 1397 } 1398 if invalidParams.Len() > 0 { 1399 return invalidParams 1400 } else { 1401 return nil 1402 } 1403} 1404 1405func validateGrpcRouteMetadata(v *types.GrpcRouteMetadata) error { 1406 if v == nil { 1407 return nil 1408 } 1409 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadata"} 1410 if v.Name == nil { 1411 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1412 } 1413 if v.Match != nil { 1414 if err := validateGrpcRouteMetadataMatchMethod(v.Match); err != nil { 1415 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1416 } 1417 } 1418 if invalidParams.Len() > 0 { 1419 return invalidParams 1420 } else { 1421 return nil 1422 } 1423} 1424 1425func validateGrpcRouteMetadataList(v []types.GrpcRouteMetadata) error { 1426 if v == nil { 1427 return nil 1428 } 1429 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataList"} 1430 for i := range v { 1431 if err := validateGrpcRouteMetadata(&v[i]); err != nil { 1432 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1433 } 1434 } 1435 if invalidParams.Len() > 0 { 1436 return invalidParams 1437 } else { 1438 return nil 1439 } 1440} 1441 1442func validateGrpcRouteMetadataMatchMethod(v types.GrpcRouteMetadataMatchMethod) error { 1443 if v == nil { 1444 return nil 1445 } 1446 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataMatchMethod"} 1447 switch uv := v.(type) { 1448 case *types.GrpcRouteMetadataMatchMethodMemberRange: 1449 if err := validateMatchRange(&uv.Value); err != nil { 1450 invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError)) 1451 } 1452 1453 } 1454 if invalidParams.Len() > 0 { 1455 return invalidParams 1456 } else { 1457 return nil 1458 } 1459} 1460 1461func validateHeaderMatchMethod(v types.HeaderMatchMethod) error { 1462 if v == nil { 1463 return nil 1464 } 1465 invalidParams := smithy.InvalidParamsError{Context: "HeaderMatchMethod"} 1466 switch uv := v.(type) { 1467 case *types.HeaderMatchMethodMemberRange: 1468 if err := validateMatchRange(&uv.Value); err != nil { 1469 invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError)) 1470 } 1471 1472 } 1473 if invalidParams.Len() > 0 { 1474 return invalidParams 1475 } else { 1476 return nil 1477 } 1478} 1479 1480func validateHealthCheckPolicy(v *types.HealthCheckPolicy) error { 1481 if v == nil { 1482 return nil 1483 } 1484 invalidParams := smithy.InvalidParamsError{Context: "HealthCheckPolicy"} 1485 if v.TimeoutMillis == nil { 1486 invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis")) 1487 } 1488 if v.IntervalMillis == nil { 1489 invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis")) 1490 } 1491 if len(v.Protocol) == 0 { 1492 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 1493 } 1494 if invalidParams.Len() > 0 { 1495 return invalidParams 1496 } else { 1497 return nil 1498 } 1499} 1500 1501func validateHttpGatewayRoute(v *types.HttpGatewayRoute) error { 1502 if v == nil { 1503 return nil 1504 } 1505 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRoute"} 1506 if v.Match == nil { 1507 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1508 } else if v.Match != nil { 1509 if err := validateHttpGatewayRouteMatch(v.Match); err != nil { 1510 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1511 } 1512 } 1513 if v.Action == nil { 1514 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1515 } else if v.Action != nil { 1516 if err := validateHttpGatewayRouteAction(v.Action); err != nil { 1517 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1518 } 1519 } 1520 if invalidParams.Len() > 0 { 1521 return invalidParams 1522 } else { 1523 return nil 1524 } 1525} 1526 1527func validateHttpGatewayRouteAction(v *types.HttpGatewayRouteAction) error { 1528 if v == nil { 1529 return nil 1530 } 1531 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteAction"} 1532 if v.Target == nil { 1533 invalidParams.Add(smithy.NewErrParamRequired("Target")) 1534 } else if v.Target != nil { 1535 if err := validateGatewayRouteTarget(v.Target); err != nil { 1536 invalidParams.AddNested("Target", err.(smithy.InvalidParamsError)) 1537 } 1538 } 1539 if invalidParams.Len() > 0 { 1540 return invalidParams 1541 } else { 1542 return nil 1543 } 1544} 1545 1546func validateHttpGatewayRouteHeader(v *types.HttpGatewayRouteHeader) error { 1547 if v == nil { 1548 return nil 1549 } 1550 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteHeader"} 1551 if v.Name == nil { 1552 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1553 } 1554 if v.Match != nil { 1555 if err := validateHeaderMatchMethod(v.Match); err != nil { 1556 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1557 } 1558 } 1559 if invalidParams.Len() > 0 { 1560 return invalidParams 1561 } else { 1562 return nil 1563 } 1564} 1565 1566func validateHttpGatewayRouteHeaders(v []types.HttpGatewayRouteHeader) error { 1567 if v == nil { 1568 return nil 1569 } 1570 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteHeaders"} 1571 for i := range v { 1572 if err := validateHttpGatewayRouteHeader(&v[i]); err != nil { 1573 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1574 } 1575 } 1576 if invalidParams.Len() > 0 { 1577 return invalidParams 1578 } else { 1579 return nil 1580 } 1581} 1582 1583func validateHttpGatewayRouteMatch(v *types.HttpGatewayRouteMatch) error { 1584 if v == nil { 1585 return nil 1586 } 1587 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteMatch"} 1588 if v.QueryParameters != nil { 1589 if err := validateHttpQueryParameters(v.QueryParameters); err != nil { 1590 invalidParams.AddNested("QueryParameters", err.(smithy.InvalidParamsError)) 1591 } 1592 } 1593 if v.Headers != nil { 1594 if err := validateHttpGatewayRouteHeaders(v.Headers); err != nil { 1595 invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError)) 1596 } 1597 } 1598 if invalidParams.Len() > 0 { 1599 return invalidParams 1600 } else { 1601 return nil 1602 } 1603} 1604 1605func validateHttpQueryParameter(v *types.HttpQueryParameter) error { 1606 if v == nil { 1607 return nil 1608 } 1609 invalidParams := smithy.InvalidParamsError{Context: "HttpQueryParameter"} 1610 if v.Name == nil { 1611 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1612 } 1613 if invalidParams.Len() > 0 { 1614 return invalidParams 1615 } else { 1616 return nil 1617 } 1618} 1619 1620func validateHttpQueryParameters(v []types.HttpQueryParameter) error { 1621 if v == nil { 1622 return nil 1623 } 1624 invalidParams := smithy.InvalidParamsError{Context: "HttpQueryParameters"} 1625 for i := range v { 1626 if err := validateHttpQueryParameter(&v[i]); err != nil { 1627 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1628 } 1629 } 1630 if invalidParams.Len() > 0 { 1631 return invalidParams 1632 } else { 1633 return nil 1634 } 1635} 1636 1637func validateHttpRetryPolicy(v *types.HttpRetryPolicy) error { 1638 if v == nil { 1639 return nil 1640 } 1641 invalidParams := smithy.InvalidParamsError{Context: "HttpRetryPolicy"} 1642 if v.PerRetryTimeout == nil { 1643 invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout")) 1644 } 1645 if v.MaxRetries == nil { 1646 invalidParams.Add(smithy.NewErrParamRequired("MaxRetries")) 1647 } 1648 if invalidParams.Len() > 0 { 1649 return invalidParams 1650 } else { 1651 return nil 1652 } 1653} 1654 1655func validateHttpRoute(v *types.HttpRoute) error { 1656 if v == nil { 1657 return nil 1658 } 1659 invalidParams := smithy.InvalidParamsError{Context: "HttpRoute"} 1660 if v.Match == nil { 1661 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1662 } else if v.Match != nil { 1663 if err := validateHttpRouteMatch(v.Match); err != nil { 1664 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1665 } 1666 } 1667 if v.Action == nil { 1668 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1669 } else if v.Action != nil { 1670 if err := validateHttpRouteAction(v.Action); err != nil { 1671 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1672 } 1673 } 1674 if v.RetryPolicy != nil { 1675 if err := validateHttpRetryPolicy(v.RetryPolicy); err != nil { 1676 invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError)) 1677 } 1678 } 1679 if invalidParams.Len() > 0 { 1680 return invalidParams 1681 } else { 1682 return nil 1683 } 1684} 1685 1686func validateHttpRouteAction(v *types.HttpRouteAction) error { 1687 if v == nil { 1688 return nil 1689 } 1690 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteAction"} 1691 if v.WeightedTargets == nil { 1692 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 1693 } else if v.WeightedTargets != nil { 1694 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 1695 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 1696 } 1697 } 1698 if invalidParams.Len() > 0 { 1699 return invalidParams 1700 } else { 1701 return nil 1702 } 1703} 1704 1705func validateHttpRouteHeader(v *types.HttpRouteHeader) error { 1706 if v == nil { 1707 return nil 1708 } 1709 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeader"} 1710 if v.Name == nil { 1711 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1712 } 1713 if v.Match != nil { 1714 if err := validateHeaderMatchMethod(v.Match); err != nil { 1715 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1716 } 1717 } 1718 if invalidParams.Len() > 0 { 1719 return invalidParams 1720 } else { 1721 return nil 1722 } 1723} 1724 1725func validateHttpRouteHeaders(v []types.HttpRouteHeader) error { 1726 if v == nil { 1727 return nil 1728 } 1729 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeaders"} 1730 for i := range v { 1731 if err := validateHttpRouteHeader(&v[i]); err != nil { 1732 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1733 } 1734 } 1735 if invalidParams.Len() > 0 { 1736 return invalidParams 1737 } else { 1738 return nil 1739 } 1740} 1741 1742func validateHttpRouteMatch(v *types.HttpRouteMatch) error { 1743 if v == nil { 1744 return nil 1745 } 1746 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteMatch"} 1747 if v.QueryParameters != nil { 1748 if err := validateHttpQueryParameters(v.QueryParameters); err != nil { 1749 invalidParams.AddNested("QueryParameters", err.(smithy.InvalidParamsError)) 1750 } 1751 } 1752 if v.Headers != nil { 1753 if err := validateHttpRouteHeaders(v.Headers); err != nil { 1754 invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError)) 1755 } 1756 } 1757 if invalidParams.Len() > 0 { 1758 return invalidParams 1759 } else { 1760 return nil 1761 } 1762} 1763 1764func validateListener(v *types.Listener) error { 1765 if v == nil { 1766 return nil 1767 } 1768 invalidParams := smithy.InvalidParamsError{Context: "Listener"} 1769 if v.PortMapping == nil { 1770 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 1771 } else if v.PortMapping != nil { 1772 if err := validatePortMapping(v.PortMapping); err != nil { 1773 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 1774 } 1775 } 1776 if v.Tls != nil { 1777 if err := validateListenerTls(v.Tls); err != nil { 1778 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 1779 } 1780 } 1781 if v.HealthCheck != nil { 1782 if err := validateHealthCheckPolicy(v.HealthCheck); err != nil { 1783 invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError)) 1784 } 1785 } 1786 if v.OutlierDetection != nil { 1787 if err := validateOutlierDetection(v.OutlierDetection); err != nil { 1788 invalidParams.AddNested("OutlierDetection", err.(smithy.InvalidParamsError)) 1789 } 1790 } 1791 if v.ConnectionPool != nil { 1792 if err := validateVirtualNodeConnectionPool(v.ConnectionPool); err != nil { 1793 invalidParams.AddNested("ConnectionPool", err.(smithy.InvalidParamsError)) 1794 } 1795 } 1796 if invalidParams.Len() > 0 { 1797 return invalidParams 1798 } else { 1799 return nil 1800 } 1801} 1802 1803func validateListeners(v []types.Listener) error { 1804 if v == nil { 1805 return nil 1806 } 1807 invalidParams := smithy.InvalidParamsError{Context: "Listeners"} 1808 for i := range v { 1809 if err := validateListener(&v[i]); err != nil { 1810 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1811 } 1812 } 1813 if invalidParams.Len() > 0 { 1814 return invalidParams 1815 } else { 1816 return nil 1817 } 1818} 1819 1820func validateListenerTls(v *types.ListenerTls) error { 1821 if v == nil { 1822 return nil 1823 } 1824 invalidParams := smithy.InvalidParamsError{Context: "ListenerTls"} 1825 if len(v.Mode) == 0 { 1826 invalidParams.Add(smithy.NewErrParamRequired("Mode")) 1827 } 1828 if v.Certificate == nil { 1829 invalidParams.Add(smithy.NewErrParamRequired("Certificate")) 1830 } else if v.Certificate != nil { 1831 if err := validateListenerTlsCertificate(v.Certificate); err != nil { 1832 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 1833 } 1834 } 1835 if v.Validation != nil { 1836 if err := validateListenerTlsValidationContext(v.Validation); err != nil { 1837 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 1838 } 1839 } 1840 if invalidParams.Len() > 0 { 1841 return invalidParams 1842 } else { 1843 return nil 1844 } 1845} 1846 1847func validateListenerTlsAcmCertificate(v *types.ListenerTlsAcmCertificate) error { 1848 if v == nil { 1849 return nil 1850 } 1851 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsAcmCertificate"} 1852 if v.CertificateArn == nil { 1853 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 1854 } 1855 if invalidParams.Len() > 0 { 1856 return invalidParams 1857 } else { 1858 return nil 1859 } 1860} 1861 1862func validateListenerTlsCertificate(v types.ListenerTlsCertificate) error { 1863 if v == nil { 1864 return nil 1865 } 1866 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsCertificate"} 1867 switch uv := v.(type) { 1868 case *types.ListenerTlsCertificateMemberAcm: 1869 if err := validateListenerTlsAcmCertificate(&uv.Value); err != nil { 1870 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 1871 } 1872 1873 case *types.ListenerTlsCertificateMemberFile: 1874 if err := validateListenerTlsFileCertificate(&uv.Value); err != nil { 1875 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1876 } 1877 1878 case *types.ListenerTlsCertificateMemberSds: 1879 if err := validateListenerTlsSdsCertificate(&uv.Value); err != nil { 1880 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 1881 } 1882 1883 } 1884 if invalidParams.Len() > 0 { 1885 return invalidParams 1886 } else { 1887 return nil 1888 } 1889} 1890 1891func validateListenerTlsFileCertificate(v *types.ListenerTlsFileCertificate) error { 1892 if v == nil { 1893 return nil 1894 } 1895 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsFileCertificate"} 1896 if v.CertificateChain == nil { 1897 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 1898 } 1899 if v.PrivateKey == nil { 1900 invalidParams.Add(smithy.NewErrParamRequired("PrivateKey")) 1901 } 1902 if invalidParams.Len() > 0 { 1903 return invalidParams 1904 } else { 1905 return nil 1906 } 1907} 1908 1909func validateListenerTlsSdsCertificate(v *types.ListenerTlsSdsCertificate) error { 1910 if v == nil { 1911 return nil 1912 } 1913 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsSdsCertificate"} 1914 if v.SecretName == nil { 1915 invalidParams.Add(smithy.NewErrParamRequired("SecretName")) 1916 } 1917 if invalidParams.Len() > 0 { 1918 return invalidParams 1919 } else { 1920 return nil 1921 } 1922} 1923 1924func validateListenerTlsValidationContext(v *types.ListenerTlsValidationContext) error { 1925 if v == nil { 1926 return nil 1927 } 1928 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsValidationContext"} 1929 if v.Trust == nil { 1930 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 1931 } else if v.Trust != nil { 1932 if err := validateListenerTlsValidationContextTrust(v.Trust); err != nil { 1933 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 1934 } 1935 } 1936 if v.SubjectAlternativeNames != nil { 1937 if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil { 1938 invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError)) 1939 } 1940 } 1941 if invalidParams.Len() > 0 { 1942 return invalidParams 1943 } else { 1944 return nil 1945 } 1946} 1947 1948func validateListenerTlsValidationContextTrust(v types.ListenerTlsValidationContextTrust) error { 1949 if v == nil { 1950 return nil 1951 } 1952 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsValidationContextTrust"} 1953 switch uv := v.(type) { 1954 case *types.ListenerTlsValidationContextTrustMemberFile: 1955 if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil { 1956 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1957 } 1958 1959 case *types.ListenerTlsValidationContextTrustMemberSds: 1960 if err := validateTlsValidationContextSdsTrust(&uv.Value); err != nil { 1961 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 1962 } 1963 1964 } 1965 if invalidParams.Len() > 0 { 1966 return invalidParams 1967 } else { 1968 return nil 1969 } 1970} 1971 1972func validateLogging(v *types.Logging) error { 1973 if v == nil { 1974 return nil 1975 } 1976 invalidParams := smithy.InvalidParamsError{Context: "Logging"} 1977 if v.AccessLog != nil { 1978 if err := validateAccessLog(v.AccessLog); err != nil { 1979 invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError)) 1980 } 1981 } 1982 if invalidParams.Len() > 0 { 1983 return invalidParams 1984 } else { 1985 return nil 1986 } 1987} 1988 1989func validateMatchRange(v *types.MatchRange) error { 1990 if v == nil { 1991 return nil 1992 } 1993 invalidParams := smithy.InvalidParamsError{Context: "MatchRange"} 1994 if v.Start == nil { 1995 invalidParams.Add(smithy.NewErrParamRequired("Start")) 1996 } 1997 if v.End == nil { 1998 invalidParams.Add(smithy.NewErrParamRequired("End")) 1999 } 2000 if invalidParams.Len() > 0 { 2001 return invalidParams 2002 } else { 2003 return nil 2004 } 2005} 2006 2007func validateMeshSpec(v *types.MeshSpec) error { 2008 if v == nil { 2009 return nil 2010 } 2011 invalidParams := smithy.InvalidParamsError{Context: "MeshSpec"} 2012 if v.EgressFilter != nil { 2013 if err := validateEgressFilter(v.EgressFilter); err != nil { 2014 invalidParams.AddNested("EgressFilter", err.(smithy.InvalidParamsError)) 2015 } 2016 } 2017 if invalidParams.Len() > 0 { 2018 return invalidParams 2019 } else { 2020 return nil 2021 } 2022} 2023 2024func validateOutlierDetection(v *types.OutlierDetection) error { 2025 if v == nil { 2026 return nil 2027 } 2028 invalidParams := smithy.InvalidParamsError{Context: "OutlierDetection"} 2029 if v.MaxServerErrors == nil { 2030 invalidParams.Add(smithy.NewErrParamRequired("MaxServerErrors")) 2031 } 2032 if v.Interval == nil { 2033 invalidParams.Add(smithy.NewErrParamRequired("Interval")) 2034 } 2035 if v.BaseEjectionDuration == nil { 2036 invalidParams.Add(smithy.NewErrParamRequired("BaseEjectionDuration")) 2037 } 2038 if v.MaxEjectionPercent == nil { 2039 invalidParams.Add(smithy.NewErrParamRequired("MaxEjectionPercent")) 2040 } 2041 if invalidParams.Len() > 0 { 2042 return invalidParams 2043 } else { 2044 return nil 2045 } 2046} 2047 2048func validatePortMapping(v *types.PortMapping) error { 2049 if v == nil { 2050 return nil 2051 } 2052 invalidParams := smithy.InvalidParamsError{Context: "PortMapping"} 2053 if len(v.Protocol) == 0 { 2054 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 2055 } 2056 if invalidParams.Len() > 0 { 2057 return invalidParams 2058 } else { 2059 return nil 2060 } 2061} 2062 2063func validateRouteSpec(v *types.RouteSpec) error { 2064 if v == nil { 2065 return nil 2066 } 2067 invalidParams := smithy.InvalidParamsError{Context: "RouteSpec"} 2068 if v.HttpRoute != nil { 2069 if err := validateHttpRoute(v.HttpRoute); err != nil { 2070 invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError)) 2071 } 2072 } 2073 if v.TcpRoute != nil { 2074 if err := validateTcpRoute(v.TcpRoute); err != nil { 2075 invalidParams.AddNested("TcpRoute", err.(smithy.InvalidParamsError)) 2076 } 2077 } 2078 if v.Http2Route != nil { 2079 if err := validateHttpRoute(v.Http2Route); err != nil { 2080 invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError)) 2081 } 2082 } 2083 if v.GrpcRoute != nil { 2084 if err := validateGrpcRoute(v.GrpcRoute); err != nil { 2085 invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError)) 2086 } 2087 } 2088 if invalidParams.Len() > 0 { 2089 return invalidParams 2090 } else { 2091 return nil 2092 } 2093} 2094 2095func validateServiceDiscovery(v types.ServiceDiscovery) error { 2096 if v == nil { 2097 return nil 2098 } 2099 invalidParams := smithy.InvalidParamsError{Context: "ServiceDiscovery"} 2100 switch uv := v.(type) { 2101 case *types.ServiceDiscoveryMemberAwsCloudMap: 2102 if err := validateAwsCloudMapServiceDiscovery(&uv.Value); err != nil { 2103 invalidParams.AddNested("[awsCloudMap]", err.(smithy.InvalidParamsError)) 2104 } 2105 2106 case *types.ServiceDiscoveryMemberDns: 2107 if err := validateDnsServiceDiscovery(&uv.Value); err != nil { 2108 invalidParams.AddNested("[dns]", err.(smithy.InvalidParamsError)) 2109 } 2110 2111 } 2112 if invalidParams.Len() > 0 { 2113 return invalidParams 2114 } else { 2115 return nil 2116 } 2117} 2118 2119func validateSubjectAlternativeNameMatchers(v *types.SubjectAlternativeNameMatchers) error { 2120 if v == nil { 2121 return nil 2122 } 2123 invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNameMatchers"} 2124 if v.Exact == nil { 2125 invalidParams.Add(smithy.NewErrParamRequired("Exact")) 2126 } 2127 if invalidParams.Len() > 0 { 2128 return invalidParams 2129 } else { 2130 return nil 2131 } 2132} 2133 2134func validateSubjectAlternativeNames(v *types.SubjectAlternativeNames) error { 2135 if v == nil { 2136 return nil 2137 } 2138 invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNames"} 2139 if v.Match == nil { 2140 invalidParams.Add(smithy.NewErrParamRequired("Match")) 2141 } else if v.Match != nil { 2142 if err := validateSubjectAlternativeNameMatchers(v.Match); err != nil { 2143 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 2144 } 2145 } 2146 if invalidParams.Len() > 0 { 2147 return invalidParams 2148 } else { 2149 return nil 2150 } 2151} 2152 2153func validateTagList(v []types.TagRef) error { 2154 if v == nil { 2155 return nil 2156 } 2157 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 2158 for i := range v { 2159 if err := validateTagRef(&v[i]); err != nil { 2160 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2161 } 2162 } 2163 if invalidParams.Len() > 0 { 2164 return invalidParams 2165 } else { 2166 return nil 2167 } 2168} 2169 2170func validateTagRef(v *types.TagRef) error { 2171 if v == nil { 2172 return nil 2173 } 2174 invalidParams := smithy.InvalidParamsError{Context: "TagRef"} 2175 if v.Key == nil { 2176 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2177 } 2178 if v.Value == nil { 2179 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2180 } 2181 if invalidParams.Len() > 0 { 2182 return invalidParams 2183 } else { 2184 return nil 2185 } 2186} 2187 2188func validateTcpRoute(v *types.TcpRoute) error { 2189 if v == nil { 2190 return nil 2191 } 2192 invalidParams := smithy.InvalidParamsError{Context: "TcpRoute"} 2193 if v.Action == nil { 2194 invalidParams.Add(smithy.NewErrParamRequired("Action")) 2195 } else if v.Action != nil { 2196 if err := validateTcpRouteAction(v.Action); err != nil { 2197 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 2198 } 2199 } 2200 if invalidParams.Len() > 0 { 2201 return invalidParams 2202 } else { 2203 return nil 2204 } 2205} 2206 2207func validateTcpRouteAction(v *types.TcpRouteAction) error { 2208 if v == nil { 2209 return nil 2210 } 2211 invalidParams := smithy.InvalidParamsError{Context: "TcpRouteAction"} 2212 if v.WeightedTargets == nil { 2213 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 2214 } else if v.WeightedTargets != nil { 2215 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 2216 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 2217 } 2218 } 2219 if invalidParams.Len() > 0 { 2220 return invalidParams 2221 } else { 2222 return nil 2223 } 2224} 2225 2226func validateTlsValidationContext(v *types.TlsValidationContext) error { 2227 if v == nil { 2228 return nil 2229 } 2230 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContext"} 2231 if v.Trust == nil { 2232 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 2233 } else if v.Trust != nil { 2234 if err := validateTlsValidationContextTrust(v.Trust); err != nil { 2235 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 2236 } 2237 } 2238 if v.SubjectAlternativeNames != nil { 2239 if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil { 2240 invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError)) 2241 } 2242 } 2243 if invalidParams.Len() > 0 { 2244 return invalidParams 2245 } else { 2246 return nil 2247 } 2248} 2249 2250func validateTlsValidationContextAcmTrust(v *types.TlsValidationContextAcmTrust) error { 2251 if v == nil { 2252 return nil 2253 } 2254 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextAcmTrust"} 2255 if v.CertificateAuthorityArns == nil { 2256 invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns")) 2257 } 2258 if invalidParams.Len() > 0 { 2259 return invalidParams 2260 } else { 2261 return nil 2262 } 2263} 2264 2265func validateTlsValidationContextFileTrust(v *types.TlsValidationContextFileTrust) error { 2266 if v == nil { 2267 return nil 2268 } 2269 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextFileTrust"} 2270 if v.CertificateChain == nil { 2271 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 2272 } 2273 if invalidParams.Len() > 0 { 2274 return invalidParams 2275 } else { 2276 return nil 2277 } 2278} 2279 2280func validateTlsValidationContextSdsTrust(v *types.TlsValidationContextSdsTrust) error { 2281 if v == nil { 2282 return nil 2283 } 2284 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextSdsTrust"} 2285 if v.SecretName == nil { 2286 invalidParams.Add(smithy.NewErrParamRequired("SecretName")) 2287 } 2288 if invalidParams.Len() > 0 { 2289 return invalidParams 2290 } else { 2291 return nil 2292 } 2293} 2294 2295func validateTlsValidationContextTrust(v types.TlsValidationContextTrust) error { 2296 if v == nil { 2297 return nil 2298 } 2299 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextTrust"} 2300 switch uv := v.(type) { 2301 case *types.TlsValidationContextTrustMemberAcm: 2302 if err := validateTlsValidationContextAcmTrust(&uv.Value); err != nil { 2303 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 2304 } 2305 2306 case *types.TlsValidationContextTrustMemberFile: 2307 if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil { 2308 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2309 } 2310 2311 case *types.TlsValidationContextTrustMemberSds: 2312 if err := validateTlsValidationContextSdsTrust(&uv.Value); err != nil { 2313 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 2314 } 2315 2316 } 2317 if invalidParams.Len() > 0 { 2318 return invalidParams 2319 } else { 2320 return nil 2321 } 2322} 2323 2324func validateVirtualGatewayAccessLog(v types.VirtualGatewayAccessLog) error { 2325 if v == nil { 2326 return nil 2327 } 2328 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayAccessLog"} 2329 switch uv := v.(type) { 2330 case *types.VirtualGatewayAccessLogMemberFile: 2331 if err := validateVirtualGatewayFileAccessLog(&uv.Value); err != nil { 2332 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2333 } 2334 2335 } 2336 if invalidParams.Len() > 0 { 2337 return invalidParams 2338 } else { 2339 return nil 2340 } 2341} 2342 2343func validateVirtualGatewayBackendDefaults(v *types.VirtualGatewayBackendDefaults) error { 2344 if v == nil { 2345 return nil 2346 } 2347 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayBackendDefaults"} 2348 if v.ClientPolicy != nil { 2349 if err := validateVirtualGatewayClientPolicy(v.ClientPolicy); err != nil { 2350 invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError)) 2351 } 2352 } 2353 if invalidParams.Len() > 0 { 2354 return invalidParams 2355 } else { 2356 return nil 2357 } 2358} 2359 2360func validateVirtualGatewayClientPolicy(v *types.VirtualGatewayClientPolicy) error { 2361 if v == nil { 2362 return nil 2363 } 2364 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicy"} 2365 if v.Tls != nil { 2366 if err := validateVirtualGatewayClientPolicyTls(v.Tls); err != nil { 2367 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 2368 } 2369 } 2370 if invalidParams.Len() > 0 { 2371 return invalidParams 2372 } else { 2373 return nil 2374 } 2375} 2376 2377func validateVirtualGatewayClientPolicyTls(v *types.VirtualGatewayClientPolicyTls) error { 2378 if v == nil { 2379 return nil 2380 } 2381 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicyTls"} 2382 if v.Certificate != nil { 2383 if err := validateVirtualGatewayClientTlsCertificate(v.Certificate); err != nil { 2384 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 2385 } 2386 } 2387 if v.Validation == nil { 2388 invalidParams.Add(smithy.NewErrParamRequired("Validation")) 2389 } else if v.Validation != nil { 2390 if err := validateVirtualGatewayTlsValidationContext(v.Validation); err != nil { 2391 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 2392 } 2393 } 2394 if invalidParams.Len() > 0 { 2395 return invalidParams 2396 } else { 2397 return nil 2398 } 2399} 2400 2401func validateVirtualGatewayClientTlsCertificate(v types.VirtualGatewayClientTlsCertificate) error { 2402 if v == nil { 2403 return nil 2404 } 2405 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientTlsCertificate"} 2406 switch uv := v.(type) { 2407 case *types.VirtualGatewayClientTlsCertificateMemberFile: 2408 if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil { 2409 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2410 } 2411 2412 case *types.VirtualGatewayClientTlsCertificateMemberSds: 2413 if err := validateVirtualGatewayListenerTlsSdsCertificate(&uv.Value); err != nil { 2414 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 2415 } 2416 2417 } 2418 if invalidParams.Len() > 0 { 2419 return invalidParams 2420 } else { 2421 return nil 2422 } 2423} 2424 2425func validateVirtualGatewayConnectionPool(v types.VirtualGatewayConnectionPool) error { 2426 if v == nil { 2427 return nil 2428 } 2429 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayConnectionPool"} 2430 switch uv := v.(type) { 2431 case *types.VirtualGatewayConnectionPoolMemberGrpc: 2432 if err := validateVirtualGatewayGrpcConnectionPool(&uv.Value); err != nil { 2433 invalidParams.AddNested("[grpc]", err.(smithy.InvalidParamsError)) 2434 } 2435 2436 case *types.VirtualGatewayConnectionPoolMemberHttp: 2437 if err := validateVirtualGatewayHttpConnectionPool(&uv.Value); err != nil { 2438 invalidParams.AddNested("[http]", err.(smithy.InvalidParamsError)) 2439 } 2440 2441 case *types.VirtualGatewayConnectionPoolMemberHttp2: 2442 if err := validateVirtualGatewayHttp2ConnectionPool(&uv.Value); err != nil { 2443 invalidParams.AddNested("[http2]", err.(smithy.InvalidParamsError)) 2444 } 2445 2446 } 2447 if invalidParams.Len() > 0 { 2448 return invalidParams 2449 } else { 2450 return nil 2451 } 2452} 2453 2454func validateVirtualGatewayFileAccessLog(v *types.VirtualGatewayFileAccessLog) error { 2455 if v == nil { 2456 return nil 2457 } 2458 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayFileAccessLog"} 2459 if v.Path == nil { 2460 invalidParams.Add(smithy.NewErrParamRequired("Path")) 2461 } 2462 if invalidParams.Len() > 0 { 2463 return invalidParams 2464 } else { 2465 return nil 2466 } 2467} 2468 2469func validateVirtualGatewayGrpcConnectionPool(v *types.VirtualGatewayGrpcConnectionPool) error { 2470 if v == nil { 2471 return nil 2472 } 2473 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayGrpcConnectionPool"} 2474 if invalidParams.Len() > 0 { 2475 return invalidParams 2476 } else { 2477 return nil 2478 } 2479} 2480 2481func validateVirtualGatewayHealthCheckPolicy(v *types.VirtualGatewayHealthCheckPolicy) error { 2482 if v == nil { 2483 return nil 2484 } 2485 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHealthCheckPolicy"} 2486 if v.TimeoutMillis == nil { 2487 invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis")) 2488 } 2489 if v.IntervalMillis == nil { 2490 invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis")) 2491 } 2492 if len(v.Protocol) == 0 { 2493 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 2494 } 2495 if invalidParams.Len() > 0 { 2496 return invalidParams 2497 } else { 2498 return nil 2499 } 2500} 2501 2502func validateVirtualGatewayHttp2ConnectionPool(v *types.VirtualGatewayHttp2ConnectionPool) error { 2503 if v == nil { 2504 return nil 2505 } 2506 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHttp2ConnectionPool"} 2507 if invalidParams.Len() > 0 { 2508 return invalidParams 2509 } else { 2510 return nil 2511 } 2512} 2513 2514func validateVirtualGatewayHttpConnectionPool(v *types.VirtualGatewayHttpConnectionPool) error { 2515 if v == nil { 2516 return nil 2517 } 2518 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHttpConnectionPool"} 2519 if invalidParams.Len() > 0 { 2520 return invalidParams 2521 } else { 2522 return nil 2523 } 2524} 2525 2526func validateVirtualGatewayListener(v *types.VirtualGatewayListener) error { 2527 if v == nil { 2528 return nil 2529 } 2530 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListener"} 2531 if v.HealthCheck != nil { 2532 if err := validateVirtualGatewayHealthCheckPolicy(v.HealthCheck); err != nil { 2533 invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError)) 2534 } 2535 } 2536 if v.PortMapping == nil { 2537 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 2538 } else if v.PortMapping != nil { 2539 if err := validateVirtualGatewayPortMapping(v.PortMapping); err != nil { 2540 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 2541 } 2542 } 2543 if v.Tls != nil { 2544 if err := validateVirtualGatewayListenerTls(v.Tls); err != nil { 2545 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 2546 } 2547 } 2548 if v.ConnectionPool != nil { 2549 if err := validateVirtualGatewayConnectionPool(v.ConnectionPool); err != nil { 2550 invalidParams.AddNested("ConnectionPool", err.(smithy.InvalidParamsError)) 2551 } 2552 } 2553 if invalidParams.Len() > 0 { 2554 return invalidParams 2555 } else { 2556 return nil 2557 } 2558} 2559 2560func validateVirtualGatewayListeners(v []types.VirtualGatewayListener) error { 2561 if v == nil { 2562 return nil 2563 } 2564 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListeners"} 2565 for i := range v { 2566 if err := validateVirtualGatewayListener(&v[i]); err != nil { 2567 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2568 } 2569 } 2570 if invalidParams.Len() > 0 { 2571 return invalidParams 2572 } else { 2573 return nil 2574 } 2575} 2576 2577func validateVirtualGatewayListenerTls(v *types.VirtualGatewayListenerTls) error { 2578 if v == nil { 2579 return nil 2580 } 2581 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTls"} 2582 if len(v.Mode) == 0 { 2583 invalidParams.Add(smithy.NewErrParamRequired("Mode")) 2584 } 2585 if v.Validation != nil { 2586 if err := validateVirtualGatewayListenerTlsValidationContext(v.Validation); err != nil { 2587 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 2588 } 2589 } 2590 if v.Certificate == nil { 2591 invalidParams.Add(smithy.NewErrParamRequired("Certificate")) 2592 } else if v.Certificate != nil { 2593 if err := validateVirtualGatewayListenerTlsCertificate(v.Certificate); err != nil { 2594 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 2595 } 2596 } 2597 if invalidParams.Len() > 0 { 2598 return invalidParams 2599 } else { 2600 return nil 2601 } 2602} 2603 2604func validateVirtualGatewayListenerTlsAcmCertificate(v *types.VirtualGatewayListenerTlsAcmCertificate) error { 2605 if v == nil { 2606 return nil 2607 } 2608 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsAcmCertificate"} 2609 if v.CertificateArn == nil { 2610 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 2611 } 2612 if invalidParams.Len() > 0 { 2613 return invalidParams 2614 } else { 2615 return nil 2616 } 2617} 2618 2619func validateVirtualGatewayListenerTlsCertificate(v types.VirtualGatewayListenerTlsCertificate) error { 2620 if v == nil { 2621 return nil 2622 } 2623 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsCertificate"} 2624 switch uv := v.(type) { 2625 case *types.VirtualGatewayListenerTlsCertificateMemberAcm: 2626 if err := validateVirtualGatewayListenerTlsAcmCertificate(&uv.Value); err != nil { 2627 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 2628 } 2629 2630 case *types.VirtualGatewayListenerTlsCertificateMemberFile: 2631 if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil { 2632 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2633 } 2634 2635 case *types.VirtualGatewayListenerTlsCertificateMemberSds: 2636 if err := validateVirtualGatewayListenerTlsSdsCertificate(&uv.Value); err != nil { 2637 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 2638 } 2639 2640 } 2641 if invalidParams.Len() > 0 { 2642 return invalidParams 2643 } else { 2644 return nil 2645 } 2646} 2647 2648func validateVirtualGatewayListenerTlsFileCertificate(v *types.VirtualGatewayListenerTlsFileCertificate) error { 2649 if v == nil { 2650 return nil 2651 } 2652 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsFileCertificate"} 2653 if v.CertificateChain == nil { 2654 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 2655 } 2656 if v.PrivateKey == nil { 2657 invalidParams.Add(smithy.NewErrParamRequired("PrivateKey")) 2658 } 2659 if invalidParams.Len() > 0 { 2660 return invalidParams 2661 } else { 2662 return nil 2663 } 2664} 2665 2666func validateVirtualGatewayListenerTlsSdsCertificate(v *types.VirtualGatewayListenerTlsSdsCertificate) error { 2667 if v == nil { 2668 return nil 2669 } 2670 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsSdsCertificate"} 2671 if v.SecretName == nil { 2672 invalidParams.Add(smithy.NewErrParamRequired("SecretName")) 2673 } 2674 if invalidParams.Len() > 0 { 2675 return invalidParams 2676 } else { 2677 return nil 2678 } 2679} 2680 2681func validateVirtualGatewayListenerTlsValidationContext(v *types.VirtualGatewayListenerTlsValidationContext) error { 2682 if v == nil { 2683 return nil 2684 } 2685 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsValidationContext"} 2686 if v.Trust == nil { 2687 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 2688 } else if v.Trust != nil { 2689 if err := validateVirtualGatewayListenerTlsValidationContextTrust(v.Trust); err != nil { 2690 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 2691 } 2692 } 2693 if v.SubjectAlternativeNames != nil { 2694 if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil { 2695 invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError)) 2696 } 2697 } 2698 if invalidParams.Len() > 0 { 2699 return invalidParams 2700 } else { 2701 return nil 2702 } 2703} 2704 2705func validateVirtualGatewayListenerTlsValidationContextTrust(v types.VirtualGatewayListenerTlsValidationContextTrust) error { 2706 if v == nil { 2707 return nil 2708 } 2709 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsValidationContextTrust"} 2710 switch uv := v.(type) { 2711 case *types.VirtualGatewayListenerTlsValidationContextTrustMemberFile: 2712 if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil { 2713 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2714 } 2715 2716 case *types.VirtualGatewayListenerTlsValidationContextTrustMemberSds: 2717 if err := validateVirtualGatewayTlsValidationContextSdsTrust(&uv.Value); err != nil { 2718 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 2719 } 2720 2721 } 2722 if invalidParams.Len() > 0 { 2723 return invalidParams 2724 } else { 2725 return nil 2726 } 2727} 2728 2729func validateVirtualGatewayLogging(v *types.VirtualGatewayLogging) error { 2730 if v == nil { 2731 return nil 2732 } 2733 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayLogging"} 2734 if v.AccessLog != nil { 2735 if err := validateVirtualGatewayAccessLog(v.AccessLog); err != nil { 2736 invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError)) 2737 } 2738 } 2739 if invalidParams.Len() > 0 { 2740 return invalidParams 2741 } else { 2742 return nil 2743 } 2744} 2745 2746func validateVirtualGatewayPortMapping(v *types.VirtualGatewayPortMapping) error { 2747 if v == nil { 2748 return nil 2749 } 2750 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayPortMapping"} 2751 if len(v.Protocol) == 0 { 2752 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 2753 } 2754 if invalidParams.Len() > 0 { 2755 return invalidParams 2756 } else { 2757 return nil 2758 } 2759} 2760 2761func validateVirtualGatewaySpec(v *types.VirtualGatewaySpec) error { 2762 if v == nil { 2763 return nil 2764 } 2765 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewaySpec"} 2766 if v.BackendDefaults != nil { 2767 if err := validateVirtualGatewayBackendDefaults(v.BackendDefaults); err != nil { 2768 invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError)) 2769 } 2770 } 2771 if v.Listeners == nil { 2772 invalidParams.Add(smithy.NewErrParamRequired("Listeners")) 2773 } else if v.Listeners != nil { 2774 if err := validateVirtualGatewayListeners(v.Listeners); err != nil { 2775 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 2776 } 2777 } 2778 if v.Logging != nil { 2779 if err := validateVirtualGatewayLogging(v.Logging); err != nil { 2780 invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError)) 2781 } 2782 } 2783 if invalidParams.Len() > 0 { 2784 return invalidParams 2785 } else { 2786 return nil 2787 } 2788} 2789 2790func validateVirtualGatewayTlsValidationContext(v *types.VirtualGatewayTlsValidationContext) error { 2791 if v == nil { 2792 return nil 2793 } 2794 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContext"} 2795 if v.Trust == nil { 2796 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 2797 } else if v.Trust != nil { 2798 if err := validateVirtualGatewayTlsValidationContextTrust(v.Trust); err != nil { 2799 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 2800 } 2801 } 2802 if v.SubjectAlternativeNames != nil { 2803 if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil { 2804 invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError)) 2805 } 2806 } 2807 if invalidParams.Len() > 0 { 2808 return invalidParams 2809 } else { 2810 return nil 2811 } 2812} 2813 2814func validateVirtualGatewayTlsValidationContextAcmTrust(v *types.VirtualGatewayTlsValidationContextAcmTrust) error { 2815 if v == nil { 2816 return nil 2817 } 2818 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextAcmTrust"} 2819 if v.CertificateAuthorityArns == nil { 2820 invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns")) 2821 } 2822 if invalidParams.Len() > 0 { 2823 return invalidParams 2824 } else { 2825 return nil 2826 } 2827} 2828 2829func validateVirtualGatewayTlsValidationContextFileTrust(v *types.VirtualGatewayTlsValidationContextFileTrust) error { 2830 if v == nil { 2831 return nil 2832 } 2833 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextFileTrust"} 2834 if v.CertificateChain == nil { 2835 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 2836 } 2837 if invalidParams.Len() > 0 { 2838 return invalidParams 2839 } else { 2840 return nil 2841 } 2842} 2843 2844func validateVirtualGatewayTlsValidationContextSdsTrust(v *types.VirtualGatewayTlsValidationContextSdsTrust) error { 2845 if v == nil { 2846 return nil 2847 } 2848 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextSdsTrust"} 2849 if v.SecretName == nil { 2850 invalidParams.Add(smithy.NewErrParamRequired("SecretName")) 2851 } 2852 if invalidParams.Len() > 0 { 2853 return invalidParams 2854 } else { 2855 return nil 2856 } 2857} 2858 2859func validateVirtualGatewayTlsValidationContextTrust(v types.VirtualGatewayTlsValidationContextTrust) error { 2860 if v == nil { 2861 return nil 2862 } 2863 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextTrust"} 2864 switch uv := v.(type) { 2865 case *types.VirtualGatewayTlsValidationContextTrustMemberAcm: 2866 if err := validateVirtualGatewayTlsValidationContextAcmTrust(&uv.Value); err != nil { 2867 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 2868 } 2869 2870 case *types.VirtualGatewayTlsValidationContextTrustMemberFile: 2871 if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil { 2872 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2873 } 2874 2875 case *types.VirtualGatewayTlsValidationContextTrustMemberSds: 2876 if err := validateVirtualGatewayTlsValidationContextSdsTrust(&uv.Value); err != nil { 2877 invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError)) 2878 } 2879 2880 } 2881 if invalidParams.Len() > 0 { 2882 return invalidParams 2883 } else { 2884 return nil 2885 } 2886} 2887 2888func validateVirtualNodeConnectionPool(v types.VirtualNodeConnectionPool) error { 2889 if v == nil { 2890 return nil 2891 } 2892 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeConnectionPool"} 2893 switch uv := v.(type) { 2894 case *types.VirtualNodeConnectionPoolMemberGrpc: 2895 if err := validateVirtualNodeGrpcConnectionPool(&uv.Value); err != nil { 2896 invalidParams.AddNested("[grpc]", err.(smithy.InvalidParamsError)) 2897 } 2898 2899 case *types.VirtualNodeConnectionPoolMemberHttp: 2900 if err := validateVirtualNodeHttpConnectionPool(&uv.Value); err != nil { 2901 invalidParams.AddNested("[http]", err.(smithy.InvalidParamsError)) 2902 } 2903 2904 case *types.VirtualNodeConnectionPoolMemberHttp2: 2905 if err := validateVirtualNodeHttp2ConnectionPool(&uv.Value); err != nil { 2906 invalidParams.AddNested("[http2]", err.(smithy.InvalidParamsError)) 2907 } 2908 2909 case *types.VirtualNodeConnectionPoolMemberTcp: 2910 if err := validateVirtualNodeTcpConnectionPool(&uv.Value); err != nil { 2911 invalidParams.AddNested("[tcp]", err.(smithy.InvalidParamsError)) 2912 } 2913 2914 } 2915 if invalidParams.Len() > 0 { 2916 return invalidParams 2917 } else { 2918 return nil 2919 } 2920} 2921 2922func validateVirtualNodeGrpcConnectionPool(v *types.VirtualNodeGrpcConnectionPool) error { 2923 if v == nil { 2924 return nil 2925 } 2926 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeGrpcConnectionPool"} 2927 if invalidParams.Len() > 0 { 2928 return invalidParams 2929 } else { 2930 return nil 2931 } 2932} 2933 2934func validateVirtualNodeHttp2ConnectionPool(v *types.VirtualNodeHttp2ConnectionPool) error { 2935 if v == nil { 2936 return nil 2937 } 2938 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeHttp2ConnectionPool"} 2939 if invalidParams.Len() > 0 { 2940 return invalidParams 2941 } else { 2942 return nil 2943 } 2944} 2945 2946func validateVirtualNodeHttpConnectionPool(v *types.VirtualNodeHttpConnectionPool) error { 2947 if v == nil { 2948 return nil 2949 } 2950 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeHttpConnectionPool"} 2951 if invalidParams.Len() > 0 { 2952 return invalidParams 2953 } else { 2954 return nil 2955 } 2956} 2957 2958func validateVirtualNodeServiceProvider(v *types.VirtualNodeServiceProvider) error { 2959 if v == nil { 2960 return nil 2961 } 2962 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeServiceProvider"} 2963 if v.VirtualNodeName == nil { 2964 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 2965 } 2966 if invalidParams.Len() > 0 { 2967 return invalidParams 2968 } else { 2969 return nil 2970 } 2971} 2972 2973func validateVirtualNodeSpec(v *types.VirtualNodeSpec) error { 2974 if v == nil { 2975 return nil 2976 } 2977 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeSpec"} 2978 if v.ServiceDiscovery != nil { 2979 if err := validateServiceDiscovery(v.ServiceDiscovery); err != nil { 2980 invalidParams.AddNested("ServiceDiscovery", err.(smithy.InvalidParamsError)) 2981 } 2982 } 2983 if v.Listeners != nil { 2984 if err := validateListeners(v.Listeners); err != nil { 2985 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 2986 } 2987 } 2988 if v.Backends != nil { 2989 if err := validateBackends(v.Backends); err != nil { 2990 invalidParams.AddNested("Backends", err.(smithy.InvalidParamsError)) 2991 } 2992 } 2993 if v.BackendDefaults != nil { 2994 if err := validateBackendDefaults(v.BackendDefaults); err != nil { 2995 invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError)) 2996 } 2997 } 2998 if v.Logging != nil { 2999 if err := validateLogging(v.Logging); err != nil { 3000 invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError)) 3001 } 3002 } 3003 if invalidParams.Len() > 0 { 3004 return invalidParams 3005 } else { 3006 return nil 3007 } 3008} 3009 3010func validateVirtualNodeTcpConnectionPool(v *types.VirtualNodeTcpConnectionPool) error { 3011 if v == nil { 3012 return nil 3013 } 3014 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeTcpConnectionPool"} 3015 if invalidParams.Len() > 0 { 3016 return invalidParams 3017 } else { 3018 return nil 3019 } 3020} 3021 3022func validateVirtualRouterListener(v *types.VirtualRouterListener) error { 3023 if v == nil { 3024 return nil 3025 } 3026 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListener"} 3027 if v.PortMapping == nil { 3028 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 3029 } else if v.PortMapping != nil { 3030 if err := validatePortMapping(v.PortMapping); err != nil { 3031 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 3032 } 3033 } 3034 if invalidParams.Len() > 0 { 3035 return invalidParams 3036 } else { 3037 return nil 3038 } 3039} 3040 3041func validateVirtualRouterListeners(v []types.VirtualRouterListener) error { 3042 if v == nil { 3043 return nil 3044 } 3045 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListeners"} 3046 for i := range v { 3047 if err := validateVirtualRouterListener(&v[i]); err != nil { 3048 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3049 } 3050 } 3051 if invalidParams.Len() > 0 { 3052 return invalidParams 3053 } else { 3054 return nil 3055 } 3056} 3057 3058func validateVirtualRouterServiceProvider(v *types.VirtualRouterServiceProvider) error { 3059 if v == nil { 3060 return nil 3061 } 3062 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterServiceProvider"} 3063 if v.VirtualRouterName == nil { 3064 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3065 } 3066 if invalidParams.Len() > 0 { 3067 return invalidParams 3068 } else { 3069 return nil 3070 } 3071} 3072 3073func validateVirtualRouterSpec(v *types.VirtualRouterSpec) error { 3074 if v == nil { 3075 return nil 3076 } 3077 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterSpec"} 3078 if v.Listeners != nil { 3079 if err := validateVirtualRouterListeners(v.Listeners); err != nil { 3080 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 3081 } 3082 } 3083 if invalidParams.Len() > 0 { 3084 return invalidParams 3085 } else { 3086 return nil 3087 } 3088} 3089 3090func validateVirtualServiceBackend(v *types.VirtualServiceBackend) error { 3091 if v == nil { 3092 return nil 3093 } 3094 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceBackend"} 3095 if v.VirtualServiceName == nil { 3096 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3097 } 3098 if v.ClientPolicy != nil { 3099 if err := validateClientPolicy(v.ClientPolicy); err != nil { 3100 invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError)) 3101 } 3102 } 3103 if invalidParams.Len() > 0 { 3104 return invalidParams 3105 } else { 3106 return nil 3107 } 3108} 3109 3110func validateVirtualServiceProvider(v types.VirtualServiceProvider) error { 3111 if v == nil { 3112 return nil 3113 } 3114 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceProvider"} 3115 switch uv := v.(type) { 3116 case *types.VirtualServiceProviderMemberVirtualNode: 3117 if err := validateVirtualNodeServiceProvider(&uv.Value); err != nil { 3118 invalidParams.AddNested("[virtualNode]", err.(smithy.InvalidParamsError)) 3119 } 3120 3121 case *types.VirtualServiceProviderMemberVirtualRouter: 3122 if err := validateVirtualRouterServiceProvider(&uv.Value); err != nil { 3123 invalidParams.AddNested("[virtualRouter]", err.(smithy.InvalidParamsError)) 3124 } 3125 3126 } 3127 if invalidParams.Len() > 0 { 3128 return invalidParams 3129 } else { 3130 return nil 3131 } 3132} 3133 3134func validateVirtualServiceSpec(v *types.VirtualServiceSpec) error { 3135 if v == nil { 3136 return nil 3137 } 3138 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceSpec"} 3139 if v.Provider != nil { 3140 if err := validateVirtualServiceProvider(v.Provider); err != nil { 3141 invalidParams.AddNested("Provider", err.(smithy.InvalidParamsError)) 3142 } 3143 } 3144 if invalidParams.Len() > 0 { 3145 return invalidParams 3146 } else { 3147 return nil 3148 } 3149} 3150 3151func validateWeightedTarget(v *types.WeightedTarget) error { 3152 if v == nil { 3153 return nil 3154 } 3155 invalidParams := smithy.InvalidParamsError{Context: "WeightedTarget"} 3156 if v.VirtualNode == nil { 3157 invalidParams.Add(smithy.NewErrParamRequired("VirtualNode")) 3158 } 3159 if invalidParams.Len() > 0 { 3160 return invalidParams 3161 } else { 3162 return nil 3163 } 3164} 3165 3166func validateWeightedTargets(v []types.WeightedTarget) error { 3167 if v == nil { 3168 return nil 3169 } 3170 invalidParams := smithy.InvalidParamsError{Context: "WeightedTargets"} 3171 for i := range v { 3172 if err := validateWeightedTarget(&v[i]); err != nil { 3173 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3174 } 3175 } 3176 if invalidParams.Len() > 0 { 3177 return invalidParams 3178 } else { 3179 return nil 3180 } 3181} 3182 3183func validateOpCreateGatewayRouteInput(v *CreateGatewayRouteInput) error { 3184 if v == nil { 3185 return nil 3186 } 3187 invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayRouteInput"} 3188 if v.GatewayRouteName == nil { 3189 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 3190 } 3191 if v.MeshName == nil { 3192 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3193 } 3194 if v.VirtualGatewayName == nil { 3195 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3196 } 3197 if v.Spec == nil { 3198 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3199 } else if v.Spec != nil { 3200 if err := validateGatewayRouteSpec(v.Spec); err != nil { 3201 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3202 } 3203 } 3204 if v.Tags != nil { 3205 if err := validateTagList(v.Tags); err != nil { 3206 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3207 } 3208 } 3209 if invalidParams.Len() > 0 { 3210 return invalidParams 3211 } else { 3212 return nil 3213 } 3214} 3215 3216func validateOpCreateMeshInput(v *CreateMeshInput) error { 3217 if v == nil { 3218 return nil 3219 } 3220 invalidParams := smithy.InvalidParamsError{Context: "CreateMeshInput"} 3221 if v.MeshName == nil { 3222 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3223 } 3224 if v.Spec != nil { 3225 if err := validateMeshSpec(v.Spec); err != nil { 3226 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3227 } 3228 } 3229 if v.Tags != nil { 3230 if err := validateTagList(v.Tags); err != nil { 3231 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3232 } 3233 } 3234 if invalidParams.Len() > 0 { 3235 return invalidParams 3236 } else { 3237 return nil 3238 } 3239} 3240 3241func validateOpCreateRouteInput(v *CreateRouteInput) error { 3242 if v == nil { 3243 return nil 3244 } 3245 invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"} 3246 if v.RouteName == nil { 3247 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 3248 } 3249 if v.MeshName == nil { 3250 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3251 } 3252 if v.VirtualRouterName == nil { 3253 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3254 } 3255 if v.Spec == nil { 3256 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3257 } else if v.Spec != nil { 3258 if err := validateRouteSpec(v.Spec); err != nil { 3259 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3260 } 3261 } 3262 if v.Tags != nil { 3263 if err := validateTagList(v.Tags); err != nil { 3264 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3265 } 3266 } 3267 if invalidParams.Len() > 0 { 3268 return invalidParams 3269 } else { 3270 return nil 3271 } 3272} 3273 3274func validateOpCreateVirtualGatewayInput(v *CreateVirtualGatewayInput) error { 3275 if v == nil { 3276 return nil 3277 } 3278 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualGatewayInput"} 3279 if v.VirtualGatewayName == nil { 3280 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3281 } 3282 if v.MeshName == nil { 3283 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3284 } 3285 if v.Spec == nil { 3286 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3287 } else if v.Spec != nil { 3288 if err := validateVirtualGatewaySpec(v.Spec); err != nil { 3289 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3290 } 3291 } 3292 if v.Tags != nil { 3293 if err := validateTagList(v.Tags); err != nil { 3294 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3295 } 3296 } 3297 if invalidParams.Len() > 0 { 3298 return invalidParams 3299 } else { 3300 return nil 3301 } 3302} 3303 3304func validateOpCreateVirtualNodeInput(v *CreateVirtualNodeInput) error { 3305 if v == nil { 3306 return nil 3307 } 3308 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualNodeInput"} 3309 if v.VirtualNodeName == nil { 3310 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 3311 } 3312 if v.MeshName == nil { 3313 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3314 } 3315 if v.Spec == nil { 3316 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3317 } else if v.Spec != nil { 3318 if err := validateVirtualNodeSpec(v.Spec); err != nil { 3319 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3320 } 3321 } 3322 if v.Tags != nil { 3323 if err := validateTagList(v.Tags); err != nil { 3324 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3325 } 3326 } 3327 if invalidParams.Len() > 0 { 3328 return invalidParams 3329 } else { 3330 return nil 3331 } 3332} 3333 3334func validateOpCreateVirtualRouterInput(v *CreateVirtualRouterInput) error { 3335 if v == nil { 3336 return nil 3337 } 3338 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualRouterInput"} 3339 if v.VirtualRouterName == nil { 3340 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3341 } 3342 if v.MeshName == nil { 3343 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3344 } 3345 if v.Spec == nil { 3346 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3347 } else if v.Spec != nil { 3348 if err := validateVirtualRouterSpec(v.Spec); err != nil { 3349 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3350 } 3351 } 3352 if v.Tags != nil { 3353 if err := validateTagList(v.Tags); err != nil { 3354 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3355 } 3356 } 3357 if invalidParams.Len() > 0 { 3358 return invalidParams 3359 } else { 3360 return nil 3361 } 3362} 3363 3364func validateOpCreateVirtualServiceInput(v *CreateVirtualServiceInput) error { 3365 if v == nil { 3366 return nil 3367 } 3368 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualServiceInput"} 3369 if v.VirtualServiceName == nil { 3370 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3371 } 3372 if v.MeshName == nil { 3373 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3374 } 3375 if v.Spec == nil { 3376 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3377 } else if v.Spec != nil { 3378 if err := validateVirtualServiceSpec(v.Spec); err != nil { 3379 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3380 } 3381 } 3382 if v.Tags != nil { 3383 if err := validateTagList(v.Tags); err != nil { 3384 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3385 } 3386 } 3387 if invalidParams.Len() > 0 { 3388 return invalidParams 3389 } else { 3390 return nil 3391 } 3392} 3393 3394func validateOpDeleteGatewayRouteInput(v *DeleteGatewayRouteInput) error { 3395 if v == nil { 3396 return nil 3397 } 3398 invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayRouteInput"} 3399 if v.GatewayRouteName == nil { 3400 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 3401 } 3402 if v.MeshName == nil { 3403 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3404 } 3405 if v.VirtualGatewayName == nil { 3406 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3407 } 3408 if invalidParams.Len() > 0 { 3409 return invalidParams 3410 } else { 3411 return nil 3412 } 3413} 3414 3415func validateOpDeleteMeshInput(v *DeleteMeshInput) error { 3416 if v == nil { 3417 return nil 3418 } 3419 invalidParams := smithy.InvalidParamsError{Context: "DeleteMeshInput"} 3420 if v.MeshName == nil { 3421 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3422 } 3423 if invalidParams.Len() > 0 { 3424 return invalidParams 3425 } else { 3426 return nil 3427 } 3428} 3429 3430func validateOpDeleteRouteInput(v *DeleteRouteInput) error { 3431 if v == nil { 3432 return nil 3433 } 3434 invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"} 3435 if v.RouteName == nil { 3436 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 3437 } 3438 if v.MeshName == nil { 3439 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3440 } 3441 if v.VirtualRouterName == nil { 3442 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3443 } 3444 if invalidParams.Len() > 0 { 3445 return invalidParams 3446 } else { 3447 return nil 3448 } 3449} 3450 3451func validateOpDeleteVirtualGatewayInput(v *DeleteVirtualGatewayInput) error { 3452 if v == nil { 3453 return nil 3454 } 3455 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualGatewayInput"} 3456 if v.VirtualGatewayName == nil { 3457 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3458 } 3459 if v.MeshName == nil { 3460 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3461 } 3462 if invalidParams.Len() > 0 { 3463 return invalidParams 3464 } else { 3465 return nil 3466 } 3467} 3468 3469func validateOpDeleteVirtualNodeInput(v *DeleteVirtualNodeInput) error { 3470 if v == nil { 3471 return nil 3472 } 3473 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualNodeInput"} 3474 if v.VirtualNodeName == nil { 3475 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 3476 } 3477 if v.MeshName == nil { 3478 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3479 } 3480 if invalidParams.Len() > 0 { 3481 return invalidParams 3482 } else { 3483 return nil 3484 } 3485} 3486 3487func validateOpDeleteVirtualRouterInput(v *DeleteVirtualRouterInput) error { 3488 if v == nil { 3489 return nil 3490 } 3491 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualRouterInput"} 3492 if v.VirtualRouterName == nil { 3493 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3494 } 3495 if v.MeshName == nil { 3496 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3497 } 3498 if invalidParams.Len() > 0 { 3499 return invalidParams 3500 } else { 3501 return nil 3502 } 3503} 3504 3505func validateOpDeleteVirtualServiceInput(v *DeleteVirtualServiceInput) error { 3506 if v == nil { 3507 return nil 3508 } 3509 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualServiceInput"} 3510 if v.VirtualServiceName == nil { 3511 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3512 } 3513 if v.MeshName == nil { 3514 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3515 } 3516 if invalidParams.Len() > 0 { 3517 return invalidParams 3518 } else { 3519 return nil 3520 } 3521} 3522 3523func validateOpDescribeGatewayRouteInput(v *DescribeGatewayRouteInput) error { 3524 if v == nil { 3525 return nil 3526 } 3527 invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayRouteInput"} 3528 if v.GatewayRouteName == nil { 3529 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 3530 } 3531 if v.MeshName == nil { 3532 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3533 } 3534 if v.VirtualGatewayName == nil { 3535 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3536 } 3537 if invalidParams.Len() > 0 { 3538 return invalidParams 3539 } else { 3540 return nil 3541 } 3542} 3543 3544func validateOpDescribeMeshInput(v *DescribeMeshInput) error { 3545 if v == nil { 3546 return nil 3547 } 3548 invalidParams := smithy.InvalidParamsError{Context: "DescribeMeshInput"} 3549 if v.MeshName == nil { 3550 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3551 } 3552 if invalidParams.Len() > 0 { 3553 return invalidParams 3554 } else { 3555 return nil 3556 } 3557} 3558 3559func validateOpDescribeRouteInput(v *DescribeRouteInput) error { 3560 if v == nil { 3561 return nil 3562 } 3563 invalidParams := smithy.InvalidParamsError{Context: "DescribeRouteInput"} 3564 if v.RouteName == nil { 3565 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 3566 } 3567 if v.MeshName == nil { 3568 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3569 } 3570 if v.VirtualRouterName == nil { 3571 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3572 } 3573 if invalidParams.Len() > 0 { 3574 return invalidParams 3575 } else { 3576 return nil 3577 } 3578} 3579 3580func validateOpDescribeVirtualGatewayInput(v *DescribeVirtualGatewayInput) error { 3581 if v == nil { 3582 return nil 3583 } 3584 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualGatewayInput"} 3585 if v.VirtualGatewayName == nil { 3586 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3587 } 3588 if v.MeshName == nil { 3589 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3590 } 3591 if invalidParams.Len() > 0 { 3592 return invalidParams 3593 } else { 3594 return nil 3595 } 3596} 3597 3598func validateOpDescribeVirtualNodeInput(v *DescribeVirtualNodeInput) error { 3599 if v == nil { 3600 return nil 3601 } 3602 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualNodeInput"} 3603 if v.VirtualNodeName == nil { 3604 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 3605 } 3606 if v.MeshName == nil { 3607 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3608 } 3609 if invalidParams.Len() > 0 { 3610 return invalidParams 3611 } else { 3612 return nil 3613 } 3614} 3615 3616func validateOpDescribeVirtualRouterInput(v *DescribeVirtualRouterInput) error { 3617 if v == nil { 3618 return nil 3619 } 3620 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualRouterInput"} 3621 if v.VirtualRouterName == nil { 3622 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3623 } 3624 if v.MeshName == nil { 3625 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3626 } 3627 if invalidParams.Len() > 0 { 3628 return invalidParams 3629 } else { 3630 return nil 3631 } 3632} 3633 3634func validateOpDescribeVirtualServiceInput(v *DescribeVirtualServiceInput) error { 3635 if v == nil { 3636 return nil 3637 } 3638 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualServiceInput"} 3639 if v.VirtualServiceName == nil { 3640 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3641 } 3642 if v.MeshName == nil { 3643 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3644 } 3645 if invalidParams.Len() > 0 { 3646 return invalidParams 3647 } else { 3648 return nil 3649 } 3650} 3651 3652func validateOpListGatewayRoutesInput(v *ListGatewayRoutesInput) error { 3653 if v == nil { 3654 return nil 3655 } 3656 invalidParams := smithy.InvalidParamsError{Context: "ListGatewayRoutesInput"} 3657 if v.MeshName == nil { 3658 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3659 } 3660 if v.VirtualGatewayName == nil { 3661 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3662 } 3663 if invalidParams.Len() > 0 { 3664 return invalidParams 3665 } else { 3666 return nil 3667 } 3668} 3669 3670func validateOpListRoutesInput(v *ListRoutesInput) error { 3671 if v == nil { 3672 return nil 3673 } 3674 invalidParams := smithy.InvalidParamsError{Context: "ListRoutesInput"} 3675 if v.MeshName == nil { 3676 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3677 } 3678 if v.VirtualRouterName == nil { 3679 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3680 } 3681 if invalidParams.Len() > 0 { 3682 return invalidParams 3683 } else { 3684 return nil 3685 } 3686} 3687 3688func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 3689 if v == nil { 3690 return nil 3691 } 3692 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 3693 if v.ResourceArn == nil { 3694 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3695 } 3696 if invalidParams.Len() > 0 { 3697 return invalidParams 3698 } else { 3699 return nil 3700 } 3701} 3702 3703func validateOpListVirtualGatewaysInput(v *ListVirtualGatewaysInput) error { 3704 if v == nil { 3705 return nil 3706 } 3707 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualGatewaysInput"} 3708 if v.MeshName == nil { 3709 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3710 } 3711 if invalidParams.Len() > 0 { 3712 return invalidParams 3713 } else { 3714 return nil 3715 } 3716} 3717 3718func validateOpListVirtualNodesInput(v *ListVirtualNodesInput) error { 3719 if v == nil { 3720 return nil 3721 } 3722 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualNodesInput"} 3723 if v.MeshName == nil { 3724 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3725 } 3726 if invalidParams.Len() > 0 { 3727 return invalidParams 3728 } else { 3729 return nil 3730 } 3731} 3732 3733func validateOpListVirtualRoutersInput(v *ListVirtualRoutersInput) error { 3734 if v == nil { 3735 return nil 3736 } 3737 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualRoutersInput"} 3738 if v.MeshName == nil { 3739 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3740 } 3741 if invalidParams.Len() > 0 { 3742 return invalidParams 3743 } else { 3744 return nil 3745 } 3746} 3747 3748func validateOpListVirtualServicesInput(v *ListVirtualServicesInput) error { 3749 if v == nil { 3750 return nil 3751 } 3752 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualServicesInput"} 3753 if v.MeshName == nil { 3754 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3755 } 3756 if invalidParams.Len() > 0 { 3757 return invalidParams 3758 } else { 3759 return nil 3760 } 3761} 3762 3763func validateOpTagResourceInput(v *TagResourceInput) error { 3764 if v == nil { 3765 return nil 3766 } 3767 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 3768 if v.ResourceArn == nil { 3769 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3770 } 3771 if v.Tags == nil { 3772 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 3773 } else if v.Tags != nil { 3774 if err := validateTagList(v.Tags); err != nil { 3775 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3776 } 3777 } 3778 if invalidParams.Len() > 0 { 3779 return invalidParams 3780 } else { 3781 return nil 3782 } 3783} 3784 3785func validateOpUntagResourceInput(v *UntagResourceInput) error { 3786 if v == nil { 3787 return nil 3788 } 3789 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 3790 if v.ResourceArn == nil { 3791 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3792 } 3793 if v.TagKeys == nil { 3794 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 3795 } 3796 if invalidParams.Len() > 0 { 3797 return invalidParams 3798 } else { 3799 return nil 3800 } 3801} 3802 3803func validateOpUpdateGatewayRouteInput(v *UpdateGatewayRouteInput) error { 3804 if v == nil { 3805 return nil 3806 } 3807 invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayRouteInput"} 3808 if v.GatewayRouteName == nil { 3809 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 3810 } 3811 if v.MeshName == nil { 3812 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3813 } 3814 if v.VirtualGatewayName == nil { 3815 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3816 } 3817 if v.Spec == nil { 3818 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3819 } else if v.Spec != nil { 3820 if err := validateGatewayRouteSpec(v.Spec); err != nil { 3821 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3822 } 3823 } 3824 if invalidParams.Len() > 0 { 3825 return invalidParams 3826 } else { 3827 return nil 3828 } 3829} 3830 3831func validateOpUpdateMeshInput(v *UpdateMeshInput) error { 3832 if v == nil { 3833 return nil 3834 } 3835 invalidParams := smithy.InvalidParamsError{Context: "UpdateMeshInput"} 3836 if v.MeshName == nil { 3837 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3838 } 3839 if v.Spec != nil { 3840 if err := validateMeshSpec(v.Spec); err != nil { 3841 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3842 } 3843 } 3844 if invalidParams.Len() > 0 { 3845 return invalidParams 3846 } else { 3847 return nil 3848 } 3849} 3850 3851func validateOpUpdateRouteInput(v *UpdateRouteInput) error { 3852 if v == nil { 3853 return nil 3854 } 3855 invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"} 3856 if v.RouteName == nil { 3857 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 3858 } 3859 if v.MeshName == nil { 3860 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3861 } 3862 if v.VirtualRouterName == nil { 3863 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3864 } 3865 if v.Spec == nil { 3866 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3867 } else if v.Spec != nil { 3868 if err := validateRouteSpec(v.Spec); err != nil { 3869 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3870 } 3871 } 3872 if invalidParams.Len() > 0 { 3873 return invalidParams 3874 } else { 3875 return nil 3876 } 3877} 3878 3879func validateOpUpdateVirtualGatewayInput(v *UpdateVirtualGatewayInput) error { 3880 if v == nil { 3881 return nil 3882 } 3883 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualGatewayInput"} 3884 if v.VirtualGatewayName == nil { 3885 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3886 } 3887 if v.MeshName == nil { 3888 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3889 } 3890 if v.Spec == nil { 3891 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3892 } else if v.Spec != nil { 3893 if err := validateVirtualGatewaySpec(v.Spec); err != nil { 3894 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3895 } 3896 } 3897 if invalidParams.Len() > 0 { 3898 return invalidParams 3899 } else { 3900 return nil 3901 } 3902} 3903 3904func validateOpUpdateVirtualNodeInput(v *UpdateVirtualNodeInput) error { 3905 if v == nil { 3906 return nil 3907 } 3908 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualNodeInput"} 3909 if v.VirtualNodeName == nil { 3910 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 3911 } 3912 if v.MeshName == nil { 3913 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3914 } 3915 if v.Spec == nil { 3916 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3917 } else if v.Spec != nil { 3918 if err := validateVirtualNodeSpec(v.Spec); err != nil { 3919 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3920 } 3921 } 3922 if invalidParams.Len() > 0 { 3923 return invalidParams 3924 } else { 3925 return nil 3926 } 3927} 3928 3929func validateOpUpdateVirtualRouterInput(v *UpdateVirtualRouterInput) error { 3930 if v == nil { 3931 return nil 3932 } 3933 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualRouterInput"} 3934 if v.VirtualRouterName == nil { 3935 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3936 } 3937 if v.MeshName == nil { 3938 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3939 } 3940 if v.Spec == nil { 3941 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3942 } else if v.Spec != nil { 3943 if err := validateVirtualRouterSpec(v.Spec); err != nil { 3944 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3945 } 3946 } 3947 if invalidParams.Len() > 0 { 3948 return invalidParams 3949 } else { 3950 return nil 3951 } 3952} 3953 3954func validateOpUpdateVirtualServiceInput(v *UpdateVirtualServiceInput) error { 3955 if v == nil { 3956 return nil 3957 } 3958 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualServiceInput"} 3959 if v.VirtualServiceName == nil { 3960 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3961 } 3962 if v.MeshName == nil { 3963 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3964 } 3965 if v.Spec == nil { 3966 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3967 } else if v.Spec != nil { 3968 if err := validateVirtualServiceSpec(v.Spec); err != nil { 3969 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3970 } 3971 } 3972 if invalidParams.Len() > 0 { 3973 return invalidParams 3974 } else { 3975 return nil 3976 } 3977} 3978