1
2
3 package ecr
4
5 import (
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
13 type validateOpBatchCheckLayerAvailability struct {
14 }
15
16 func (*validateOpBatchCheckLayerAvailability) ID() string {
17 return "OperationInputValidation"
18 }
19
20 func (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
33 type validateOpBatchDeleteImage struct {
34 }
35
36 func (*validateOpBatchDeleteImage) ID() string {
37 return "OperationInputValidation"
38 }
39
40 func (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
53 type validateOpBatchGetImage struct {
54 }
55
56 func (*validateOpBatchGetImage) ID() string {
57 return "OperationInputValidation"
58 }
59
60 func (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
73 type validateOpBatchGetRepositoryScanningConfiguration struct {
74 }
75
76 func (*validateOpBatchGetRepositoryScanningConfiguration) ID() string {
77 return "OperationInputValidation"
78 }
79
80 func (m *validateOpBatchGetRepositoryScanningConfiguration) 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.(*BatchGetRepositoryScanningConfigurationInput)
84 if !ok {
85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86 }
87 if err := validateOpBatchGetRepositoryScanningConfigurationInput(input); err != nil {
88 return out, metadata, err
89 }
90 return next.HandleInitialize(ctx, in)
91 }
92
93 type validateOpCompleteLayerUpload struct {
94 }
95
96 func (*validateOpCompleteLayerUpload) ID() string {
97 return "OperationInputValidation"
98 }
99
100 func (m *validateOpCompleteLayerUpload) 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.(*CompleteLayerUploadInput)
104 if !ok {
105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106 }
107 if err := validateOpCompleteLayerUploadInput(input); err != nil {
108 return out, metadata, err
109 }
110 return next.HandleInitialize(ctx, in)
111 }
112
113 type validateOpCreatePullThroughCacheRule struct {
114 }
115
116 func (*validateOpCreatePullThroughCacheRule) ID() string {
117 return "OperationInputValidation"
118 }
119
120 func (m *validateOpCreatePullThroughCacheRule) 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.(*CreatePullThroughCacheRuleInput)
124 if !ok {
125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126 }
127 if err := validateOpCreatePullThroughCacheRuleInput(input); err != nil {
128 return out, metadata, err
129 }
130 return next.HandleInitialize(ctx, in)
131 }
132
133 type validateOpCreateRepository struct {
134 }
135
136 func (*validateOpCreateRepository) ID() string {
137 return "OperationInputValidation"
138 }
139
140 func (m *validateOpCreateRepository) 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.(*CreateRepositoryInput)
144 if !ok {
145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146 }
147 if err := validateOpCreateRepositoryInput(input); err != nil {
148 return out, metadata, err
149 }
150 return next.HandleInitialize(ctx, in)
151 }
152
153 type validateOpDeleteLifecyclePolicy struct {
154 }
155
156 func (*validateOpDeleteLifecyclePolicy) ID() string {
157 return "OperationInputValidation"
158 }
159
160 func (m *validateOpDeleteLifecyclePolicy) 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.(*DeleteLifecyclePolicyInput)
164 if !ok {
165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166 }
167 if err := validateOpDeleteLifecyclePolicyInput(input); err != nil {
168 return out, metadata, err
169 }
170 return next.HandleInitialize(ctx, in)
171 }
172
173 type validateOpDeletePullThroughCacheRule struct {
174 }
175
176 func (*validateOpDeletePullThroughCacheRule) ID() string {
177 return "OperationInputValidation"
178 }
179
180 func (m *validateOpDeletePullThroughCacheRule) 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.(*DeletePullThroughCacheRuleInput)
184 if !ok {
185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186 }
187 if err := validateOpDeletePullThroughCacheRuleInput(input); err != nil {
188 return out, metadata, err
189 }
190 return next.HandleInitialize(ctx, in)
191 }
192
193 type validateOpDeleteRepository struct {
194 }
195
196 func (*validateOpDeleteRepository) ID() string {
197 return "OperationInputValidation"
198 }
199
200 func (m *validateOpDeleteRepository) 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.(*DeleteRepositoryInput)
204 if !ok {
205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206 }
207 if err := validateOpDeleteRepositoryInput(input); err != nil {
208 return out, metadata, err
209 }
210 return next.HandleInitialize(ctx, in)
211 }
212
213 type validateOpDeleteRepositoryPolicy struct {
214 }
215
216 func (*validateOpDeleteRepositoryPolicy) ID() string {
217 return "OperationInputValidation"
218 }
219
220 func (m *validateOpDeleteRepositoryPolicy) 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.(*DeleteRepositoryPolicyInput)
224 if !ok {
225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226 }
227 if err := validateOpDeleteRepositoryPolicyInput(input); err != nil {
228 return out, metadata, err
229 }
230 return next.HandleInitialize(ctx, in)
231 }
232
233 type validateOpDescribeImageReplicationStatus struct {
234 }
235
236 func (*validateOpDescribeImageReplicationStatus) ID() string {
237 return "OperationInputValidation"
238 }
239
240 func (m *validateOpDescribeImageReplicationStatus) 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.(*DescribeImageReplicationStatusInput)
244 if !ok {
245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246 }
247 if err := validateOpDescribeImageReplicationStatusInput(input); err != nil {
248 return out, metadata, err
249 }
250 return next.HandleInitialize(ctx, in)
251 }
252
253 type validateOpDescribeImageScanFindings struct {
254 }
255
256 func (*validateOpDescribeImageScanFindings) ID() string {
257 return "OperationInputValidation"
258 }
259
260 func (m *validateOpDescribeImageScanFindings) 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.(*DescribeImageScanFindingsInput)
264 if !ok {
265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266 }
267 if err := validateOpDescribeImageScanFindingsInput(input); err != nil {
268 return out, metadata, err
269 }
270 return next.HandleInitialize(ctx, in)
271 }
272
273 type validateOpDescribeImages struct {
274 }
275
276 func (*validateOpDescribeImages) ID() string {
277 return "OperationInputValidation"
278 }
279
280 func (m *validateOpDescribeImages) 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.(*DescribeImagesInput)
284 if !ok {
285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286 }
287 if err := validateOpDescribeImagesInput(input); err != nil {
288 return out, metadata, err
289 }
290 return next.HandleInitialize(ctx, in)
291 }
292
293 type validateOpGetDownloadUrlForLayer struct {
294 }
295
296 func (*validateOpGetDownloadUrlForLayer) ID() string {
297 return "OperationInputValidation"
298 }
299
300 func (m *validateOpGetDownloadUrlForLayer) 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.(*GetDownloadUrlForLayerInput)
304 if !ok {
305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306 }
307 if err := validateOpGetDownloadUrlForLayerInput(input); err != nil {
308 return out, metadata, err
309 }
310 return next.HandleInitialize(ctx, in)
311 }
312
313 type validateOpGetLifecyclePolicy struct {
314 }
315
316 func (*validateOpGetLifecyclePolicy) ID() string {
317 return "OperationInputValidation"
318 }
319
320 func (m *validateOpGetLifecyclePolicy) 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.(*GetLifecyclePolicyInput)
324 if !ok {
325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326 }
327 if err := validateOpGetLifecyclePolicyInput(input); err != nil {
328 return out, metadata, err
329 }
330 return next.HandleInitialize(ctx, in)
331 }
332
333 type validateOpGetLifecyclePolicyPreview struct {
334 }
335
336 func (*validateOpGetLifecyclePolicyPreview) ID() string {
337 return "OperationInputValidation"
338 }
339
340 func (m *validateOpGetLifecyclePolicyPreview) 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.(*GetLifecyclePolicyPreviewInput)
344 if !ok {
345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346 }
347 if err := validateOpGetLifecyclePolicyPreviewInput(input); err != nil {
348 return out, metadata, err
349 }
350 return next.HandleInitialize(ctx, in)
351 }
352
353 type validateOpGetRepositoryPolicy struct {
354 }
355
356 func (*validateOpGetRepositoryPolicy) ID() string {
357 return "OperationInputValidation"
358 }
359
360 func (m *validateOpGetRepositoryPolicy) 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.(*GetRepositoryPolicyInput)
364 if !ok {
365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366 }
367 if err := validateOpGetRepositoryPolicyInput(input); err != nil {
368 return out, metadata, err
369 }
370 return next.HandleInitialize(ctx, in)
371 }
372
373 type validateOpInitiateLayerUpload struct {
374 }
375
376 func (*validateOpInitiateLayerUpload) ID() string {
377 return "OperationInputValidation"
378 }
379
380 func (m *validateOpInitiateLayerUpload) 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.(*InitiateLayerUploadInput)
384 if !ok {
385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386 }
387 if err := validateOpInitiateLayerUploadInput(input); err != nil {
388 return out, metadata, err
389 }
390 return next.HandleInitialize(ctx, in)
391 }
392
393 type validateOpListImages struct {
394 }
395
396 func (*validateOpListImages) ID() string {
397 return "OperationInputValidation"
398 }
399
400 func (m *validateOpListImages) 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.(*ListImagesInput)
404 if !ok {
405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406 }
407 if err := validateOpListImagesInput(input); err != nil {
408 return out, metadata, err
409 }
410 return next.HandleInitialize(ctx, in)
411 }
412
413 type validateOpListTagsForResource struct {
414 }
415
416 func (*validateOpListTagsForResource) ID() string {
417 return "OperationInputValidation"
418 }
419
420 func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
424 if !ok {
425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426 }
427 if err := validateOpListTagsForResourceInput(input); err != nil {
428 return out, metadata, err
429 }
430 return next.HandleInitialize(ctx, in)
431 }
432
433 type validateOpPutImage struct {
434 }
435
436 func (*validateOpPutImage) ID() string {
437 return "OperationInputValidation"
438 }
439
440 func (m *validateOpPutImage) 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.(*PutImageInput)
444 if !ok {
445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446 }
447 if err := validateOpPutImageInput(input); err != nil {
448 return out, metadata, err
449 }
450 return next.HandleInitialize(ctx, in)
451 }
452
453 type validateOpPutImageScanningConfiguration struct {
454 }
455
456 func (*validateOpPutImageScanningConfiguration) ID() string {
457 return "OperationInputValidation"
458 }
459
460 func (m *validateOpPutImageScanningConfiguration) 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.(*PutImageScanningConfigurationInput)
464 if !ok {
465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466 }
467 if err := validateOpPutImageScanningConfigurationInput(input); err != nil {
468 return out, metadata, err
469 }
470 return next.HandleInitialize(ctx, in)
471 }
472
473 type validateOpPutImageTagMutability struct {
474 }
475
476 func (*validateOpPutImageTagMutability) ID() string {
477 return "OperationInputValidation"
478 }
479
480 func (m *validateOpPutImageTagMutability) 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.(*PutImageTagMutabilityInput)
484 if !ok {
485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486 }
487 if err := validateOpPutImageTagMutabilityInput(input); err != nil {
488 return out, metadata, err
489 }
490 return next.HandleInitialize(ctx, in)
491 }
492
493 type validateOpPutLifecyclePolicy struct {
494 }
495
496 func (*validateOpPutLifecyclePolicy) ID() string {
497 return "OperationInputValidation"
498 }
499
500 func (m *validateOpPutLifecyclePolicy) 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.(*PutLifecyclePolicyInput)
504 if !ok {
505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506 }
507 if err := validateOpPutLifecyclePolicyInput(input); err != nil {
508 return out, metadata, err
509 }
510 return next.HandleInitialize(ctx, in)
511 }
512
513 type validateOpPutRegistryPolicy struct {
514 }
515
516 func (*validateOpPutRegistryPolicy) ID() string {
517 return "OperationInputValidation"
518 }
519
520 func (m *validateOpPutRegistryPolicy) 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.(*PutRegistryPolicyInput)
524 if !ok {
525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526 }
527 if err := validateOpPutRegistryPolicyInput(input); err != nil {
528 return out, metadata, err
529 }
530 return next.HandleInitialize(ctx, in)
531 }
532
533 type validateOpPutRegistryScanningConfiguration struct {
534 }
535
536 func (*validateOpPutRegistryScanningConfiguration) ID() string {
537 return "OperationInputValidation"
538 }
539
540 func (m *validateOpPutRegistryScanningConfiguration) 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.(*PutRegistryScanningConfigurationInput)
544 if !ok {
545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546 }
547 if err := validateOpPutRegistryScanningConfigurationInput(input); err != nil {
548 return out, metadata, err
549 }
550 return next.HandleInitialize(ctx, in)
551 }
552
553 type validateOpPutReplicationConfiguration struct {
554 }
555
556 func (*validateOpPutReplicationConfiguration) ID() string {
557 return "OperationInputValidation"
558 }
559
560 func (m *validateOpPutReplicationConfiguration) 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.(*PutReplicationConfigurationInput)
564 if !ok {
565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566 }
567 if err := validateOpPutReplicationConfigurationInput(input); err != nil {
568 return out, metadata, err
569 }
570 return next.HandleInitialize(ctx, in)
571 }
572
573 type validateOpSetRepositoryPolicy struct {
574 }
575
576 func (*validateOpSetRepositoryPolicy) ID() string {
577 return "OperationInputValidation"
578 }
579
580 func (m *validateOpSetRepositoryPolicy) 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.(*SetRepositoryPolicyInput)
584 if !ok {
585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586 }
587 if err := validateOpSetRepositoryPolicyInput(input); err != nil {
588 return out, metadata, err
589 }
590 return next.HandleInitialize(ctx, in)
591 }
592
593 type validateOpStartImageScan struct {
594 }
595
596 func (*validateOpStartImageScan) ID() string {
597 return "OperationInputValidation"
598 }
599
600 func (m *validateOpStartImageScan) 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.(*StartImageScanInput)
604 if !ok {
605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606 }
607 if err := validateOpStartImageScanInput(input); err != nil {
608 return out, metadata, err
609 }
610 return next.HandleInitialize(ctx, in)
611 }
612
613 type validateOpStartLifecyclePolicyPreview struct {
614 }
615
616 func (*validateOpStartLifecyclePolicyPreview) ID() string {
617 return "OperationInputValidation"
618 }
619
620 func (m *validateOpStartLifecyclePolicyPreview) 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.(*StartLifecyclePolicyPreviewInput)
624 if !ok {
625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626 }
627 if err := validateOpStartLifecyclePolicyPreviewInput(input); err != nil {
628 return out, metadata, err
629 }
630 return next.HandleInitialize(ctx, in)
631 }
632
633 type validateOpTagResource struct {
634 }
635
636 func (*validateOpTagResource) ID() string {
637 return "OperationInputValidation"
638 }
639
640 func (m *validateOpTagResource) 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.(*TagResourceInput)
644 if !ok {
645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646 }
647 if err := validateOpTagResourceInput(input); err != nil {
648 return out, metadata, err
649 }
650 return next.HandleInitialize(ctx, in)
651 }
652
653 type validateOpUntagResource struct {
654 }
655
656 func (*validateOpUntagResource) ID() string {
657 return "OperationInputValidation"
658 }
659
660 func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
661 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
662 ) {
663 input, ok := in.Parameters.(*UntagResourceInput)
664 if !ok {
665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666 }
667 if err := validateOpUntagResourceInput(input); err != nil {
668 return out, metadata, err
669 }
670 return next.HandleInitialize(ctx, in)
671 }
672
673 type validateOpUploadLayerPart struct {
674 }
675
676 func (*validateOpUploadLayerPart) ID() string {
677 return "OperationInputValidation"
678 }
679
680 func (m *validateOpUploadLayerPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
681 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
682 ) {
683 input, ok := in.Parameters.(*UploadLayerPartInput)
684 if !ok {
685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686 }
687 if err := validateOpUploadLayerPartInput(input); err != nil {
688 return out, metadata, err
689 }
690 return next.HandleInitialize(ctx, in)
691 }
692
693 func addOpBatchCheckLayerAvailabilityValidationMiddleware(stack *middleware.Stack) error {
694 return stack.Initialize.Add(&validateOpBatchCheckLayerAvailability{}, middleware.After)
695 }
696
697 func addOpBatchDeleteImageValidationMiddleware(stack *middleware.Stack) error {
698 return stack.Initialize.Add(&validateOpBatchDeleteImage{}, middleware.After)
699 }
700
701 func addOpBatchGetImageValidationMiddleware(stack *middleware.Stack) error {
702 return stack.Initialize.Add(&validateOpBatchGetImage{}, middleware.After)
703 }
704
705 func addOpBatchGetRepositoryScanningConfigurationValidationMiddleware(stack *middleware.Stack) error {
706 return stack.Initialize.Add(&validateOpBatchGetRepositoryScanningConfiguration{}, middleware.After)
707 }
708
709 func addOpCompleteLayerUploadValidationMiddleware(stack *middleware.Stack) error {
710 return stack.Initialize.Add(&validateOpCompleteLayerUpload{}, middleware.After)
711 }
712
713 func addOpCreatePullThroughCacheRuleValidationMiddleware(stack *middleware.Stack) error {
714 return stack.Initialize.Add(&validateOpCreatePullThroughCacheRule{}, middleware.After)
715 }
716
717 func addOpCreateRepositoryValidationMiddleware(stack *middleware.Stack) error {
718 return stack.Initialize.Add(&validateOpCreateRepository{}, middleware.After)
719 }
720
721 func addOpDeleteLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error {
722 return stack.Initialize.Add(&validateOpDeleteLifecyclePolicy{}, middleware.After)
723 }
724
725 func addOpDeletePullThroughCacheRuleValidationMiddleware(stack *middleware.Stack) error {
726 return stack.Initialize.Add(&validateOpDeletePullThroughCacheRule{}, middleware.After)
727 }
728
729 func addOpDeleteRepositoryValidationMiddleware(stack *middleware.Stack) error {
730 return stack.Initialize.Add(&validateOpDeleteRepository{}, middleware.After)
731 }
732
733 func addOpDeleteRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
734 return stack.Initialize.Add(&validateOpDeleteRepositoryPolicy{}, middleware.After)
735 }
736
737 func addOpDescribeImageReplicationStatusValidationMiddleware(stack *middleware.Stack) error {
738 return stack.Initialize.Add(&validateOpDescribeImageReplicationStatus{}, middleware.After)
739 }
740
741 func addOpDescribeImageScanFindingsValidationMiddleware(stack *middleware.Stack) error {
742 return stack.Initialize.Add(&validateOpDescribeImageScanFindings{}, middleware.After)
743 }
744
745 func addOpDescribeImagesValidationMiddleware(stack *middleware.Stack) error {
746 return stack.Initialize.Add(&validateOpDescribeImages{}, middleware.After)
747 }
748
749 func addOpGetDownloadUrlForLayerValidationMiddleware(stack *middleware.Stack) error {
750 return stack.Initialize.Add(&validateOpGetDownloadUrlForLayer{}, middleware.After)
751 }
752
753 func addOpGetLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error {
754 return stack.Initialize.Add(&validateOpGetLifecyclePolicy{}, middleware.After)
755 }
756
757 func addOpGetLifecyclePolicyPreviewValidationMiddleware(stack *middleware.Stack) error {
758 return stack.Initialize.Add(&validateOpGetLifecyclePolicyPreview{}, middleware.After)
759 }
760
761 func addOpGetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
762 return stack.Initialize.Add(&validateOpGetRepositoryPolicy{}, middleware.After)
763 }
764
765 func addOpInitiateLayerUploadValidationMiddleware(stack *middleware.Stack) error {
766 return stack.Initialize.Add(&validateOpInitiateLayerUpload{}, middleware.After)
767 }
768
769 func addOpListImagesValidationMiddleware(stack *middleware.Stack) error {
770 return stack.Initialize.Add(&validateOpListImages{}, middleware.After)
771 }
772
773 func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
774 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
775 }
776
777 func addOpPutImageValidationMiddleware(stack *middleware.Stack) error {
778 return stack.Initialize.Add(&validateOpPutImage{}, middleware.After)
779 }
780
781 func addOpPutImageScanningConfigurationValidationMiddleware(stack *middleware.Stack) error {
782 return stack.Initialize.Add(&validateOpPutImageScanningConfiguration{}, middleware.After)
783 }
784
785 func addOpPutImageTagMutabilityValidationMiddleware(stack *middleware.Stack) error {
786 return stack.Initialize.Add(&validateOpPutImageTagMutability{}, middleware.After)
787 }
788
789 func addOpPutLifecyclePolicyValidationMiddleware(stack *middleware.Stack) error {
790 return stack.Initialize.Add(&validateOpPutLifecyclePolicy{}, middleware.After)
791 }
792
793 func addOpPutRegistryPolicyValidationMiddleware(stack *middleware.Stack) error {
794 return stack.Initialize.Add(&validateOpPutRegistryPolicy{}, middleware.After)
795 }
796
797 func addOpPutRegistryScanningConfigurationValidationMiddleware(stack *middleware.Stack) error {
798 return stack.Initialize.Add(&validateOpPutRegistryScanningConfiguration{}, middleware.After)
799 }
800
801 func addOpPutReplicationConfigurationValidationMiddleware(stack *middleware.Stack) error {
802 return stack.Initialize.Add(&validateOpPutReplicationConfiguration{}, middleware.After)
803 }
804
805 func addOpSetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
806 return stack.Initialize.Add(&validateOpSetRepositoryPolicy{}, middleware.After)
807 }
808
809 func addOpStartImageScanValidationMiddleware(stack *middleware.Stack) error {
810 return stack.Initialize.Add(&validateOpStartImageScan{}, middleware.After)
811 }
812
813 func addOpStartLifecyclePolicyPreviewValidationMiddleware(stack *middleware.Stack) error {
814 return stack.Initialize.Add(&validateOpStartLifecyclePolicyPreview{}, middleware.After)
815 }
816
817 func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
818 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
819 }
820
821 func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
822 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
823 }
824
825 func addOpUploadLayerPartValidationMiddleware(stack *middleware.Stack) error {
826 return stack.Initialize.Add(&validateOpUploadLayerPart{}, middleware.After)
827 }
828
829 func validateEncryptionConfiguration(v *types.EncryptionConfiguration) error {
830 if v == nil {
831 return nil
832 }
833 invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfiguration"}
834 if len(v.EncryptionType) == 0 {
835 invalidParams.Add(smithy.NewErrParamRequired("EncryptionType"))
836 }
837 if invalidParams.Len() > 0 {
838 return invalidParams
839 } else {
840 return nil
841 }
842 }
843
844 func validateRegistryScanningRule(v *types.RegistryScanningRule) error {
845 if v == nil {
846 return nil
847 }
848 invalidParams := smithy.InvalidParamsError{Context: "RegistryScanningRule"}
849 if len(v.ScanFrequency) == 0 {
850 invalidParams.Add(smithy.NewErrParamRequired("ScanFrequency"))
851 }
852 if v.RepositoryFilters == nil {
853 invalidParams.Add(smithy.NewErrParamRequired("RepositoryFilters"))
854 } else if v.RepositoryFilters != nil {
855 if err := validateScanningRepositoryFilterList(v.RepositoryFilters); err != nil {
856 invalidParams.AddNested("RepositoryFilters", err.(smithy.InvalidParamsError))
857 }
858 }
859 if invalidParams.Len() > 0 {
860 return invalidParams
861 } else {
862 return nil
863 }
864 }
865
866 func validateRegistryScanningRuleList(v []types.RegistryScanningRule) error {
867 if v == nil {
868 return nil
869 }
870 invalidParams := smithy.InvalidParamsError{Context: "RegistryScanningRuleList"}
871 for i := range v {
872 if err := validateRegistryScanningRule(&v[i]); err != nil {
873 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
874 }
875 }
876 if invalidParams.Len() > 0 {
877 return invalidParams
878 } else {
879 return nil
880 }
881 }
882
883 func validateReplicationConfiguration(v *types.ReplicationConfiguration) error {
884 if v == nil {
885 return nil
886 }
887 invalidParams := smithy.InvalidParamsError{Context: "ReplicationConfiguration"}
888 if v.Rules == nil {
889 invalidParams.Add(smithy.NewErrParamRequired("Rules"))
890 } else if v.Rules != nil {
891 if err := validateReplicationRuleList(v.Rules); err != nil {
892 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
893 }
894 }
895 if invalidParams.Len() > 0 {
896 return invalidParams
897 } else {
898 return nil
899 }
900 }
901
902 func validateReplicationDestination(v *types.ReplicationDestination) error {
903 if v == nil {
904 return nil
905 }
906 invalidParams := smithy.InvalidParamsError{Context: "ReplicationDestination"}
907 if v.Region == nil {
908 invalidParams.Add(smithy.NewErrParamRequired("Region"))
909 }
910 if v.RegistryId == nil {
911 invalidParams.Add(smithy.NewErrParamRequired("RegistryId"))
912 }
913 if invalidParams.Len() > 0 {
914 return invalidParams
915 } else {
916 return nil
917 }
918 }
919
920 func validateReplicationDestinationList(v []types.ReplicationDestination) error {
921 if v == nil {
922 return nil
923 }
924 invalidParams := smithy.InvalidParamsError{Context: "ReplicationDestinationList"}
925 for i := range v {
926 if err := validateReplicationDestination(&v[i]); err != nil {
927 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
928 }
929 }
930 if invalidParams.Len() > 0 {
931 return invalidParams
932 } else {
933 return nil
934 }
935 }
936
937 func validateReplicationRule(v *types.ReplicationRule) error {
938 if v == nil {
939 return nil
940 }
941 invalidParams := smithy.InvalidParamsError{Context: "ReplicationRule"}
942 if v.Destinations == nil {
943 invalidParams.Add(smithy.NewErrParamRequired("Destinations"))
944 } else if v.Destinations != nil {
945 if err := validateReplicationDestinationList(v.Destinations); err != nil {
946 invalidParams.AddNested("Destinations", err.(smithy.InvalidParamsError))
947 }
948 }
949 if v.RepositoryFilters != nil {
950 if err := validateRepositoryFilterList(v.RepositoryFilters); err != nil {
951 invalidParams.AddNested("RepositoryFilters", err.(smithy.InvalidParamsError))
952 }
953 }
954 if invalidParams.Len() > 0 {
955 return invalidParams
956 } else {
957 return nil
958 }
959 }
960
961 func validateReplicationRuleList(v []types.ReplicationRule) error {
962 if v == nil {
963 return nil
964 }
965 invalidParams := smithy.InvalidParamsError{Context: "ReplicationRuleList"}
966 for i := range v {
967 if err := validateReplicationRule(&v[i]); err != nil {
968 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
969 }
970 }
971 if invalidParams.Len() > 0 {
972 return invalidParams
973 } else {
974 return nil
975 }
976 }
977
978 func validateRepositoryFilter(v *types.RepositoryFilter) error {
979 if v == nil {
980 return nil
981 }
982 invalidParams := smithy.InvalidParamsError{Context: "RepositoryFilter"}
983 if v.Filter == nil {
984 invalidParams.Add(smithy.NewErrParamRequired("Filter"))
985 }
986 if len(v.FilterType) == 0 {
987 invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
988 }
989 if invalidParams.Len() > 0 {
990 return invalidParams
991 } else {
992 return nil
993 }
994 }
995
996 func validateRepositoryFilterList(v []types.RepositoryFilter) error {
997 if v == nil {
998 return nil
999 }
1000 invalidParams := smithy.InvalidParamsError{Context: "RepositoryFilterList"}
1001 for i := range v {
1002 if err := validateRepositoryFilter(&v[i]); err != nil {
1003 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1004 }
1005 }
1006 if invalidParams.Len() > 0 {
1007 return invalidParams
1008 } else {
1009 return nil
1010 }
1011 }
1012
1013 func validateScanningRepositoryFilter(v *types.ScanningRepositoryFilter) error {
1014 if v == nil {
1015 return nil
1016 }
1017 invalidParams := smithy.InvalidParamsError{Context: "ScanningRepositoryFilter"}
1018 if v.Filter == nil {
1019 invalidParams.Add(smithy.NewErrParamRequired("Filter"))
1020 }
1021 if len(v.FilterType) == 0 {
1022 invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
1023 }
1024 if invalidParams.Len() > 0 {
1025 return invalidParams
1026 } else {
1027 return nil
1028 }
1029 }
1030
1031 func validateScanningRepositoryFilterList(v []types.ScanningRepositoryFilter) error {
1032 if v == nil {
1033 return nil
1034 }
1035 invalidParams := smithy.InvalidParamsError{Context: "ScanningRepositoryFilterList"}
1036 for i := range v {
1037 if err := validateScanningRepositoryFilter(&v[i]); err != nil {
1038 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1039 }
1040 }
1041 if invalidParams.Len() > 0 {
1042 return invalidParams
1043 } else {
1044 return nil
1045 }
1046 }
1047
1048 func validateTag(v *types.Tag) error {
1049 if v == nil {
1050 return nil
1051 }
1052 invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1053 if v.Key == nil {
1054 invalidParams.Add(smithy.NewErrParamRequired("Key"))
1055 }
1056 if v.Value == nil {
1057 invalidParams.Add(smithy.NewErrParamRequired("Value"))
1058 }
1059 if invalidParams.Len() > 0 {
1060 return invalidParams
1061 } else {
1062 return nil
1063 }
1064 }
1065
1066 func validateTagList(v []types.Tag) error {
1067 if v == nil {
1068 return nil
1069 }
1070 invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1071 for i := range v {
1072 if err := validateTag(&v[i]); err != nil {
1073 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1074 }
1075 }
1076 if invalidParams.Len() > 0 {
1077 return invalidParams
1078 } else {
1079 return nil
1080 }
1081 }
1082
1083 func validateOpBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput) error {
1084 if v == nil {
1085 return nil
1086 }
1087 invalidParams := smithy.InvalidParamsError{Context: "BatchCheckLayerAvailabilityInput"}
1088 if v.RepositoryName == nil {
1089 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1090 }
1091 if v.LayerDigests == nil {
1092 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests"))
1093 }
1094 if invalidParams.Len() > 0 {
1095 return invalidParams
1096 } else {
1097 return nil
1098 }
1099 }
1100
1101 func validateOpBatchDeleteImageInput(v *BatchDeleteImageInput) error {
1102 if v == nil {
1103 return nil
1104 }
1105 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteImageInput"}
1106 if v.RepositoryName == nil {
1107 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1108 }
1109 if v.ImageIds == nil {
1110 invalidParams.Add(smithy.NewErrParamRequired("ImageIds"))
1111 }
1112 if invalidParams.Len() > 0 {
1113 return invalidParams
1114 } else {
1115 return nil
1116 }
1117 }
1118
1119 func validateOpBatchGetImageInput(v *BatchGetImageInput) error {
1120 if v == nil {
1121 return nil
1122 }
1123 invalidParams := smithy.InvalidParamsError{Context: "BatchGetImageInput"}
1124 if v.RepositoryName == nil {
1125 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1126 }
1127 if v.ImageIds == nil {
1128 invalidParams.Add(smithy.NewErrParamRequired("ImageIds"))
1129 }
1130 if invalidParams.Len() > 0 {
1131 return invalidParams
1132 } else {
1133 return nil
1134 }
1135 }
1136
1137 func validateOpBatchGetRepositoryScanningConfigurationInput(v *BatchGetRepositoryScanningConfigurationInput) error {
1138 if v == nil {
1139 return nil
1140 }
1141 invalidParams := smithy.InvalidParamsError{Context: "BatchGetRepositoryScanningConfigurationInput"}
1142 if v.RepositoryNames == nil {
1143 invalidParams.Add(smithy.NewErrParamRequired("RepositoryNames"))
1144 }
1145 if invalidParams.Len() > 0 {
1146 return invalidParams
1147 } else {
1148 return nil
1149 }
1150 }
1151
1152 func validateOpCompleteLayerUploadInput(v *CompleteLayerUploadInput) error {
1153 if v == nil {
1154 return nil
1155 }
1156 invalidParams := smithy.InvalidParamsError{Context: "CompleteLayerUploadInput"}
1157 if v.RepositoryName == nil {
1158 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1159 }
1160 if v.UploadId == nil {
1161 invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
1162 }
1163 if v.LayerDigests == nil {
1164 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests"))
1165 }
1166 if invalidParams.Len() > 0 {
1167 return invalidParams
1168 } else {
1169 return nil
1170 }
1171 }
1172
1173 func validateOpCreatePullThroughCacheRuleInput(v *CreatePullThroughCacheRuleInput) error {
1174 if v == nil {
1175 return nil
1176 }
1177 invalidParams := smithy.InvalidParamsError{Context: "CreatePullThroughCacheRuleInput"}
1178 if v.EcrRepositoryPrefix == nil {
1179 invalidParams.Add(smithy.NewErrParamRequired("EcrRepositoryPrefix"))
1180 }
1181 if v.UpstreamRegistryUrl == nil {
1182 invalidParams.Add(smithy.NewErrParamRequired("UpstreamRegistryUrl"))
1183 }
1184 if invalidParams.Len() > 0 {
1185 return invalidParams
1186 } else {
1187 return nil
1188 }
1189 }
1190
1191 func validateOpCreateRepositoryInput(v *CreateRepositoryInput) error {
1192 if v == nil {
1193 return nil
1194 }
1195 invalidParams := smithy.InvalidParamsError{Context: "CreateRepositoryInput"}
1196 if v.RepositoryName == nil {
1197 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1198 }
1199 if v.Tags != nil {
1200 if err := validateTagList(v.Tags); err != nil {
1201 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1202 }
1203 }
1204 if v.EncryptionConfiguration != nil {
1205 if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
1206 invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
1207 }
1208 }
1209 if invalidParams.Len() > 0 {
1210 return invalidParams
1211 } else {
1212 return nil
1213 }
1214 }
1215
1216 func validateOpDeleteLifecyclePolicyInput(v *DeleteLifecyclePolicyInput) error {
1217 if v == nil {
1218 return nil
1219 }
1220 invalidParams := smithy.InvalidParamsError{Context: "DeleteLifecyclePolicyInput"}
1221 if v.RepositoryName == nil {
1222 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1223 }
1224 if invalidParams.Len() > 0 {
1225 return invalidParams
1226 } else {
1227 return nil
1228 }
1229 }
1230
1231 func validateOpDeletePullThroughCacheRuleInput(v *DeletePullThroughCacheRuleInput) error {
1232 if v == nil {
1233 return nil
1234 }
1235 invalidParams := smithy.InvalidParamsError{Context: "DeletePullThroughCacheRuleInput"}
1236 if v.EcrRepositoryPrefix == nil {
1237 invalidParams.Add(smithy.NewErrParamRequired("EcrRepositoryPrefix"))
1238 }
1239 if invalidParams.Len() > 0 {
1240 return invalidParams
1241 } else {
1242 return nil
1243 }
1244 }
1245
1246 func validateOpDeleteRepositoryInput(v *DeleteRepositoryInput) error {
1247 if v == nil {
1248 return nil
1249 }
1250 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryInput"}
1251 if v.RepositoryName == nil {
1252 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1253 }
1254 if invalidParams.Len() > 0 {
1255 return invalidParams
1256 } else {
1257 return nil
1258 }
1259 }
1260
1261 func validateOpDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput) error {
1262 if v == nil {
1263 return nil
1264 }
1265 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryPolicyInput"}
1266 if v.RepositoryName == nil {
1267 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1268 }
1269 if invalidParams.Len() > 0 {
1270 return invalidParams
1271 } else {
1272 return nil
1273 }
1274 }
1275
1276 func validateOpDescribeImageReplicationStatusInput(v *DescribeImageReplicationStatusInput) error {
1277 if v == nil {
1278 return nil
1279 }
1280 invalidParams := smithy.InvalidParamsError{Context: "DescribeImageReplicationStatusInput"}
1281 if v.RepositoryName == nil {
1282 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1283 }
1284 if v.ImageId == nil {
1285 invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1286 }
1287 if invalidParams.Len() > 0 {
1288 return invalidParams
1289 } else {
1290 return nil
1291 }
1292 }
1293
1294 func validateOpDescribeImageScanFindingsInput(v *DescribeImageScanFindingsInput) error {
1295 if v == nil {
1296 return nil
1297 }
1298 invalidParams := smithy.InvalidParamsError{Context: "DescribeImageScanFindingsInput"}
1299 if v.RepositoryName == nil {
1300 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1301 }
1302 if v.ImageId == nil {
1303 invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1304 }
1305 if invalidParams.Len() > 0 {
1306 return invalidParams
1307 } else {
1308 return nil
1309 }
1310 }
1311
1312 func validateOpDescribeImagesInput(v *DescribeImagesInput) error {
1313 if v == nil {
1314 return nil
1315 }
1316 invalidParams := smithy.InvalidParamsError{Context: "DescribeImagesInput"}
1317 if v.RepositoryName == nil {
1318 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1319 }
1320 if invalidParams.Len() > 0 {
1321 return invalidParams
1322 } else {
1323 return nil
1324 }
1325 }
1326
1327 func validateOpGetDownloadUrlForLayerInput(v *GetDownloadUrlForLayerInput) error {
1328 if v == nil {
1329 return nil
1330 }
1331 invalidParams := smithy.InvalidParamsError{Context: "GetDownloadUrlForLayerInput"}
1332 if v.RepositoryName == nil {
1333 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1334 }
1335 if v.LayerDigest == nil {
1336 invalidParams.Add(smithy.NewErrParamRequired("LayerDigest"))
1337 }
1338 if invalidParams.Len() > 0 {
1339 return invalidParams
1340 } else {
1341 return nil
1342 }
1343 }
1344
1345 func validateOpGetLifecyclePolicyInput(v *GetLifecyclePolicyInput) error {
1346 if v == nil {
1347 return nil
1348 }
1349 invalidParams := smithy.InvalidParamsError{Context: "GetLifecyclePolicyInput"}
1350 if v.RepositoryName == nil {
1351 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1352 }
1353 if invalidParams.Len() > 0 {
1354 return invalidParams
1355 } else {
1356 return nil
1357 }
1358 }
1359
1360 func validateOpGetLifecyclePolicyPreviewInput(v *GetLifecyclePolicyPreviewInput) error {
1361 if v == nil {
1362 return nil
1363 }
1364 invalidParams := smithy.InvalidParamsError{Context: "GetLifecyclePolicyPreviewInput"}
1365 if v.RepositoryName == nil {
1366 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1367 }
1368 if invalidParams.Len() > 0 {
1369 return invalidParams
1370 } else {
1371 return nil
1372 }
1373 }
1374
1375 func validateOpGetRepositoryPolicyInput(v *GetRepositoryPolicyInput) error {
1376 if v == nil {
1377 return nil
1378 }
1379 invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryPolicyInput"}
1380 if v.RepositoryName == nil {
1381 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1382 }
1383 if invalidParams.Len() > 0 {
1384 return invalidParams
1385 } else {
1386 return nil
1387 }
1388 }
1389
1390 func validateOpInitiateLayerUploadInput(v *InitiateLayerUploadInput) error {
1391 if v == nil {
1392 return nil
1393 }
1394 invalidParams := smithy.InvalidParamsError{Context: "InitiateLayerUploadInput"}
1395 if v.RepositoryName == nil {
1396 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1397 }
1398 if invalidParams.Len() > 0 {
1399 return invalidParams
1400 } else {
1401 return nil
1402 }
1403 }
1404
1405 func validateOpListImagesInput(v *ListImagesInput) error {
1406 if v == nil {
1407 return nil
1408 }
1409 invalidParams := smithy.InvalidParamsError{Context: "ListImagesInput"}
1410 if v.RepositoryName == nil {
1411 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1412 }
1413 if invalidParams.Len() > 0 {
1414 return invalidParams
1415 } else {
1416 return nil
1417 }
1418 }
1419
1420 func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1421 if v == nil {
1422 return nil
1423 }
1424 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1425 if v.ResourceArn == nil {
1426 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1427 }
1428 if invalidParams.Len() > 0 {
1429 return invalidParams
1430 } else {
1431 return nil
1432 }
1433 }
1434
1435 func validateOpPutImageInput(v *PutImageInput) error {
1436 if v == nil {
1437 return nil
1438 }
1439 invalidParams := smithy.InvalidParamsError{Context: "PutImageInput"}
1440 if v.RepositoryName == nil {
1441 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1442 }
1443 if v.ImageManifest == nil {
1444 invalidParams.Add(smithy.NewErrParamRequired("ImageManifest"))
1445 }
1446 if invalidParams.Len() > 0 {
1447 return invalidParams
1448 } else {
1449 return nil
1450 }
1451 }
1452
1453 func validateOpPutImageScanningConfigurationInput(v *PutImageScanningConfigurationInput) error {
1454 if v == nil {
1455 return nil
1456 }
1457 invalidParams := smithy.InvalidParamsError{Context: "PutImageScanningConfigurationInput"}
1458 if v.RepositoryName == nil {
1459 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1460 }
1461 if v.ImageScanningConfiguration == nil {
1462 invalidParams.Add(smithy.NewErrParamRequired("ImageScanningConfiguration"))
1463 }
1464 if invalidParams.Len() > 0 {
1465 return invalidParams
1466 } else {
1467 return nil
1468 }
1469 }
1470
1471 func validateOpPutImageTagMutabilityInput(v *PutImageTagMutabilityInput) error {
1472 if v == nil {
1473 return nil
1474 }
1475 invalidParams := smithy.InvalidParamsError{Context: "PutImageTagMutabilityInput"}
1476 if v.RepositoryName == nil {
1477 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1478 }
1479 if len(v.ImageTagMutability) == 0 {
1480 invalidParams.Add(smithy.NewErrParamRequired("ImageTagMutability"))
1481 }
1482 if invalidParams.Len() > 0 {
1483 return invalidParams
1484 } else {
1485 return nil
1486 }
1487 }
1488
1489 func validateOpPutLifecyclePolicyInput(v *PutLifecyclePolicyInput) error {
1490 if v == nil {
1491 return nil
1492 }
1493 invalidParams := smithy.InvalidParamsError{Context: "PutLifecyclePolicyInput"}
1494 if v.RepositoryName == nil {
1495 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1496 }
1497 if v.LifecyclePolicyText == nil {
1498 invalidParams.Add(smithy.NewErrParamRequired("LifecyclePolicyText"))
1499 }
1500 if invalidParams.Len() > 0 {
1501 return invalidParams
1502 } else {
1503 return nil
1504 }
1505 }
1506
1507 func validateOpPutRegistryPolicyInput(v *PutRegistryPolicyInput) error {
1508 if v == nil {
1509 return nil
1510 }
1511 invalidParams := smithy.InvalidParamsError{Context: "PutRegistryPolicyInput"}
1512 if v.PolicyText == nil {
1513 invalidParams.Add(smithy.NewErrParamRequired("PolicyText"))
1514 }
1515 if invalidParams.Len() > 0 {
1516 return invalidParams
1517 } else {
1518 return nil
1519 }
1520 }
1521
1522 func validateOpPutRegistryScanningConfigurationInput(v *PutRegistryScanningConfigurationInput) error {
1523 if v == nil {
1524 return nil
1525 }
1526 invalidParams := smithy.InvalidParamsError{Context: "PutRegistryScanningConfigurationInput"}
1527 if v.Rules != nil {
1528 if err := validateRegistryScanningRuleList(v.Rules); err != nil {
1529 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
1530 }
1531 }
1532 if invalidParams.Len() > 0 {
1533 return invalidParams
1534 } else {
1535 return nil
1536 }
1537 }
1538
1539 func validateOpPutReplicationConfigurationInput(v *PutReplicationConfigurationInput) error {
1540 if v == nil {
1541 return nil
1542 }
1543 invalidParams := smithy.InvalidParamsError{Context: "PutReplicationConfigurationInput"}
1544 if v.ReplicationConfiguration == nil {
1545 invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfiguration"))
1546 } else if v.ReplicationConfiguration != nil {
1547 if err := validateReplicationConfiguration(v.ReplicationConfiguration); err != nil {
1548 invalidParams.AddNested("ReplicationConfiguration", err.(smithy.InvalidParamsError))
1549 }
1550 }
1551 if invalidParams.Len() > 0 {
1552 return invalidParams
1553 } else {
1554 return nil
1555 }
1556 }
1557
1558 func validateOpSetRepositoryPolicyInput(v *SetRepositoryPolicyInput) error {
1559 if v == nil {
1560 return nil
1561 }
1562 invalidParams := smithy.InvalidParamsError{Context: "SetRepositoryPolicyInput"}
1563 if v.RepositoryName == nil {
1564 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1565 }
1566 if v.PolicyText == nil {
1567 invalidParams.Add(smithy.NewErrParamRequired("PolicyText"))
1568 }
1569 if invalidParams.Len() > 0 {
1570 return invalidParams
1571 } else {
1572 return nil
1573 }
1574 }
1575
1576 func validateOpStartImageScanInput(v *StartImageScanInput) error {
1577 if v == nil {
1578 return nil
1579 }
1580 invalidParams := smithy.InvalidParamsError{Context: "StartImageScanInput"}
1581 if v.RepositoryName == nil {
1582 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1583 }
1584 if v.ImageId == nil {
1585 invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
1586 }
1587 if invalidParams.Len() > 0 {
1588 return invalidParams
1589 } else {
1590 return nil
1591 }
1592 }
1593
1594 func validateOpStartLifecyclePolicyPreviewInput(v *StartLifecyclePolicyPreviewInput) error {
1595 if v == nil {
1596 return nil
1597 }
1598 invalidParams := smithy.InvalidParamsError{Context: "StartLifecyclePolicyPreviewInput"}
1599 if v.RepositoryName == nil {
1600 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1601 }
1602 if invalidParams.Len() > 0 {
1603 return invalidParams
1604 } else {
1605 return nil
1606 }
1607 }
1608
1609 func validateOpTagResourceInput(v *TagResourceInput) error {
1610 if v == nil {
1611 return nil
1612 }
1613 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1614 if v.ResourceArn == nil {
1615 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1616 }
1617 if v.Tags == nil {
1618 invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1619 } else if v.Tags != nil {
1620 if err := validateTagList(v.Tags); err != nil {
1621 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1622 }
1623 }
1624 if invalidParams.Len() > 0 {
1625 return invalidParams
1626 } else {
1627 return nil
1628 }
1629 }
1630
1631 func validateOpUntagResourceInput(v *UntagResourceInput) error {
1632 if v == nil {
1633 return nil
1634 }
1635 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1636 if v.ResourceArn == nil {
1637 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1638 }
1639 if v.TagKeys == nil {
1640 invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1641 }
1642 if invalidParams.Len() > 0 {
1643 return invalidParams
1644 } else {
1645 return nil
1646 }
1647 }
1648
1649 func validateOpUploadLayerPartInput(v *UploadLayerPartInput) error {
1650 if v == nil {
1651 return nil
1652 }
1653 invalidParams := smithy.InvalidParamsError{Context: "UploadLayerPartInput"}
1654 if v.RepositoryName == nil {
1655 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
1656 }
1657 if v.UploadId == nil {
1658 invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
1659 }
1660 if v.PartFirstByte == nil {
1661 invalidParams.Add(smithy.NewErrParamRequired("PartFirstByte"))
1662 }
1663 if v.PartLastByte == nil {
1664 invalidParams.Add(smithy.NewErrParamRequired("PartLastByte"))
1665 }
1666 if v.LayerPartBlob == nil {
1667 invalidParams.Add(smithy.NewErrParamRequired("LayerPartBlob"))
1668 }
1669 if invalidParams.Len() > 0 {
1670 return invalidParams
1671 } else {
1672 return nil
1673 }
1674 }
1675
View as plain text