1
2
3 package ecrpublic
4
5 import (
6 "context"
7 "fmt"
8 smithy "github.com/aws/smithy-go"
9 "github.com/aws/smithy-go/middleware"
10 )
11
12 type validateOpBatchCheckLayerAvailability struct {
13 }
14
15 func (*validateOpBatchCheckLayerAvailability) ID() string {
16 return "OperationInputValidation"
17 }
18
19 func (m *validateOpBatchCheckLayerAvailability) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21 ) {
22 input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput)
23 if !ok {
24 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25 }
26 if err := validateOpBatchCheckLayerAvailabilityInput(input); err != nil {
27 return out, metadata, err
28 }
29 return next.HandleInitialize(ctx, in)
30 }
31
32 type validateOpBatchDeleteImage struct {
33 }
34
35 func (*validateOpBatchDeleteImage) ID() string {
36 return "OperationInputValidation"
37 }
38
39 func (m *validateOpBatchDeleteImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41 ) {
42 input, ok := in.Parameters.(*BatchDeleteImageInput)
43 if !ok {
44 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45 }
46 if err := validateOpBatchDeleteImageInput(input); err != nil {
47 return out, metadata, err
48 }
49 return next.HandleInitialize(ctx, in)
50 }
51
52 type validateOpCompleteLayerUpload struct {
53 }
54
55 func (*validateOpCompleteLayerUpload) ID() string {
56 return "OperationInputValidation"
57 }
58
59 func (m *validateOpCompleteLayerUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61 ) {
62 input, ok := in.Parameters.(*CompleteLayerUploadInput)
63 if !ok {
64 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65 }
66 if err := validateOpCompleteLayerUploadInput(input); err != nil {
67 return out, metadata, err
68 }
69 return next.HandleInitialize(ctx, in)
70 }
71
72 type validateOpCreateRepository struct {
73 }
74
75 func (*validateOpCreateRepository) ID() string {
76 return "OperationInputValidation"
77 }
78
79 func (m *validateOpCreateRepository) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81 ) {
82 input, ok := in.Parameters.(*CreateRepositoryInput)
83 if !ok {
84 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85 }
86 if err := validateOpCreateRepositoryInput(input); err != nil {
87 return out, metadata, err
88 }
89 return next.HandleInitialize(ctx, in)
90 }
91
92 type validateOpDeleteRepository struct {
93 }
94
95 func (*validateOpDeleteRepository) ID() string {
96 return "OperationInputValidation"
97 }
98
99 func (m *validateOpDeleteRepository) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101 ) {
102 input, ok := in.Parameters.(*DeleteRepositoryInput)
103 if !ok {
104 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105 }
106 if err := validateOpDeleteRepositoryInput(input); err != nil {
107 return out, metadata, err
108 }
109 return next.HandleInitialize(ctx, in)
110 }
111
112 type validateOpDeleteRepositoryPolicy struct {
113 }
114
115 func (*validateOpDeleteRepositoryPolicy) ID() string {
116 return "OperationInputValidation"
117 }
118
119 func (m *validateOpDeleteRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121 ) {
122 input, ok := in.Parameters.(*DeleteRepositoryPolicyInput)
123 if !ok {
124 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125 }
126 if err := validateOpDeleteRepositoryPolicyInput(input); err != nil {
127 return out, metadata, err
128 }
129 return next.HandleInitialize(ctx, in)
130 }
131
132 type validateOpDescribeImages struct {
133 }
134
135 func (*validateOpDescribeImages) ID() string {
136 return "OperationInputValidation"
137 }
138
139 func (m *validateOpDescribeImages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141 ) {
142 input, ok := in.Parameters.(*DescribeImagesInput)
143 if !ok {
144 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145 }
146 if err := validateOpDescribeImagesInput(input); err != nil {
147 return out, metadata, err
148 }
149 return next.HandleInitialize(ctx, in)
150 }
151
152 type validateOpDescribeImageTags struct {
153 }
154
155 func (*validateOpDescribeImageTags) ID() string {
156 return "OperationInputValidation"
157 }
158
159 func (m *validateOpDescribeImageTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161 ) {
162 input, ok := in.Parameters.(*DescribeImageTagsInput)
163 if !ok {
164 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165 }
166 if err := validateOpDescribeImageTagsInput(input); err != nil {
167 return out, metadata, err
168 }
169 return next.HandleInitialize(ctx, in)
170 }
171
172 type validateOpGetRepositoryCatalogData struct {
173 }
174
175 func (*validateOpGetRepositoryCatalogData) ID() string {
176 return "OperationInputValidation"
177 }
178
179 func (m *validateOpGetRepositoryCatalogData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181 ) {
182 input, ok := in.Parameters.(*GetRepositoryCatalogDataInput)
183 if !ok {
184 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185 }
186 if err := validateOpGetRepositoryCatalogDataInput(input); err != nil {
187 return out, metadata, err
188 }
189 return next.HandleInitialize(ctx, in)
190 }
191
192 type validateOpGetRepositoryPolicy struct {
193 }
194
195 func (*validateOpGetRepositoryPolicy) ID() string {
196 return "OperationInputValidation"
197 }
198
199 func (m *validateOpGetRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201 ) {
202 input, ok := in.Parameters.(*GetRepositoryPolicyInput)
203 if !ok {
204 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205 }
206 if err := validateOpGetRepositoryPolicyInput(input); err != nil {
207 return out, metadata, err
208 }
209 return next.HandleInitialize(ctx, in)
210 }
211
212 type validateOpInitiateLayerUpload struct {
213 }
214
215 func (*validateOpInitiateLayerUpload) ID() string {
216 return "OperationInputValidation"
217 }
218
219 func (m *validateOpInitiateLayerUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221 ) {
222 input, ok := in.Parameters.(*InitiateLayerUploadInput)
223 if !ok {
224 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225 }
226 if err := validateOpInitiateLayerUploadInput(input); err != nil {
227 return out, metadata, err
228 }
229 return next.HandleInitialize(ctx, in)
230 }
231
232 type validateOpListTagsForResource struct {
233 }
234
235 func (*validateOpListTagsForResource) ID() string {
236 return "OperationInputValidation"
237 }
238
239 func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241 ) {
242 input, ok := in.Parameters.(*ListTagsForResourceInput)
243 if !ok {
244 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245 }
246 if err := validateOpListTagsForResourceInput(input); err != nil {
247 return out, metadata, err
248 }
249 return next.HandleInitialize(ctx, in)
250 }
251
252 type validateOpPutImage struct {
253 }
254
255 func (*validateOpPutImage) ID() string {
256 return "OperationInputValidation"
257 }
258
259 func (m *validateOpPutImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261 ) {
262 input, ok := in.Parameters.(*PutImageInput)
263 if !ok {
264 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265 }
266 if err := validateOpPutImageInput(input); err != nil {
267 return out, metadata, err
268 }
269 return next.HandleInitialize(ctx, in)
270 }
271
272 type validateOpPutRepositoryCatalogData struct {
273 }
274
275 func (*validateOpPutRepositoryCatalogData) ID() string {
276 return "OperationInputValidation"
277 }
278
279 func (m *validateOpPutRepositoryCatalogData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281 ) {
282 input, ok := in.Parameters.(*PutRepositoryCatalogDataInput)
283 if !ok {
284 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285 }
286 if err := validateOpPutRepositoryCatalogDataInput(input); err != nil {
287 return out, metadata, err
288 }
289 return next.HandleInitialize(ctx, in)
290 }
291
292 type validateOpSetRepositoryPolicy struct {
293 }
294
295 func (*validateOpSetRepositoryPolicy) ID() string {
296 return "OperationInputValidation"
297 }
298
299 func (m *validateOpSetRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301 ) {
302 input, ok := in.Parameters.(*SetRepositoryPolicyInput)
303 if !ok {
304 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305 }
306 if err := validateOpSetRepositoryPolicyInput(input); err != nil {
307 return out, metadata, err
308 }
309 return next.HandleInitialize(ctx, in)
310 }
311
312 type validateOpTagResource struct {
313 }
314
315 func (*validateOpTagResource) ID() string {
316 return "OperationInputValidation"
317 }
318
319 func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321 ) {
322 input, ok := in.Parameters.(*TagResourceInput)
323 if !ok {
324 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325 }
326 if err := validateOpTagResourceInput(input); err != nil {
327 return out, metadata, err
328 }
329 return next.HandleInitialize(ctx, in)
330 }
331
332 type validateOpUntagResource struct {
333 }
334
335 func (*validateOpUntagResource) ID() string {
336 return "OperationInputValidation"
337 }
338
339 func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341 ) {
342 input, ok := in.Parameters.(*UntagResourceInput)
343 if !ok {
344 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345 }
346 if err := validateOpUntagResourceInput(input); err != nil {
347 return out, metadata, err
348 }
349 return next.HandleInitialize(ctx, in)
350 }
351
352 type validateOpUploadLayerPart struct {
353 }
354
355 func (*validateOpUploadLayerPart) ID() string {
356 return "OperationInputValidation"
357 }
358
359 func (m *validateOpUploadLayerPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360 out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361 ) {
362 input, ok := in.Parameters.(*UploadLayerPartInput)
363 if !ok {
364 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365 }
366 if err := validateOpUploadLayerPartInput(input); err != nil {
367 return out, metadata, err
368 }
369 return next.HandleInitialize(ctx, in)
370 }
371
372 func addOpBatchCheckLayerAvailabilityValidationMiddleware(stack *middleware.Stack) error {
373 return stack.Initialize.Add(&validateOpBatchCheckLayerAvailability{}, middleware.After)
374 }
375
376 func addOpBatchDeleteImageValidationMiddleware(stack *middleware.Stack) error {
377 return stack.Initialize.Add(&validateOpBatchDeleteImage{}, middleware.After)
378 }
379
380 func addOpCompleteLayerUploadValidationMiddleware(stack *middleware.Stack) error {
381 return stack.Initialize.Add(&validateOpCompleteLayerUpload{}, middleware.After)
382 }
383
384 func addOpCreateRepositoryValidationMiddleware(stack *middleware.Stack) error {
385 return stack.Initialize.Add(&validateOpCreateRepository{}, middleware.After)
386 }
387
388 func addOpDeleteRepositoryValidationMiddleware(stack *middleware.Stack) error {
389 return stack.Initialize.Add(&validateOpDeleteRepository{}, middleware.After)
390 }
391
392 func addOpDeleteRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
393 return stack.Initialize.Add(&validateOpDeleteRepositoryPolicy{}, middleware.After)
394 }
395
396 func addOpDescribeImagesValidationMiddleware(stack *middleware.Stack) error {
397 return stack.Initialize.Add(&validateOpDescribeImages{}, middleware.After)
398 }
399
400 func addOpDescribeImageTagsValidationMiddleware(stack *middleware.Stack) error {
401 return stack.Initialize.Add(&validateOpDescribeImageTags{}, middleware.After)
402 }
403
404 func addOpGetRepositoryCatalogDataValidationMiddleware(stack *middleware.Stack) error {
405 return stack.Initialize.Add(&validateOpGetRepositoryCatalogData{}, middleware.After)
406 }
407
408 func addOpGetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
409 return stack.Initialize.Add(&validateOpGetRepositoryPolicy{}, middleware.After)
410 }
411
412 func addOpInitiateLayerUploadValidationMiddleware(stack *middleware.Stack) error {
413 return stack.Initialize.Add(&validateOpInitiateLayerUpload{}, middleware.After)
414 }
415
416 func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
417 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
418 }
419
420 func addOpPutImageValidationMiddleware(stack *middleware.Stack) error {
421 return stack.Initialize.Add(&validateOpPutImage{}, middleware.After)
422 }
423
424 func addOpPutRepositoryCatalogDataValidationMiddleware(stack *middleware.Stack) error {
425 return stack.Initialize.Add(&validateOpPutRepositoryCatalogData{}, middleware.After)
426 }
427
428 func addOpSetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error {
429 return stack.Initialize.Add(&validateOpSetRepositoryPolicy{}, middleware.After)
430 }
431
432 func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
433 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
434 }
435
436 func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
437 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
438 }
439
440 func addOpUploadLayerPartValidationMiddleware(stack *middleware.Stack) error {
441 return stack.Initialize.Add(&validateOpUploadLayerPart{}, middleware.After)
442 }
443
444 func validateOpBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput) error {
445 if v == nil {
446 return nil
447 }
448 invalidParams := smithy.InvalidParamsError{Context: "BatchCheckLayerAvailabilityInput"}
449 if v.RepositoryName == nil {
450 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
451 }
452 if v.LayerDigests == nil {
453 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests"))
454 }
455 if invalidParams.Len() > 0 {
456 return invalidParams
457 } else {
458 return nil
459 }
460 }
461
462 func validateOpBatchDeleteImageInput(v *BatchDeleteImageInput) error {
463 if v == nil {
464 return nil
465 }
466 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteImageInput"}
467 if v.RepositoryName == nil {
468 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
469 }
470 if v.ImageIds == nil {
471 invalidParams.Add(smithy.NewErrParamRequired("ImageIds"))
472 }
473 if invalidParams.Len() > 0 {
474 return invalidParams
475 } else {
476 return nil
477 }
478 }
479
480 func validateOpCompleteLayerUploadInput(v *CompleteLayerUploadInput) error {
481 if v == nil {
482 return nil
483 }
484 invalidParams := smithy.InvalidParamsError{Context: "CompleteLayerUploadInput"}
485 if v.RepositoryName == nil {
486 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
487 }
488 if v.UploadId == nil {
489 invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
490 }
491 if v.LayerDigests == nil {
492 invalidParams.Add(smithy.NewErrParamRequired("LayerDigests"))
493 }
494 if invalidParams.Len() > 0 {
495 return invalidParams
496 } else {
497 return nil
498 }
499 }
500
501 func validateOpCreateRepositoryInput(v *CreateRepositoryInput) error {
502 if v == nil {
503 return nil
504 }
505 invalidParams := smithy.InvalidParamsError{Context: "CreateRepositoryInput"}
506 if v.RepositoryName == nil {
507 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
508 }
509 if invalidParams.Len() > 0 {
510 return invalidParams
511 } else {
512 return nil
513 }
514 }
515
516 func validateOpDeleteRepositoryInput(v *DeleteRepositoryInput) error {
517 if v == nil {
518 return nil
519 }
520 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryInput"}
521 if v.RepositoryName == nil {
522 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
523 }
524 if invalidParams.Len() > 0 {
525 return invalidParams
526 } else {
527 return nil
528 }
529 }
530
531 func validateOpDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput) error {
532 if v == nil {
533 return nil
534 }
535 invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryPolicyInput"}
536 if v.RepositoryName == nil {
537 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
538 }
539 if invalidParams.Len() > 0 {
540 return invalidParams
541 } else {
542 return nil
543 }
544 }
545
546 func validateOpDescribeImagesInput(v *DescribeImagesInput) error {
547 if v == nil {
548 return nil
549 }
550 invalidParams := smithy.InvalidParamsError{Context: "DescribeImagesInput"}
551 if v.RepositoryName == nil {
552 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
553 }
554 if invalidParams.Len() > 0 {
555 return invalidParams
556 } else {
557 return nil
558 }
559 }
560
561 func validateOpDescribeImageTagsInput(v *DescribeImageTagsInput) error {
562 if v == nil {
563 return nil
564 }
565 invalidParams := smithy.InvalidParamsError{Context: "DescribeImageTagsInput"}
566 if v.RepositoryName == nil {
567 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
568 }
569 if invalidParams.Len() > 0 {
570 return invalidParams
571 } else {
572 return nil
573 }
574 }
575
576 func validateOpGetRepositoryCatalogDataInput(v *GetRepositoryCatalogDataInput) error {
577 if v == nil {
578 return nil
579 }
580 invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryCatalogDataInput"}
581 if v.RepositoryName == nil {
582 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
583 }
584 if invalidParams.Len() > 0 {
585 return invalidParams
586 } else {
587 return nil
588 }
589 }
590
591 func validateOpGetRepositoryPolicyInput(v *GetRepositoryPolicyInput) error {
592 if v == nil {
593 return nil
594 }
595 invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryPolicyInput"}
596 if v.RepositoryName == nil {
597 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
598 }
599 if invalidParams.Len() > 0 {
600 return invalidParams
601 } else {
602 return nil
603 }
604 }
605
606 func validateOpInitiateLayerUploadInput(v *InitiateLayerUploadInput) error {
607 if v == nil {
608 return nil
609 }
610 invalidParams := smithy.InvalidParamsError{Context: "InitiateLayerUploadInput"}
611 if v.RepositoryName == nil {
612 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
613 }
614 if invalidParams.Len() > 0 {
615 return invalidParams
616 } else {
617 return nil
618 }
619 }
620
621 func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
622 if v == nil {
623 return nil
624 }
625 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
626 if v.ResourceArn == nil {
627 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
628 }
629 if invalidParams.Len() > 0 {
630 return invalidParams
631 } else {
632 return nil
633 }
634 }
635
636 func validateOpPutImageInput(v *PutImageInput) error {
637 if v == nil {
638 return nil
639 }
640 invalidParams := smithy.InvalidParamsError{Context: "PutImageInput"}
641 if v.RepositoryName == nil {
642 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
643 }
644 if v.ImageManifest == nil {
645 invalidParams.Add(smithy.NewErrParamRequired("ImageManifest"))
646 }
647 if invalidParams.Len() > 0 {
648 return invalidParams
649 } else {
650 return nil
651 }
652 }
653
654 func validateOpPutRepositoryCatalogDataInput(v *PutRepositoryCatalogDataInput) error {
655 if v == nil {
656 return nil
657 }
658 invalidParams := smithy.InvalidParamsError{Context: "PutRepositoryCatalogDataInput"}
659 if v.RepositoryName == nil {
660 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
661 }
662 if v.CatalogData == nil {
663 invalidParams.Add(smithy.NewErrParamRequired("CatalogData"))
664 }
665 if invalidParams.Len() > 0 {
666 return invalidParams
667 } else {
668 return nil
669 }
670 }
671
672 func validateOpSetRepositoryPolicyInput(v *SetRepositoryPolicyInput) error {
673 if v == nil {
674 return nil
675 }
676 invalidParams := smithy.InvalidParamsError{Context: "SetRepositoryPolicyInput"}
677 if v.RepositoryName == nil {
678 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
679 }
680 if v.PolicyText == nil {
681 invalidParams.Add(smithy.NewErrParamRequired("PolicyText"))
682 }
683 if invalidParams.Len() > 0 {
684 return invalidParams
685 } else {
686 return nil
687 }
688 }
689
690 func validateOpTagResourceInput(v *TagResourceInput) error {
691 if v == nil {
692 return nil
693 }
694 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
695 if v.ResourceArn == nil {
696 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
697 }
698 if v.Tags == nil {
699 invalidParams.Add(smithy.NewErrParamRequired("Tags"))
700 }
701 if invalidParams.Len() > 0 {
702 return invalidParams
703 } else {
704 return nil
705 }
706 }
707
708 func validateOpUntagResourceInput(v *UntagResourceInput) error {
709 if v == nil {
710 return nil
711 }
712 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
713 if v.ResourceArn == nil {
714 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
715 }
716 if v.TagKeys == nil {
717 invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
718 }
719 if invalidParams.Len() > 0 {
720 return invalidParams
721 } else {
722 return nil
723 }
724 }
725
726 func validateOpUploadLayerPartInput(v *UploadLayerPartInput) error {
727 if v == nil {
728 return nil
729 }
730 invalidParams := smithy.InvalidParamsError{Context: "UploadLayerPartInput"}
731 if v.RepositoryName == nil {
732 invalidParams.Add(smithy.NewErrParamRequired("RepositoryName"))
733 }
734 if v.UploadId == nil {
735 invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
736 }
737 if v.PartFirstByte == nil {
738 invalidParams.Add(smithy.NewErrParamRequired("PartFirstByte"))
739 }
740 if v.PartLastByte == nil {
741 invalidParams.Add(smithy.NewErrParamRequired("PartLastByte"))
742 }
743 if v.LayerPartBlob == nil {
744 invalidParams.Add(smithy.NewErrParamRequired("LayerPartBlob"))
745 }
746 if invalidParams.Len() > 0 {
747 return invalidParams
748 } else {
749 return nil
750 }
751 }
752
View as plain text