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