1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package codepipeline 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/codepipeline/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAcknowledgeJob struct { 14} 15 16func (*validateOpAcknowledgeJob) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAcknowledgeJob) 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.(*AcknowledgeJobInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAcknowledgeJobInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAcknowledgeThirdPartyJob struct { 34} 35 36func (*validateOpAcknowledgeThirdPartyJob) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAcknowledgeThirdPartyJob) 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.(*AcknowledgeThirdPartyJobInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAcknowledgeThirdPartyJobInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateCustomActionType struct { 54} 55 56func (*validateOpCreateCustomActionType) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateCustomActionType) 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.(*CreateCustomActionTypeInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateCustomActionTypeInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreatePipeline struct { 74} 75 76func (*validateOpCreatePipeline) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreatePipeline) 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.(*CreatePipelineInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreatePipelineInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteCustomActionType struct { 94} 95 96func (*validateOpDeleteCustomActionType) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteCustomActionType) 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.(*DeleteCustomActionTypeInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteCustomActionTypeInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeletePipeline struct { 114} 115 116func (*validateOpDeletePipeline) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeletePipeline) 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.(*DeletePipelineInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeletePipelineInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteWebhook struct { 134} 135 136func (*validateOpDeleteWebhook) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteWebhook) 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.(*DeleteWebhookInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteWebhookInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDisableStageTransition struct { 154} 155 156func (*validateOpDisableStageTransition) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDisableStageTransition) 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.(*DisableStageTransitionInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDisableStageTransitionInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpEnableStageTransition struct { 174} 175 176func (*validateOpEnableStageTransition) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpEnableStageTransition) 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.(*EnableStageTransitionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpEnableStageTransitionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpGetActionType struct { 194} 195 196func (*validateOpGetActionType) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpGetActionType) 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.(*GetActionTypeInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpGetActionTypeInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpGetJobDetails struct { 214} 215 216func (*validateOpGetJobDetails) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpGetJobDetails) 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.(*GetJobDetailsInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpGetJobDetailsInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetPipelineExecution struct { 234} 235 236func (*validateOpGetPipelineExecution) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetPipelineExecution) 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.(*GetPipelineExecutionInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetPipelineExecutionInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetPipeline struct { 254} 255 256func (*validateOpGetPipeline) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetPipeline) 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.(*GetPipelineInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetPipelineInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetPipelineState struct { 274} 275 276func (*validateOpGetPipelineState) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetPipelineState) 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.(*GetPipelineStateInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetPipelineStateInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpGetThirdPartyJobDetails struct { 294} 295 296func (*validateOpGetThirdPartyJobDetails) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpGetThirdPartyJobDetails) 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.(*GetThirdPartyJobDetailsInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpGetThirdPartyJobDetailsInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpListActionExecutions struct { 314} 315 316func (*validateOpListActionExecutions) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpListActionExecutions) 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.(*ListActionExecutionsInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpListActionExecutionsInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpListPipelineExecutions struct { 334} 335 336func (*validateOpListPipelineExecutions) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpListPipelineExecutions) 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.(*ListPipelineExecutionsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpListPipelineExecutionsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpListTagsForResource struct { 354} 355 356func (*validateOpListTagsForResource) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpListTagsForResourceInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpPollForJobs struct { 374} 375 376func (*validateOpPollForJobs) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpPollForJobs) 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.(*PollForJobsInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpPollForJobsInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpPollForThirdPartyJobs struct { 394} 395 396func (*validateOpPollForThirdPartyJobs) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpPollForThirdPartyJobs) 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.(*PollForThirdPartyJobsInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpPollForThirdPartyJobsInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpPutActionRevision struct { 414} 415 416func (*validateOpPutActionRevision) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpPutActionRevision) 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.(*PutActionRevisionInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpPutActionRevisionInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpPutApprovalResult struct { 434} 435 436func (*validateOpPutApprovalResult) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpPutApprovalResult) 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.(*PutApprovalResultInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpPutApprovalResultInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpPutJobFailureResult struct { 454} 455 456func (*validateOpPutJobFailureResult) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpPutJobFailureResult) 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.(*PutJobFailureResultInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpPutJobFailureResultInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpPutJobSuccessResult struct { 474} 475 476func (*validateOpPutJobSuccessResult) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpPutJobSuccessResult) 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.(*PutJobSuccessResultInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpPutJobSuccessResultInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpPutThirdPartyJobFailureResult struct { 494} 495 496func (*validateOpPutThirdPartyJobFailureResult) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpPutThirdPartyJobFailureResult) 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.(*PutThirdPartyJobFailureResultInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpPutThirdPartyJobFailureResultInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpPutThirdPartyJobSuccessResult struct { 514} 515 516func (*validateOpPutThirdPartyJobSuccessResult) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpPutThirdPartyJobSuccessResult) 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.(*PutThirdPartyJobSuccessResultInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpPutThirdPartyJobSuccessResultInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpPutWebhook struct { 534} 535 536func (*validateOpPutWebhook) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpPutWebhook) 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.(*PutWebhookInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpPutWebhookInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpRetryStageExecution struct { 554} 555 556func (*validateOpRetryStageExecution) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpRetryStageExecution) 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.(*RetryStageExecutionInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpRetryStageExecutionInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpStartPipelineExecution struct { 574} 575 576func (*validateOpStartPipelineExecution) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpStartPipelineExecution) 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.(*StartPipelineExecutionInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpStartPipelineExecutionInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpStopPipelineExecution struct { 594} 595 596func (*validateOpStopPipelineExecution) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpStopPipelineExecution) 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.(*StopPipelineExecutionInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpStopPipelineExecutionInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpTagResource struct { 614} 615 616func (*validateOpTagResource) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpTagResource) 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.(*TagResourceInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpTagResourceInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpUntagResource struct { 634} 635 636func (*validateOpUntagResource) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpUntagResource) 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.(*UntagResourceInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpUntagResourceInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpUpdateActionType struct { 654} 655 656func (*validateOpUpdateActionType) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpUpdateActionType) 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.(*UpdateActionTypeInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpUpdateActionTypeInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpUpdatePipeline struct { 674} 675 676func (*validateOpUpdatePipeline) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpUpdatePipeline) 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.(*UpdatePipelineInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpUpdatePipelineInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693func addOpAcknowledgeJobValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpAcknowledgeJob{}, middleware.After) 695} 696 697func addOpAcknowledgeThirdPartyJobValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpAcknowledgeThirdPartyJob{}, middleware.After) 699} 700 701func addOpCreateCustomActionTypeValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpCreateCustomActionType{}, middleware.After) 703} 704 705func addOpCreatePipelineValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpCreatePipeline{}, middleware.After) 707} 708 709func addOpDeleteCustomActionTypeValidationMiddleware(stack *middleware.Stack) error { 710 return stack.Initialize.Add(&validateOpDeleteCustomActionType{}, middleware.After) 711} 712 713func addOpDeletePipelineValidationMiddleware(stack *middleware.Stack) error { 714 return stack.Initialize.Add(&validateOpDeletePipeline{}, middleware.After) 715} 716 717func addOpDeleteWebhookValidationMiddleware(stack *middleware.Stack) error { 718 return stack.Initialize.Add(&validateOpDeleteWebhook{}, middleware.After) 719} 720 721func addOpDisableStageTransitionValidationMiddleware(stack *middleware.Stack) error { 722 return stack.Initialize.Add(&validateOpDisableStageTransition{}, middleware.After) 723} 724 725func addOpEnableStageTransitionValidationMiddleware(stack *middleware.Stack) error { 726 return stack.Initialize.Add(&validateOpEnableStageTransition{}, middleware.After) 727} 728 729func addOpGetActionTypeValidationMiddleware(stack *middleware.Stack) error { 730 return stack.Initialize.Add(&validateOpGetActionType{}, middleware.After) 731} 732 733func addOpGetJobDetailsValidationMiddleware(stack *middleware.Stack) error { 734 return stack.Initialize.Add(&validateOpGetJobDetails{}, middleware.After) 735} 736 737func addOpGetPipelineExecutionValidationMiddleware(stack *middleware.Stack) error { 738 return stack.Initialize.Add(&validateOpGetPipelineExecution{}, middleware.After) 739} 740 741func addOpGetPipelineValidationMiddleware(stack *middleware.Stack) error { 742 return stack.Initialize.Add(&validateOpGetPipeline{}, middleware.After) 743} 744 745func addOpGetPipelineStateValidationMiddleware(stack *middleware.Stack) error { 746 return stack.Initialize.Add(&validateOpGetPipelineState{}, middleware.After) 747} 748 749func addOpGetThirdPartyJobDetailsValidationMiddleware(stack *middleware.Stack) error { 750 return stack.Initialize.Add(&validateOpGetThirdPartyJobDetails{}, middleware.After) 751} 752 753func addOpListActionExecutionsValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpListActionExecutions{}, middleware.After) 755} 756 757func addOpListPipelineExecutionsValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpListPipelineExecutions{}, middleware.After) 759} 760 761func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 763} 764 765func addOpPollForJobsValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpPollForJobs{}, middleware.After) 767} 768 769func addOpPollForThirdPartyJobsValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpPollForThirdPartyJobs{}, middleware.After) 771} 772 773func addOpPutActionRevisionValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpPutActionRevision{}, middleware.After) 775} 776 777func addOpPutApprovalResultValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpPutApprovalResult{}, middleware.After) 779} 780 781func addOpPutJobFailureResultValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpPutJobFailureResult{}, middleware.After) 783} 784 785func addOpPutJobSuccessResultValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpPutJobSuccessResult{}, middleware.After) 787} 788 789func addOpPutThirdPartyJobFailureResultValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpPutThirdPartyJobFailureResult{}, middleware.After) 791} 792 793func addOpPutThirdPartyJobSuccessResultValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpPutThirdPartyJobSuccessResult{}, middleware.After) 795} 796 797func addOpPutWebhookValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpPutWebhook{}, middleware.After) 799} 800 801func addOpRetryStageExecutionValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpRetryStageExecution{}, middleware.After) 803} 804 805func addOpStartPipelineExecutionValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpStartPipelineExecution{}, middleware.After) 807} 808 809func addOpStopPipelineExecutionValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpStopPipelineExecution{}, middleware.After) 811} 812 813func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 815} 816 817func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 819} 820 821func addOpUpdateActionTypeValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpUpdateActionType{}, middleware.After) 823} 824 825func addOpUpdatePipelineValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpUpdatePipeline{}, middleware.After) 827} 828 829func validateActionConfigurationProperty(v *types.ActionConfigurationProperty) error { 830 if v == nil { 831 return nil 832 } 833 invalidParams := smithy.InvalidParamsError{Context: "ActionConfigurationProperty"} 834 if v.Name == nil { 835 invalidParams.Add(smithy.NewErrParamRequired("Name")) 836 } 837 if invalidParams.Len() > 0 { 838 return invalidParams 839 } else { 840 return nil 841 } 842} 843 844func validateActionConfigurationPropertyList(v []types.ActionConfigurationProperty) error { 845 if v == nil { 846 return nil 847 } 848 invalidParams := smithy.InvalidParamsError{Context: "ActionConfigurationPropertyList"} 849 for i := range v { 850 if err := validateActionConfigurationProperty(&v[i]); err != nil { 851 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 852 } 853 } 854 if invalidParams.Len() > 0 { 855 return invalidParams 856 } else { 857 return nil 858 } 859} 860 861func validateActionDeclaration(v *types.ActionDeclaration) error { 862 if v == nil { 863 return nil 864 } 865 invalidParams := smithy.InvalidParamsError{Context: "ActionDeclaration"} 866 if v.Name == nil { 867 invalidParams.Add(smithy.NewErrParamRequired("Name")) 868 } 869 if v.ActionTypeId == nil { 870 invalidParams.Add(smithy.NewErrParamRequired("ActionTypeId")) 871 } else if v.ActionTypeId != nil { 872 if err := validateActionTypeId(v.ActionTypeId); err != nil { 873 invalidParams.AddNested("ActionTypeId", err.(smithy.InvalidParamsError)) 874 } 875 } 876 if v.OutputArtifacts != nil { 877 if err := validateOutputArtifactList(v.OutputArtifacts); err != nil { 878 invalidParams.AddNested("OutputArtifacts", err.(smithy.InvalidParamsError)) 879 } 880 } 881 if v.InputArtifacts != nil { 882 if err := validateInputArtifactList(v.InputArtifacts); err != nil { 883 invalidParams.AddNested("InputArtifacts", err.(smithy.InvalidParamsError)) 884 } 885 } 886 if invalidParams.Len() > 0 { 887 return invalidParams 888 } else { 889 return nil 890 } 891} 892 893func validateActionRevision(v *types.ActionRevision) error { 894 if v == nil { 895 return nil 896 } 897 invalidParams := smithy.InvalidParamsError{Context: "ActionRevision"} 898 if v.RevisionId == nil { 899 invalidParams.Add(smithy.NewErrParamRequired("RevisionId")) 900 } 901 if v.RevisionChangeId == nil { 902 invalidParams.Add(smithy.NewErrParamRequired("RevisionChangeId")) 903 } 904 if v.Created == nil { 905 invalidParams.Add(smithy.NewErrParamRequired("Created")) 906 } 907 if invalidParams.Len() > 0 { 908 return invalidParams 909 } else { 910 return nil 911 } 912} 913 914func validateActionTypeArtifactDetails(v *types.ActionTypeArtifactDetails) error { 915 if v == nil { 916 return nil 917 } 918 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeArtifactDetails"} 919 if invalidParams.Len() > 0 { 920 return invalidParams 921 } else { 922 return nil 923 } 924} 925 926func validateActionTypeDeclaration(v *types.ActionTypeDeclaration) error { 927 if v == nil { 928 return nil 929 } 930 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeDeclaration"} 931 if v.Executor == nil { 932 invalidParams.Add(smithy.NewErrParamRequired("Executor")) 933 } else if v.Executor != nil { 934 if err := validateActionTypeExecutor(v.Executor); err != nil { 935 invalidParams.AddNested("Executor", err.(smithy.InvalidParamsError)) 936 } 937 } 938 if v.Id == nil { 939 invalidParams.Add(smithy.NewErrParamRequired("Id")) 940 } else if v.Id != nil { 941 if err := validateActionTypeIdentifier(v.Id); err != nil { 942 invalidParams.AddNested("Id", err.(smithy.InvalidParamsError)) 943 } 944 } 945 if v.InputArtifactDetails == nil { 946 invalidParams.Add(smithy.NewErrParamRequired("InputArtifactDetails")) 947 } else if v.InputArtifactDetails != nil { 948 if err := validateActionTypeArtifactDetails(v.InputArtifactDetails); err != nil { 949 invalidParams.AddNested("InputArtifactDetails", err.(smithy.InvalidParamsError)) 950 } 951 } 952 if v.OutputArtifactDetails == nil { 953 invalidParams.Add(smithy.NewErrParamRequired("OutputArtifactDetails")) 954 } else if v.OutputArtifactDetails != nil { 955 if err := validateActionTypeArtifactDetails(v.OutputArtifactDetails); err != nil { 956 invalidParams.AddNested("OutputArtifactDetails", err.(smithy.InvalidParamsError)) 957 } 958 } 959 if v.Permissions != nil { 960 if err := validateActionTypePermissions(v.Permissions); err != nil { 961 invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError)) 962 } 963 } 964 if v.Properties != nil { 965 if err := validateActionTypeProperties(v.Properties); err != nil { 966 invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError)) 967 } 968 } 969 if invalidParams.Len() > 0 { 970 return invalidParams 971 } else { 972 return nil 973 } 974} 975 976func validateActionTypeExecutor(v *types.ActionTypeExecutor) error { 977 if v == nil { 978 return nil 979 } 980 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeExecutor"} 981 if v.Configuration == nil { 982 invalidParams.Add(smithy.NewErrParamRequired("Configuration")) 983 } else if v.Configuration != nil { 984 if err := validateExecutorConfiguration(v.Configuration); err != nil { 985 invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError)) 986 } 987 } 988 if len(v.Type) == 0 { 989 invalidParams.Add(smithy.NewErrParamRequired("Type")) 990 } 991 if invalidParams.Len() > 0 { 992 return invalidParams 993 } else { 994 return nil 995 } 996} 997 998func validateActionTypeId(v *types.ActionTypeId) error { 999 if v == nil { 1000 return nil 1001 } 1002 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeId"} 1003 if len(v.Category) == 0 { 1004 invalidParams.Add(smithy.NewErrParamRequired("Category")) 1005 } 1006 if len(v.Owner) == 0 { 1007 invalidParams.Add(smithy.NewErrParamRequired("Owner")) 1008 } 1009 if v.Provider == nil { 1010 invalidParams.Add(smithy.NewErrParamRequired("Provider")) 1011 } 1012 if v.Version == nil { 1013 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1014 } 1015 if invalidParams.Len() > 0 { 1016 return invalidParams 1017 } else { 1018 return nil 1019 } 1020} 1021 1022func validateActionTypeIdentifier(v *types.ActionTypeIdentifier) error { 1023 if v == nil { 1024 return nil 1025 } 1026 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeIdentifier"} 1027 if len(v.Category) == 0 { 1028 invalidParams.Add(smithy.NewErrParamRequired("Category")) 1029 } 1030 if v.Owner == nil { 1031 invalidParams.Add(smithy.NewErrParamRequired("Owner")) 1032 } 1033 if v.Provider == nil { 1034 invalidParams.Add(smithy.NewErrParamRequired("Provider")) 1035 } 1036 if v.Version == nil { 1037 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1038 } 1039 if invalidParams.Len() > 0 { 1040 return invalidParams 1041 } else { 1042 return nil 1043 } 1044} 1045 1046func validateActionTypePermissions(v *types.ActionTypePermissions) error { 1047 if v == nil { 1048 return nil 1049 } 1050 invalidParams := smithy.InvalidParamsError{Context: "ActionTypePermissions"} 1051 if v.AllowedAccounts == nil { 1052 invalidParams.Add(smithy.NewErrParamRequired("AllowedAccounts")) 1053 } 1054 if invalidParams.Len() > 0 { 1055 return invalidParams 1056 } else { 1057 return nil 1058 } 1059} 1060 1061func validateActionTypeProperties(v []types.ActionTypeProperty) error { 1062 if v == nil { 1063 return nil 1064 } 1065 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeProperties"} 1066 for i := range v { 1067 if err := validateActionTypeProperty(&v[i]); err != nil { 1068 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1069 } 1070 } 1071 if invalidParams.Len() > 0 { 1072 return invalidParams 1073 } else { 1074 return nil 1075 } 1076} 1077 1078func validateActionTypeProperty(v *types.ActionTypeProperty) error { 1079 if v == nil { 1080 return nil 1081 } 1082 invalidParams := smithy.InvalidParamsError{Context: "ActionTypeProperty"} 1083 if v.Name == nil { 1084 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1085 } 1086 if invalidParams.Len() > 0 { 1087 return invalidParams 1088 } else { 1089 return nil 1090 } 1091} 1092 1093func validateApprovalResult(v *types.ApprovalResult) error { 1094 if v == nil { 1095 return nil 1096 } 1097 invalidParams := smithy.InvalidParamsError{Context: "ApprovalResult"} 1098 if v.Summary == nil { 1099 invalidParams.Add(smithy.NewErrParamRequired("Summary")) 1100 } 1101 if len(v.Status) == 0 { 1102 invalidParams.Add(smithy.NewErrParamRequired("Status")) 1103 } 1104 if invalidParams.Len() > 0 { 1105 return invalidParams 1106 } else { 1107 return nil 1108 } 1109} 1110 1111func validateArtifactDetails(v *types.ArtifactDetails) error { 1112 if v == nil { 1113 return nil 1114 } 1115 invalidParams := smithy.InvalidParamsError{Context: "ArtifactDetails"} 1116 if invalidParams.Len() > 0 { 1117 return invalidParams 1118 } else { 1119 return nil 1120 } 1121} 1122 1123func validateArtifactStore(v *types.ArtifactStore) error { 1124 if v == nil { 1125 return nil 1126 } 1127 invalidParams := smithy.InvalidParamsError{Context: "ArtifactStore"} 1128 if len(v.Type) == 0 { 1129 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1130 } 1131 if v.Location == nil { 1132 invalidParams.Add(smithy.NewErrParamRequired("Location")) 1133 } 1134 if v.EncryptionKey != nil { 1135 if err := validateEncryptionKey(v.EncryptionKey); err != nil { 1136 invalidParams.AddNested("EncryptionKey", err.(smithy.InvalidParamsError)) 1137 } 1138 } 1139 if invalidParams.Len() > 0 { 1140 return invalidParams 1141 } else { 1142 return nil 1143 } 1144} 1145 1146func validateArtifactStoreMap(v map[string]types.ArtifactStore) error { 1147 if v == nil { 1148 return nil 1149 } 1150 invalidParams := smithy.InvalidParamsError{Context: "ArtifactStoreMap"} 1151 for key := range v { 1152 value := v[key] 1153 if err := validateArtifactStore(&value); err != nil { 1154 invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError)) 1155 } 1156 } 1157 if invalidParams.Len() > 0 { 1158 return invalidParams 1159 } else { 1160 return nil 1161 } 1162} 1163 1164func validateBlockerDeclaration(v *types.BlockerDeclaration) error { 1165 if v == nil { 1166 return nil 1167 } 1168 invalidParams := smithy.InvalidParamsError{Context: "BlockerDeclaration"} 1169 if v.Name == nil { 1170 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1171 } 1172 if len(v.Type) == 0 { 1173 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1174 } 1175 if invalidParams.Len() > 0 { 1176 return invalidParams 1177 } else { 1178 return nil 1179 } 1180} 1181 1182func validateCurrentRevision(v *types.CurrentRevision) error { 1183 if v == nil { 1184 return nil 1185 } 1186 invalidParams := smithy.InvalidParamsError{Context: "CurrentRevision"} 1187 if v.Revision == nil { 1188 invalidParams.Add(smithy.NewErrParamRequired("Revision")) 1189 } 1190 if v.ChangeIdentifier == nil { 1191 invalidParams.Add(smithy.NewErrParamRequired("ChangeIdentifier")) 1192 } 1193 if invalidParams.Len() > 0 { 1194 return invalidParams 1195 } else { 1196 return nil 1197 } 1198} 1199 1200func validateEncryptionKey(v *types.EncryptionKey) error { 1201 if v == nil { 1202 return nil 1203 } 1204 invalidParams := smithy.InvalidParamsError{Context: "EncryptionKey"} 1205 if v.Id == nil { 1206 invalidParams.Add(smithy.NewErrParamRequired("Id")) 1207 } 1208 if len(v.Type) == 0 { 1209 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1210 } 1211 if invalidParams.Len() > 0 { 1212 return invalidParams 1213 } else { 1214 return nil 1215 } 1216} 1217 1218func validateExecutorConfiguration(v *types.ExecutorConfiguration) error { 1219 if v == nil { 1220 return nil 1221 } 1222 invalidParams := smithy.InvalidParamsError{Context: "ExecutorConfiguration"} 1223 if v.LambdaExecutorConfiguration != nil { 1224 if err := validateLambdaExecutorConfiguration(v.LambdaExecutorConfiguration); err != nil { 1225 invalidParams.AddNested("LambdaExecutorConfiguration", err.(smithy.InvalidParamsError)) 1226 } 1227 } 1228 if invalidParams.Len() > 0 { 1229 return invalidParams 1230 } else { 1231 return nil 1232 } 1233} 1234 1235func validateFailureDetails(v *types.FailureDetails) error { 1236 if v == nil { 1237 return nil 1238 } 1239 invalidParams := smithy.InvalidParamsError{Context: "FailureDetails"} 1240 if len(v.Type) == 0 { 1241 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1242 } 1243 if v.Message == nil { 1244 invalidParams.Add(smithy.NewErrParamRequired("Message")) 1245 } 1246 if invalidParams.Len() > 0 { 1247 return invalidParams 1248 } else { 1249 return nil 1250 } 1251} 1252 1253func validateInputArtifact(v *types.InputArtifact) error { 1254 if v == nil { 1255 return nil 1256 } 1257 invalidParams := smithy.InvalidParamsError{Context: "InputArtifact"} 1258 if v.Name == nil { 1259 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1260 } 1261 if invalidParams.Len() > 0 { 1262 return invalidParams 1263 } else { 1264 return nil 1265 } 1266} 1267 1268func validateInputArtifactList(v []types.InputArtifact) error { 1269 if v == nil { 1270 return nil 1271 } 1272 invalidParams := smithy.InvalidParamsError{Context: "InputArtifactList"} 1273 for i := range v { 1274 if err := validateInputArtifact(&v[i]); err != nil { 1275 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1276 } 1277 } 1278 if invalidParams.Len() > 0 { 1279 return invalidParams 1280 } else { 1281 return nil 1282 } 1283} 1284 1285func validateLambdaExecutorConfiguration(v *types.LambdaExecutorConfiguration) error { 1286 if v == nil { 1287 return nil 1288 } 1289 invalidParams := smithy.InvalidParamsError{Context: "LambdaExecutorConfiguration"} 1290 if v.LambdaFunctionArn == nil { 1291 invalidParams.Add(smithy.NewErrParamRequired("LambdaFunctionArn")) 1292 } 1293 if invalidParams.Len() > 0 { 1294 return invalidParams 1295 } else { 1296 return nil 1297 } 1298} 1299 1300func validateOutputArtifact(v *types.OutputArtifact) error { 1301 if v == nil { 1302 return nil 1303 } 1304 invalidParams := smithy.InvalidParamsError{Context: "OutputArtifact"} 1305 if v.Name == nil { 1306 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1307 } 1308 if invalidParams.Len() > 0 { 1309 return invalidParams 1310 } else { 1311 return nil 1312 } 1313} 1314 1315func validateOutputArtifactList(v []types.OutputArtifact) error { 1316 if v == nil { 1317 return nil 1318 } 1319 invalidParams := smithy.InvalidParamsError{Context: "OutputArtifactList"} 1320 for i := range v { 1321 if err := validateOutputArtifact(&v[i]); err != nil { 1322 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1323 } 1324 } 1325 if invalidParams.Len() > 0 { 1326 return invalidParams 1327 } else { 1328 return nil 1329 } 1330} 1331 1332func validatePipelineDeclaration(v *types.PipelineDeclaration) error { 1333 if v == nil { 1334 return nil 1335 } 1336 invalidParams := smithy.InvalidParamsError{Context: "PipelineDeclaration"} 1337 if v.Name == nil { 1338 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1339 } 1340 if v.RoleArn == nil { 1341 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1342 } 1343 if v.ArtifactStore != nil { 1344 if err := validateArtifactStore(v.ArtifactStore); err != nil { 1345 invalidParams.AddNested("ArtifactStore", err.(smithy.InvalidParamsError)) 1346 } 1347 } 1348 if v.ArtifactStores != nil { 1349 if err := validateArtifactStoreMap(v.ArtifactStores); err != nil { 1350 invalidParams.AddNested("ArtifactStores", err.(smithy.InvalidParamsError)) 1351 } 1352 } 1353 if v.Stages == nil { 1354 invalidParams.Add(smithy.NewErrParamRequired("Stages")) 1355 } else if v.Stages != nil { 1356 if err := validatePipelineStageDeclarationList(v.Stages); err != nil { 1357 invalidParams.AddNested("Stages", err.(smithy.InvalidParamsError)) 1358 } 1359 } 1360 if invalidParams.Len() > 0 { 1361 return invalidParams 1362 } else { 1363 return nil 1364 } 1365} 1366 1367func validatePipelineStageDeclarationList(v []types.StageDeclaration) error { 1368 if v == nil { 1369 return nil 1370 } 1371 invalidParams := smithy.InvalidParamsError{Context: "PipelineStageDeclarationList"} 1372 for i := range v { 1373 if err := validateStageDeclaration(&v[i]); err != nil { 1374 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1375 } 1376 } 1377 if invalidParams.Len() > 0 { 1378 return invalidParams 1379 } else { 1380 return nil 1381 } 1382} 1383 1384func validateStageActionDeclarationList(v []types.ActionDeclaration) error { 1385 if v == nil { 1386 return nil 1387 } 1388 invalidParams := smithy.InvalidParamsError{Context: "StageActionDeclarationList"} 1389 for i := range v { 1390 if err := validateActionDeclaration(&v[i]); err != nil { 1391 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1392 } 1393 } 1394 if invalidParams.Len() > 0 { 1395 return invalidParams 1396 } else { 1397 return nil 1398 } 1399} 1400 1401func validateStageBlockerDeclarationList(v []types.BlockerDeclaration) error { 1402 if v == nil { 1403 return nil 1404 } 1405 invalidParams := smithy.InvalidParamsError{Context: "StageBlockerDeclarationList"} 1406 for i := range v { 1407 if err := validateBlockerDeclaration(&v[i]); err != nil { 1408 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1409 } 1410 } 1411 if invalidParams.Len() > 0 { 1412 return invalidParams 1413 } else { 1414 return nil 1415 } 1416} 1417 1418func validateStageDeclaration(v *types.StageDeclaration) error { 1419 if v == nil { 1420 return nil 1421 } 1422 invalidParams := smithy.InvalidParamsError{Context: "StageDeclaration"} 1423 if v.Name == nil { 1424 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1425 } 1426 if v.Blockers != nil { 1427 if err := validateStageBlockerDeclarationList(v.Blockers); err != nil { 1428 invalidParams.AddNested("Blockers", err.(smithy.InvalidParamsError)) 1429 } 1430 } 1431 if v.Actions == nil { 1432 invalidParams.Add(smithy.NewErrParamRequired("Actions")) 1433 } else if v.Actions != nil { 1434 if err := validateStageActionDeclarationList(v.Actions); err != nil { 1435 invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError)) 1436 } 1437 } 1438 if invalidParams.Len() > 0 { 1439 return invalidParams 1440 } else { 1441 return nil 1442 } 1443} 1444 1445func validateTag(v *types.Tag) error { 1446 if v == nil { 1447 return nil 1448 } 1449 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 1450 if v.Key == nil { 1451 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1452 } 1453 if v.Value == nil { 1454 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1455 } 1456 if invalidParams.Len() > 0 { 1457 return invalidParams 1458 } else { 1459 return nil 1460 } 1461} 1462 1463func validateTagList(v []types.Tag) error { 1464 if v == nil { 1465 return nil 1466 } 1467 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 1468 for i := range v { 1469 if err := validateTag(&v[i]); err != nil { 1470 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1471 } 1472 } 1473 if invalidParams.Len() > 0 { 1474 return invalidParams 1475 } else { 1476 return nil 1477 } 1478} 1479 1480func validateWebhookDefinition(v *types.WebhookDefinition) error { 1481 if v == nil { 1482 return nil 1483 } 1484 invalidParams := smithy.InvalidParamsError{Context: "WebhookDefinition"} 1485 if v.Name == nil { 1486 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1487 } 1488 if v.TargetPipeline == nil { 1489 invalidParams.Add(smithy.NewErrParamRequired("TargetPipeline")) 1490 } 1491 if v.TargetAction == nil { 1492 invalidParams.Add(smithy.NewErrParamRequired("TargetAction")) 1493 } 1494 if v.Filters == nil { 1495 invalidParams.Add(smithy.NewErrParamRequired("Filters")) 1496 } else if v.Filters != nil { 1497 if err := validateWebhookFilters(v.Filters); err != nil { 1498 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 1499 } 1500 } 1501 if len(v.Authentication) == 0 { 1502 invalidParams.Add(smithy.NewErrParamRequired("Authentication")) 1503 } 1504 if v.AuthenticationConfiguration == nil { 1505 invalidParams.Add(smithy.NewErrParamRequired("AuthenticationConfiguration")) 1506 } 1507 if invalidParams.Len() > 0 { 1508 return invalidParams 1509 } else { 1510 return nil 1511 } 1512} 1513 1514func validateWebhookFilterRule(v *types.WebhookFilterRule) error { 1515 if v == nil { 1516 return nil 1517 } 1518 invalidParams := smithy.InvalidParamsError{Context: "WebhookFilterRule"} 1519 if v.JsonPath == nil { 1520 invalidParams.Add(smithy.NewErrParamRequired("JsonPath")) 1521 } 1522 if invalidParams.Len() > 0 { 1523 return invalidParams 1524 } else { 1525 return nil 1526 } 1527} 1528 1529func validateWebhookFilters(v []types.WebhookFilterRule) error { 1530 if v == nil { 1531 return nil 1532 } 1533 invalidParams := smithy.InvalidParamsError{Context: "WebhookFilters"} 1534 for i := range v { 1535 if err := validateWebhookFilterRule(&v[i]); err != nil { 1536 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1537 } 1538 } 1539 if invalidParams.Len() > 0 { 1540 return invalidParams 1541 } else { 1542 return nil 1543 } 1544} 1545 1546func validateOpAcknowledgeJobInput(v *AcknowledgeJobInput) error { 1547 if v == nil { 1548 return nil 1549 } 1550 invalidParams := smithy.InvalidParamsError{Context: "AcknowledgeJobInput"} 1551 if v.JobId == nil { 1552 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1553 } 1554 if v.Nonce == nil { 1555 invalidParams.Add(smithy.NewErrParamRequired("Nonce")) 1556 } 1557 if invalidParams.Len() > 0 { 1558 return invalidParams 1559 } else { 1560 return nil 1561 } 1562} 1563 1564func validateOpAcknowledgeThirdPartyJobInput(v *AcknowledgeThirdPartyJobInput) error { 1565 if v == nil { 1566 return nil 1567 } 1568 invalidParams := smithy.InvalidParamsError{Context: "AcknowledgeThirdPartyJobInput"} 1569 if v.JobId == nil { 1570 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1571 } 1572 if v.Nonce == nil { 1573 invalidParams.Add(smithy.NewErrParamRequired("Nonce")) 1574 } 1575 if v.ClientToken == nil { 1576 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 1577 } 1578 if invalidParams.Len() > 0 { 1579 return invalidParams 1580 } else { 1581 return nil 1582 } 1583} 1584 1585func validateOpCreateCustomActionTypeInput(v *CreateCustomActionTypeInput) error { 1586 if v == nil { 1587 return nil 1588 } 1589 invalidParams := smithy.InvalidParamsError{Context: "CreateCustomActionTypeInput"} 1590 if len(v.Category) == 0 { 1591 invalidParams.Add(smithy.NewErrParamRequired("Category")) 1592 } 1593 if v.Provider == nil { 1594 invalidParams.Add(smithy.NewErrParamRequired("Provider")) 1595 } 1596 if v.Version == nil { 1597 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1598 } 1599 if v.ConfigurationProperties != nil { 1600 if err := validateActionConfigurationPropertyList(v.ConfigurationProperties); err != nil { 1601 invalidParams.AddNested("ConfigurationProperties", err.(smithy.InvalidParamsError)) 1602 } 1603 } 1604 if v.InputArtifactDetails == nil { 1605 invalidParams.Add(smithy.NewErrParamRequired("InputArtifactDetails")) 1606 } else if v.InputArtifactDetails != nil { 1607 if err := validateArtifactDetails(v.InputArtifactDetails); err != nil { 1608 invalidParams.AddNested("InputArtifactDetails", err.(smithy.InvalidParamsError)) 1609 } 1610 } 1611 if v.OutputArtifactDetails == nil { 1612 invalidParams.Add(smithy.NewErrParamRequired("OutputArtifactDetails")) 1613 } else if v.OutputArtifactDetails != nil { 1614 if err := validateArtifactDetails(v.OutputArtifactDetails); err != nil { 1615 invalidParams.AddNested("OutputArtifactDetails", err.(smithy.InvalidParamsError)) 1616 } 1617 } 1618 if v.Tags != nil { 1619 if err := validateTagList(v.Tags); err != nil { 1620 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1621 } 1622 } 1623 if invalidParams.Len() > 0 { 1624 return invalidParams 1625 } else { 1626 return nil 1627 } 1628} 1629 1630func validateOpCreatePipelineInput(v *CreatePipelineInput) error { 1631 if v == nil { 1632 return nil 1633 } 1634 invalidParams := smithy.InvalidParamsError{Context: "CreatePipelineInput"} 1635 if v.Pipeline == nil { 1636 invalidParams.Add(smithy.NewErrParamRequired("Pipeline")) 1637 } else if v.Pipeline != nil { 1638 if err := validatePipelineDeclaration(v.Pipeline); err != nil { 1639 invalidParams.AddNested("Pipeline", err.(smithy.InvalidParamsError)) 1640 } 1641 } 1642 if v.Tags != nil { 1643 if err := validateTagList(v.Tags); err != nil { 1644 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1645 } 1646 } 1647 if invalidParams.Len() > 0 { 1648 return invalidParams 1649 } else { 1650 return nil 1651 } 1652} 1653 1654func validateOpDeleteCustomActionTypeInput(v *DeleteCustomActionTypeInput) error { 1655 if v == nil { 1656 return nil 1657 } 1658 invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomActionTypeInput"} 1659 if len(v.Category) == 0 { 1660 invalidParams.Add(smithy.NewErrParamRequired("Category")) 1661 } 1662 if v.Provider == nil { 1663 invalidParams.Add(smithy.NewErrParamRequired("Provider")) 1664 } 1665 if v.Version == nil { 1666 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1667 } 1668 if invalidParams.Len() > 0 { 1669 return invalidParams 1670 } else { 1671 return nil 1672 } 1673} 1674 1675func validateOpDeletePipelineInput(v *DeletePipelineInput) error { 1676 if v == nil { 1677 return nil 1678 } 1679 invalidParams := smithy.InvalidParamsError{Context: "DeletePipelineInput"} 1680 if v.Name == nil { 1681 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1682 } 1683 if invalidParams.Len() > 0 { 1684 return invalidParams 1685 } else { 1686 return nil 1687 } 1688} 1689 1690func validateOpDeleteWebhookInput(v *DeleteWebhookInput) error { 1691 if v == nil { 1692 return nil 1693 } 1694 invalidParams := smithy.InvalidParamsError{Context: "DeleteWebhookInput"} 1695 if v.Name == nil { 1696 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1697 } 1698 if invalidParams.Len() > 0 { 1699 return invalidParams 1700 } else { 1701 return nil 1702 } 1703} 1704 1705func validateOpDisableStageTransitionInput(v *DisableStageTransitionInput) error { 1706 if v == nil { 1707 return nil 1708 } 1709 invalidParams := smithy.InvalidParamsError{Context: "DisableStageTransitionInput"} 1710 if v.PipelineName == nil { 1711 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1712 } 1713 if v.StageName == nil { 1714 invalidParams.Add(smithy.NewErrParamRequired("StageName")) 1715 } 1716 if len(v.TransitionType) == 0 { 1717 invalidParams.Add(smithy.NewErrParamRequired("TransitionType")) 1718 } 1719 if v.Reason == nil { 1720 invalidParams.Add(smithy.NewErrParamRequired("Reason")) 1721 } 1722 if invalidParams.Len() > 0 { 1723 return invalidParams 1724 } else { 1725 return nil 1726 } 1727} 1728 1729func validateOpEnableStageTransitionInput(v *EnableStageTransitionInput) error { 1730 if v == nil { 1731 return nil 1732 } 1733 invalidParams := smithy.InvalidParamsError{Context: "EnableStageTransitionInput"} 1734 if v.PipelineName == nil { 1735 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1736 } 1737 if v.StageName == nil { 1738 invalidParams.Add(smithy.NewErrParamRequired("StageName")) 1739 } 1740 if len(v.TransitionType) == 0 { 1741 invalidParams.Add(smithy.NewErrParamRequired("TransitionType")) 1742 } 1743 if invalidParams.Len() > 0 { 1744 return invalidParams 1745 } else { 1746 return nil 1747 } 1748} 1749 1750func validateOpGetActionTypeInput(v *GetActionTypeInput) error { 1751 if v == nil { 1752 return nil 1753 } 1754 invalidParams := smithy.InvalidParamsError{Context: "GetActionTypeInput"} 1755 if len(v.Category) == 0 { 1756 invalidParams.Add(smithy.NewErrParamRequired("Category")) 1757 } 1758 if v.Owner == nil { 1759 invalidParams.Add(smithy.NewErrParamRequired("Owner")) 1760 } 1761 if v.Provider == nil { 1762 invalidParams.Add(smithy.NewErrParamRequired("Provider")) 1763 } 1764 if v.Version == nil { 1765 invalidParams.Add(smithy.NewErrParamRequired("Version")) 1766 } 1767 if invalidParams.Len() > 0 { 1768 return invalidParams 1769 } else { 1770 return nil 1771 } 1772} 1773 1774func validateOpGetJobDetailsInput(v *GetJobDetailsInput) error { 1775 if v == nil { 1776 return nil 1777 } 1778 invalidParams := smithy.InvalidParamsError{Context: "GetJobDetailsInput"} 1779 if v.JobId == nil { 1780 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1781 } 1782 if invalidParams.Len() > 0 { 1783 return invalidParams 1784 } else { 1785 return nil 1786 } 1787} 1788 1789func validateOpGetPipelineExecutionInput(v *GetPipelineExecutionInput) error { 1790 if v == nil { 1791 return nil 1792 } 1793 invalidParams := smithy.InvalidParamsError{Context: "GetPipelineExecutionInput"} 1794 if v.PipelineName == nil { 1795 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1796 } 1797 if v.PipelineExecutionId == nil { 1798 invalidParams.Add(smithy.NewErrParamRequired("PipelineExecutionId")) 1799 } 1800 if invalidParams.Len() > 0 { 1801 return invalidParams 1802 } else { 1803 return nil 1804 } 1805} 1806 1807func validateOpGetPipelineInput(v *GetPipelineInput) error { 1808 if v == nil { 1809 return nil 1810 } 1811 invalidParams := smithy.InvalidParamsError{Context: "GetPipelineInput"} 1812 if v.Name == nil { 1813 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1814 } 1815 if invalidParams.Len() > 0 { 1816 return invalidParams 1817 } else { 1818 return nil 1819 } 1820} 1821 1822func validateOpGetPipelineStateInput(v *GetPipelineStateInput) error { 1823 if v == nil { 1824 return nil 1825 } 1826 invalidParams := smithy.InvalidParamsError{Context: "GetPipelineStateInput"} 1827 if v.Name == nil { 1828 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1829 } 1830 if invalidParams.Len() > 0 { 1831 return invalidParams 1832 } else { 1833 return nil 1834 } 1835} 1836 1837func validateOpGetThirdPartyJobDetailsInput(v *GetThirdPartyJobDetailsInput) error { 1838 if v == nil { 1839 return nil 1840 } 1841 invalidParams := smithy.InvalidParamsError{Context: "GetThirdPartyJobDetailsInput"} 1842 if v.JobId == nil { 1843 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1844 } 1845 if v.ClientToken == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 1847 } 1848 if invalidParams.Len() > 0 { 1849 return invalidParams 1850 } else { 1851 return nil 1852 } 1853} 1854 1855func validateOpListActionExecutionsInput(v *ListActionExecutionsInput) error { 1856 if v == nil { 1857 return nil 1858 } 1859 invalidParams := smithy.InvalidParamsError{Context: "ListActionExecutionsInput"} 1860 if v.PipelineName == nil { 1861 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1862 } 1863 if invalidParams.Len() > 0 { 1864 return invalidParams 1865 } else { 1866 return nil 1867 } 1868} 1869 1870func validateOpListPipelineExecutionsInput(v *ListPipelineExecutionsInput) error { 1871 if v == nil { 1872 return nil 1873 } 1874 invalidParams := smithy.InvalidParamsError{Context: "ListPipelineExecutionsInput"} 1875 if v.PipelineName == nil { 1876 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1877 } 1878 if invalidParams.Len() > 0 { 1879 return invalidParams 1880 } else { 1881 return nil 1882 } 1883} 1884 1885func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1886 if v == nil { 1887 return nil 1888 } 1889 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1890 if v.ResourceArn == nil { 1891 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1892 } 1893 if invalidParams.Len() > 0 { 1894 return invalidParams 1895 } else { 1896 return nil 1897 } 1898} 1899 1900func validateOpPollForJobsInput(v *PollForJobsInput) error { 1901 if v == nil { 1902 return nil 1903 } 1904 invalidParams := smithy.InvalidParamsError{Context: "PollForJobsInput"} 1905 if v.ActionTypeId == nil { 1906 invalidParams.Add(smithy.NewErrParamRequired("ActionTypeId")) 1907 } else if v.ActionTypeId != nil { 1908 if err := validateActionTypeId(v.ActionTypeId); err != nil { 1909 invalidParams.AddNested("ActionTypeId", err.(smithy.InvalidParamsError)) 1910 } 1911 } 1912 if invalidParams.Len() > 0 { 1913 return invalidParams 1914 } else { 1915 return nil 1916 } 1917} 1918 1919func validateOpPollForThirdPartyJobsInput(v *PollForThirdPartyJobsInput) error { 1920 if v == nil { 1921 return nil 1922 } 1923 invalidParams := smithy.InvalidParamsError{Context: "PollForThirdPartyJobsInput"} 1924 if v.ActionTypeId == nil { 1925 invalidParams.Add(smithy.NewErrParamRequired("ActionTypeId")) 1926 } else if v.ActionTypeId != nil { 1927 if err := validateActionTypeId(v.ActionTypeId); err != nil { 1928 invalidParams.AddNested("ActionTypeId", err.(smithy.InvalidParamsError)) 1929 } 1930 } 1931 if invalidParams.Len() > 0 { 1932 return invalidParams 1933 } else { 1934 return nil 1935 } 1936} 1937 1938func validateOpPutActionRevisionInput(v *PutActionRevisionInput) error { 1939 if v == nil { 1940 return nil 1941 } 1942 invalidParams := smithy.InvalidParamsError{Context: "PutActionRevisionInput"} 1943 if v.PipelineName == nil { 1944 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1945 } 1946 if v.StageName == nil { 1947 invalidParams.Add(smithy.NewErrParamRequired("StageName")) 1948 } 1949 if v.ActionName == nil { 1950 invalidParams.Add(smithy.NewErrParamRequired("ActionName")) 1951 } 1952 if v.ActionRevision == nil { 1953 invalidParams.Add(smithy.NewErrParamRequired("ActionRevision")) 1954 } else if v.ActionRevision != nil { 1955 if err := validateActionRevision(v.ActionRevision); err != nil { 1956 invalidParams.AddNested("ActionRevision", err.(smithy.InvalidParamsError)) 1957 } 1958 } 1959 if invalidParams.Len() > 0 { 1960 return invalidParams 1961 } else { 1962 return nil 1963 } 1964} 1965 1966func validateOpPutApprovalResultInput(v *PutApprovalResultInput) error { 1967 if v == nil { 1968 return nil 1969 } 1970 invalidParams := smithy.InvalidParamsError{Context: "PutApprovalResultInput"} 1971 if v.PipelineName == nil { 1972 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 1973 } 1974 if v.StageName == nil { 1975 invalidParams.Add(smithy.NewErrParamRequired("StageName")) 1976 } 1977 if v.ActionName == nil { 1978 invalidParams.Add(smithy.NewErrParamRequired("ActionName")) 1979 } 1980 if v.Result == nil { 1981 invalidParams.Add(smithy.NewErrParamRequired("Result")) 1982 } else if v.Result != nil { 1983 if err := validateApprovalResult(v.Result); err != nil { 1984 invalidParams.AddNested("Result", err.(smithy.InvalidParamsError)) 1985 } 1986 } 1987 if v.Token == nil { 1988 invalidParams.Add(smithy.NewErrParamRequired("Token")) 1989 } 1990 if invalidParams.Len() > 0 { 1991 return invalidParams 1992 } else { 1993 return nil 1994 } 1995} 1996 1997func validateOpPutJobFailureResultInput(v *PutJobFailureResultInput) error { 1998 if v == nil { 1999 return nil 2000 } 2001 invalidParams := smithy.InvalidParamsError{Context: "PutJobFailureResultInput"} 2002 if v.JobId == nil { 2003 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 2004 } 2005 if v.FailureDetails == nil { 2006 invalidParams.Add(smithy.NewErrParamRequired("FailureDetails")) 2007 } else if v.FailureDetails != nil { 2008 if err := validateFailureDetails(v.FailureDetails); err != nil { 2009 invalidParams.AddNested("FailureDetails", err.(smithy.InvalidParamsError)) 2010 } 2011 } 2012 if invalidParams.Len() > 0 { 2013 return invalidParams 2014 } else { 2015 return nil 2016 } 2017} 2018 2019func validateOpPutJobSuccessResultInput(v *PutJobSuccessResultInput) error { 2020 if v == nil { 2021 return nil 2022 } 2023 invalidParams := smithy.InvalidParamsError{Context: "PutJobSuccessResultInput"} 2024 if v.JobId == nil { 2025 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 2026 } 2027 if v.CurrentRevision != nil { 2028 if err := validateCurrentRevision(v.CurrentRevision); err != nil { 2029 invalidParams.AddNested("CurrentRevision", err.(smithy.InvalidParamsError)) 2030 } 2031 } 2032 if invalidParams.Len() > 0 { 2033 return invalidParams 2034 } else { 2035 return nil 2036 } 2037} 2038 2039func validateOpPutThirdPartyJobFailureResultInput(v *PutThirdPartyJobFailureResultInput) error { 2040 if v == nil { 2041 return nil 2042 } 2043 invalidParams := smithy.InvalidParamsError{Context: "PutThirdPartyJobFailureResultInput"} 2044 if v.JobId == nil { 2045 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 2046 } 2047 if v.ClientToken == nil { 2048 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 2049 } 2050 if v.FailureDetails == nil { 2051 invalidParams.Add(smithy.NewErrParamRequired("FailureDetails")) 2052 } else if v.FailureDetails != nil { 2053 if err := validateFailureDetails(v.FailureDetails); err != nil { 2054 invalidParams.AddNested("FailureDetails", err.(smithy.InvalidParamsError)) 2055 } 2056 } 2057 if invalidParams.Len() > 0 { 2058 return invalidParams 2059 } else { 2060 return nil 2061 } 2062} 2063 2064func validateOpPutThirdPartyJobSuccessResultInput(v *PutThirdPartyJobSuccessResultInput) error { 2065 if v == nil { 2066 return nil 2067 } 2068 invalidParams := smithy.InvalidParamsError{Context: "PutThirdPartyJobSuccessResultInput"} 2069 if v.JobId == nil { 2070 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 2071 } 2072 if v.ClientToken == nil { 2073 invalidParams.Add(smithy.NewErrParamRequired("ClientToken")) 2074 } 2075 if v.CurrentRevision != nil { 2076 if err := validateCurrentRevision(v.CurrentRevision); err != nil { 2077 invalidParams.AddNested("CurrentRevision", err.(smithy.InvalidParamsError)) 2078 } 2079 } 2080 if invalidParams.Len() > 0 { 2081 return invalidParams 2082 } else { 2083 return nil 2084 } 2085} 2086 2087func validateOpPutWebhookInput(v *PutWebhookInput) error { 2088 if v == nil { 2089 return nil 2090 } 2091 invalidParams := smithy.InvalidParamsError{Context: "PutWebhookInput"} 2092 if v.Webhook == nil { 2093 invalidParams.Add(smithy.NewErrParamRequired("Webhook")) 2094 } else if v.Webhook != nil { 2095 if err := validateWebhookDefinition(v.Webhook); err != nil { 2096 invalidParams.AddNested("Webhook", err.(smithy.InvalidParamsError)) 2097 } 2098 } 2099 if v.Tags != nil { 2100 if err := validateTagList(v.Tags); err != nil { 2101 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2102 } 2103 } 2104 if invalidParams.Len() > 0 { 2105 return invalidParams 2106 } else { 2107 return nil 2108 } 2109} 2110 2111func validateOpRetryStageExecutionInput(v *RetryStageExecutionInput) error { 2112 if v == nil { 2113 return nil 2114 } 2115 invalidParams := smithy.InvalidParamsError{Context: "RetryStageExecutionInput"} 2116 if v.PipelineName == nil { 2117 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 2118 } 2119 if v.StageName == nil { 2120 invalidParams.Add(smithy.NewErrParamRequired("StageName")) 2121 } 2122 if v.PipelineExecutionId == nil { 2123 invalidParams.Add(smithy.NewErrParamRequired("PipelineExecutionId")) 2124 } 2125 if len(v.RetryMode) == 0 { 2126 invalidParams.Add(smithy.NewErrParamRequired("RetryMode")) 2127 } 2128 if invalidParams.Len() > 0 { 2129 return invalidParams 2130 } else { 2131 return nil 2132 } 2133} 2134 2135func validateOpStartPipelineExecutionInput(v *StartPipelineExecutionInput) error { 2136 if v == nil { 2137 return nil 2138 } 2139 invalidParams := smithy.InvalidParamsError{Context: "StartPipelineExecutionInput"} 2140 if v.Name == nil { 2141 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2142 } 2143 if invalidParams.Len() > 0 { 2144 return invalidParams 2145 } else { 2146 return nil 2147 } 2148} 2149 2150func validateOpStopPipelineExecutionInput(v *StopPipelineExecutionInput) error { 2151 if v == nil { 2152 return nil 2153 } 2154 invalidParams := smithy.InvalidParamsError{Context: "StopPipelineExecutionInput"} 2155 if v.PipelineName == nil { 2156 invalidParams.Add(smithy.NewErrParamRequired("PipelineName")) 2157 } 2158 if v.PipelineExecutionId == nil { 2159 invalidParams.Add(smithy.NewErrParamRequired("PipelineExecutionId")) 2160 } 2161 if invalidParams.Len() > 0 { 2162 return invalidParams 2163 } else { 2164 return nil 2165 } 2166} 2167 2168func validateOpTagResourceInput(v *TagResourceInput) error { 2169 if v == nil { 2170 return nil 2171 } 2172 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2173 if v.ResourceArn == nil { 2174 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2175 } 2176 if v.Tags == nil { 2177 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2178 } else if v.Tags != nil { 2179 if err := validateTagList(v.Tags); err != nil { 2180 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 2181 } 2182 } 2183 if invalidParams.Len() > 0 { 2184 return invalidParams 2185 } else { 2186 return nil 2187 } 2188} 2189 2190func validateOpUntagResourceInput(v *UntagResourceInput) error { 2191 if v == nil { 2192 return nil 2193 } 2194 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2195 if v.ResourceArn == nil { 2196 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2197 } 2198 if v.TagKeys == nil { 2199 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2200 } 2201 if invalidParams.Len() > 0 { 2202 return invalidParams 2203 } else { 2204 return nil 2205 } 2206} 2207 2208func validateOpUpdateActionTypeInput(v *UpdateActionTypeInput) error { 2209 if v == nil { 2210 return nil 2211 } 2212 invalidParams := smithy.InvalidParamsError{Context: "UpdateActionTypeInput"} 2213 if v.ActionType == nil { 2214 invalidParams.Add(smithy.NewErrParamRequired("ActionType")) 2215 } else if v.ActionType != nil { 2216 if err := validateActionTypeDeclaration(v.ActionType); err != nil { 2217 invalidParams.AddNested("ActionType", err.(smithy.InvalidParamsError)) 2218 } 2219 } 2220 if invalidParams.Len() > 0 { 2221 return invalidParams 2222 } else { 2223 return nil 2224 } 2225} 2226 2227func validateOpUpdatePipelineInput(v *UpdatePipelineInput) error { 2228 if v == nil { 2229 return nil 2230 } 2231 invalidParams := smithy.InvalidParamsError{Context: "UpdatePipelineInput"} 2232 if v.Pipeline == nil { 2233 invalidParams.Add(smithy.NewErrParamRequired("Pipeline")) 2234 } else if v.Pipeline != nil { 2235 if err := validatePipelineDeclaration(v.Pipeline); err != nil { 2236 invalidParams.AddNested("Pipeline", err.(smithy.InvalidParamsError)) 2237 } 2238 } 2239 if invalidParams.Len() > 0 { 2240 return invalidParams 2241 } else { 2242 return nil 2243 } 2244} 2245