1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ecr 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/ecr/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchCheckLayerAvailability struct { 14} 15 16func (*validateOpBatchCheckLayerAvailability) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchCheckLayerAvailability) 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.(*BatchCheckLayerAvailabilityInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchCheckLayerAvailabilityInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchDeleteImage struct { 34} 35 36func (*validateOpBatchDeleteImage) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchDeleteImage) 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.(*BatchDeleteImageInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchDeleteImageInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpBatchGetImage struct { 54} 55 56func (*validateOpBatchGetImage) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpBatchGetImage) 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.(*BatchGetImageInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpBatchGetImageInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCompleteLayerUpload struct { 74} 75 76func (*validateOpCompleteLayerUpload) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCompleteLayerUpload) 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.(*CompleteLayerUploadInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCompleteLayerUploadInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateRepository struct { 94} 95 96func (*validateOpCreateRepository) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateRepository) 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.(*CreateRepositoryInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateRepositoryInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteLifecyclePolicy struct { 114} 115 116func (*validateOpDeleteLifecyclePolicy) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteLifecyclePolicy) 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.(*DeleteLifecyclePolicyInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteLifecyclePolicyInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteRepository struct { 134} 135 136func (*validateOpDeleteRepository) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteRepository) 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.(*DeleteRepositoryInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteRepositoryInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteRepositoryPolicy struct { 154} 155 156func (*validateOpDeleteRepositoryPolicy) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteRepositoryPolicy) 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.(*DeleteRepositoryPolicyInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteRepositoryPolicyInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDescribeImageScanFindings struct { 174} 175 176func (*validateOpDescribeImageScanFindings) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDescribeImageScanFindings) 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.(*DescribeImageScanFindingsInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDescribeImageScanFindingsInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDescribeImages struct { 194} 195 196func (*validateOpDescribeImages) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDescribeImages) 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.(*DescribeImagesInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDescribeImagesInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpGetDownloadUrlForLayer struct { 214} 215 216func (*validateOpGetDownloadUrlForLayer) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpGetDownloadUrlForLayer) 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.(*GetDownloadUrlForLayerInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpGetDownloadUrlForLayerInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetLifecyclePolicy struct { 234} 235 236func (*validateOpGetLifecyclePolicy) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetLifecyclePolicy) 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.(*GetLifecyclePolicyInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetLifecyclePolicyInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetLifecyclePolicyPreview struct { 254} 255 256func (*validateOpGetLifecyclePolicyPreview) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetLifecyclePolicyPreview) 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.(*GetLifecyclePolicyPreviewInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetLifecyclePolicyPreviewInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetRepositoryPolicy struct { 274} 275 276func (*validateOpGetRepositoryPolicy) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetRepositoryPolicy) 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.(*GetRepositoryPolicyInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetRepositoryPolicyInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpInitiateLayerUpload struct { 294} 295 296func (*validateOpInitiateLayerUpload) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpInitiateLayerUpload) 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.(*InitiateLayerUploadInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpInitiateLayerUploadInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpListImages struct { 314} 315 316func (*validateOpListImages) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpListImages) 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.(*ListImagesInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpListImagesInput(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 validateOpPutImage struct { 354} 355 356func (*validateOpPutImage) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpPutImage) 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.(*PutImageInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpPutImageInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpPutImageScanningConfiguration struct { 374} 375 376func (*validateOpPutImageScanningConfiguration) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpPutImageScanningConfiguration) 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.(*PutImageScanningConfigurationInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpPutImageScanningConfigurationInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpPutImageTagMutability struct { 394} 395 396func (*validateOpPutImageTagMutability) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpPutImageTagMutability) 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.(*PutImageTagMutabilityInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpPutImageTagMutabilityInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpPutLifecyclePolicy struct { 414} 415 416func (*validateOpPutLifecyclePolicy) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpPutLifecyclePolicy) 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.(*PutLifecyclePolicyInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpPutLifecyclePolicyInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpPutRegistryPolicy struct { 434} 435 436func (*validateOpPutRegistryPolicy) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpPutRegistryPolicy) 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.(*PutRegistryPolicyInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpPutRegistryPolicyInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpPutReplicationConfiguration struct { 454} 455 456func (*validateOpPutReplicationConfiguration) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpPutReplicationConfiguration) 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.(*PutReplicationConfigurationInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpPutReplicationConfigurationInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpSetRepositoryPolicy struct { 474} 475 476func (*validateOpSetRepositoryPolicy) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpSetRepositoryPolicy) 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.(*SetRepositoryPolicyInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpSetRepositoryPolicyInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpStartImageScan struct { 494} 495 496func (*validateOpStartImageScan) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpStartImageScan) 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.(*StartImageScanInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpStartImageScanInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpStartLifecyclePolicyPreview struct { 514} 515 516func (*validateOpStartLifecyclePolicyPreview) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpStartLifecyclePolicyPreview) 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.(*StartLifecyclePolicyPreviewInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpStartLifecyclePolicyPreviewInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpTagResource struct { 534} 535 536func (*validateOpTagResource) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpTagResource) 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.(*TagResourceInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpTagResourceInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpUntagResource struct { 554} 555 556func (*validateOpUntagResource) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpUntagResource) 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.(*UntagResourceInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpUntagResourceInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpUploadLayerPart struct { 574} 575 576func (*validateOpUploadLayerPart) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpUploadLayerPart) 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.(*UploadLayerPartInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpUploadLayerPartInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593func addOpBatchCheckLayerAvailabilityValidationMiddleware(stack *middleware.Stack) error { 594 return stack.Initialize.Add(&validateOpBatchCheckLayerAvailability{}, middleware.After) 595} 596 597func addOpBatchDeleteImageValidationMiddleware(stack *middleware.Stack) error { 598 return stack.Initialize.Add(&validateOpBatchDeleteImage{}, middleware.After) 599} 600 601func addOpBatchGetImageValidationMiddleware(stack *middleware.Stack) error { 602 return stack.Initialize.Add(&validateOpBatchGetImage{}, middleware.After) 603} 604 605func addOpCompleteLayerUploadValidationMiddleware(stack *middleware.Stack) error { 606 return stack.Initialize.Add(&validateOpCompleteLayerUpload{}, middleware.After) 607} 608 609func addOpCreateRepositoryValidationMiddleware(stack *middleware.Stack) error { 610 return stack.Initialize.Add(&validateOpCreateRepository{}, middleware.After) 611} 612 613func addOpDeleteLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error { 614 return stack.Initialize.Add(&validateOpDeleteLifecyclePolicy{}, middleware.After) 615} 616 617func addOpDeleteRepositoryValidationMiddleware(stack *middleware.Stack) error { 618 return stack.Initialize.Add(&validateOpDeleteRepository{}, middleware.After) 619} 620 621func addOpDeleteRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { 622 return stack.Initialize.Add(&validateOpDeleteRepositoryPolicy{}, middleware.After) 623} 624 625func addOpDescribeImageScanFindingsValidationMiddleware(stack *middleware.Stack) error { 626 return stack.Initialize.Add(&validateOpDescribeImageScanFindings{}, middleware.After) 627} 628 629func addOpDescribeImagesValidationMiddleware(stack *middleware.Stack) error { 630 return stack.Initialize.Add(&validateOpDescribeImages{}, middleware.After) 631} 632 633func addOpGetDownloadUrlForLayerValidationMiddleware(stack *middleware.Stack) error { 634 return stack.Initialize.Add(&validateOpGetDownloadUrlForLayer{}, middleware.After) 635} 636 637func addOpGetLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error { 638 return stack.Initialize.Add(&validateOpGetLifecyclePolicy{}, middleware.After) 639} 640 641func addOpGetLifecyclePolicyPreviewValidationMiddleware(stack *middleware.Stack) error { 642 return stack.Initialize.Add(&validateOpGetLifecyclePolicyPreview{}, middleware.After) 643} 644 645func addOpGetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { 646 return stack.Initialize.Add(&validateOpGetRepositoryPolicy{}, middleware.After) 647} 648 649func addOpInitiateLayerUploadValidationMiddleware(stack *middleware.Stack) error { 650 return stack.Initialize.Add(&validateOpInitiateLayerUpload{}, middleware.After) 651} 652 653func addOpListImagesValidationMiddleware(stack *middleware.Stack) error { 654 return stack.Initialize.Add(&validateOpListImages{}, middleware.After) 655} 656 657func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 658 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 659} 660 661func addOpPutImageValidationMiddleware(stack *middleware.Stack) error { 662 return stack.Initialize.Add(&validateOpPutImage{}, middleware.After) 663} 664 665func addOpPutImageScanningConfigurationValidationMiddleware(stack *middleware.Stack) error { 666 return stack.Initialize.Add(&validateOpPutImageScanningConfiguration{}, middleware.After) 667} 668 669func addOpPutImageTagMutabilityValidationMiddleware(stack *middleware.Stack) error { 670 return stack.Initialize.Add(&validateOpPutImageTagMutability{}, middleware.After) 671} 672 673func addOpPutLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpPutLifecyclePolicy{}, middleware.After) 675} 676 677func addOpPutRegistryPolicyValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpPutRegistryPolicy{}, middleware.After) 679} 680 681func addOpPutReplicationConfigurationValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpPutReplicationConfiguration{}, middleware.After) 683} 684 685func addOpSetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { 686 return stack.Initialize.Add(&validateOpSetRepositoryPolicy{}, middleware.After) 687} 688 689func addOpStartImageScanValidationMiddleware(stack *middleware.Stack) error { 690 return stack.Initialize.Add(&validateOpStartImageScan{}, middleware.After) 691} 692 693func addOpStartLifecyclePolicyPreviewValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpStartLifecyclePolicyPreview{}, middleware.After) 695} 696 697func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 699} 700 701func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 703} 704 705func addOpUploadLayerPartValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpUploadLayerPart{}, middleware.After) 707} 708 709func validateEncryptionConfiguration(v *types.EncryptionConfiguration) error { 710 if v == nil { 711 return nil 712 } 713 invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfiguration"} 714 if len(v.EncryptionType) == 0 { 715 invalidParams.Add(smithy.NewErrParamRequired("EncryptionType")) 716 } 717 if invalidParams.Len() > 0 { 718 return invalidParams 719 } else { 720 return nil 721 } 722} 723 724func validateReplicationConfiguration(v *types.ReplicationConfiguration) error { 725 if v == nil { 726 return nil 727 } 728 invalidParams := smithy.InvalidParamsError{Context: "ReplicationConfiguration"} 729 if v.Rules == nil { 730 invalidParams.Add(smithy.NewErrParamRequired("Rules")) 731 } else if v.Rules != nil { 732 if err := validateReplicationRuleList(v.Rules); err != nil { 733 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError)) 734 } 735 } 736 if invalidParams.Len() > 0 { 737 return invalidParams 738 } else { 739 return nil 740 } 741} 742 743func validateReplicationDestination(v *types.ReplicationDestination) error { 744 if v == nil { 745 return nil 746 } 747 invalidParams := smithy.InvalidParamsError{Context: "ReplicationDestination"} 748 if v.Region == nil { 749 invalidParams.Add(smithy.NewErrParamRequired("Region")) 750 } 751 if v.RegistryId == nil { 752 invalidParams.Add(smithy.NewErrParamRequired("RegistryId")) 753 } 754 if invalidParams.Len() > 0 { 755 return invalidParams 756 } else { 757 return nil 758 } 759} 760 761func validateReplicationDestinationList(v []types.ReplicationDestination) error { 762 if v == nil { 763 return nil 764 } 765 invalidParams := smithy.InvalidParamsError{Context: "ReplicationDestinationList"} 766 for i := range v { 767 if err := validateReplicationDestination(&v[i]); err != nil { 768 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 769 } 770 } 771 if invalidParams.Len() > 0 { 772 return invalidParams 773 } else { 774 return nil 775 } 776} 777 778func validateReplicationRule(v *types.ReplicationRule) error { 779 if v == nil { 780 return nil 781 } 782 invalidParams := smithy.InvalidParamsError{Context: "ReplicationRule"} 783 if v.Destinations == nil { 784 invalidParams.Add(smithy.NewErrParamRequired("Destinations")) 785 } else if v.Destinations != nil { 786 if err := validateReplicationDestinationList(v.Destinations); err != nil { 787 invalidParams.AddNested("Destinations", err.(smithy.InvalidParamsError)) 788 } 789 } 790 if invalidParams.Len() > 0 { 791 return invalidParams 792 } else { 793 return nil 794 } 795} 796 797func validateReplicationRuleList(v []types.ReplicationRule) error { 798 if v == nil { 799 return nil 800 } 801 invalidParams := smithy.InvalidParamsError{Context: "ReplicationRuleList"} 802 for i := range v { 803 if err := validateReplicationRule(&v[i]); err != nil { 804 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 805 } 806 } 807 if invalidParams.Len() > 0 { 808 return invalidParams 809 } else { 810 return nil 811 } 812} 813 814func validateOpBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput) error { 815 if v == nil { 816 return nil 817 } 818 invalidParams := smithy.InvalidParamsError{Context: "BatchCheckLayerAvailabilityInput"} 819 if v.RepositoryName == nil { 820 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 821 } 822 if v.LayerDigests == nil { 823 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests")) 824 } 825 if invalidParams.Len() > 0 { 826 return invalidParams 827 } else { 828 return nil 829 } 830} 831 832func validateOpBatchDeleteImageInput(v *BatchDeleteImageInput) error { 833 if v == nil { 834 return nil 835 } 836 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteImageInput"} 837 if v.RepositoryName == nil { 838 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 839 } 840 if v.ImageIds == nil { 841 invalidParams.Add(smithy.NewErrParamRequired("ImageIds")) 842 } 843 if invalidParams.Len() > 0 { 844 return invalidParams 845 } else { 846 return nil 847 } 848} 849 850func validateOpBatchGetImageInput(v *BatchGetImageInput) error { 851 if v == nil { 852 return nil 853 } 854 invalidParams := smithy.InvalidParamsError{Context: "BatchGetImageInput"} 855 if v.RepositoryName == nil { 856 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 857 } 858 if v.ImageIds == nil { 859 invalidParams.Add(smithy.NewErrParamRequired("ImageIds")) 860 } 861 if invalidParams.Len() > 0 { 862 return invalidParams 863 } else { 864 return nil 865 } 866} 867 868func validateOpCompleteLayerUploadInput(v *CompleteLayerUploadInput) error { 869 if v == nil { 870 return nil 871 } 872 invalidParams := smithy.InvalidParamsError{Context: "CompleteLayerUploadInput"} 873 if v.RepositoryName == nil { 874 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 875 } 876 if v.UploadId == nil { 877 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 878 } 879 if v.LayerDigests == nil { 880 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests")) 881 } 882 if invalidParams.Len() > 0 { 883 return invalidParams 884 } else { 885 return nil 886 } 887} 888 889func validateOpCreateRepositoryInput(v *CreateRepositoryInput) error { 890 if v == nil { 891 return nil 892 } 893 invalidParams := smithy.InvalidParamsError{Context: "CreateRepositoryInput"} 894 if v.RepositoryName == nil { 895 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 896 } 897 if v.EncryptionConfiguration != nil { 898 if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil { 899 invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError)) 900 } 901 } 902 if invalidParams.Len() > 0 { 903 return invalidParams 904 } else { 905 return nil 906 } 907} 908 909func validateOpDeleteLifecyclePolicyInput(v *DeleteLifecyclePolicyInput) error { 910 if v == nil { 911 return nil 912 } 913 invalidParams := smithy.InvalidParamsError{Context: "DeleteLifecyclePolicyInput"} 914 if v.RepositoryName == nil { 915 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 916 } 917 if invalidParams.Len() > 0 { 918 return invalidParams 919 } else { 920 return nil 921 } 922} 923 924func validateOpDeleteRepositoryInput(v *DeleteRepositoryInput) error { 925 if v == nil { 926 return nil 927 } 928 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryInput"} 929 if v.RepositoryName == nil { 930 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 931 } 932 if invalidParams.Len() > 0 { 933 return invalidParams 934 } else { 935 return nil 936 } 937} 938 939func validateOpDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput) error { 940 if v == nil { 941 return nil 942 } 943 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryPolicyInput"} 944 if v.RepositoryName == nil { 945 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 946 } 947 if invalidParams.Len() > 0 { 948 return invalidParams 949 } else { 950 return nil 951 } 952} 953 954func validateOpDescribeImageScanFindingsInput(v *DescribeImageScanFindingsInput) error { 955 if v == nil { 956 return nil 957 } 958 invalidParams := smithy.InvalidParamsError{Context: "DescribeImageScanFindingsInput"} 959 if v.RepositoryName == nil { 960 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 961 } 962 if v.ImageId == nil { 963 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 964 } 965 if invalidParams.Len() > 0 { 966 return invalidParams 967 } else { 968 return nil 969 } 970} 971 972func validateOpDescribeImagesInput(v *DescribeImagesInput) error { 973 if v == nil { 974 return nil 975 } 976 invalidParams := smithy.InvalidParamsError{Context: "DescribeImagesInput"} 977 if v.RepositoryName == nil { 978 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 979 } 980 if invalidParams.Len() > 0 { 981 return invalidParams 982 } else { 983 return nil 984 } 985} 986 987func validateOpGetDownloadUrlForLayerInput(v *GetDownloadUrlForLayerInput) error { 988 if v == nil { 989 return nil 990 } 991 invalidParams := smithy.InvalidParamsError{Context: "GetDownloadUrlForLayerInput"} 992 if v.RepositoryName == nil { 993 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 994 } 995 if v.LayerDigest == nil { 996 invalidParams.Add(smithy.NewErrParamRequired("LayerDigest")) 997 } 998 if invalidParams.Len() > 0 { 999 return invalidParams 1000 } else { 1001 return nil 1002 } 1003} 1004 1005func validateOpGetLifecyclePolicyInput(v *GetLifecyclePolicyInput) error { 1006 if v == nil { 1007 return nil 1008 } 1009 invalidParams := smithy.InvalidParamsError{Context: "GetLifecyclePolicyInput"} 1010 if v.RepositoryName == nil { 1011 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1012 } 1013 if invalidParams.Len() > 0 { 1014 return invalidParams 1015 } else { 1016 return nil 1017 } 1018} 1019 1020func validateOpGetLifecyclePolicyPreviewInput(v *GetLifecyclePolicyPreviewInput) error { 1021 if v == nil { 1022 return nil 1023 } 1024 invalidParams := smithy.InvalidParamsError{Context: "GetLifecyclePolicyPreviewInput"} 1025 if v.RepositoryName == nil { 1026 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1027 } 1028 if invalidParams.Len() > 0 { 1029 return invalidParams 1030 } else { 1031 return nil 1032 } 1033} 1034 1035func validateOpGetRepositoryPolicyInput(v *GetRepositoryPolicyInput) error { 1036 if v == nil { 1037 return nil 1038 } 1039 invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryPolicyInput"} 1040 if v.RepositoryName == nil { 1041 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1042 } 1043 if invalidParams.Len() > 0 { 1044 return invalidParams 1045 } else { 1046 return nil 1047 } 1048} 1049 1050func validateOpInitiateLayerUploadInput(v *InitiateLayerUploadInput) error { 1051 if v == nil { 1052 return nil 1053 } 1054 invalidParams := smithy.InvalidParamsError{Context: "InitiateLayerUploadInput"} 1055 if v.RepositoryName == nil { 1056 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1057 } 1058 if invalidParams.Len() > 0 { 1059 return invalidParams 1060 } else { 1061 return nil 1062 } 1063} 1064 1065func validateOpListImagesInput(v *ListImagesInput) error { 1066 if v == nil { 1067 return nil 1068 } 1069 invalidParams := smithy.InvalidParamsError{Context: "ListImagesInput"} 1070 if v.RepositoryName == nil { 1071 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1072 } 1073 if invalidParams.Len() > 0 { 1074 return invalidParams 1075 } else { 1076 return nil 1077 } 1078} 1079 1080func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1081 if v == nil { 1082 return nil 1083 } 1084 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1085 if v.ResourceArn == nil { 1086 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1087 } 1088 if invalidParams.Len() > 0 { 1089 return invalidParams 1090 } else { 1091 return nil 1092 } 1093} 1094 1095func validateOpPutImageInput(v *PutImageInput) error { 1096 if v == nil { 1097 return nil 1098 } 1099 invalidParams := smithy.InvalidParamsError{Context: "PutImageInput"} 1100 if v.RepositoryName == nil { 1101 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1102 } 1103 if v.ImageManifest == nil { 1104 invalidParams.Add(smithy.NewErrParamRequired("ImageManifest")) 1105 } 1106 if invalidParams.Len() > 0 { 1107 return invalidParams 1108 } else { 1109 return nil 1110 } 1111} 1112 1113func validateOpPutImageScanningConfigurationInput(v *PutImageScanningConfigurationInput) error { 1114 if v == nil { 1115 return nil 1116 } 1117 invalidParams := smithy.InvalidParamsError{Context: "PutImageScanningConfigurationInput"} 1118 if v.RepositoryName == nil { 1119 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1120 } 1121 if v.ImageScanningConfiguration == nil { 1122 invalidParams.Add(smithy.NewErrParamRequired("ImageScanningConfiguration")) 1123 } 1124 if invalidParams.Len() > 0 { 1125 return invalidParams 1126 } else { 1127 return nil 1128 } 1129} 1130 1131func validateOpPutImageTagMutabilityInput(v *PutImageTagMutabilityInput) error { 1132 if v == nil { 1133 return nil 1134 } 1135 invalidParams := smithy.InvalidParamsError{Context: "PutImageTagMutabilityInput"} 1136 if v.RepositoryName == nil { 1137 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1138 } 1139 if len(v.ImageTagMutability) == 0 { 1140 invalidParams.Add(smithy.NewErrParamRequired("ImageTagMutability")) 1141 } 1142 if invalidParams.Len() > 0 { 1143 return invalidParams 1144 } else { 1145 return nil 1146 } 1147} 1148 1149func validateOpPutLifecyclePolicyInput(v *PutLifecyclePolicyInput) error { 1150 if v == nil { 1151 return nil 1152 } 1153 invalidParams := smithy.InvalidParamsError{Context: "PutLifecyclePolicyInput"} 1154 if v.RepositoryName == nil { 1155 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1156 } 1157 if v.LifecyclePolicyText == nil { 1158 invalidParams.Add(smithy.NewErrParamRequired("LifecyclePolicyText")) 1159 } 1160 if invalidParams.Len() > 0 { 1161 return invalidParams 1162 } else { 1163 return nil 1164 } 1165} 1166 1167func validateOpPutRegistryPolicyInput(v *PutRegistryPolicyInput) error { 1168 if v == nil { 1169 return nil 1170 } 1171 invalidParams := smithy.InvalidParamsError{Context: "PutRegistryPolicyInput"} 1172 if v.PolicyText == nil { 1173 invalidParams.Add(smithy.NewErrParamRequired("PolicyText")) 1174 } 1175 if invalidParams.Len() > 0 { 1176 return invalidParams 1177 } else { 1178 return nil 1179 } 1180} 1181 1182func validateOpPutReplicationConfigurationInput(v *PutReplicationConfigurationInput) error { 1183 if v == nil { 1184 return nil 1185 } 1186 invalidParams := smithy.InvalidParamsError{Context: "PutReplicationConfigurationInput"} 1187 if v.ReplicationConfiguration == nil { 1188 invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfiguration")) 1189 } else if v.ReplicationConfiguration != nil { 1190 if err := validateReplicationConfiguration(v.ReplicationConfiguration); err != nil { 1191 invalidParams.AddNested("ReplicationConfiguration", err.(smithy.InvalidParamsError)) 1192 } 1193 } 1194 if invalidParams.Len() > 0 { 1195 return invalidParams 1196 } else { 1197 return nil 1198 } 1199} 1200 1201func validateOpSetRepositoryPolicyInput(v *SetRepositoryPolicyInput) error { 1202 if v == nil { 1203 return nil 1204 } 1205 invalidParams := smithy.InvalidParamsError{Context: "SetRepositoryPolicyInput"} 1206 if v.RepositoryName == nil { 1207 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1208 } 1209 if v.PolicyText == nil { 1210 invalidParams.Add(smithy.NewErrParamRequired("PolicyText")) 1211 } 1212 if invalidParams.Len() > 0 { 1213 return invalidParams 1214 } else { 1215 return nil 1216 } 1217} 1218 1219func validateOpStartImageScanInput(v *StartImageScanInput) error { 1220 if v == nil { 1221 return nil 1222 } 1223 invalidParams := smithy.InvalidParamsError{Context: "StartImageScanInput"} 1224 if v.RepositoryName == nil { 1225 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1226 } 1227 if v.ImageId == nil { 1228 invalidParams.Add(smithy.NewErrParamRequired("ImageId")) 1229 } 1230 if invalidParams.Len() > 0 { 1231 return invalidParams 1232 } else { 1233 return nil 1234 } 1235} 1236 1237func validateOpStartLifecyclePolicyPreviewInput(v *StartLifecyclePolicyPreviewInput) error { 1238 if v == nil { 1239 return nil 1240 } 1241 invalidParams := smithy.InvalidParamsError{Context: "StartLifecyclePolicyPreviewInput"} 1242 if v.RepositoryName == nil { 1243 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1244 } 1245 if invalidParams.Len() > 0 { 1246 return invalidParams 1247 } else { 1248 return nil 1249 } 1250} 1251 1252func validateOpTagResourceInput(v *TagResourceInput) error { 1253 if v == nil { 1254 return nil 1255 } 1256 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1257 if v.ResourceArn == nil { 1258 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1259 } 1260 if v.Tags == nil { 1261 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1262 } 1263 if invalidParams.Len() > 0 { 1264 return invalidParams 1265 } else { 1266 return nil 1267 } 1268} 1269 1270func validateOpUntagResourceInput(v *UntagResourceInput) error { 1271 if v == nil { 1272 return nil 1273 } 1274 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1275 if v.ResourceArn == nil { 1276 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1277 } 1278 if v.TagKeys == nil { 1279 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1280 } 1281 if invalidParams.Len() > 0 { 1282 return invalidParams 1283 } else { 1284 return nil 1285 } 1286} 1287 1288func validateOpUploadLayerPartInput(v *UploadLayerPartInput) error { 1289 if v == nil { 1290 return nil 1291 } 1292 invalidParams := smithy.InvalidParamsError{Context: "UploadLayerPartInput"} 1293 if v.RepositoryName == nil { 1294 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) 1295 } 1296 if v.UploadId == nil { 1297 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 1298 } 1299 if v.PartFirstByte == nil { 1300 invalidParams.Add(smithy.NewErrParamRequired("PartFirstByte")) 1301 } 1302 if v.PartLastByte == nil { 1303 invalidParams.Add(smithy.NewErrParamRequired("PartLastByte")) 1304 } 1305 if v.LayerPartBlob == nil { 1306 invalidParams.Add(smithy.NewErrParamRequired("LayerPartBlob")) 1307 } 1308 if invalidParams.Len() > 0 { 1309 return invalidParams 1310 } else { 1311 return nil 1312 } 1313} 1314