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.Validation == nil { 1054 invalidParams.Add(smithy.NewErrParamRequired("Validation")) 1055 } else if v.Validation != nil { 1056 if err := validateTlsValidationContext(v.Validation); err != nil { 1057 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 1058 } 1059 } 1060 if invalidParams.Len() > 0 { 1061 return invalidParams 1062 } else { 1063 return nil 1064 } 1065} 1066 1067func validateDnsServiceDiscovery(v *types.DnsServiceDiscovery) error { 1068 if v == nil { 1069 return nil 1070 } 1071 invalidParams := smithy.InvalidParamsError{Context: "DnsServiceDiscovery"} 1072 if v.Hostname == nil { 1073 invalidParams.Add(smithy.NewErrParamRequired("Hostname")) 1074 } 1075 if invalidParams.Len() > 0 { 1076 return invalidParams 1077 } else { 1078 return nil 1079 } 1080} 1081 1082func validateEgressFilter(v *types.EgressFilter) error { 1083 if v == nil { 1084 return nil 1085 } 1086 invalidParams := smithy.InvalidParamsError{Context: "EgressFilter"} 1087 if len(v.Type) == 0 { 1088 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1089 } 1090 if invalidParams.Len() > 0 { 1091 return invalidParams 1092 } else { 1093 return nil 1094 } 1095} 1096 1097func validateFileAccessLog(v *types.FileAccessLog) error { 1098 if v == nil { 1099 return nil 1100 } 1101 invalidParams := smithy.InvalidParamsError{Context: "FileAccessLog"} 1102 if v.Path == nil { 1103 invalidParams.Add(smithy.NewErrParamRequired("Path")) 1104 } 1105 if invalidParams.Len() > 0 { 1106 return invalidParams 1107 } else { 1108 return nil 1109 } 1110} 1111 1112func validateGatewayRouteSpec(v *types.GatewayRouteSpec) error { 1113 if v == nil { 1114 return nil 1115 } 1116 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteSpec"} 1117 if v.HttpRoute != nil { 1118 if err := validateHttpGatewayRoute(v.HttpRoute); err != nil { 1119 invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError)) 1120 } 1121 } 1122 if v.Http2Route != nil { 1123 if err := validateHttpGatewayRoute(v.Http2Route); err != nil { 1124 invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError)) 1125 } 1126 } 1127 if v.GrpcRoute != nil { 1128 if err := validateGrpcGatewayRoute(v.GrpcRoute); err != nil { 1129 invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError)) 1130 } 1131 } 1132 if invalidParams.Len() > 0 { 1133 return invalidParams 1134 } else { 1135 return nil 1136 } 1137} 1138 1139func validateGatewayRouteTarget(v *types.GatewayRouteTarget) error { 1140 if v == nil { 1141 return nil 1142 } 1143 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteTarget"} 1144 if v.VirtualService == nil { 1145 invalidParams.Add(smithy.NewErrParamRequired("VirtualService")) 1146 } else if v.VirtualService != nil { 1147 if err := validateGatewayRouteVirtualService(v.VirtualService); err != nil { 1148 invalidParams.AddNested("VirtualService", err.(smithy.InvalidParamsError)) 1149 } 1150 } 1151 if invalidParams.Len() > 0 { 1152 return invalidParams 1153 } else { 1154 return nil 1155 } 1156} 1157 1158func validateGatewayRouteVirtualService(v *types.GatewayRouteVirtualService) error { 1159 if v == nil { 1160 return nil 1161 } 1162 invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteVirtualService"} 1163 if v.VirtualServiceName == nil { 1164 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 1165 } 1166 if invalidParams.Len() > 0 { 1167 return invalidParams 1168 } else { 1169 return nil 1170 } 1171} 1172 1173func validateGrpcGatewayRoute(v *types.GrpcGatewayRoute) error { 1174 if v == nil { 1175 return nil 1176 } 1177 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRoute"} 1178 if v.Match == nil { 1179 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1180 } 1181 if v.Action == nil { 1182 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1183 } else if v.Action != nil { 1184 if err := validateGrpcGatewayRouteAction(v.Action); err != nil { 1185 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1186 } 1187 } 1188 if invalidParams.Len() > 0 { 1189 return invalidParams 1190 } else { 1191 return nil 1192 } 1193} 1194 1195func validateGrpcGatewayRouteAction(v *types.GrpcGatewayRouteAction) error { 1196 if v == nil { 1197 return nil 1198 } 1199 invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteAction"} 1200 if v.Target == nil { 1201 invalidParams.Add(smithy.NewErrParamRequired("Target")) 1202 } else if v.Target != nil { 1203 if err := validateGatewayRouteTarget(v.Target); err != nil { 1204 invalidParams.AddNested("Target", err.(smithy.InvalidParamsError)) 1205 } 1206 } 1207 if invalidParams.Len() > 0 { 1208 return invalidParams 1209 } else { 1210 return nil 1211 } 1212} 1213 1214func validateGrpcRetryPolicy(v *types.GrpcRetryPolicy) error { 1215 if v == nil { 1216 return nil 1217 } 1218 invalidParams := smithy.InvalidParamsError{Context: "GrpcRetryPolicy"} 1219 if v.PerRetryTimeout == nil { 1220 invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout")) 1221 } 1222 if v.MaxRetries == nil { 1223 invalidParams.Add(smithy.NewErrParamRequired("MaxRetries")) 1224 } 1225 if invalidParams.Len() > 0 { 1226 return invalidParams 1227 } else { 1228 return nil 1229 } 1230} 1231 1232func validateGrpcRoute(v *types.GrpcRoute) error { 1233 if v == nil { 1234 return nil 1235 } 1236 invalidParams := smithy.InvalidParamsError{Context: "GrpcRoute"} 1237 if v.Action == nil { 1238 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1239 } else if v.Action != nil { 1240 if err := validateGrpcRouteAction(v.Action); err != nil { 1241 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1242 } 1243 } 1244 if v.Match == nil { 1245 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1246 } else if v.Match != nil { 1247 if err := validateGrpcRouteMatch(v.Match); err != nil { 1248 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1249 } 1250 } 1251 if v.RetryPolicy != nil { 1252 if err := validateGrpcRetryPolicy(v.RetryPolicy); err != nil { 1253 invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError)) 1254 } 1255 } 1256 if invalidParams.Len() > 0 { 1257 return invalidParams 1258 } else { 1259 return nil 1260 } 1261} 1262 1263func validateGrpcRouteAction(v *types.GrpcRouteAction) error { 1264 if v == nil { 1265 return nil 1266 } 1267 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteAction"} 1268 if v.WeightedTargets == nil { 1269 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 1270 } else if v.WeightedTargets != nil { 1271 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 1272 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 1273 } 1274 } 1275 if invalidParams.Len() > 0 { 1276 return invalidParams 1277 } else { 1278 return nil 1279 } 1280} 1281 1282func validateGrpcRouteMatch(v *types.GrpcRouteMatch) error { 1283 if v == nil { 1284 return nil 1285 } 1286 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMatch"} 1287 if v.Metadata != nil { 1288 if err := validateGrpcRouteMetadataList(v.Metadata); err != nil { 1289 invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError)) 1290 } 1291 } 1292 if invalidParams.Len() > 0 { 1293 return invalidParams 1294 } else { 1295 return nil 1296 } 1297} 1298 1299func validateGrpcRouteMetadata(v *types.GrpcRouteMetadata) error { 1300 if v == nil { 1301 return nil 1302 } 1303 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadata"} 1304 if v.Name == nil { 1305 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1306 } 1307 if v.Match != nil { 1308 if err := validateGrpcRouteMetadataMatchMethod(v.Match); err != nil { 1309 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1310 } 1311 } 1312 if invalidParams.Len() > 0 { 1313 return invalidParams 1314 } else { 1315 return nil 1316 } 1317} 1318 1319func validateGrpcRouteMetadataList(v []types.GrpcRouteMetadata) error { 1320 if v == nil { 1321 return nil 1322 } 1323 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataList"} 1324 for i := range v { 1325 if err := validateGrpcRouteMetadata(&v[i]); err != nil { 1326 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1327 } 1328 } 1329 if invalidParams.Len() > 0 { 1330 return invalidParams 1331 } else { 1332 return nil 1333 } 1334} 1335 1336func validateGrpcRouteMetadataMatchMethod(v types.GrpcRouteMetadataMatchMethod) error { 1337 if v == nil { 1338 return nil 1339 } 1340 invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataMatchMethod"} 1341 switch uv := v.(type) { 1342 case *types.GrpcRouteMetadataMatchMethodMemberRange: 1343 if err := validateMatchRange(&uv.Value); err != nil { 1344 invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError)) 1345 } 1346 1347 } 1348 if invalidParams.Len() > 0 { 1349 return invalidParams 1350 } else { 1351 return nil 1352 } 1353} 1354 1355func validateHeaderMatchMethod(v types.HeaderMatchMethod) error { 1356 if v == nil { 1357 return nil 1358 } 1359 invalidParams := smithy.InvalidParamsError{Context: "HeaderMatchMethod"} 1360 switch uv := v.(type) { 1361 case *types.HeaderMatchMethodMemberRange: 1362 if err := validateMatchRange(&uv.Value); err != nil { 1363 invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError)) 1364 } 1365 1366 } 1367 if invalidParams.Len() > 0 { 1368 return invalidParams 1369 } else { 1370 return nil 1371 } 1372} 1373 1374func validateHealthCheckPolicy(v *types.HealthCheckPolicy) error { 1375 if v == nil { 1376 return nil 1377 } 1378 invalidParams := smithy.InvalidParamsError{Context: "HealthCheckPolicy"} 1379 if v.TimeoutMillis == nil { 1380 invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis")) 1381 } 1382 if v.IntervalMillis == nil { 1383 invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis")) 1384 } 1385 if len(v.Protocol) == 0 { 1386 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 1387 } 1388 if invalidParams.Len() > 0 { 1389 return invalidParams 1390 } else { 1391 return nil 1392 } 1393} 1394 1395func validateHttpGatewayRoute(v *types.HttpGatewayRoute) error { 1396 if v == nil { 1397 return nil 1398 } 1399 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRoute"} 1400 if v.Match == nil { 1401 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1402 } else if v.Match != nil { 1403 if err := validateHttpGatewayRouteMatch(v.Match); err != nil { 1404 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1405 } 1406 } 1407 if v.Action == nil { 1408 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1409 } else if v.Action != nil { 1410 if err := validateHttpGatewayRouteAction(v.Action); err != nil { 1411 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1412 } 1413 } 1414 if invalidParams.Len() > 0 { 1415 return invalidParams 1416 } else { 1417 return nil 1418 } 1419} 1420 1421func validateHttpGatewayRouteAction(v *types.HttpGatewayRouteAction) error { 1422 if v == nil { 1423 return nil 1424 } 1425 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteAction"} 1426 if v.Target == nil { 1427 invalidParams.Add(smithy.NewErrParamRequired("Target")) 1428 } else if v.Target != nil { 1429 if err := validateGatewayRouteTarget(v.Target); err != nil { 1430 invalidParams.AddNested("Target", err.(smithy.InvalidParamsError)) 1431 } 1432 } 1433 if invalidParams.Len() > 0 { 1434 return invalidParams 1435 } else { 1436 return nil 1437 } 1438} 1439 1440func validateHttpGatewayRouteMatch(v *types.HttpGatewayRouteMatch) error { 1441 if v == nil { 1442 return nil 1443 } 1444 invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteMatch"} 1445 if v.Prefix == nil { 1446 invalidParams.Add(smithy.NewErrParamRequired("Prefix")) 1447 } 1448 if invalidParams.Len() > 0 { 1449 return invalidParams 1450 } else { 1451 return nil 1452 } 1453} 1454 1455func validateHttpRetryPolicy(v *types.HttpRetryPolicy) error { 1456 if v == nil { 1457 return nil 1458 } 1459 invalidParams := smithy.InvalidParamsError{Context: "HttpRetryPolicy"} 1460 if v.PerRetryTimeout == nil { 1461 invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout")) 1462 } 1463 if v.MaxRetries == nil { 1464 invalidParams.Add(smithy.NewErrParamRequired("MaxRetries")) 1465 } 1466 if invalidParams.Len() > 0 { 1467 return invalidParams 1468 } else { 1469 return nil 1470 } 1471} 1472 1473func validateHttpRoute(v *types.HttpRoute) error { 1474 if v == nil { 1475 return nil 1476 } 1477 invalidParams := smithy.InvalidParamsError{Context: "HttpRoute"} 1478 if v.Match == nil { 1479 invalidParams.Add(smithy.NewErrParamRequired("Match")) 1480 } else if v.Match != nil { 1481 if err := validateHttpRouteMatch(v.Match); err != nil { 1482 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1483 } 1484 } 1485 if v.Action == nil { 1486 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1487 } else if v.Action != nil { 1488 if err := validateHttpRouteAction(v.Action); err != nil { 1489 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1490 } 1491 } 1492 if v.RetryPolicy != nil { 1493 if err := validateHttpRetryPolicy(v.RetryPolicy); err != nil { 1494 invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError)) 1495 } 1496 } 1497 if invalidParams.Len() > 0 { 1498 return invalidParams 1499 } else { 1500 return nil 1501 } 1502} 1503 1504func validateHttpRouteAction(v *types.HttpRouteAction) error { 1505 if v == nil { 1506 return nil 1507 } 1508 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteAction"} 1509 if v.WeightedTargets == nil { 1510 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 1511 } else if v.WeightedTargets != nil { 1512 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 1513 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 1514 } 1515 } 1516 if invalidParams.Len() > 0 { 1517 return invalidParams 1518 } else { 1519 return nil 1520 } 1521} 1522 1523func validateHttpRouteHeader(v *types.HttpRouteHeader) error { 1524 if v == nil { 1525 return nil 1526 } 1527 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeader"} 1528 if v.Name == nil { 1529 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1530 } 1531 if v.Match != nil { 1532 if err := validateHeaderMatchMethod(v.Match); err != nil { 1533 invalidParams.AddNested("Match", err.(smithy.InvalidParamsError)) 1534 } 1535 } 1536 if invalidParams.Len() > 0 { 1537 return invalidParams 1538 } else { 1539 return nil 1540 } 1541} 1542 1543func validateHttpRouteHeaders(v []types.HttpRouteHeader) error { 1544 if v == nil { 1545 return nil 1546 } 1547 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeaders"} 1548 for i := range v { 1549 if err := validateHttpRouteHeader(&v[i]); err != nil { 1550 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1551 } 1552 } 1553 if invalidParams.Len() > 0 { 1554 return invalidParams 1555 } else { 1556 return nil 1557 } 1558} 1559 1560func validateHttpRouteMatch(v *types.HttpRouteMatch) error { 1561 if v == nil { 1562 return nil 1563 } 1564 invalidParams := smithy.InvalidParamsError{Context: "HttpRouteMatch"} 1565 if v.Prefix == nil { 1566 invalidParams.Add(smithy.NewErrParamRequired("Prefix")) 1567 } 1568 if v.Headers != nil { 1569 if err := validateHttpRouteHeaders(v.Headers); err != nil { 1570 invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError)) 1571 } 1572 } 1573 if invalidParams.Len() > 0 { 1574 return invalidParams 1575 } else { 1576 return nil 1577 } 1578} 1579 1580func validateListener(v *types.Listener) error { 1581 if v == nil { 1582 return nil 1583 } 1584 invalidParams := smithy.InvalidParamsError{Context: "Listener"} 1585 if v.PortMapping == nil { 1586 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 1587 } else if v.PortMapping != nil { 1588 if err := validatePortMapping(v.PortMapping); err != nil { 1589 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 1590 } 1591 } 1592 if v.Tls != nil { 1593 if err := validateListenerTls(v.Tls); err != nil { 1594 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 1595 } 1596 } 1597 if v.HealthCheck != nil { 1598 if err := validateHealthCheckPolicy(v.HealthCheck); err != nil { 1599 invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError)) 1600 } 1601 } 1602 if invalidParams.Len() > 0 { 1603 return invalidParams 1604 } else { 1605 return nil 1606 } 1607} 1608 1609func validateListeners(v []types.Listener) error { 1610 if v == nil { 1611 return nil 1612 } 1613 invalidParams := smithy.InvalidParamsError{Context: "Listeners"} 1614 for i := range v { 1615 if err := validateListener(&v[i]); err != nil { 1616 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1617 } 1618 } 1619 if invalidParams.Len() > 0 { 1620 return invalidParams 1621 } else { 1622 return nil 1623 } 1624} 1625 1626func validateListenerTls(v *types.ListenerTls) error { 1627 if v == nil { 1628 return nil 1629 } 1630 invalidParams := smithy.InvalidParamsError{Context: "ListenerTls"} 1631 if len(v.Mode) == 0 { 1632 invalidParams.Add(smithy.NewErrParamRequired("Mode")) 1633 } 1634 if v.Certificate == nil { 1635 invalidParams.Add(smithy.NewErrParamRequired("Certificate")) 1636 } else if v.Certificate != nil { 1637 if err := validateListenerTlsCertificate(v.Certificate); err != nil { 1638 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 1639 } 1640 } 1641 if invalidParams.Len() > 0 { 1642 return invalidParams 1643 } else { 1644 return nil 1645 } 1646} 1647 1648func validateListenerTlsAcmCertificate(v *types.ListenerTlsAcmCertificate) error { 1649 if v == nil { 1650 return nil 1651 } 1652 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsAcmCertificate"} 1653 if v.CertificateArn == nil { 1654 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 1655 } 1656 if invalidParams.Len() > 0 { 1657 return invalidParams 1658 } else { 1659 return nil 1660 } 1661} 1662 1663func validateListenerTlsCertificate(v types.ListenerTlsCertificate) error { 1664 if v == nil { 1665 return nil 1666 } 1667 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsCertificate"} 1668 switch uv := v.(type) { 1669 case *types.ListenerTlsCertificateMemberAcm: 1670 if err := validateListenerTlsAcmCertificate(&uv.Value); err != nil { 1671 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 1672 } 1673 1674 case *types.ListenerTlsCertificateMemberFile: 1675 if err := validateListenerTlsFileCertificate(&uv.Value); err != nil { 1676 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1677 } 1678 1679 } 1680 if invalidParams.Len() > 0 { 1681 return invalidParams 1682 } else { 1683 return nil 1684 } 1685} 1686 1687func validateListenerTlsFileCertificate(v *types.ListenerTlsFileCertificate) error { 1688 if v == nil { 1689 return nil 1690 } 1691 invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsFileCertificate"} 1692 if v.CertificateChain == nil { 1693 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 1694 } 1695 if v.PrivateKey == nil { 1696 invalidParams.Add(smithy.NewErrParamRequired("PrivateKey")) 1697 } 1698 if invalidParams.Len() > 0 { 1699 return invalidParams 1700 } else { 1701 return nil 1702 } 1703} 1704 1705func validateLogging(v *types.Logging) error { 1706 if v == nil { 1707 return nil 1708 } 1709 invalidParams := smithy.InvalidParamsError{Context: "Logging"} 1710 if v.AccessLog != nil { 1711 if err := validateAccessLog(v.AccessLog); err != nil { 1712 invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError)) 1713 } 1714 } 1715 if invalidParams.Len() > 0 { 1716 return invalidParams 1717 } else { 1718 return nil 1719 } 1720} 1721 1722func validateMatchRange(v *types.MatchRange) error { 1723 if v == nil { 1724 return nil 1725 } 1726 invalidParams := smithy.InvalidParamsError{Context: "MatchRange"} 1727 if v.Start == nil { 1728 invalidParams.Add(smithy.NewErrParamRequired("Start")) 1729 } 1730 if v.End == nil { 1731 invalidParams.Add(smithy.NewErrParamRequired("End")) 1732 } 1733 if invalidParams.Len() > 0 { 1734 return invalidParams 1735 } else { 1736 return nil 1737 } 1738} 1739 1740func validateMeshSpec(v *types.MeshSpec) error { 1741 if v == nil { 1742 return nil 1743 } 1744 invalidParams := smithy.InvalidParamsError{Context: "MeshSpec"} 1745 if v.EgressFilter != nil { 1746 if err := validateEgressFilter(v.EgressFilter); err != nil { 1747 invalidParams.AddNested("EgressFilter", err.(smithy.InvalidParamsError)) 1748 } 1749 } 1750 if invalidParams.Len() > 0 { 1751 return invalidParams 1752 } else { 1753 return nil 1754 } 1755} 1756 1757func validatePortMapping(v *types.PortMapping) error { 1758 if v == nil { 1759 return nil 1760 } 1761 invalidParams := smithy.InvalidParamsError{Context: "PortMapping"} 1762 if len(v.Protocol) == 0 { 1763 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 1764 } 1765 if invalidParams.Len() > 0 { 1766 return invalidParams 1767 } else { 1768 return nil 1769 } 1770} 1771 1772func validateRouteSpec(v *types.RouteSpec) error { 1773 if v == nil { 1774 return nil 1775 } 1776 invalidParams := smithy.InvalidParamsError{Context: "RouteSpec"} 1777 if v.HttpRoute != nil { 1778 if err := validateHttpRoute(v.HttpRoute); err != nil { 1779 invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError)) 1780 } 1781 } 1782 if v.TcpRoute != nil { 1783 if err := validateTcpRoute(v.TcpRoute); err != nil { 1784 invalidParams.AddNested("TcpRoute", err.(smithy.InvalidParamsError)) 1785 } 1786 } 1787 if v.Http2Route != nil { 1788 if err := validateHttpRoute(v.Http2Route); err != nil { 1789 invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError)) 1790 } 1791 } 1792 if v.GrpcRoute != nil { 1793 if err := validateGrpcRoute(v.GrpcRoute); err != nil { 1794 invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError)) 1795 } 1796 } 1797 if invalidParams.Len() > 0 { 1798 return invalidParams 1799 } else { 1800 return nil 1801 } 1802} 1803 1804func validateServiceDiscovery(v types.ServiceDiscovery) error { 1805 if v == nil { 1806 return nil 1807 } 1808 invalidParams := smithy.InvalidParamsError{Context: "ServiceDiscovery"} 1809 switch uv := v.(type) { 1810 case *types.ServiceDiscoveryMemberAwsCloudMap: 1811 if err := validateAwsCloudMapServiceDiscovery(&uv.Value); err != nil { 1812 invalidParams.AddNested("[awsCloudMap]", err.(smithy.InvalidParamsError)) 1813 } 1814 1815 case *types.ServiceDiscoveryMemberDns: 1816 if err := validateDnsServiceDiscovery(&uv.Value); err != nil { 1817 invalidParams.AddNested("[dns]", err.(smithy.InvalidParamsError)) 1818 } 1819 1820 } 1821 if invalidParams.Len() > 0 { 1822 return invalidParams 1823 } else { 1824 return nil 1825 } 1826} 1827 1828func validateTagList(v []types.TagRef) error { 1829 if v == nil { 1830 return nil 1831 } 1832 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1833 for i := range v { 1834 if err := validateTagRef(&v[i]); err != nil { 1835 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1836 } 1837 } 1838 if invalidParams.Len() > 0 { 1839 return invalidParams 1840 } else { 1841 return nil 1842 } 1843} 1844 1845func validateTagRef(v *types.TagRef) error { 1846 if v == nil { 1847 return nil 1848 } 1849 invalidParams := smithy.InvalidParamsError{Context: "TagRef"} 1850 if v.Key == nil { 1851 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1852 } 1853 if invalidParams.Len() > 0 { 1854 return invalidParams 1855 } else { 1856 return nil 1857 } 1858} 1859 1860func validateTcpRoute(v *types.TcpRoute) error { 1861 if v == nil { 1862 return nil 1863 } 1864 invalidParams := smithy.InvalidParamsError{Context: "TcpRoute"} 1865 if v.Action == nil { 1866 invalidParams.Add(smithy.NewErrParamRequired("Action")) 1867 } else if v.Action != nil { 1868 if err := validateTcpRouteAction(v.Action); err != nil { 1869 invalidParams.AddNested("Action", err.(smithy.InvalidParamsError)) 1870 } 1871 } 1872 if invalidParams.Len() > 0 { 1873 return invalidParams 1874 } else { 1875 return nil 1876 } 1877} 1878 1879func validateTcpRouteAction(v *types.TcpRouteAction) error { 1880 if v == nil { 1881 return nil 1882 } 1883 invalidParams := smithy.InvalidParamsError{Context: "TcpRouteAction"} 1884 if v.WeightedTargets == nil { 1885 invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets")) 1886 } else if v.WeightedTargets != nil { 1887 if err := validateWeightedTargets(v.WeightedTargets); err != nil { 1888 invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError)) 1889 } 1890 } 1891 if invalidParams.Len() > 0 { 1892 return invalidParams 1893 } else { 1894 return nil 1895 } 1896} 1897 1898func validateTlsValidationContext(v *types.TlsValidationContext) error { 1899 if v == nil { 1900 return nil 1901 } 1902 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContext"} 1903 if v.Trust == nil { 1904 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 1905 } else if v.Trust != nil { 1906 if err := validateTlsValidationContextTrust(v.Trust); err != nil { 1907 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 1908 } 1909 } 1910 if invalidParams.Len() > 0 { 1911 return invalidParams 1912 } else { 1913 return nil 1914 } 1915} 1916 1917func validateTlsValidationContextAcmTrust(v *types.TlsValidationContextAcmTrust) error { 1918 if v == nil { 1919 return nil 1920 } 1921 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextAcmTrust"} 1922 if v.CertificateAuthorityArns == nil { 1923 invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns")) 1924 } 1925 if invalidParams.Len() > 0 { 1926 return invalidParams 1927 } else { 1928 return nil 1929 } 1930} 1931 1932func validateTlsValidationContextFileTrust(v *types.TlsValidationContextFileTrust) error { 1933 if v == nil { 1934 return nil 1935 } 1936 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextFileTrust"} 1937 if v.CertificateChain == nil { 1938 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 1939 } 1940 if invalidParams.Len() > 0 { 1941 return invalidParams 1942 } else { 1943 return nil 1944 } 1945} 1946 1947func validateTlsValidationContextTrust(v types.TlsValidationContextTrust) error { 1948 if v == nil { 1949 return nil 1950 } 1951 invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextTrust"} 1952 switch uv := v.(type) { 1953 case *types.TlsValidationContextTrustMemberAcm: 1954 if err := validateTlsValidationContextAcmTrust(&uv.Value); err != nil { 1955 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 1956 } 1957 1958 case *types.TlsValidationContextTrustMemberFile: 1959 if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil { 1960 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1961 } 1962 1963 } 1964 if invalidParams.Len() > 0 { 1965 return invalidParams 1966 } else { 1967 return nil 1968 } 1969} 1970 1971func validateVirtualGatewayAccessLog(v types.VirtualGatewayAccessLog) error { 1972 if v == nil { 1973 return nil 1974 } 1975 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayAccessLog"} 1976 switch uv := v.(type) { 1977 case *types.VirtualGatewayAccessLogMemberFile: 1978 if err := validateVirtualGatewayFileAccessLog(&uv.Value); err != nil { 1979 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 1980 } 1981 1982 } 1983 if invalidParams.Len() > 0 { 1984 return invalidParams 1985 } else { 1986 return nil 1987 } 1988} 1989 1990func validateVirtualGatewayBackendDefaults(v *types.VirtualGatewayBackendDefaults) error { 1991 if v == nil { 1992 return nil 1993 } 1994 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayBackendDefaults"} 1995 if v.ClientPolicy != nil { 1996 if err := validateVirtualGatewayClientPolicy(v.ClientPolicy); err != nil { 1997 invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError)) 1998 } 1999 } 2000 if invalidParams.Len() > 0 { 2001 return invalidParams 2002 } else { 2003 return nil 2004 } 2005} 2006 2007func validateVirtualGatewayClientPolicy(v *types.VirtualGatewayClientPolicy) error { 2008 if v == nil { 2009 return nil 2010 } 2011 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicy"} 2012 if v.Tls != nil { 2013 if err := validateVirtualGatewayClientPolicyTls(v.Tls); err != nil { 2014 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 2015 } 2016 } 2017 if invalidParams.Len() > 0 { 2018 return invalidParams 2019 } else { 2020 return nil 2021 } 2022} 2023 2024func validateVirtualGatewayClientPolicyTls(v *types.VirtualGatewayClientPolicyTls) error { 2025 if v == nil { 2026 return nil 2027 } 2028 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicyTls"} 2029 if v.Validation == nil { 2030 invalidParams.Add(smithy.NewErrParamRequired("Validation")) 2031 } else if v.Validation != nil { 2032 if err := validateVirtualGatewayTlsValidationContext(v.Validation); err != nil { 2033 invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError)) 2034 } 2035 } 2036 if invalidParams.Len() > 0 { 2037 return invalidParams 2038 } else { 2039 return nil 2040 } 2041} 2042 2043func validateVirtualGatewayFileAccessLog(v *types.VirtualGatewayFileAccessLog) error { 2044 if v == nil { 2045 return nil 2046 } 2047 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayFileAccessLog"} 2048 if v.Path == nil { 2049 invalidParams.Add(smithy.NewErrParamRequired("Path")) 2050 } 2051 if invalidParams.Len() > 0 { 2052 return invalidParams 2053 } else { 2054 return nil 2055 } 2056} 2057 2058func validateVirtualGatewayHealthCheckPolicy(v *types.VirtualGatewayHealthCheckPolicy) error { 2059 if v == nil { 2060 return nil 2061 } 2062 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHealthCheckPolicy"} 2063 if v.TimeoutMillis == nil { 2064 invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis")) 2065 } 2066 if v.IntervalMillis == nil { 2067 invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis")) 2068 } 2069 if len(v.Protocol) == 0 { 2070 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 2071 } 2072 if invalidParams.Len() > 0 { 2073 return invalidParams 2074 } else { 2075 return nil 2076 } 2077} 2078 2079func validateVirtualGatewayListener(v *types.VirtualGatewayListener) error { 2080 if v == nil { 2081 return nil 2082 } 2083 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListener"} 2084 if v.HealthCheck != nil { 2085 if err := validateVirtualGatewayHealthCheckPolicy(v.HealthCheck); err != nil { 2086 invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError)) 2087 } 2088 } 2089 if v.PortMapping == nil { 2090 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 2091 } else if v.PortMapping != nil { 2092 if err := validateVirtualGatewayPortMapping(v.PortMapping); err != nil { 2093 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 2094 } 2095 } 2096 if v.Tls != nil { 2097 if err := validateVirtualGatewayListenerTls(v.Tls); err != nil { 2098 invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError)) 2099 } 2100 } 2101 if invalidParams.Len() > 0 { 2102 return invalidParams 2103 } else { 2104 return nil 2105 } 2106} 2107 2108func validateVirtualGatewayListeners(v []types.VirtualGatewayListener) error { 2109 if v == nil { 2110 return nil 2111 } 2112 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListeners"} 2113 for i := range v { 2114 if err := validateVirtualGatewayListener(&v[i]); err != nil { 2115 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2116 } 2117 } 2118 if invalidParams.Len() > 0 { 2119 return invalidParams 2120 } else { 2121 return nil 2122 } 2123} 2124 2125func validateVirtualGatewayListenerTls(v *types.VirtualGatewayListenerTls) error { 2126 if v == nil { 2127 return nil 2128 } 2129 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTls"} 2130 if len(v.Mode) == 0 { 2131 invalidParams.Add(smithy.NewErrParamRequired("Mode")) 2132 } 2133 if v.Certificate == nil { 2134 invalidParams.Add(smithy.NewErrParamRequired("Certificate")) 2135 } else if v.Certificate != nil { 2136 if err := validateVirtualGatewayListenerTlsCertificate(v.Certificate); err != nil { 2137 invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError)) 2138 } 2139 } 2140 if invalidParams.Len() > 0 { 2141 return invalidParams 2142 } else { 2143 return nil 2144 } 2145} 2146 2147func validateVirtualGatewayListenerTlsAcmCertificate(v *types.VirtualGatewayListenerTlsAcmCertificate) error { 2148 if v == nil { 2149 return nil 2150 } 2151 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsAcmCertificate"} 2152 if v.CertificateArn == nil { 2153 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 2154 } 2155 if invalidParams.Len() > 0 { 2156 return invalidParams 2157 } else { 2158 return nil 2159 } 2160} 2161 2162func validateVirtualGatewayListenerTlsCertificate(v types.VirtualGatewayListenerTlsCertificate) error { 2163 if v == nil { 2164 return nil 2165 } 2166 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsCertificate"} 2167 switch uv := v.(type) { 2168 case *types.VirtualGatewayListenerTlsCertificateMemberAcm: 2169 if err := validateVirtualGatewayListenerTlsAcmCertificate(&uv.Value); err != nil { 2170 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 2171 } 2172 2173 case *types.VirtualGatewayListenerTlsCertificateMemberFile: 2174 if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil { 2175 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2176 } 2177 2178 } 2179 if invalidParams.Len() > 0 { 2180 return invalidParams 2181 } else { 2182 return nil 2183 } 2184} 2185 2186func validateVirtualGatewayListenerTlsFileCertificate(v *types.VirtualGatewayListenerTlsFileCertificate) error { 2187 if v == nil { 2188 return nil 2189 } 2190 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsFileCertificate"} 2191 if v.CertificateChain == nil { 2192 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 2193 } 2194 if v.PrivateKey == nil { 2195 invalidParams.Add(smithy.NewErrParamRequired("PrivateKey")) 2196 } 2197 if invalidParams.Len() > 0 { 2198 return invalidParams 2199 } else { 2200 return nil 2201 } 2202} 2203 2204func validateVirtualGatewayLogging(v *types.VirtualGatewayLogging) error { 2205 if v == nil { 2206 return nil 2207 } 2208 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayLogging"} 2209 if v.AccessLog != nil { 2210 if err := validateVirtualGatewayAccessLog(v.AccessLog); err != nil { 2211 invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError)) 2212 } 2213 } 2214 if invalidParams.Len() > 0 { 2215 return invalidParams 2216 } else { 2217 return nil 2218 } 2219} 2220 2221func validateVirtualGatewayPortMapping(v *types.VirtualGatewayPortMapping) error { 2222 if v == nil { 2223 return nil 2224 } 2225 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayPortMapping"} 2226 if len(v.Protocol) == 0 { 2227 invalidParams.Add(smithy.NewErrParamRequired("Protocol")) 2228 } 2229 if invalidParams.Len() > 0 { 2230 return invalidParams 2231 } else { 2232 return nil 2233 } 2234} 2235 2236func validateVirtualGatewaySpec(v *types.VirtualGatewaySpec) error { 2237 if v == nil { 2238 return nil 2239 } 2240 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewaySpec"} 2241 if v.BackendDefaults != nil { 2242 if err := validateVirtualGatewayBackendDefaults(v.BackendDefaults); err != nil { 2243 invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError)) 2244 } 2245 } 2246 if v.Listeners == nil { 2247 invalidParams.Add(smithy.NewErrParamRequired("Listeners")) 2248 } else if v.Listeners != nil { 2249 if err := validateVirtualGatewayListeners(v.Listeners); err != nil { 2250 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 2251 } 2252 } 2253 if v.Logging != nil { 2254 if err := validateVirtualGatewayLogging(v.Logging); err != nil { 2255 invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError)) 2256 } 2257 } 2258 if invalidParams.Len() > 0 { 2259 return invalidParams 2260 } else { 2261 return nil 2262 } 2263} 2264 2265func validateVirtualGatewayTlsValidationContext(v *types.VirtualGatewayTlsValidationContext) error { 2266 if v == nil { 2267 return nil 2268 } 2269 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContext"} 2270 if v.Trust == nil { 2271 invalidParams.Add(smithy.NewErrParamRequired("Trust")) 2272 } else if v.Trust != nil { 2273 if err := validateVirtualGatewayTlsValidationContextTrust(v.Trust); err != nil { 2274 invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError)) 2275 } 2276 } 2277 if invalidParams.Len() > 0 { 2278 return invalidParams 2279 } else { 2280 return nil 2281 } 2282} 2283 2284func validateVirtualGatewayTlsValidationContextAcmTrust(v *types.VirtualGatewayTlsValidationContextAcmTrust) error { 2285 if v == nil { 2286 return nil 2287 } 2288 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextAcmTrust"} 2289 if v.CertificateAuthorityArns == nil { 2290 invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns")) 2291 } 2292 if invalidParams.Len() > 0 { 2293 return invalidParams 2294 } else { 2295 return nil 2296 } 2297} 2298 2299func validateVirtualGatewayTlsValidationContextFileTrust(v *types.VirtualGatewayTlsValidationContextFileTrust) error { 2300 if v == nil { 2301 return nil 2302 } 2303 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextFileTrust"} 2304 if v.CertificateChain == nil { 2305 invalidParams.Add(smithy.NewErrParamRequired("CertificateChain")) 2306 } 2307 if invalidParams.Len() > 0 { 2308 return invalidParams 2309 } else { 2310 return nil 2311 } 2312} 2313 2314func validateVirtualGatewayTlsValidationContextTrust(v types.VirtualGatewayTlsValidationContextTrust) error { 2315 if v == nil { 2316 return nil 2317 } 2318 invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextTrust"} 2319 switch uv := v.(type) { 2320 case *types.VirtualGatewayTlsValidationContextTrustMemberAcm: 2321 if err := validateVirtualGatewayTlsValidationContextAcmTrust(&uv.Value); err != nil { 2322 invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError)) 2323 } 2324 2325 case *types.VirtualGatewayTlsValidationContextTrustMemberFile: 2326 if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil { 2327 invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError)) 2328 } 2329 2330 } 2331 if invalidParams.Len() > 0 { 2332 return invalidParams 2333 } else { 2334 return nil 2335 } 2336} 2337 2338func validateVirtualNodeServiceProvider(v *types.VirtualNodeServiceProvider) error { 2339 if v == nil { 2340 return nil 2341 } 2342 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeServiceProvider"} 2343 if v.VirtualNodeName == nil { 2344 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 2345 } 2346 if invalidParams.Len() > 0 { 2347 return invalidParams 2348 } else { 2349 return nil 2350 } 2351} 2352 2353func validateVirtualNodeSpec(v *types.VirtualNodeSpec) error { 2354 if v == nil { 2355 return nil 2356 } 2357 invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeSpec"} 2358 if v.ServiceDiscovery != nil { 2359 if err := validateServiceDiscovery(v.ServiceDiscovery); err != nil { 2360 invalidParams.AddNested("ServiceDiscovery", err.(smithy.InvalidParamsError)) 2361 } 2362 } 2363 if v.Listeners != nil { 2364 if err := validateListeners(v.Listeners); err != nil { 2365 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 2366 } 2367 } 2368 if v.Backends != nil { 2369 if err := validateBackends(v.Backends); err != nil { 2370 invalidParams.AddNested("Backends", err.(smithy.InvalidParamsError)) 2371 } 2372 } 2373 if v.BackendDefaults != nil { 2374 if err := validateBackendDefaults(v.BackendDefaults); err != nil { 2375 invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError)) 2376 } 2377 } 2378 if v.Logging != nil { 2379 if err := validateLogging(v.Logging); err != nil { 2380 invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError)) 2381 } 2382 } 2383 if invalidParams.Len() > 0 { 2384 return invalidParams 2385 } else { 2386 return nil 2387 } 2388} 2389 2390func validateVirtualRouterListener(v *types.VirtualRouterListener) error { 2391 if v == nil { 2392 return nil 2393 } 2394 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListener"} 2395 if v.PortMapping == nil { 2396 invalidParams.Add(smithy.NewErrParamRequired("PortMapping")) 2397 } else if v.PortMapping != nil { 2398 if err := validatePortMapping(v.PortMapping); err != nil { 2399 invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError)) 2400 } 2401 } 2402 if invalidParams.Len() > 0 { 2403 return invalidParams 2404 } else { 2405 return nil 2406 } 2407} 2408 2409func validateVirtualRouterListeners(v []types.VirtualRouterListener) error { 2410 if v == nil { 2411 return nil 2412 } 2413 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListeners"} 2414 for i := range v { 2415 if err := validateVirtualRouterListener(&v[i]); err != nil { 2416 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2417 } 2418 } 2419 if invalidParams.Len() > 0 { 2420 return invalidParams 2421 } else { 2422 return nil 2423 } 2424} 2425 2426func validateVirtualRouterServiceProvider(v *types.VirtualRouterServiceProvider) error { 2427 if v == nil { 2428 return nil 2429 } 2430 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterServiceProvider"} 2431 if v.VirtualRouterName == nil { 2432 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2433 } 2434 if invalidParams.Len() > 0 { 2435 return invalidParams 2436 } else { 2437 return nil 2438 } 2439} 2440 2441func validateVirtualRouterSpec(v *types.VirtualRouterSpec) error { 2442 if v == nil { 2443 return nil 2444 } 2445 invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterSpec"} 2446 if v.Listeners != nil { 2447 if err := validateVirtualRouterListeners(v.Listeners); err != nil { 2448 invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError)) 2449 } 2450 } 2451 if invalidParams.Len() > 0 { 2452 return invalidParams 2453 } else { 2454 return nil 2455 } 2456} 2457 2458func validateVirtualServiceBackend(v *types.VirtualServiceBackend) error { 2459 if v == nil { 2460 return nil 2461 } 2462 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceBackend"} 2463 if v.VirtualServiceName == nil { 2464 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 2465 } 2466 if v.ClientPolicy != nil { 2467 if err := validateClientPolicy(v.ClientPolicy); err != nil { 2468 invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError)) 2469 } 2470 } 2471 if invalidParams.Len() > 0 { 2472 return invalidParams 2473 } else { 2474 return nil 2475 } 2476} 2477 2478func validateVirtualServiceProvider(v types.VirtualServiceProvider) error { 2479 if v == nil { 2480 return nil 2481 } 2482 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceProvider"} 2483 switch uv := v.(type) { 2484 case *types.VirtualServiceProviderMemberVirtualNode: 2485 if err := validateVirtualNodeServiceProvider(&uv.Value); err != nil { 2486 invalidParams.AddNested("[virtualNode]", err.(smithy.InvalidParamsError)) 2487 } 2488 2489 case *types.VirtualServiceProviderMemberVirtualRouter: 2490 if err := validateVirtualRouterServiceProvider(&uv.Value); err != nil { 2491 invalidParams.AddNested("[virtualRouter]", err.(smithy.InvalidParamsError)) 2492 } 2493 2494 } 2495 if invalidParams.Len() > 0 { 2496 return invalidParams 2497 } else { 2498 return nil 2499 } 2500} 2501 2502func validateVirtualServiceSpec(v *types.VirtualServiceSpec) error { 2503 if v == nil { 2504 return nil 2505 } 2506 invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceSpec"} 2507 if v.Provider != nil { 2508 if err := validateVirtualServiceProvider(v.Provider); err != nil { 2509 invalidParams.AddNested("Provider", err.(smithy.InvalidParamsError)) 2510 } 2511 } 2512 if invalidParams.Len() > 0 { 2513 return invalidParams 2514 } else { 2515 return nil 2516 } 2517} 2518 2519func validateWeightedTarget(v *types.WeightedTarget) error { 2520 if v == nil { 2521 return nil 2522 } 2523 invalidParams := smithy.InvalidParamsError{Context: "WeightedTarget"} 2524 if v.VirtualNode == nil { 2525 invalidParams.Add(smithy.NewErrParamRequired("VirtualNode")) 2526 } 2527 if invalidParams.Len() > 0 { 2528 return invalidParams 2529 } else { 2530 return nil 2531 } 2532} 2533 2534func validateWeightedTargets(v []types.WeightedTarget) error { 2535 if v == nil { 2536 return nil 2537 } 2538 invalidParams := smithy.InvalidParamsError{Context: "WeightedTargets"} 2539 for i := range v { 2540 if err := validateWeightedTarget(&v[i]); err != nil { 2541 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2542 } 2543 } 2544 if invalidParams.Len() > 0 { 2545 return invalidParams 2546 } else { 2547 return nil 2548 } 2549} 2550 2551func validateOpCreateGatewayRouteInput(v *CreateGatewayRouteInput) error { 2552 if v == nil { 2553 return nil 2554 } 2555 invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayRouteInput"} 2556 if v.GatewayRouteName == nil { 2557 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 2558 } 2559 if v.MeshName == nil { 2560 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2561 } 2562 if v.VirtualGatewayName == nil { 2563 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2564 } 2565 if v.Spec == nil { 2566 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2567 } else if v.Spec != nil { 2568 if err := validateGatewayRouteSpec(v.Spec); err != nil { 2569 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2570 } 2571 } 2572 if v.Tags != nil { 2573 if err := validateTagList(v.Tags); err != nil { 2574 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2575 } 2576 } 2577 if invalidParams.Len() > 0 { 2578 return invalidParams 2579 } else { 2580 return nil 2581 } 2582} 2583 2584func validateOpCreateMeshInput(v *CreateMeshInput) error { 2585 if v == nil { 2586 return nil 2587 } 2588 invalidParams := smithy.InvalidParamsError{Context: "CreateMeshInput"} 2589 if v.MeshName == nil { 2590 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2591 } 2592 if v.Spec != nil { 2593 if err := validateMeshSpec(v.Spec); err != nil { 2594 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2595 } 2596 } 2597 if v.Tags != nil { 2598 if err := validateTagList(v.Tags); err != nil { 2599 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2600 } 2601 } 2602 if invalidParams.Len() > 0 { 2603 return invalidParams 2604 } else { 2605 return nil 2606 } 2607} 2608 2609func validateOpCreateRouteInput(v *CreateRouteInput) error { 2610 if v == nil { 2611 return nil 2612 } 2613 invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"} 2614 if v.RouteName == nil { 2615 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 2616 } 2617 if v.MeshName == nil { 2618 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2619 } 2620 if v.VirtualRouterName == nil { 2621 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2622 } 2623 if v.Spec == nil { 2624 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2625 } else if v.Spec != nil { 2626 if err := validateRouteSpec(v.Spec); err != nil { 2627 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2628 } 2629 } 2630 if v.Tags != nil { 2631 if err := validateTagList(v.Tags); err != nil { 2632 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2633 } 2634 } 2635 if invalidParams.Len() > 0 { 2636 return invalidParams 2637 } else { 2638 return nil 2639 } 2640} 2641 2642func validateOpCreateVirtualGatewayInput(v *CreateVirtualGatewayInput) error { 2643 if v == nil { 2644 return nil 2645 } 2646 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualGatewayInput"} 2647 if v.VirtualGatewayName == nil { 2648 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2649 } 2650 if v.MeshName == nil { 2651 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2652 } 2653 if v.Spec == nil { 2654 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2655 } else if v.Spec != nil { 2656 if err := validateVirtualGatewaySpec(v.Spec); err != nil { 2657 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2658 } 2659 } 2660 if v.Tags != nil { 2661 if err := validateTagList(v.Tags); err != nil { 2662 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2663 } 2664 } 2665 if invalidParams.Len() > 0 { 2666 return invalidParams 2667 } else { 2668 return nil 2669 } 2670} 2671 2672func validateOpCreateVirtualNodeInput(v *CreateVirtualNodeInput) error { 2673 if v == nil { 2674 return nil 2675 } 2676 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualNodeInput"} 2677 if v.VirtualNodeName == nil { 2678 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 2679 } 2680 if v.MeshName == nil { 2681 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2682 } 2683 if v.Spec == nil { 2684 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2685 } else if v.Spec != nil { 2686 if err := validateVirtualNodeSpec(v.Spec); err != nil { 2687 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2688 } 2689 } 2690 if v.Tags != nil { 2691 if err := validateTagList(v.Tags); err != nil { 2692 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2693 } 2694 } 2695 if invalidParams.Len() > 0 { 2696 return invalidParams 2697 } else { 2698 return nil 2699 } 2700} 2701 2702func validateOpCreateVirtualRouterInput(v *CreateVirtualRouterInput) error { 2703 if v == nil { 2704 return nil 2705 } 2706 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualRouterInput"} 2707 if v.VirtualRouterName == nil { 2708 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2709 } 2710 if v.MeshName == nil { 2711 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2712 } 2713 if v.Spec == nil { 2714 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2715 } else if v.Spec != nil { 2716 if err := validateVirtualRouterSpec(v.Spec); err != nil { 2717 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2718 } 2719 } 2720 if v.Tags != nil { 2721 if err := validateTagList(v.Tags); err != nil { 2722 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2723 } 2724 } 2725 if invalidParams.Len() > 0 { 2726 return invalidParams 2727 } else { 2728 return nil 2729 } 2730} 2731 2732func validateOpCreateVirtualServiceInput(v *CreateVirtualServiceInput) error { 2733 if v == nil { 2734 return nil 2735 } 2736 invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualServiceInput"} 2737 if v.VirtualServiceName == nil { 2738 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 2739 } 2740 if v.MeshName == nil { 2741 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2742 } 2743 if v.Spec == nil { 2744 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 2745 } else if v.Spec != nil { 2746 if err := validateVirtualServiceSpec(v.Spec); err != nil { 2747 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 2748 } 2749 } 2750 if v.Tags != nil { 2751 if err := validateTagList(v.Tags); err != nil { 2752 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2753 } 2754 } 2755 if invalidParams.Len() > 0 { 2756 return invalidParams 2757 } else { 2758 return nil 2759 } 2760} 2761 2762func validateOpDeleteGatewayRouteInput(v *DeleteGatewayRouteInput) error { 2763 if v == nil { 2764 return nil 2765 } 2766 invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayRouteInput"} 2767 if v.GatewayRouteName == nil { 2768 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 2769 } 2770 if v.MeshName == nil { 2771 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2772 } 2773 if v.VirtualGatewayName == nil { 2774 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2775 } 2776 if invalidParams.Len() > 0 { 2777 return invalidParams 2778 } else { 2779 return nil 2780 } 2781} 2782 2783func validateOpDeleteMeshInput(v *DeleteMeshInput) error { 2784 if v == nil { 2785 return nil 2786 } 2787 invalidParams := smithy.InvalidParamsError{Context: "DeleteMeshInput"} 2788 if v.MeshName == nil { 2789 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2790 } 2791 if invalidParams.Len() > 0 { 2792 return invalidParams 2793 } else { 2794 return nil 2795 } 2796} 2797 2798func validateOpDeleteRouteInput(v *DeleteRouteInput) error { 2799 if v == nil { 2800 return nil 2801 } 2802 invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"} 2803 if v.RouteName == nil { 2804 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 2805 } 2806 if v.MeshName == nil { 2807 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2808 } 2809 if v.VirtualRouterName == nil { 2810 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2811 } 2812 if invalidParams.Len() > 0 { 2813 return invalidParams 2814 } else { 2815 return nil 2816 } 2817} 2818 2819func validateOpDeleteVirtualGatewayInput(v *DeleteVirtualGatewayInput) error { 2820 if v == nil { 2821 return nil 2822 } 2823 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualGatewayInput"} 2824 if v.VirtualGatewayName == nil { 2825 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2826 } 2827 if v.MeshName == nil { 2828 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2829 } 2830 if invalidParams.Len() > 0 { 2831 return invalidParams 2832 } else { 2833 return nil 2834 } 2835} 2836 2837func validateOpDeleteVirtualNodeInput(v *DeleteVirtualNodeInput) error { 2838 if v == nil { 2839 return nil 2840 } 2841 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualNodeInput"} 2842 if v.VirtualNodeName == nil { 2843 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 2844 } 2845 if v.MeshName == nil { 2846 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2847 } 2848 if invalidParams.Len() > 0 { 2849 return invalidParams 2850 } else { 2851 return nil 2852 } 2853} 2854 2855func validateOpDeleteVirtualRouterInput(v *DeleteVirtualRouterInput) error { 2856 if v == nil { 2857 return nil 2858 } 2859 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualRouterInput"} 2860 if v.VirtualRouterName == nil { 2861 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2862 } 2863 if v.MeshName == nil { 2864 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2865 } 2866 if invalidParams.Len() > 0 { 2867 return invalidParams 2868 } else { 2869 return nil 2870 } 2871} 2872 2873func validateOpDeleteVirtualServiceInput(v *DeleteVirtualServiceInput) error { 2874 if v == nil { 2875 return nil 2876 } 2877 invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualServiceInput"} 2878 if v.VirtualServiceName == nil { 2879 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 2880 } 2881 if v.MeshName == nil { 2882 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2883 } 2884 if invalidParams.Len() > 0 { 2885 return invalidParams 2886 } else { 2887 return nil 2888 } 2889} 2890 2891func validateOpDescribeGatewayRouteInput(v *DescribeGatewayRouteInput) error { 2892 if v == nil { 2893 return nil 2894 } 2895 invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayRouteInput"} 2896 if v.GatewayRouteName == nil { 2897 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 2898 } 2899 if v.MeshName == nil { 2900 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2901 } 2902 if v.VirtualGatewayName == nil { 2903 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2904 } 2905 if invalidParams.Len() > 0 { 2906 return invalidParams 2907 } else { 2908 return nil 2909 } 2910} 2911 2912func validateOpDescribeMeshInput(v *DescribeMeshInput) error { 2913 if v == nil { 2914 return nil 2915 } 2916 invalidParams := smithy.InvalidParamsError{Context: "DescribeMeshInput"} 2917 if v.MeshName == nil { 2918 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2919 } 2920 if invalidParams.Len() > 0 { 2921 return invalidParams 2922 } else { 2923 return nil 2924 } 2925} 2926 2927func validateOpDescribeRouteInput(v *DescribeRouteInput) error { 2928 if v == nil { 2929 return nil 2930 } 2931 invalidParams := smithy.InvalidParamsError{Context: "DescribeRouteInput"} 2932 if v.RouteName == nil { 2933 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 2934 } 2935 if v.MeshName == nil { 2936 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2937 } 2938 if v.VirtualRouterName == nil { 2939 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2940 } 2941 if invalidParams.Len() > 0 { 2942 return invalidParams 2943 } else { 2944 return nil 2945 } 2946} 2947 2948func validateOpDescribeVirtualGatewayInput(v *DescribeVirtualGatewayInput) error { 2949 if v == nil { 2950 return nil 2951 } 2952 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualGatewayInput"} 2953 if v.VirtualGatewayName == nil { 2954 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 2955 } 2956 if v.MeshName == nil { 2957 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2958 } 2959 if invalidParams.Len() > 0 { 2960 return invalidParams 2961 } else { 2962 return nil 2963 } 2964} 2965 2966func validateOpDescribeVirtualNodeInput(v *DescribeVirtualNodeInput) error { 2967 if v == nil { 2968 return nil 2969 } 2970 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualNodeInput"} 2971 if v.VirtualNodeName == nil { 2972 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 2973 } 2974 if v.MeshName == nil { 2975 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2976 } 2977 if invalidParams.Len() > 0 { 2978 return invalidParams 2979 } else { 2980 return nil 2981 } 2982} 2983 2984func validateOpDescribeVirtualRouterInput(v *DescribeVirtualRouterInput) error { 2985 if v == nil { 2986 return nil 2987 } 2988 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualRouterInput"} 2989 if v.VirtualRouterName == nil { 2990 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 2991 } 2992 if v.MeshName == nil { 2993 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 2994 } 2995 if invalidParams.Len() > 0 { 2996 return invalidParams 2997 } else { 2998 return nil 2999 } 3000} 3001 3002func validateOpDescribeVirtualServiceInput(v *DescribeVirtualServiceInput) error { 3003 if v == nil { 3004 return nil 3005 } 3006 invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualServiceInput"} 3007 if v.VirtualServiceName == nil { 3008 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3009 } 3010 if v.MeshName == nil { 3011 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3012 } 3013 if invalidParams.Len() > 0 { 3014 return invalidParams 3015 } else { 3016 return nil 3017 } 3018} 3019 3020func validateOpListGatewayRoutesInput(v *ListGatewayRoutesInput) error { 3021 if v == nil { 3022 return nil 3023 } 3024 invalidParams := smithy.InvalidParamsError{Context: "ListGatewayRoutesInput"} 3025 if v.MeshName == nil { 3026 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3027 } 3028 if v.VirtualGatewayName == nil { 3029 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3030 } 3031 if invalidParams.Len() > 0 { 3032 return invalidParams 3033 } else { 3034 return nil 3035 } 3036} 3037 3038func validateOpListRoutesInput(v *ListRoutesInput) error { 3039 if v == nil { 3040 return nil 3041 } 3042 invalidParams := smithy.InvalidParamsError{Context: "ListRoutesInput"} 3043 if v.MeshName == nil { 3044 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3045 } 3046 if v.VirtualRouterName == nil { 3047 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3048 } 3049 if invalidParams.Len() > 0 { 3050 return invalidParams 3051 } else { 3052 return nil 3053 } 3054} 3055 3056func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 3057 if v == nil { 3058 return nil 3059 } 3060 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 3061 if v.ResourceArn == nil { 3062 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3063 } 3064 if invalidParams.Len() > 0 { 3065 return invalidParams 3066 } else { 3067 return nil 3068 } 3069} 3070 3071func validateOpListVirtualGatewaysInput(v *ListVirtualGatewaysInput) error { 3072 if v == nil { 3073 return nil 3074 } 3075 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualGatewaysInput"} 3076 if v.MeshName == nil { 3077 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3078 } 3079 if invalidParams.Len() > 0 { 3080 return invalidParams 3081 } else { 3082 return nil 3083 } 3084} 3085 3086func validateOpListVirtualNodesInput(v *ListVirtualNodesInput) error { 3087 if v == nil { 3088 return nil 3089 } 3090 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualNodesInput"} 3091 if v.MeshName == nil { 3092 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3093 } 3094 if invalidParams.Len() > 0 { 3095 return invalidParams 3096 } else { 3097 return nil 3098 } 3099} 3100 3101func validateOpListVirtualRoutersInput(v *ListVirtualRoutersInput) error { 3102 if v == nil { 3103 return nil 3104 } 3105 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualRoutersInput"} 3106 if v.MeshName == nil { 3107 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3108 } 3109 if invalidParams.Len() > 0 { 3110 return invalidParams 3111 } else { 3112 return nil 3113 } 3114} 3115 3116func validateOpListVirtualServicesInput(v *ListVirtualServicesInput) error { 3117 if v == nil { 3118 return nil 3119 } 3120 invalidParams := smithy.InvalidParamsError{Context: "ListVirtualServicesInput"} 3121 if v.MeshName == nil { 3122 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3123 } 3124 if invalidParams.Len() > 0 { 3125 return invalidParams 3126 } else { 3127 return nil 3128 } 3129} 3130 3131func validateOpTagResourceInput(v *TagResourceInput) error { 3132 if v == nil { 3133 return nil 3134 } 3135 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 3136 if v.ResourceArn == nil { 3137 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3138 } 3139 if v.Tags == nil { 3140 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 3141 } else if v.Tags != nil { 3142 if err := validateTagList(v.Tags); err != nil { 3143 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 3144 } 3145 } 3146 if invalidParams.Len() > 0 { 3147 return invalidParams 3148 } else { 3149 return nil 3150 } 3151} 3152 3153func validateOpUntagResourceInput(v *UntagResourceInput) error { 3154 if v == nil { 3155 return nil 3156 } 3157 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 3158 if v.ResourceArn == nil { 3159 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 3160 } 3161 if v.TagKeys == nil { 3162 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 3163 } 3164 if invalidParams.Len() > 0 { 3165 return invalidParams 3166 } else { 3167 return nil 3168 } 3169} 3170 3171func validateOpUpdateGatewayRouteInput(v *UpdateGatewayRouteInput) error { 3172 if v == nil { 3173 return nil 3174 } 3175 invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayRouteInput"} 3176 if v.GatewayRouteName == nil { 3177 invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName")) 3178 } 3179 if v.MeshName == nil { 3180 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3181 } 3182 if v.VirtualGatewayName == nil { 3183 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3184 } 3185 if v.Spec == nil { 3186 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3187 } else if v.Spec != nil { 3188 if err := validateGatewayRouteSpec(v.Spec); err != nil { 3189 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3190 } 3191 } 3192 if invalidParams.Len() > 0 { 3193 return invalidParams 3194 } else { 3195 return nil 3196 } 3197} 3198 3199func validateOpUpdateMeshInput(v *UpdateMeshInput) error { 3200 if v == nil { 3201 return nil 3202 } 3203 invalidParams := smithy.InvalidParamsError{Context: "UpdateMeshInput"} 3204 if v.MeshName == nil { 3205 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3206 } 3207 if v.Spec != nil { 3208 if err := validateMeshSpec(v.Spec); err != nil { 3209 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3210 } 3211 } 3212 if invalidParams.Len() > 0 { 3213 return invalidParams 3214 } else { 3215 return nil 3216 } 3217} 3218 3219func validateOpUpdateRouteInput(v *UpdateRouteInput) error { 3220 if v == nil { 3221 return nil 3222 } 3223 invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"} 3224 if v.RouteName == nil { 3225 invalidParams.Add(smithy.NewErrParamRequired("RouteName")) 3226 } 3227 if v.MeshName == nil { 3228 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3229 } 3230 if v.VirtualRouterName == nil { 3231 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3232 } 3233 if v.Spec == nil { 3234 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3235 } else if v.Spec != nil { 3236 if err := validateRouteSpec(v.Spec); err != nil { 3237 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3238 } 3239 } 3240 if invalidParams.Len() > 0 { 3241 return invalidParams 3242 } else { 3243 return nil 3244 } 3245} 3246 3247func validateOpUpdateVirtualGatewayInput(v *UpdateVirtualGatewayInput) error { 3248 if v == nil { 3249 return nil 3250 } 3251 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualGatewayInput"} 3252 if v.VirtualGatewayName == nil { 3253 invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName")) 3254 } 3255 if v.MeshName == nil { 3256 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3257 } 3258 if v.Spec == nil { 3259 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3260 } else if v.Spec != nil { 3261 if err := validateVirtualGatewaySpec(v.Spec); err != nil { 3262 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3263 } 3264 } 3265 if invalidParams.Len() > 0 { 3266 return invalidParams 3267 } else { 3268 return nil 3269 } 3270} 3271 3272func validateOpUpdateVirtualNodeInput(v *UpdateVirtualNodeInput) error { 3273 if v == nil { 3274 return nil 3275 } 3276 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualNodeInput"} 3277 if v.VirtualNodeName == nil { 3278 invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName")) 3279 } 3280 if v.MeshName == nil { 3281 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3282 } 3283 if v.Spec == nil { 3284 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3285 } else if v.Spec != nil { 3286 if err := validateVirtualNodeSpec(v.Spec); err != nil { 3287 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3288 } 3289 } 3290 if invalidParams.Len() > 0 { 3291 return invalidParams 3292 } else { 3293 return nil 3294 } 3295} 3296 3297func validateOpUpdateVirtualRouterInput(v *UpdateVirtualRouterInput) error { 3298 if v == nil { 3299 return nil 3300 } 3301 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualRouterInput"} 3302 if v.VirtualRouterName == nil { 3303 invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName")) 3304 } 3305 if v.MeshName == nil { 3306 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3307 } 3308 if v.Spec == nil { 3309 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3310 } else if v.Spec != nil { 3311 if err := validateVirtualRouterSpec(v.Spec); err != nil { 3312 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3313 } 3314 } 3315 if invalidParams.Len() > 0 { 3316 return invalidParams 3317 } else { 3318 return nil 3319 } 3320} 3321 3322func validateOpUpdateVirtualServiceInput(v *UpdateVirtualServiceInput) error { 3323 if v == nil { 3324 return nil 3325 } 3326 invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualServiceInput"} 3327 if v.VirtualServiceName == nil { 3328 invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName")) 3329 } 3330 if v.MeshName == nil { 3331 invalidParams.Add(smithy.NewErrParamRequired("MeshName")) 3332 } 3333 if v.Spec == nil { 3334 invalidParams.Add(smithy.NewErrParamRequired("Spec")) 3335 } else if v.Spec != nil { 3336 if err := validateVirtualServiceSpec(v.Spec); err != nil { 3337 invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError)) 3338 } 3339 } 3340 if invalidParams.Len() > 0 { 3341 return invalidParams 3342 } else { 3343 return nil 3344 } 3345} 3346