1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package acmpca
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/acmpca/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateCertificateAuthorityAuditReport struct {
14}
15
16func (*validateOpCreateCertificateAuthorityAuditReport) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateCertificateAuthorityAuditReport) 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.(*CreateCertificateAuthorityAuditReportInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateCertificateAuthorityAuditReportInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateCertificateAuthority struct {
34}
35
36func (*validateOpCreateCertificateAuthority) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateCertificateAuthority) 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.(*CreateCertificateAuthorityInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateCertificateAuthorityInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreatePermission struct {
54}
55
56func (*validateOpCreatePermission) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreatePermission) 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.(*CreatePermissionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreatePermissionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteCertificateAuthority struct {
74}
75
76func (*validateOpDeleteCertificateAuthority) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteCertificateAuthority) 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.(*DeleteCertificateAuthorityInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteCertificateAuthorityInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeletePermission struct {
94}
95
96func (*validateOpDeletePermission) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeletePermission) 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.(*DeletePermissionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeletePermissionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeletePolicy struct {
114}
115
116func (*validateOpDeletePolicy) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeletePolicy) 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.(*DeletePolicyInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeletePolicyInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDescribeCertificateAuthorityAuditReport struct {
134}
135
136func (*validateOpDescribeCertificateAuthorityAuditReport) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDescribeCertificateAuthorityAuditReport) 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.(*DescribeCertificateAuthorityAuditReportInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDescribeCertificateAuthorityAuditReportInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDescribeCertificateAuthority struct {
154}
155
156func (*validateOpDescribeCertificateAuthority) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDescribeCertificateAuthority) 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.(*DescribeCertificateAuthorityInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDescribeCertificateAuthorityInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpGetCertificateAuthorityCertificate struct {
174}
175
176func (*validateOpGetCertificateAuthorityCertificate) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpGetCertificateAuthorityCertificate) 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.(*GetCertificateAuthorityCertificateInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpGetCertificateAuthorityCertificateInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpGetCertificateAuthorityCsr struct {
194}
195
196func (*validateOpGetCertificateAuthorityCsr) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpGetCertificateAuthorityCsr) 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.(*GetCertificateAuthorityCsrInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpGetCertificateAuthorityCsrInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGetCertificate struct {
214}
215
216func (*validateOpGetCertificate) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGetCertificate) 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.(*GetCertificateInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGetCertificateInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetPolicy struct {
234}
235
236func (*validateOpGetPolicy) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetPolicy) 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.(*GetPolicyInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetPolicyInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpImportCertificateAuthorityCertificate struct {
254}
255
256func (*validateOpImportCertificateAuthorityCertificate) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpImportCertificateAuthorityCertificate) 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.(*ImportCertificateAuthorityCertificateInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpImportCertificateAuthorityCertificateInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpIssueCertificate struct {
274}
275
276func (*validateOpIssueCertificate) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpIssueCertificate) 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.(*IssueCertificateInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpIssueCertificateInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpListPermissions struct {
294}
295
296func (*validateOpListPermissions) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpListPermissions) 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.(*ListPermissionsInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpListPermissionsInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpListTags struct {
314}
315
316func (*validateOpListTags) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpListTags) 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.(*ListTagsInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpListTagsInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpPutPolicy struct {
334}
335
336func (*validateOpPutPolicy) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpPutPolicy) 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.(*PutPolicyInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpPutPolicyInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpRestoreCertificateAuthority struct {
354}
355
356func (*validateOpRestoreCertificateAuthority) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpRestoreCertificateAuthority) 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.(*RestoreCertificateAuthorityInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpRestoreCertificateAuthorityInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpRevokeCertificate struct {
374}
375
376func (*validateOpRevokeCertificate) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpRevokeCertificate) 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.(*RevokeCertificateInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpRevokeCertificateInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpTagCertificateAuthority struct {
394}
395
396func (*validateOpTagCertificateAuthority) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpTagCertificateAuthority) 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.(*TagCertificateAuthorityInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpTagCertificateAuthorityInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUntagCertificateAuthority struct {
414}
415
416func (*validateOpUntagCertificateAuthority) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUntagCertificateAuthority) 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.(*UntagCertificateAuthorityInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUntagCertificateAuthorityInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUpdateCertificateAuthority struct {
434}
435
436func (*validateOpUpdateCertificateAuthority) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUpdateCertificateAuthority) 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.(*UpdateCertificateAuthorityInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUpdateCertificateAuthorityInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453func addOpCreateCertificateAuthorityAuditReportValidationMiddleware(stack *middleware.Stack) error {
454	return stack.Initialize.Add(&validateOpCreateCertificateAuthorityAuditReport{}, middleware.After)
455}
456
457func addOpCreateCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
458	return stack.Initialize.Add(&validateOpCreateCertificateAuthority{}, middleware.After)
459}
460
461func addOpCreatePermissionValidationMiddleware(stack *middleware.Stack) error {
462	return stack.Initialize.Add(&validateOpCreatePermission{}, middleware.After)
463}
464
465func addOpDeleteCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
466	return stack.Initialize.Add(&validateOpDeleteCertificateAuthority{}, middleware.After)
467}
468
469func addOpDeletePermissionValidationMiddleware(stack *middleware.Stack) error {
470	return stack.Initialize.Add(&validateOpDeletePermission{}, middleware.After)
471}
472
473func addOpDeletePolicyValidationMiddleware(stack *middleware.Stack) error {
474	return stack.Initialize.Add(&validateOpDeletePolicy{}, middleware.After)
475}
476
477func addOpDescribeCertificateAuthorityAuditReportValidationMiddleware(stack *middleware.Stack) error {
478	return stack.Initialize.Add(&validateOpDescribeCertificateAuthorityAuditReport{}, middleware.After)
479}
480
481func addOpDescribeCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
482	return stack.Initialize.Add(&validateOpDescribeCertificateAuthority{}, middleware.After)
483}
484
485func addOpGetCertificateAuthorityCertificateValidationMiddleware(stack *middleware.Stack) error {
486	return stack.Initialize.Add(&validateOpGetCertificateAuthorityCertificate{}, middleware.After)
487}
488
489func addOpGetCertificateAuthorityCsrValidationMiddleware(stack *middleware.Stack) error {
490	return stack.Initialize.Add(&validateOpGetCertificateAuthorityCsr{}, middleware.After)
491}
492
493func addOpGetCertificateValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpGetCertificate{}, middleware.After)
495}
496
497func addOpGetPolicyValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpGetPolicy{}, middleware.After)
499}
500
501func addOpImportCertificateAuthorityCertificateValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpImportCertificateAuthorityCertificate{}, middleware.After)
503}
504
505func addOpIssueCertificateValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpIssueCertificate{}, middleware.After)
507}
508
509func addOpListPermissionsValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpListPermissions{}, middleware.After)
511}
512
513func addOpListTagsValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpListTags{}, middleware.After)
515}
516
517func addOpPutPolicyValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpPutPolicy{}, middleware.After)
519}
520
521func addOpRestoreCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpRestoreCertificateAuthority{}, middleware.After)
523}
524
525func addOpRevokeCertificateValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpRevokeCertificate{}, middleware.After)
527}
528
529func addOpTagCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpTagCertificateAuthority{}, middleware.After)
531}
532
533func addOpUntagCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpUntagCertificateAuthority{}, middleware.After)
535}
536
537func addOpUpdateCertificateAuthorityValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpUpdateCertificateAuthority{}, middleware.After)
539}
540
541func validateCertificateAuthorityConfiguration(v *types.CertificateAuthorityConfiguration) error {
542	if v == nil {
543		return nil
544	}
545	invalidParams := smithy.InvalidParamsError{Context: "CertificateAuthorityConfiguration"}
546	if len(v.KeyAlgorithm) == 0 {
547		invalidParams.Add(smithy.NewErrParamRequired("KeyAlgorithm"))
548	}
549	if len(v.SigningAlgorithm) == 0 {
550		invalidParams.Add(smithy.NewErrParamRequired("SigningAlgorithm"))
551	}
552	if v.Subject == nil {
553		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
554	}
555	if invalidParams.Len() > 0 {
556		return invalidParams
557	} else {
558		return nil
559	}
560}
561
562func validateCrlConfiguration(v *types.CrlConfiguration) error {
563	if v == nil {
564		return nil
565	}
566	invalidParams := smithy.InvalidParamsError{Context: "CrlConfiguration"}
567	if invalidParams.Len() > 0 {
568		return invalidParams
569	} else {
570		return nil
571	}
572}
573
574func validateRevocationConfiguration(v *types.RevocationConfiguration) error {
575	if v == nil {
576		return nil
577	}
578	invalidParams := smithy.InvalidParamsError{Context: "RevocationConfiguration"}
579	if v.CrlConfiguration != nil {
580		if err := validateCrlConfiguration(v.CrlConfiguration); err != nil {
581			invalidParams.AddNested("CrlConfiguration", err.(smithy.InvalidParamsError))
582		}
583	}
584	if invalidParams.Len() > 0 {
585		return invalidParams
586	} else {
587		return nil
588	}
589}
590
591func validateTag(v *types.Tag) error {
592	if v == nil {
593		return nil
594	}
595	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
596	if v.Key == nil {
597		invalidParams.Add(smithy.NewErrParamRequired("Key"))
598	}
599	if invalidParams.Len() > 0 {
600		return invalidParams
601	} else {
602		return nil
603	}
604}
605
606func validateTagList(v []types.Tag) error {
607	if v == nil {
608		return nil
609	}
610	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
611	for i := range v {
612		if err := validateTag(&v[i]); err != nil {
613			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
614		}
615	}
616	if invalidParams.Len() > 0 {
617		return invalidParams
618	} else {
619		return nil
620	}
621}
622
623func validateValidity(v *types.Validity) error {
624	if v == nil {
625		return nil
626	}
627	invalidParams := smithy.InvalidParamsError{Context: "Validity"}
628	if v.Value == nil {
629		invalidParams.Add(smithy.NewErrParamRequired("Value"))
630	}
631	if len(v.Type) == 0 {
632		invalidParams.Add(smithy.NewErrParamRequired("Type"))
633	}
634	if invalidParams.Len() > 0 {
635		return invalidParams
636	} else {
637		return nil
638	}
639}
640
641func validateOpCreateCertificateAuthorityAuditReportInput(v *CreateCertificateAuthorityAuditReportInput) error {
642	if v == nil {
643		return nil
644	}
645	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateAuthorityAuditReportInput"}
646	if v.CertificateAuthorityArn == nil {
647		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
648	}
649	if v.S3BucketName == nil {
650		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
651	}
652	if len(v.AuditReportResponseFormat) == 0 {
653		invalidParams.Add(smithy.NewErrParamRequired("AuditReportResponseFormat"))
654	}
655	if invalidParams.Len() > 0 {
656		return invalidParams
657	} else {
658		return nil
659	}
660}
661
662func validateOpCreateCertificateAuthorityInput(v *CreateCertificateAuthorityInput) error {
663	if v == nil {
664		return nil
665	}
666	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateAuthorityInput"}
667	if v.CertificateAuthorityConfiguration == nil {
668		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityConfiguration"))
669	} else if v.CertificateAuthorityConfiguration != nil {
670		if err := validateCertificateAuthorityConfiguration(v.CertificateAuthorityConfiguration); err != nil {
671			invalidParams.AddNested("CertificateAuthorityConfiguration", err.(smithy.InvalidParamsError))
672		}
673	}
674	if v.RevocationConfiguration != nil {
675		if err := validateRevocationConfiguration(v.RevocationConfiguration); err != nil {
676			invalidParams.AddNested("RevocationConfiguration", err.(smithy.InvalidParamsError))
677		}
678	}
679	if len(v.CertificateAuthorityType) == 0 {
680		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityType"))
681	}
682	if v.Tags != nil {
683		if err := validateTagList(v.Tags); err != nil {
684			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
685		}
686	}
687	if invalidParams.Len() > 0 {
688		return invalidParams
689	} else {
690		return nil
691	}
692}
693
694func validateOpCreatePermissionInput(v *CreatePermissionInput) error {
695	if v == nil {
696		return nil
697	}
698	invalidParams := smithy.InvalidParamsError{Context: "CreatePermissionInput"}
699	if v.CertificateAuthorityArn == nil {
700		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
701	}
702	if v.Principal == nil {
703		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
704	}
705	if v.Actions == nil {
706		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
707	}
708	if invalidParams.Len() > 0 {
709		return invalidParams
710	} else {
711		return nil
712	}
713}
714
715func validateOpDeleteCertificateAuthorityInput(v *DeleteCertificateAuthorityInput) error {
716	if v == nil {
717		return nil
718	}
719	invalidParams := smithy.InvalidParamsError{Context: "DeleteCertificateAuthorityInput"}
720	if v.CertificateAuthorityArn == nil {
721		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
722	}
723	if invalidParams.Len() > 0 {
724		return invalidParams
725	} else {
726		return nil
727	}
728}
729
730func validateOpDeletePermissionInput(v *DeletePermissionInput) error {
731	if v == nil {
732		return nil
733	}
734	invalidParams := smithy.InvalidParamsError{Context: "DeletePermissionInput"}
735	if v.CertificateAuthorityArn == nil {
736		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
737	}
738	if v.Principal == nil {
739		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
740	}
741	if invalidParams.Len() > 0 {
742		return invalidParams
743	} else {
744		return nil
745	}
746}
747
748func validateOpDeletePolicyInput(v *DeletePolicyInput) error {
749	if v == nil {
750		return nil
751	}
752	invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyInput"}
753	if v.ResourceArn == nil {
754		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
755	}
756	if invalidParams.Len() > 0 {
757		return invalidParams
758	} else {
759		return nil
760	}
761}
762
763func validateOpDescribeCertificateAuthorityAuditReportInput(v *DescribeCertificateAuthorityAuditReportInput) error {
764	if v == nil {
765		return nil
766	}
767	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificateAuthorityAuditReportInput"}
768	if v.CertificateAuthorityArn == nil {
769		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
770	}
771	if v.AuditReportId == nil {
772		invalidParams.Add(smithy.NewErrParamRequired("AuditReportId"))
773	}
774	if invalidParams.Len() > 0 {
775		return invalidParams
776	} else {
777		return nil
778	}
779}
780
781func validateOpDescribeCertificateAuthorityInput(v *DescribeCertificateAuthorityInput) error {
782	if v == nil {
783		return nil
784	}
785	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificateAuthorityInput"}
786	if v.CertificateAuthorityArn == nil {
787		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
788	}
789	if invalidParams.Len() > 0 {
790		return invalidParams
791	} else {
792		return nil
793	}
794}
795
796func validateOpGetCertificateAuthorityCertificateInput(v *GetCertificateAuthorityCertificateInput) error {
797	if v == nil {
798		return nil
799	}
800	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateAuthorityCertificateInput"}
801	if v.CertificateAuthorityArn == nil {
802		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
803	}
804	if invalidParams.Len() > 0 {
805		return invalidParams
806	} else {
807		return nil
808	}
809}
810
811func validateOpGetCertificateAuthorityCsrInput(v *GetCertificateAuthorityCsrInput) error {
812	if v == nil {
813		return nil
814	}
815	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateAuthorityCsrInput"}
816	if v.CertificateAuthorityArn == nil {
817		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
818	}
819	if invalidParams.Len() > 0 {
820		return invalidParams
821	} else {
822		return nil
823	}
824}
825
826func validateOpGetCertificateInput(v *GetCertificateInput) error {
827	if v == nil {
828		return nil
829	}
830	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateInput"}
831	if v.CertificateAuthorityArn == nil {
832		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
833	}
834	if v.CertificateArn == nil {
835		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
836	}
837	if invalidParams.Len() > 0 {
838		return invalidParams
839	} else {
840		return nil
841	}
842}
843
844func validateOpGetPolicyInput(v *GetPolicyInput) error {
845	if v == nil {
846		return nil
847	}
848	invalidParams := smithy.InvalidParamsError{Context: "GetPolicyInput"}
849	if v.ResourceArn == nil {
850		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
851	}
852	if invalidParams.Len() > 0 {
853		return invalidParams
854	} else {
855		return nil
856	}
857}
858
859func validateOpImportCertificateAuthorityCertificateInput(v *ImportCertificateAuthorityCertificateInput) error {
860	if v == nil {
861		return nil
862	}
863	invalidParams := smithy.InvalidParamsError{Context: "ImportCertificateAuthorityCertificateInput"}
864	if v.CertificateAuthorityArn == nil {
865		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
866	}
867	if v.Certificate == nil {
868		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
869	}
870	if invalidParams.Len() > 0 {
871		return invalidParams
872	} else {
873		return nil
874	}
875}
876
877func validateOpIssueCertificateInput(v *IssueCertificateInput) error {
878	if v == nil {
879		return nil
880	}
881	invalidParams := smithy.InvalidParamsError{Context: "IssueCertificateInput"}
882	if v.CertificateAuthorityArn == nil {
883		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
884	}
885	if v.Csr == nil {
886		invalidParams.Add(smithy.NewErrParamRequired("Csr"))
887	}
888	if len(v.SigningAlgorithm) == 0 {
889		invalidParams.Add(smithy.NewErrParamRequired("SigningAlgorithm"))
890	}
891	if v.Validity == nil {
892		invalidParams.Add(smithy.NewErrParamRequired("Validity"))
893	} else if v.Validity != nil {
894		if err := validateValidity(v.Validity); err != nil {
895			invalidParams.AddNested("Validity", err.(smithy.InvalidParamsError))
896		}
897	}
898	if invalidParams.Len() > 0 {
899		return invalidParams
900	} else {
901		return nil
902	}
903}
904
905func validateOpListPermissionsInput(v *ListPermissionsInput) error {
906	if v == nil {
907		return nil
908	}
909	invalidParams := smithy.InvalidParamsError{Context: "ListPermissionsInput"}
910	if v.CertificateAuthorityArn == nil {
911		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
912	}
913	if invalidParams.Len() > 0 {
914		return invalidParams
915	} else {
916		return nil
917	}
918}
919
920func validateOpListTagsInput(v *ListTagsInput) error {
921	if v == nil {
922		return nil
923	}
924	invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
925	if v.CertificateAuthorityArn == nil {
926		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
927	}
928	if invalidParams.Len() > 0 {
929		return invalidParams
930	} else {
931		return nil
932	}
933}
934
935func validateOpPutPolicyInput(v *PutPolicyInput) error {
936	if v == nil {
937		return nil
938	}
939	invalidParams := smithy.InvalidParamsError{Context: "PutPolicyInput"}
940	if v.ResourceArn == nil {
941		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
942	}
943	if v.Policy == nil {
944		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
945	}
946	if invalidParams.Len() > 0 {
947		return invalidParams
948	} else {
949		return nil
950	}
951}
952
953func validateOpRestoreCertificateAuthorityInput(v *RestoreCertificateAuthorityInput) error {
954	if v == nil {
955		return nil
956	}
957	invalidParams := smithy.InvalidParamsError{Context: "RestoreCertificateAuthorityInput"}
958	if v.CertificateAuthorityArn == nil {
959		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
960	}
961	if invalidParams.Len() > 0 {
962		return invalidParams
963	} else {
964		return nil
965	}
966}
967
968func validateOpRevokeCertificateInput(v *RevokeCertificateInput) error {
969	if v == nil {
970		return nil
971	}
972	invalidParams := smithy.InvalidParamsError{Context: "RevokeCertificateInput"}
973	if v.CertificateAuthorityArn == nil {
974		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
975	}
976	if v.CertificateSerial == nil {
977		invalidParams.Add(smithy.NewErrParamRequired("CertificateSerial"))
978	}
979	if len(v.RevocationReason) == 0 {
980		invalidParams.Add(smithy.NewErrParamRequired("RevocationReason"))
981	}
982	if invalidParams.Len() > 0 {
983		return invalidParams
984	} else {
985		return nil
986	}
987}
988
989func validateOpTagCertificateAuthorityInput(v *TagCertificateAuthorityInput) error {
990	if v == nil {
991		return nil
992	}
993	invalidParams := smithy.InvalidParamsError{Context: "TagCertificateAuthorityInput"}
994	if v.CertificateAuthorityArn == nil {
995		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
996	}
997	if v.Tags == nil {
998		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
999	} else if v.Tags != nil {
1000		if err := validateTagList(v.Tags); err != nil {
1001			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1002		}
1003	}
1004	if invalidParams.Len() > 0 {
1005		return invalidParams
1006	} else {
1007		return nil
1008	}
1009}
1010
1011func validateOpUntagCertificateAuthorityInput(v *UntagCertificateAuthorityInput) error {
1012	if v == nil {
1013		return nil
1014	}
1015	invalidParams := smithy.InvalidParamsError{Context: "UntagCertificateAuthorityInput"}
1016	if v.CertificateAuthorityArn == nil {
1017		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1018	}
1019	if v.Tags == nil {
1020		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1021	} else if v.Tags != nil {
1022		if err := validateTagList(v.Tags); err != nil {
1023			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1024		}
1025	}
1026	if invalidParams.Len() > 0 {
1027		return invalidParams
1028	} else {
1029		return nil
1030	}
1031}
1032
1033func validateOpUpdateCertificateAuthorityInput(v *UpdateCertificateAuthorityInput) error {
1034	if v == nil {
1035		return nil
1036	}
1037	invalidParams := smithy.InvalidParamsError{Context: "UpdateCertificateAuthorityInput"}
1038	if v.CertificateAuthorityArn == nil {
1039		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1040	}
1041	if v.RevocationConfiguration != nil {
1042		if err := validateRevocationConfiguration(v.RevocationConfiguration); err != nil {
1043			invalidParams.AddNested("RevocationConfiguration", err.(smithy.InvalidParamsError))
1044		}
1045	}
1046	if invalidParams.Len() > 0 {
1047		return invalidParams
1048	} else {
1049		return nil
1050	}
1051}
1052