1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package robomaker 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/robomaker/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchDeleteWorlds struct { 14} 15 16func (*validateOpBatchDeleteWorlds) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchDeleteWorlds) 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.(*BatchDeleteWorldsInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchDeleteWorldsInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchDescribeSimulationJob struct { 34} 35 36func (*validateOpBatchDescribeSimulationJob) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchDescribeSimulationJob) 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.(*BatchDescribeSimulationJobInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchDescribeSimulationJobInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCancelDeploymentJob struct { 54} 55 56func (*validateOpCancelDeploymentJob) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCancelDeploymentJob) 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.(*CancelDeploymentJobInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCancelDeploymentJobInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCancelSimulationJobBatch struct { 74} 75 76func (*validateOpCancelSimulationJobBatch) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCancelSimulationJobBatch) 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.(*CancelSimulationJobBatchInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCancelSimulationJobBatchInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCancelSimulationJob struct { 94} 95 96func (*validateOpCancelSimulationJob) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCancelSimulationJob) 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.(*CancelSimulationJobInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCancelSimulationJobInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCancelWorldExportJob struct { 114} 115 116func (*validateOpCancelWorldExportJob) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCancelWorldExportJob) 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.(*CancelWorldExportJobInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCancelWorldExportJobInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCancelWorldGenerationJob struct { 134} 135 136func (*validateOpCancelWorldGenerationJob) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCancelWorldGenerationJob) 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.(*CancelWorldGenerationJobInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCancelWorldGenerationJobInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateDeploymentJob struct { 154} 155 156func (*validateOpCreateDeploymentJob) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateDeploymentJob) 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.(*CreateDeploymentJobInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateDeploymentJobInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateFleet struct { 174} 175 176func (*validateOpCreateFleet) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateFleet) 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.(*CreateFleetInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateFleetInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateRobotApplication struct { 194} 195 196func (*validateOpCreateRobotApplication) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateRobotApplication) 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.(*CreateRobotApplicationInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateRobotApplicationInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreateRobotApplicationVersion struct { 214} 215 216func (*validateOpCreateRobotApplicationVersion) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreateRobotApplicationVersion) 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.(*CreateRobotApplicationVersionInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreateRobotApplicationVersionInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpCreateRobot struct { 234} 235 236func (*validateOpCreateRobot) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpCreateRobot) 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.(*CreateRobotInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpCreateRobotInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpCreateSimulationApplication struct { 254} 255 256func (*validateOpCreateSimulationApplication) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpCreateSimulationApplication) 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.(*CreateSimulationApplicationInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpCreateSimulationApplicationInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpCreateSimulationApplicationVersion struct { 274} 275 276func (*validateOpCreateSimulationApplicationVersion) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpCreateSimulationApplicationVersion) 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.(*CreateSimulationApplicationVersionInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpCreateSimulationApplicationVersionInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpCreateSimulationJob struct { 294} 295 296func (*validateOpCreateSimulationJob) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpCreateSimulationJob) 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.(*CreateSimulationJobInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpCreateSimulationJobInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpCreateWorldExportJob struct { 314} 315 316func (*validateOpCreateWorldExportJob) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpCreateWorldExportJob) 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.(*CreateWorldExportJobInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpCreateWorldExportJobInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpCreateWorldGenerationJob struct { 334} 335 336func (*validateOpCreateWorldGenerationJob) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpCreateWorldGenerationJob) 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.(*CreateWorldGenerationJobInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpCreateWorldGenerationJobInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpCreateWorldTemplate struct { 354} 355 356func (*validateOpCreateWorldTemplate) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpCreateWorldTemplate) 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.(*CreateWorldTemplateInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpCreateWorldTemplateInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDeleteFleet struct { 374} 375 376func (*validateOpDeleteFleet) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDeleteFleet) 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.(*DeleteFleetInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDeleteFleetInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDeleteRobotApplication struct { 394} 395 396func (*validateOpDeleteRobotApplication) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDeleteRobotApplication) 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.(*DeleteRobotApplicationInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDeleteRobotApplicationInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDeleteRobot struct { 414} 415 416func (*validateOpDeleteRobot) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDeleteRobot) 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.(*DeleteRobotInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDeleteRobotInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDeleteSimulationApplication struct { 434} 435 436func (*validateOpDeleteSimulationApplication) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDeleteSimulationApplication) 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.(*DeleteSimulationApplicationInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDeleteSimulationApplicationInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDeleteWorldTemplate struct { 454} 455 456func (*validateOpDeleteWorldTemplate) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDeleteWorldTemplate) 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.(*DeleteWorldTemplateInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDeleteWorldTemplateInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDeregisterRobot struct { 474} 475 476func (*validateOpDeregisterRobot) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDeregisterRobot) 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.(*DeregisterRobotInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDeregisterRobotInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDescribeDeploymentJob struct { 494} 495 496func (*validateOpDescribeDeploymentJob) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDescribeDeploymentJob) 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.(*DescribeDeploymentJobInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDescribeDeploymentJobInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDescribeFleet struct { 514} 515 516func (*validateOpDescribeFleet) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDescribeFleet) 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.(*DescribeFleetInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDescribeFleetInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDescribeRobotApplication struct { 534} 535 536func (*validateOpDescribeRobotApplication) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDescribeRobotApplication) 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.(*DescribeRobotApplicationInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDescribeRobotApplicationInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpDescribeRobot struct { 554} 555 556func (*validateOpDescribeRobot) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpDescribeRobot) 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.(*DescribeRobotInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpDescribeRobotInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpDescribeSimulationApplication struct { 574} 575 576func (*validateOpDescribeSimulationApplication) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpDescribeSimulationApplication) 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.(*DescribeSimulationApplicationInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpDescribeSimulationApplicationInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpDescribeSimulationJobBatch struct { 594} 595 596func (*validateOpDescribeSimulationJobBatch) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpDescribeSimulationJobBatch) 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.(*DescribeSimulationJobBatchInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpDescribeSimulationJobBatchInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpDescribeSimulationJob struct { 614} 615 616func (*validateOpDescribeSimulationJob) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpDescribeSimulationJob) 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.(*DescribeSimulationJobInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpDescribeSimulationJobInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpDescribeWorldExportJob struct { 634} 635 636func (*validateOpDescribeWorldExportJob) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpDescribeWorldExportJob) 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.(*DescribeWorldExportJobInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpDescribeWorldExportJobInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpDescribeWorldGenerationJob struct { 654} 655 656func (*validateOpDescribeWorldGenerationJob) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpDescribeWorldGenerationJob) 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.(*DescribeWorldGenerationJobInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpDescribeWorldGenerationJobInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpDescribeWorld struct { 674} 675 676func (*validateOpDescribeWorld) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpDescribeWorld) 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.(*DescribeWorldInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpDescribeWorldInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpDescribeWorldTemplate struct { 694} 695 696func (*validateOpDescribeWorldTemplate) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpDescribeWorldTemplate) 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.(*DescribeWorldTemplateInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpDescribeWorldTemplateInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpListTagsForResource struct { 714} 715 716func (*validateOpListTagsForResource) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpListTagsForResourceInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpRegisterRobot struct { 734} 735 736func (*validateOpRegisterRobot) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpRegisterRobot) 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.(*RegisterRobotInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpRegisterRobotInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpRestartSimulationJob struct { 754} 755 756func (*validateOpRestartSimulationJob) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpRestartSimulationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 762) { 763 input, ok := in.Parameters.(*RestartSimulationJobInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpRestartSimulationJobInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpStartSimulationJobBatch struct { 774} 775 776func (*validateOpStartSimulationJobBatch) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpStartSimulationJobBatch) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 782) { 783 input, ok := in.Parameters.(*StartSimulationJobBatchInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpStartSimulationJobBatchInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpSyncDeploymentJob struct { 794} 795 796func (*validateOpSyncDeploymentJob) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpSyncDeploymentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*SyncDeploymentJobInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpSyncDeploymentJobInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpTagResource struct { 814} 815 816func (*validateOpTagResource) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*TagResourceInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpTagResourceInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpUntagResource struct { 834} 835 836func (*validateOpUntagResource) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*UntagResourceInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpUntagResourceInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpUpdateRobotApplication struct { 854} 855 856func (*validateOpUpdateRobotApplication) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpUpdateRobotApplication) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*UpdateRobotApplicationInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpUpdateRobotApplicationInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpUpdateSimulationApplication struct { 874} 875 876func (*validateOpUpdateSimulationApplication) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpUpdateSimulationApplication) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 882) { 883 input, ok := in.Parameters.(*UpdateSimulationApplicationInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpUpdateSimulationApplicationInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpUpdateWorldTemplate struct { 894} 895 896func (*validateOpUpdateWorldTemplate) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpUpdateWorldTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 902) { 903 input, ok := in.Parameters.(*UpdateWorldTemplateInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpUpdateWorldTemplateInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913func addOpBatchDeleteWorldsValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpBatchDeleteWorlds{}, middleware.After) 915} 916 917func addOpBatchDescribeSimulationJobValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpBatchDescribeSimulationJob{}, middleware.After) 919} 920 921func addOpCancelDeploymentJobValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpCancelDeploymentJob{}, middleware.After) 923} 924 925func addOpCancelSimulationJobBatchValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpCancelSimulationJobBatch{}, middleware.After) 927} 928 929func addOpCancelSimulationJobValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpCancelSimulationJob{}, middleware.After) 931} 932 933func addOpCancelWorldExportJobValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpCancelWorldExportJob{}, middleware.After) 935} 936 937func addOpCancelWorldGenerationJobValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpCancelWorldGenerationJob{}, middleware.After) 939} 940 941func addOpCreateDeploymentJobValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpCreateDeploymentJob{}, middleware.After) 943} 944 945func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After) 947} 948 949func addOpCreateRobotApplicationValidationMiddleware(stack *middleware.Stack) error { 950 return stack.Initialize.Add(&validateOpCreateRobotApplication{}, middleware.After) 951} 952 953func addOpCreateRobotApplicationVersionValidationMiddleware(stack *middleware.Stack) error { 954 return stack.Initialize.Add(&validateOpCreateRobotApplicationVersion{}, middleware.After) 955} 956 957func addOpCreateRobotValidationMiddleware(stack *middleware.Stack) error { 958 return stack.Initialize.Add(&validateOpCreateRobot{}, middleware.After) 959} 960 961func addOpCreateSimulationApplicationValidationMiddleware(stack *middleware.Stack) error { 962 return stack.Initialize.Add(&validateOpCreateSimulationApplication{}, middleware.After) 963} 964 965func addOpCreateSimulationApplicationVersionValidationMiddleware(stack *middleware.Stack) error { 966 return stack.Initialize.Add(&validateOpCreateSimulationApplicationVersion{}, middleware.After) 967} 968 969func addOpCreateSimulationJobValidationMiddleware(stack *middleware.Stack) error { 970 return stack.Initialize.Add(&validateOpCreateSimulationJob{}, middleware.After) 971} 972 973func addOpCreateWorldExportJobValidationMiddleware(stack *middleware.Stack) error { 974 return stack.Initialize.Add(&validateOpCreateWorldExportJob{}, middleware.After) 975} 976 977func addOpCreateWorldGenerationJobValidationMiddleware(stack *middleware.Stack) error { 978 return stack.Initialize.Add(&validateOpCreateWorldGenerationJob{}, middleware.After) 979} 980 981func addOpCreateWorldTemplateValidationMiddleware(stack *middleware.Stack) error { 982 return stack.Initialize.Add(&validateOpCreateWorldTemplate{}, middleware.After) 983} 984 985func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error { 986 return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After) 987} 988 989func addOpDeleteRobotApplicationValidationMiddleware(stack *middleware.Stack) error { 990 return stack.Initialize.Add(&validateOpDeleteRobotApplication{}, middleware.After) 991} 992 993func addOpDeleteRobotValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpDeleteRobot{}, middleware.After) 995} 996 997func addOpDeleteSimulationApplicationValidationMiddleware(stack *middleware.Stack) error { 998 return stack.Initialize.Add(&validateOpDeleteSimulationApplication{}, middleware.After) 999} 1000 1001func addOpDeleteWorldTemplateValidationMiddleware(stack *middleware.Stack) error { 1002 return stack.Initialize.Add(&validateOpDeleteWorldTemplate{}, middleware.After) 1003} 1004 1005func addOpDeregisterRobotValidationMiddleware(stack *middleware.Stack) error { 1006 return stack.Initialize.Add(&validateOpDeregisterRobot{}, middleware.After) 1007} 1008 1009func addOpDescribeDeploymentJobValidationMiddleware(stack *middleware.Stack) error { 1010 return stack.Initialize.Add(&validateOpDescribeDeploymentJob{}, middleware.After) 1011} 1012 1013func addOpDescribeFleetValidationMiddleware(stack *middleware.Stack) error { 1014 return stack.Initialize.Add(&validateOpDescribeFleet{}, middleware.After) 1015} 1016 1017func addOpDescribeRobotApplicationValidationMiddleware(stack *middleware.Stack) error { 1018 return stack.Initialize.Add(&validateOpDescribeRobotApplication{}, middleware.After) 1019} 1020 1021func addOpDescribeRobotValidationMiddleware(stack *middleware.Stack) error { 1022 return stack.Initialize.Add(&validateOpDescribeRobot{}, middleware.After) 1023} 1024 1025func addOpDescribeSimulationApplicationValidationMiddleware(stack *middleware.Stack) error { 1026 return stack.Initialize.Add(&validateOpDescribeSimulationApplication{}, middleware.After) 1027} 1028 1029func addOpDescribeSimulationJobBatchValidationMiddleware(stack *middleware.Stack) error { 1030 return stack.Initialize.Add(&validateOpDescribeSimulationJobBatch{}, middleware.After) 1031} 1032 1033func addOpDescribeSimulationJobValidationMiddleware(stack *middleware.Stack) error { 1034 return stack.Initialize.Add(&validateOpDescribeSimulationJob{}, middleware.After) 1035} 1036 1037func addOpDescribeWorldExportJobValidationMiddleware(stack *middleware.Stack) error { 1038 return stack.Initialize.Add(&validateOpDescribeWorldExportJob{}, middleware.After) 1039} 1040 1041func addOpDescribeWorldGenerationJobValidationMiddleware(stack *middleware.Stack) error { 1042 return stack.Initialize.Add(&validateOpDescribeWorldGenerationJob{}, middleware.After) 1043} 1044 1045func addOpDescribeWorldValidationMiddleware(stack *middleware.Stack) error { 1046 return stack.Initialize.Add(&validateOpDescribeWorld{}, middleware.After) 1047} 1048 1049func addOpDescribeWorldTemplateValidationMiddleware(stack *middleware.Stack) error { 1050 return stack.Initialize.Add(&validateOpDescribeWorldTemplate{}, middleware.After) 1051} 1052 1053func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1054 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 1055} 1056 1057func addOpRegisterRobotValidationMiddleware(stack *middleware.Stack) error { 1058 return stack.Initialize.Add(&validateOpRegisterRobot{}, middleware.After) 1059} 1060 1061func addOpRestartSimulationJobValidationMiddleware(stack *middleware.Stack) error { 1062 return stack.Initialize.Add(&validateOpRestartSimulationJob{}, middleware.After) 1063} 1064 1065func addOpStartSimulationJobBatchValidationMiddleware(stack *middleware.Stack) error { 1066 return stack.Initialize.Add(&validateOpStartSimulationJobBatch{}, middleware.After) 1067} 1068 1069func addOpSyncDeploymentJobValidationMiddleware(stack *middleware.Stack) error { 1070 return stack.Initialize.Add(&validateOpSyncDeploymentJob{}, middleware.After) 1071} 1072 1073func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1074 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1075} 1076 1077func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1078 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1079} 1080 1081func addOpUpdateRobotApplicationValidationMiddleware(stack *middleware.Stack) error { 1082 return stack.Initialize.Add(&validateOpUpdateRobotApplication{}, middleware.After) 1083} 1084 1085func addOpUpdateSimulationApplicationValidationMiddleware(stack *middleware.Stack) error { 1086 return stack.Initialize.Add(&validateOpUpdateSimulationApplication{}, middleware.After) 1087} 1088 1089func addOpUpdateWorldTemplateValidationMiddleware(stack *middleware.Stack) error { 1090 return stack.Initialize.Add(&validateOpUpdateWorldTemplate{}, middleware.After) 1091} 1092 1093func validateCreateSimulationJobRequests(v []types.SimulationJobRequest) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationJobRequests"} 1098 for i := range v { 1099 if err := validateSimulationJobRequest(&v[i]); err != nil { 1100 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1101 } 1102 } 1103 if invalidParams.Len() > 0 { 1104 return invalidParams 1105 } else { 1106 return nil 1107 } 1108} 1109 1110func validateDataSourceConfig(v *types.DataSourceConfig) error { 1111 if v == nil { 1112 return nil 1113 } 1114 invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfig"} 1115 if v.Name == nil { 1116 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1117 } 1118 if v.S3Bucket == nil { 1119 invalidParams.Add(smithy.NewErrParamRequired("S3Bucket")) 1120 } 1121 if v.S3Keys == nil { 1122 invalidParams.Add(smithy.NewErrParamRequired("S3Keys")) 1123 } 1124 if invalidParams.Len() > 0 { 1125 return invalidParams 1126 } else { 1127 return nil 1128 } 1129} 1130 1131func validateDataSourceConfigs(v []types.DataSourceConfig) error { 1132 if v == nil { 1133 return nil 1134 } 1135 invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfigs"} 1136 for i := range v { 1137 if err := validateDataSourceConfig(&v[i]); err != nil { 1138 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1139 } 1140 } 1141 if invalidParams.Len() > 0 { 1142 return invalidParams 1143 } else { 1144 return nil 1145 } 1146} 1147 1148func validateDeploymentApplicationConfig(v *types.DeploymentApplicationConfig) error { 1149 if v == nil { 1150 return nil 1151 } 1152 invalidParams := smithy.InvalidParamsError{Context: "DeploymentApplicationConfig"} 1153 if v.Application == nil { 1154 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1155 } 1156 if v.ApplicationVersion == nil { 1157 invalidParams.Add(smithy.NewErrParamRequired("ApplicationVersion")) 1158 } 1159 if v.LaunchConfig == nil { 1160 invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig")) 1161 } else if v.LaunchConfig != nil { 1162 if err := validateDeploymentLaunchConfig(v.LaunchConfig); err != nil { 1163 invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError)) 1164 } 1165 } 1166 if invalidParams.Len() > 0 { 1167 return invalidParams 1168 } else { 1169 return nil 1170 } 1171} 1172 1173func validateDeploymentApplicationConfigs(v []types.DeploymentApplicationConfig) error { 1174 if v == nil { 1175 return nil 1176 } 1177 invalidParams := smithy.InvalidParamsError{Context: "DeploymentApplicationConfigs"} 1178 for i := range v { 1179 if err := validateDeploymentApplicationConfig(&v[i]); err != nil { 1180 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1181 } 1182 } 1183 if invalidParams.Len() > 0 { 1184 return invalidParams 1185 } else { 1186 return nil 1187 } 1188} 1189 1190func validateDeploymentConfig(v *types.DeploymentConfig) error { 1191 if v == nil { 1192 return nil 1193 } 1194 invalidParams := smithy.InvalidParamsError{Context: "DeploymentConfig"} 1195 if v.DownloadConditionFile != nil { 1196 if err := validateS3Object(v.DownloadConditionFile); err != nil { 1197 invalidParams.AddNested("DownloadConditionFile", err.(smithy.InvalidParamsError)) 1198 } 1199 } 1200 if invalidParams.Len() > 0 { 1201 return invalidParams 1202 } else { 1203 return nil 1204 } 1205} 1206 1207func validateDeploymentLaunchConfig(v *types.DeploymentLaunchConfig) error { 1208 if v == nil { 1209 return nil 1210 } 1211 invalidParams := smithy.InvalidParamsError{Context: "DeploymentLaunchConfig"} 1212 if v.PackageName == nil { 1213 invalidParams.Add(smithy.NewErrParamRequired("PackageName")) 1214 } 1215 if v.LaunchFile == nil { 1216 invalidParams.Add(smithy.NewErrParamRequired("LaunchFile")) 1217 } 1218 if invalidParams.Len() > 0 { 1219 return invalidParams 1220 } else { 1221 return nil 1222 } 1223} 1224 1225func validateLaunchConfig(v *types.LaunchConfig) error { 1226 if v == nil { 1227 return nil 1228 } 1229 invalidParams := smithy.InvalidParamsError{Context: "LaunchConfig"} 1230 if v.PackageName == nil { 1231 invalidParams.Add(smithy.NewErrParamRequired("PackageName")) 1232 } 1233 if v.LaunchFile == nil { 1234 invalidParams.Add(smithy.NewErrParamRequired("LaunchFile")) 1235 } 1236 if v.PortForwardingConfig != nil { 1237 if err := validatePortForwardingConfig(v.PortForwardingConfig); err != nil { 1238 invalidParams.AddNested("PortForwardingConfig", err.(smithy.InvalidParamsError)) 1239 } 1240 } 1241 if invalidParams.Len() > 0 { 1242 return invalidParams 1243 } else { 1244 return nil 1245 } 1246} 1247 1248func validateLoggingConfig(v *types.LoggingConfig) error { 1249 if v == nil { 1250 return nil 1251 } 1252 invalidParams := smithy.InvalidParamsError{Context: "LoggingConfig"} 1253 if v.RecordAllRosTopics == nil { 1254 invalidParams.Add(smithy.NewErrParamRequired("RecordAllRosTopics")) 1255 } 1256 if invalidParams.Len() > 0 { 1257 return invalidParams 1258 } else { 1259 return nil 1260 } 1261} 1262 1263func validatePortForwardingConfig(v *types.PortForwardingConfig) error { 1264 if v == nil { 1265 return nil 1266 } 1267 invalidParams := smithy.InvalidParamsError{Context: "PortForwardingConfig"} 1268 if v.PortMappings != nil { 1269 if err := validatePortMappingList(v.PortMappings); err != nil { 1270 invalidParams.AddNested("PortMappings", err.(smithy.InvalidParamsError)) 1271 } 1272 } 1273 if invalidParams.Len() > 0 { 1274 return invalidParams 1275 } else { 1276 return nil 1277 } 1278} 1279 1280func validatePortMapping(v *types.PortMapping) error { 1281 if v == nil { 1282 return nil 1283 } 1284 invalidParams := smithy.InvalidParamsError{Context: "PortMapping"} 1285 if invalidParams.Len() > 0 { 1286 return invalidParams 1287 } else { 1288 return nil 1289 } 1290} 1291 1292func validatePortMappingList(v []types.PortMapping) error { 1293 if v == nil { 1294 return nil 1295 } 1296 invalidParams := smithy.InvalidParamsError{Context: "PortMappingList"} 1297 for i := range v { 1298 if err := validatePortMapping(&v[i]); err != nil { 1299 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1300 } 1301 } 1302 if invalidParams.Len() > 0 { 1303 return invalidParams 1304 } else { 1305 return nil 1306 } 1307} 1308 1309func validateRobotApplicationConfig(v *types.RobotApplicationConfig) error { 1310 if v == nil { 1311 return nil 1312 } 1313 invalidParams := smithy.InvalidParamsError{Context: "RobotApplicationConfig"} 1314 if v.Application == nil { 1315 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1316 } 1317 if v.LaunchConfig == nil { 1318 invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig")) 1319 } else if v.LaunchConfig != nil { 1320 if err := validateLaunchConfig(v.LaunchConfig); err != nil { 1321 invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError)) 1322 } 1323 } 1324 if v.UploadConfigurations != nil { 1325 if err := validateUploadConfigurations(v.UploadConfigurations); err != nil { 1326 invalidParams.AddNested("UploadConfigurations", err.(smithy.InvalidParamsError)) 1327 } 1328 } 1329 if v.Tools != nil { 1330 if err := validateTools(v.Tools); err != nil { 1331 invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError)) 1332 } 1333 } 1334 if invalidParams.Len() > 0 { 1335 return invalidParams 1336 } else { 1337 return nil 1338 } 1339} 1340 1341func validateRobotApplicationConfigs(v []types.RobotApplicationConfig) error { 1342 if v == nil { 1343 return nil 1344 } 1345 invalidParams := smithy.InvalidParamsError{Context: "RobotApplicationConfigs"} 1346 for i := range v { 1347 if err := validateRobotApplicationConfig(&v[i]); err != nil { 1348 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1349 } 1350 } 1351 if invalidParams.Len() > 0 { 1352 return invalidParams 1353 } else { 1354 return nil 1355 } 1356} 1357 1358func validateS3Object(v *types.S3Object) error { 1359 if v == nil { 1360 return nil 1361 } 1362 invalidParams := smithy.InvalidParamsError{Context: "S3Object"} 1363 if v.Bucket == nil { 1364 invalidParams.Add(smithy.NewErrParamRequired("Bucket")) 1365 } 1366 if v.Key == nil { 1367 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1368 } 1369 if invalidParams.Len() > 0 { 1370 return invalidParams 1371 } else { 1372 return nil 1373 } 1374} 1375 1376func validateSimulationApplicationConfig(v *types.SimulationApplicationConfig) error { 1377 if v == nil { 1378 return nil 1379 } 1380 invalidParams := smithy.InvalidParamsError{Context: "SimulationApplicationConfig"} 1381 if v.Application == nil { 1382 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1383 } 1384 if v.LaunchConfig == nil { 1385 invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig")) 1386 } else if v.LaunchConfig != nil { 1387 if err := validateLaunchConfig(v.LaunchConfig); err != nil { 1388 invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError)) 1389 } 1390 } 1391 if v.UploadConfigurations != nil { 1392 if err := validateUploadConfigurations(v.UploadConfigurations); err != nil { 1393 invalidParams.AddNested("UploadConfigurations", err.(smithy.InvalidParamsError)) 1394 } 1395 } 1396 if v.Tools != nil { 1397 if err := validateTools(v.Tools); err != nil { 1398 invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError)) 1399 } 1400 } 1401 if invalidParams.Len() > 0 { 1402 return invalidParams 1403 } else { 1404 return nil 1405 } 1406} 1407 1408func validateSimulationApplicationConfigs(v []types.SimulationApplicationConfig) error { 1409 if v == nil { 1410 return nil 1411 } 1412 invalidParams := smithy.InvalidParamsError{Context: "SimulationApplicationConfigs"} 1413 for i := range v { 1414 if err := validateSimulationApplicationConfig(&v[i]); err != nil { 1415 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1416 } 1417 } 1418 if invalidParams.Len() > 0 { 1419 return invalidParams 1420 } else { 1421 return nil 1422 } 1423} 1424 1425func validateSimulationJobRequest(v *types.SimulationJobRequest) error { 1426 if v == nil { 1427 return nil 1428 } 1429 invalidParams := smithy.InvalidParamsError{Context: "SimulationJobRequest"} 1430 if v.LoggingConfig != nil { 1431 if err := validateLoggingConfig(v.LoggingConfig); err != nil { 1432 invalidParams.AddNested("LoggingConfig", err.(smithy.InvalidParamsError)) 1433 } 1434 } 1435 if v.RobotApplications != nil { 1436 if err := validateRobotApplicationConfigs(v.RobotApplications); err != nil { 1437 invalidParams.AddNested("RobotApplications", err.(smithy.InvalidParamsError)) 1438 } 1439 } 1440 if v.SimulationApplications != nil { 1441 if err := validateSimulationApplicationConfigs(v.SimulationApplications); err != nil { 1442 invalidParams.AddNested("SimulationApplications", err.(smithy.InvalidParamsError)) 1443 } 1444 } 1445 if v.DataSources != nil { 1446 if err := validateDataSourceConfigs(v.DataSources); err != nil { 1447 invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError)) 1448 } 1449 } 1450 if v.VpcConfig != nil { 1451 if err := validateVPCConfig(v.VpcConfig); err != nil { 1452 invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError)) 1453 } 1454 } 1455 if invalidParams.Len() > 0 { 1456 return invalidParams 1457 } else { 1458 return nil 1459 } 1460} 1461 1462func validateTemplateLocation(v *types.TemplateLocation) error { 1463 if v == nil { 1464 return nil 1465 } 1466 invalidParams := smithy.InvalidParamsError{Context: "TemplateLocation"} 1467 if v.S3Bucket == nil { 1468 invalidParams.Add(smithy.NewErrParamRequired("S3Bucket")) 1469 } 1470 if v.S3Key == nil { 1471 invalidParams.Add(smithy.NewErrParamRequired("S3Key")) 1472 } 1473 if invalidParams.Len() > 0 { 1474 return invalidParams 1475 } else { 1476 return nil 1477 } 1478} 1479 1480func validateTool(v *types.Tool) error { 1481 if v == nil { 1482 return nil 1483 } 1484 invalidParams := smithy.InvalidParamsError{Context: "Tool"} 1485 if v.Name == nil { 1486 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1487 } 1488 if v.Command == nil { 1489 invalidParams.Add(smithy.NewErrParamRequired("Command")) 1490 } 1491 if invalidParams.Len() > 0 { 1492 return invalidParams 1493 } else { 1494 return nil 1495 } 1496} 1497 1498func validateTools(v []types.Tool) error { 1499 if v == nil { 1500 return nil 1501 } 1502 invalidParams := smithy.InvalidParamsError{Context: "Tools"} 1503 for i := range v { 1504 if err := validateTool(&v[i]); err != nil { 1505 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1506 } 1507 } 1508 if invalidParams.Len() > 0 { 1509 return invalidParams 1510 } else { 1511 return nil 1512 } 1513} 1514 1515func validateUploadConfiguration(v *types.UploadConfiguration) error { 1516 if v == nil { 1517 return nil 1518 } 1519 invalidParams := smithy.InvalidParamsError{Context: "UploadConfiguration"} 1520 if v.Name == nil { 1521 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1522 } 1523 if v.Path == nil { 1524 invalidParams.Add(smithy.NewErrParamRequired("Path")) 1525 } 1526 if len(v.UploadBehavior) == 0 { 1527 invalidParams.Add(smithy.NewErrParamRequired("UploadBehavior")) 1528 } 1529 if invalidParams.Len() > 0 { 1530 return invalidParams 1531 } else { 1532 return nil 1533 } 1534} 1535 1536func validateUploadConfigurations(v []types.UploadConfiguration) error { 1537 if v == nil { 1538 return nil 1539 } 1540 invalidParams := smithy.InvalidParamsError{Context: "UploadConfigurations"} 1541 for i := range v { 1542 if err := validateUploadConfiguration(&v[i]); err != nil { 1543 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1544 } 1545 } 1546 if invalidParams.Len() > 0 { 1547 return invalidParams 1548 } else { 1549 return nil 1550 } 1551} 1552 1553func validateVPCConfig(v *types.VPCConfig) error { 1554 if v == nil { 1555 return nil 1556 } 1557 invalidParams := smithy.InvalidParamsError{Context: "VPCConfig"} 1558 if v.Subnets == nil { 1559 invalidParams.Add(smithy.NewErrParamRequired("Subnets")) 1560 } 1561 if invalidParams.Len() > 0 { 1562 return invalidParams 1563 } else { 1564 return nil 1565 } 1566} 1567 1568func validateOpBatchDeleteWorldsInput(v *BatchDeleteWorldsInput) error { 1569 if v == nil { 1570 return nil 1571 } 1572 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteWorldsInput"} 1573 if v.Worlds == nil { 1574 invalidParams.Add(smithy.NewErrParamRequired("Worlds")) 1575 } 1576 if invalidParams.Len() > 0 { 1577 return invalidParams 1578 } else { 1579 return nil 1580 } 1581} 1582 1583func validateOpBatchDescribeSimulationJobInput(v *BatchDescribeSimulationJobInput) error { 1584 if v == nil { 1585 return nil 1586 } 1587 invalidParams := smithy.InvalidParamsError{Context: "BatchDescribeSimulationJobInput"} 1588 if v.Jobs == nil { 1589 invalidParams.Add(smithy.NewErrParamRequired("Jobs")) 1590 } 1591 if invalidParams.Len() > 0 { 1592 return invalidParams 1593 } else { 1594 return nil 1595 } 1596} 1597 1598func validateOpCancelDeploymentJobInput(v *CancelDeploymentJobInput) error { 1599 if v == nil { 1600 return nil 1601 } 1602 invalidParams := smithy.InvalidParamsError{Context: "CancelDeploymentJobInput"} 1603 if v.Job == nil { 1604 invalidParams.Add(smithy.NewErrParamRequired("Job")) 1605 } 1606 if invalidParams.Len() > 0 { 1607 return invalidParams 1608 } else { 1609 return nil 1610 } 1611} 1612 1613func validateOpCancelSimulationJobBatchInput(v *CancelSimulationJobBatchInput) error { 1614 if v == nil { 1615 return nil 1616 } 1617 invalidParams := smithy.InvalidParamsError{Context: "CancelSimulationJobBatchInput"} 1618 if v.Batch == nil { 1619 invalidParams.Add(smithy.NewErrParamRequired("Batch")) 1620 } 1621 if invalidParams.Len() > 0 { 1622 return invalidParams 1623 } else { 1624 return nil 1625 } 1626} 1627 1628func validateOpCancelSimulationJobInput(v *CancelSimulationJobInput) error { 1629 if v == nil { 1630 return nil 1631 } 1632 invalidParams := smithy.InvalidParamsError{Context: "CancelSimulationJobInput"} 1633 if v.Job == nil { 1634 invalidParams.Add(smithy.NewErrParamRequired("Job")) 1635 } 1636 if invalidParams.Len() > 0 { 1637 return invalidParams 1638 } else { 1639 return nil 1640 } 1641} 1642 1643func validateOpCancelWorldExportJobInput(v *CancelWorldExportJobInput) error { 1644 if v == nil { 1645 return nil 1646 } 1647 invalidParams := smithy.InvalidParamsError{Context: "CancelWorldExportJobInput"} 1648 if v.Job == nil { 1649 invalidParams.Add(smithy.NewErrParamRequired("Job")) 1650 } 1651 if invalidParams.Len() > 0 { 1652 return invalidParams 1653 } else { 1654 return nil 1655 } 1656} 1657 1658func validateOpCancelWorldGenerationJobInput(v *CancelWorldGenerationJobInput) error { 1659 if v == nil { 1660 return nil 1661 } 1662 invalidParams := smithy.InvalidParamsError{Context: "CancelWorldGenerationJobInput"} 1663 if v.Job == nil { 1664 invalidParams.Add(smithy.NewErrParamRequired("Job")) 1665 } 1666 if invalidParams.Len() > 0 { 1667 return invalidParams 1668 } else { 1669 return nil 1670 } 1671} 1672 1673func validateOpCreateDeploymentJobInput(v *CreateDeploymentJobInput) error { 1674 if v == nil { 1675 return nil 1676 } 1677 invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentJobInput"} 1678 if v.DeploymentConfig != nil { 1679 if err := validateDeploymentConfig(v.DeploymentConfig); err != nil { 1680 invalidParams.AddNested("DeploymentConfig", err.(smithy.InvalidParamsError)) 1681 } 1682 } 1683 if v.ClientRequestToken == nil { 1684 invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken")) 1685 } 1686 if v.Fleet == nil { 1687 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 1688 } 1689 if v.DeploymentApplicationConfigs == nil { 1690 invalidParams.Add(smithy.NewErrParamRequired("DeploymentApplicationConfigs")) 1691 } else if v.DeploymentApplicationConfigs != nil { 1692 if err := validateDeploymentApplicationConfigs(v.DeploymentApplicationConfigs); err != nil { 1693 invalidParams.AddNested("DeploymentApplicationConfigs", err.(smithy.InvalidParamsError)) 1694 } 1695 } 1696 if invalidParams.Len() > 0 { 1697 return invalidParams 1698 } else { 1699 return nil 1700 } 1701} 1702 1703func validateOpCreateFleetInput(v *CreateFleetInput) error { 1704 if v == nil { 1705 return nil 1706 } 1707 invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"} 1708 if v.Name == nil { 1709 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1710 } 1711 if invalidParams.Len() > 0 { 1712 return invalidParams 1713 } else { 1714 return nil 1715 } 1716} 1717 1718func validateOpCreateRobotApplicationInput(v *CreateRobotApplicationInput) error { 1719 if v == nil { 1720 return nil 1721 } 1722 invalidParams := smithy.InvalidParamsError{Context: "CreateRobotApplicationInput"} 1723 if v.Name == nil { 1724 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1725 } 1726 if v.Sources == nil { 1727 invalidParams.Add(smithy.NewErrParamRequired("Sources")) 1728 } 1729 if v.RobotSoftwareSuite == nil { 1730 invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite")) 1731 } 1732 if invalidParams.Len() > 0 { 1733 return invalidParams 1734 } else { 1735 return nil 1736 } 1737} 1738 1739func validateOpCreateRobotApplicationVersionInput(v *CreateRobotApplicationVersionInput) error { 1740 if v == nil { 1741 return nil 1742 } 1743 invalidParams := smithy.InvalidParamsError{Context: "CreateRobotApplicationVersionInput"} 1744 if v.Application == nil { 1745 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1746 } 1747 if invalidParams.Len() > 0 { 1748 return invalidParams 1749 } else { 1750 return nil 1751 } 1752} 1753 1754func validateOpCreateRobotInput(v *CreateRobotInput) error { 1755 if v == nil { 1756 return nil 1757 } 1758 invalidParams := smithy.InvalidParamsError{Context: "CreateRobotInput"} 1759 if v.Name == nil { 1760 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1761 } 1762 if len(v.Architecture) == 0 { 1763 invalidParams.Add(smithy.NewErrParamRequired("Architecture")) 1764 } 1765 if v.GreengrassGroupId == nil { 1766 invalidParams.Add(smithy.NewErrParamRequired("GreengrassGroupId")) 1767 } 1768 if invalidParams.Len() > 0 { 1769 return invalidParams 1770 } else { 1771 return nil 1772 } 1773} 1774 1775func validateOpCreateSimulationApplicationInput(v *CreateSimulationApplicationInput) error { 1776 if v == nil { 1777 return nil 1778 } 1779 invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationApplicationInput"} 1780 if v.Name == nil { 1781 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1782 } 1783 if v.Sources == nil { 1784 invalidParams.Add(smithy.NewErrParamRequired("Sources")) 1785 } 1786 if v.SimulationSoftwareSuite == nil { 1787 invalidParams.Add(smithy.NewErrParamRequired("SimulationSoftwareSuite")) 1788 } 1789 if v.RobotSoftwareSuite == nil { 1790 invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite")) 1791 } 1792 if invalidParams.Len() > 0 { 1793 return invalidParams 1794 } else { 1795 return nil 1796 } 1797} 1798 1799func validateOpCreateSimulationApplicationVersionInput(v *CreateSimulationApplicationVersionInput) error { 1800 if v == nil { 1801 return nil 1802 } 1803 invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationApplicationVersionInput"} 1804 if v.Application == nil { 1805 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1806 } 1807 if invalidParams.Len() > 0 { 1808 return invalidParams 1809 } else { 1810 return nil 1811 } 1812} 1813 1814func validateOpCreateSimulationJobInput(v *CreateSimulationJobInput) error { 1815 if v == nil { 1816 return nil 1817 } 1818 invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationJobInput"} 1819 if v.LoggingConfig != nil { 1820 if err := validateLoggingConfig(v.LoggingConfig); err != nil { 1821 invalidParams.AddNested("LoggingConfig", err.(smithy.InvalidParamsError)) 1822 } 1823 } 1824 if v.IamRole == nil { 1825 invalidParams.Add(smithy.NewErrParamRequired("IamRole")) 1826 } 1827 if v.RobotApplications != nil { 1828 if err := validateRobotApplicationConfigs(v.RobotApplications); err != nil { 1829 invalidParams.AddNested("RobotApplications", err.(smithy.InvalidParamsError)) 1830 } 1831 } 1832 if v.SimulationApplications != nil { 1833 if err := validateSimulationApplicationConfigs(v.SimulationApplications); err != nil { 1834 invalidParams.AddNested("SimulationApplications", err.(smithy.InvalidParamsError)) 1835 } 1836 } 1837 if v.DataSources != nil { 1838 if err := validateDataSourceConfigs(v.DataSources); err != nil { 1839 invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError)) 1840 } 1841 } 1842 if v.VpcConfig != nil { 1843 if err := validateVPCConfig(v.VpcConfig); err != nil { 1844 invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError)) 1845 } 1846 } 1847 if invalidParams.Len() > 0 { 1848 return invalidParams 1849 } else { 1850 return nil 1851 } 1852} 1853 1854func validateOpCreateWorldExportJobInput(v *CreateWorldExportJobInput) error { 1855 if v == nil { 1856 return nil 1857 } 1858 invalidParams := smithy.InvalidParamsError{Context: "CreateWorldExportJobInput"} 1859 if v.Worlds == nil { 1860 invalidParams.Add(smithy.NewErrParamRequired("Worlds")) 1861 } 1862 if v.OutputLocation == nil { 1863 invalidParams.Add(smithy.NewErrParamRequired("OutputLocation")) 1864 } 1865 if v.IamRole == nil { 1866 invalidParams.Add(smithy.NewErrParamRequired("IamRole")) 1867 } 1868 if invalidParams.Len() > 0 { 1869 return invalidParams 1870 } else { 1871 return nil 1872 } 1873} 1874 1875func validateOpCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput) error { 1876 if v == nil { 1877 return nil 1878 } 1879 invalidParams := smithy.InvalidParamsError{Context: "CreateWorldGenerationJobInput"} 1880 if v.Template == nil { 1881 invalidParams.Add(smithy.NewErrParamRequired("Template")) 1882 } 1883 if v.WorldCount == nil { 1884 invalidParams.Add(smithy.NewErrParamRequired("WorldCount")) 1885 } 1886 if invalidParams.Len() > 0 { 1887 return invalidParams 1888 } else { 1889 return nil 1890 } 1891} 1892 1893func validateOpCreateWorldTemplateInput(v *CreateWorldTemplateInput) error { 1894 if v == nil { 1895 return nil 1896 } 1897 invalidParams := smithy.InvalidParamsError{Context: "CreateWorldTemplateInput"} 1898 if v.TemplateLocation != nil { 1899 if err := validateTemplateLocation(v.TemplateLocation); err != nil { 1900 invalidParams.AddNested("TemplateLocation", err.(smithy.InvalidParamsError)) 1901 } 1902 } 1903 if invalidParams.Len() > 0 { 1904 return invalidParams 1905 } else { 1906 return nil 1907 } 1908} 1909 1910func validateOpDeleteFleetInput(v *DeleteFleetInput) error { 1911 if v == nil { 1912 return nil 1913 } 1914 invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"} 1915 if v.Fleet == nil { 1916 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 1917 } 1918 if invalidParams.Len() > 0 { 1919 return invalidParams 1920 } else { 1921 return nil 1922 } 1923} 1924 1925func validateOpDeleteRobotApplicationInput(v *DeleteRobotApplicationInput) error { 1926 if v == nil { 1927 return nil 1928 } 1929 invalidParams := smithy.InvalidParamsError{Context: "DeleteRobotApplicationInput"} 1930 if v.Application == nil { 1931 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1932 } 1933 if invalidParams.Len() > 0 { 1934 return invalidParams 1935 } else { 1936 return nil 1937 } 1938} 1939 1940func validateOpDeleteRobotInput(v *DeleteRobotInput) error { 1941 if v == nil { 1942 return nil 1943 } 1944 invalidParams := smithy.InvalidParamsError{Context: "DeleteRobotInput"} 1945 if v.Robot == nil { 1946 invalidParams.Add(smithy.NewErrParamRequired("Robot")) 1947 } 1948 if invalidParams.Len() > 0 { 1949 return invalidParams 1950 } else { 1951 return nil 1952 } 1953} 1954 1955func validateOpDeleteSimulationApplicationInput(v *DeleteSimulationApplicationInput) error { 1956 if v == nil { 1957 return nil 1958 } 1959 invalidParams := smithy.InvalidParamsError{Context: "DeleteSimulationApplicationInput"} 1960 if v.Application == nil { 1961 invalidParams.Add(smithy.NewErrParamRequired("Application")) 1962 } 1963 if invalidParams.Len() > 0 { 1964 return invalidParams 1965 } else { 1966 return nil 1967 } 1968} 1969 1970func validateOpDeleteWorldTemplateInput(v *DeleteWorldTemplateInput) error { 1971 if v == nil { 1972 return nil 1973 } 1974 invalidParams := smithy.InvalidParamsError{Context: "DeleteWorldTemplateInput"} 1975 if v.Template == nil { 1976 invalidParams.Add(smithy.NewErrParamRequired("Template")) 1977 } 1978 if invalidParams.Len() > 0 { 1979 return invalidParams 1980 } else { 1981 return nil 1982 } 1983} 1984 1985func validateOpDeregisterRobotInput(v *DeregisterRobotInput) error { 1986 if v == nil { 1987 return nil 1988 } 1989 invalidParams := smithy.InvalidParamsError{Context: "DeregisterRobotInput"} 1990 if v.Fleet == nil { 1991 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 1992 } 1993 if v.Robot == nil { 1994 invalidParams.Add(smithy.NewErrParamRequired("Robot")) 1995 } 1996 if invalidParams.Len() > 0 { 1997 return invalidParams 1998 } else { 1999 return nil 2000 } 2001} 2002 2003func validateOpDescribeDeploymentJobInput(v *DescribeDeploymentJobInput) error { 2004 if v == nil { 2005 return nil 2006 } 2007 invalidParams := smithy.InvalidParamsError{Context: "DescribeDeploymentJobInput"} 2008 if v.Job == nil { 2009 invalidParams.Add(smithy.NewErrParamRequired("Job")) 2010 } 2011 if invalidParams.Len() > 0 { 2012 return invalidParams 2013 } else { 2014 return nil 2015 } 2016} 2017 2018func validateOpDescribeFleetInput(v *DescribeFleetInput) error { 2019 if v == nil { 2020 return nil 2021 } 2022 invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetInput"} 2023 if v.Fleet == nil { 2024 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 2025 } 2026 if invalidParams.Len() > 0 { 2027 return invalidParams 2028 } else { 2029 return nil 2030 } 2031} 2032 2033func validateOpDescribeRobotApplicationInput(v *DescribeRobotApplicationInput) error { 2034 if v == nil { 2035 return nil 2036 } 2037 invalidParams := smithy.InvalidParamsError{Context: "DescribeRobotApplicationInput"} 2038 if v.Application == nil { 2039 invalidParams.Add(smithy.NewErrParamRequired("Application")) 2040 } 2041 if invalidParams.Len() > 0 { 2042 return invalidParams 2043 } else { 2044 return nil 2045 } 2046} 2047 2048func validateOpDescribeRobotInput(v *DescribeRobotInput) error { 2049 if v == nil { 2050 return nil 2051 } 2052 invalidParams := smithy.InvalidParamsError{Context: "DescribeRobotInput"} 2053 if v.Robot == nil { 2054 invalidParams.Add(smithy.NewErrParamRequired("Robot")) 2055 } 2056 if invalidParams.Len() > 0 { 2057 return invalidParams 2058 } else { 2059 return nil 2060 } 2061} 2062 2063func validateOpDescribeSimulationApplicationInput(v *DescribeSimulationApplicationInput) error { 2064 if v == nil { 2065 return nil 2066 } 2067 invalidParams := smithy.InvalidParamsError{Context: "DescribeSimulationApplicationInput"} 2068 if v.Application == nil { 2069 invalidParams.Add(smithy.NewErrParamRequired("Application")) 2070 } 2071 if invalidParams.Len() > 0 { 2072 return invalidParams 2073 } else { 2074 return nil 2075 } 2076} 2077 2078func validateOpDescribeSimulationJobBatchInput(v *DescribeSimulationJobBatchInput) error { 2079 if v == nil { 2080 return nil 2081 } 2082 invalidParams := smithy.InvalidParamsError{Context: "DescribeSimulationJobBatchInput"} 2083 if v.Batch == nil { 2084 invalidParams.Add(smithy.NewErrParamRequired("Batch")) 2085 } 2086 if invalidParams.Len() > 0 { 2087 return invalidParams 2088 } else { 2089 return nil 2090 } 2091} 2092 2093func validateOpDescribeSimulationJobInput(v *DescribeSimulationJobInput) error { 2094 if v == nil { 2095 return nil 2096 } 2097 invalidParams := smithy.InvalidParamsError{Context: "DescribeSimulationJobInput"} 2098 if v.Job == nil { 2099 invalidParams.Add(smithy.NewErrParamRequired("Job")) 2100 } 2101 if invalidParams.Len() > 0 { 2102 return invalidParams 2103 } else { 2104 return nil 2105 } 2106} 2107 2108func validateOpDescribeWorldExportJobInput(v *DescribeWorldExportJobInput) error { 2109 if v == nil { 2110 return nil 2111 } 2112 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorldExportJobInput"} 2113 if v.Job == nil { 2114 invalidParams.Add(smithy.NewErrParamRequired("Job")) 2115 } 2116 if invalidParams.Len() > 0 { 2117 return invalidParams 2118 } else { 2119 return nil 2120 } 2121} 2122 2123func validateOpDescribeWorldGenerationJobInput(v *DescribeWorldGenerationJobInput) error { 2124 if v == nil { 2125 return nil 2126 } 2127 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorldGenerationJobInput"} 2128 if v.Job == nil { 2129 invalidParams.Add(smithy.NewErrParamRequired("Job")) 2130 } 2131 if invalidParams.Len() > 0 { 2132 return invalidParams 2133 } else { 2134 return nil 2135 } 2136} 2137 2138func validateOpDescribeWorldInput(v *DescribeWorldInput) error { 2139 if v == nil { 2140 return nil 2141 } 2142 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorldInput"} 2143 if v.World == nil { 2144 invalidParams.Add(smithy.NewErrParamRequired("World")) 2145 } 2146 if invalidParams.Len() > 0 { 2147 return invalidParams 2148 } else { 2149 return nil 2150 } 2151} 2152 2153func validateOpDescribeWorldTemplateInput(v *DescribeWorldTemplateInput) error { 2154 if v == nil { 2155 return nil 2156 } 2157 invalidParams := smithy.InvalidParamsError{Context: "DescribeWorldTemplateInput"} 2158 if v.Template == nil { 2159 invalidParams.Add(smithy.NewErrParamRequired("Template")) 2160 } 2161 if invalidParams.Len() > 0 { 2162 return invalidParams 2163 } else { 2164 return nil 2165 } 2166} 2167 2168func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 2169 if v == nil { 2170 return nil 2171 } 2172 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 2173 if v.ResourceArn == nil { 2174 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2175 } 2176 if invalidParams.Len() > 0 { 2177 return invalidParams 2178 } else { 2179 return nil 2180 } 2181} 2182 2183func validateOpRegisterRobotInput(v *RegisterRobotInput) error { 2184 if v == nil { 2185 return nil 2186 } 2187 invalidParams := smithy.InvalidParamsError{Context: "RegisterRobotInput"} 2188 if v.Fleet == nil { 2189 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 2190 } 2191 if v.Robot == nil { 2192 invalidParams.Add(smithy.NewErrParamRequired("Robot")) 2193 } 2194 if invalidParams.Len() > 0 { 2195 return invalidParams 2196 } else { 2197 return nil 2198 } 2199} 2200 2201func validateOpRestartSimulationJobInput(v *RestartSimulationJobInput) error { 2202 if v == nil { 2203 return nil 2204 } 2205 invalidParams := smithy.InvalidParamsError{Context: "RestartSimulationJobInput"} 2206 if v.Job == nil { 2207 invalidParams.Add(smithy.NewErrParamRequired("Job")) 2208 } 2209 if invalidParams.Len() > 0 { 2210 return invalidParams 2211 } else { 2212 return nil 2213 } 2214} 2215 2216func validateOpStartSimulationJobBatchInput(v *StartSimulationJobBatchInput) error { 2217 if v == nil { 2218 return nil 2219 } 2220 invalidParams := smithy.InvalidParamsError{Context: "StartSimulationJobBatchInput"} 2221 if v.CreateSimulationJobRequests == nil { 2222 invalidParams.Add(smithy.NewErrParamRequired("CreateSimulationJobRequests")) 2223 } else if v.CreateSimulationJobRequests != nil { 2224 if err := validateCreateSimulationJobRequests(v.CreateSimulationJobRequests); err != nil { 2225 invalidParams.AddNested("CreateSimulationJobRequests", err.(smithy.InvalidParamsError)) 2226 } 2227 } 2228 if invalidParams.Len() > 0 { 2229 return invalidParams 2230 } else { 2231 return nil 2232 } 2233} 2234 2235func validateOpSyncDeploymentJobInput(v *SyncDeploymentJobInput) error { 2236 if v == nil { 2237 return nil 2238 } 2239 invalidParams := smithy.InvalidParamsError{Context: "SyncDeploymentJobInput"} 2240 if v.ClientRequestToken == nil { 2241 invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken")) 2242 } 2243 if v.Fleet == nil { 2244 invalidParams.Add(smithy.NewErrParamRequired("Fleet")) 2245 } 2246 if invalidParams.Len() > 0 { 2247 return invalidParams 2248 } else { 2249 return nil 2250 } 2251} 2252 2253func validateOpTagResourceInput(v *TagResourceInput) error { 2254 if v == nil { 2255 return nil 2256 } 2257 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2258 if v.ResourceArn == nil { 2259 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2260 } 2261 if v.Tags == nil { 2262 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2263 } 2264 if invalidParams.Len() > 0 { 2265 return invalidParams 2266 } else { 2267 return nil 2268 } 2269} 2270 2271func validateOpUntagResourceInput(v *UntagResourceInput) error { 2272 if v == nil { 2273 return nil 2274 } 2275 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2276 if v.ResourceArn == nil { 2277 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2278 } 2279 if v.TagKeys == nil { 2280 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2281 } 2282 if invalidParams.Len() > 0 { 2283 return invalidParams 2284 } else { 2285 return nil 2286 } 2287} 2288 2289func validateOpUpdateRobotApplicationInput(v *UpdateRobotApplicationInput) error { 2290 if v == nil { 2291 return nil 2292 } 2293 invalidParams := smithy.InvalidParamsError{Context: "UpdateRobotApplicationInput"} 2294 if v.Application == nil { 2295 invalidParams.Add(smithy.NewErrParamRequired("Application")) 2296 } 2297 if v.Sources == nil { 2298 invalidParams.Add(smithy.NewErrParamRequired("Sources")) 2299 } 2300 if v.RobotSoftwareSuite == nil { 2301 invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite")) 2302 } 2303 if invalidParams.Len() > 0 { 2304 return invalidParams 2305 } else { 2306 return nil 2307 } 2308} 2309 2310func validateOpUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput) error { 2311 if v == nil { 2312 return nil 2313 } 2314 invalidParams := smithy.InvalidParamsError{Context: "UpdateSimulationApplicationInput"} 2315 if v.Application == nil { 2316 invalidParams.Add(smithy.NewErrParamRequired("Application")) 2317 } 2318 if v.Sources == nil { 2319 invalidParams.Add(smithy.NewErrParamRequired("Sources")) 2320 } 2321 if v.SimulationSoftwareSuite == nil { 2322 invalidParams.Add(smithy.NewErrParamRequired("SimulationSoftwareSuite")) 2323 } 2324 if v.RobotSoftwareSuite == nil { 2325 invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite")) 2326 } 2327 if invalidParams.Len() > 0 { 2328 return invalidParams 2329 } else { 2330 return nil 2331 } 2332} 2333 2334func validateOpUpdateWorldTemplateInput(v *UpdateWorldTemplateInput) error { 2335 if v == nil { 2336 return nil 2337 } 2338 invalidParams := smithy.InvalidParamsError{Context: "UpdateWorldTemplateInput"} 2339 if v.Template == nil { 2340 invalidParams.Add(smithy.NewErrParamRequired("Template")) 2341 } 2342 if v.TemplateLocation != nil { 2343 if err := validateTemplateLocation(v.TemplateLocation); err != nil { 2344 invalidParams.AddNested("TemplateLocation", err.(smithy.InvalidParamsError)) 2345 } 2346 } 2347 if invalidParams.Len() > 0 { 2348 return invalidParams 2349 } else { 2350 return nil 2351 } 2352} 2353