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