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 validateAccessDescription(v *types.AccessDescription) error {
542	if v == nil {
543		return nil
544	}
545	invalidParams := smithy.InvalidParamsError{Context: "AccessDescription"}
546	if v.AccessMethod == nil {
547		invalidParams.Add(smithy.NewErrParamRequired("AccessMethod"))
548	}
549	if v.AccessLocation == nil {
550		invalidParams.Add(smithy.NewErrParamRequired("AccessLocation"))
551	} else if v.AccessLocation != nil {
552		if err := validateGeneralName(v.AccessLocation); err != nil {
553			invalidParams.AddNested("AccessLocation", err.(smithy.InvalidParamsError))
554		}
555	}
556	if invalidParams.Len() > 0 {
557		return invalidParams
558	} else {
559		return nil
560	}
561}
562
563func validateAccessDescriptionList(v []types.AccessDescription) error {
564	if v == nil {
565		return nil
566	}
567	invalidParams := smithy.InvalidParamsError{Context: "AccessDescriptionList"}
568	for i := range v {
569		if err := validateAccessDescription(&v[i]); err != nil {
570			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
571		}
572	}
573	if invalidParams.Len() > 0 {
574		return invalidParams
575	} else {
576		return nil
577	}
578}
579
580func validateApiPassthrough(v *types.ApiPassthrough) error {
581	if v == nil {
582		return nil
583	}
584	invalidParams := smithy.InvalidParamsError{Context: "ApiPassthrough"}
585	if v.Extensions != nil {
586		if err := validateExtensions(v.Extensions); err != nil {
587			invalidParams.AddNested("Extensions", err.(smithy.InvalidParamsError))
588		}
589	}
590	if invalidParams.Len() > 0 {
591		return invalidParams
592	} else {
593		return nil
594	}
595}
596
597func validateCertificateAuthorityConfiguration(v *types.CertificateAuthorityConfiguration) error {
598	if v == nil {
599		return nil
600	}
601	invalidParams := smithy.InvalidParamsError{Context: "CertificateAuthorityConfiguration"}
602	if len(v.KeyAlgorithm) == 0 {
603		invalidParams.Add(smithy.NewErrParamRequired("KeyAlgorithm"))
604	}
605	if len(v.SigningAlgorithm) == 0 {
606		invalidParams.Add(smithy.NewErrParamRequired("SigningAlgorithm"))
607	}
608	if v.Subject == nil {
609		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
610	}
611	if v.CsrExtensions != nil {
612		if err := validateCsrExtensions(v.CsrExtensions); err != nil {
613			invalidParams.AddNested("CsrExtensions", err.(smithy.InvalidParamsError))
614		}
615	}
616	if invalidParams.Len() > 0 {
617		return invalidParams
618	} else {
619		return nil
620	}
621}
622
623func validateCertificatePolicyList(v []types.PolicyInformation) error {
624	if v == nil {
625		return nil
626	}
627	invalidParams := smithy.InvalidParamsError{Context: "CertificatePolicyList"}
628	for i := range v {
629		if err := validatePolicyInformation(&v[i]); err != nil {
630			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
631		}
632	}
633	if invalidParams.Len() > 0 {
634		return invalidParams
635	} else {
636		return nil
637	}
638}
639
640func validateCrlConfiguration(v *types.CrlConfiguration) error {
641	if v == nil {
642		return nil
643	}
644	invalidParams := smithy.InvalidParamsError{Context: "CrlConfiguration"}
645	if invalidParams.Len() > 0 {
646		return invalidParams
647	} else {
648		return nil
649	}
650}
651
652func validateCsrExtensions(v *types.CsrExtensions) error {
653	if v == nil {
654		return nil
655	}
656	invalidParams := smithy.InvalidParamsError{Context: "CsrExtensions"}
657	if v.SubjectInformationAccess != nil {
658		if err := validateAccessDescriptionList(v.SubjectInformationAccess); err != nil {
659			invalidParams.AddNested("SubjectInformationAccess", err.(smithy.InvalidParamsError))
660		}
661	}
662	if invalidParams.Len() > 0 {
663		return invalidParams
664	} else {
665		return nil
666	}
667}
668
669func validateEdiPartyName(v *types.EdiPartyName) error {
670	if v == nil {
671		return nil
672	}
673	invalidParams := smithy.InvalidParamsError{Context: "EdiPartyName"}
674	if v.PartyName == nil {
675		invalidParams.Add(smithy.NewErrParamRequired("PartyName"))
676	}
677	if invalidParams.Len() > 0 {
678		return invalidParams
679	} else {
680		return nil
681	}
682}
683
684func validateExtensions(v *types.Extensions) error {
685	if v == nil {
686		return nil
687	}
688	invalidParams := smithy.InvalidParamsError{Context: "Extensions"}
689	if v.CertificatePolicies != nil {
690		if err := validateCertificatePolicyList(v.CertificatePolicies); err != nil {
691			invalidParams.AddNested("CertificatePolicies", err.(smithy.InvalidParamsError))
692		}
693	}
694	if v.SubjectAlternativeNames != nil {
695		if err := validateGeneralNameList(v.SubjectAlternativeNames); err != nil {
696			invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError))
697		}
698	}
699	if invalidParams.Len() > 0 {
700		return invalidParams
701	} else {
702		return nil
703	}
704}
705
706func validateGeneralName(v *types.GeneralName) error {
707	if v == nil {
708		return nil
709	}
710	invalidParams := smithy.InvalidParamsError{Context: "GeneralName"}
711	if v.OtherName != nil {
712		if err := validateOtherName(v.OtherName); err != nil {
713			invalidParams.AddNested("OtherName", err.(smithy.InvalidParamsError))
714		}
715	}
716	if v.EdiPartyName != nil {
717		if err := validateEdiPartyName(v.EdiPartyName); err != nil {
718			invalidParams.AddNested("EdiPartyName", err.(smithy.InvalidParamsError))
719		}
720	}
721	if invalidParams.Len() > 0 {
722		return invalidParams
723	} else {
724		return nil
725	}
726}
727
728func validateGeneralNameList(v []types.GeneralName) error {
729	if v == nil {
730		return nil
731	}
732	invalidParams := smithy.InvalidParamsError{Context: "GeneralNameList"}
733	for i := range v {
734		if err := validateGeneralName(&v[i]); err != nil {
735			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
736		}
737	}
738	if invalidParams.Len() > 0 {
739		return invalidParams
740	} else {
741		return nil
742	}
743}
744
745func validateOtherName(v *types.OtherName) error {
746	if v == nil {
747		return nil
748	}
749	invalidParams := smithy.InvalidParamsError{Context: "OtherName"}
750	if v.TypeId == nil {
751		invalidParams.Add(smithy.NewErrParamRequired("TypeId"))
752	}
753	if v.Value == nil {
754		invalidParams.Add(smithy.NewErrParamRequired("Value"))
755	}
756	if invalidParams.Len() > 0 {
757		return invalidParams
758	} else {
759		return nil
760	}
761}
762
763func validatePolicyInformation(v *types.PolicyInformation) error {
764	if v == nil {
765		return nil
766	}
767	invalidParams := smithy.InvalidParamsError{Context: "PolicyInformation"}
768	if v.CertPolicyId == nil {
769		invalidParams.Add(smithy.NewErrParamRequired("CertPolicyId"))
770	}
771	if v.PolicyQualifiers != nil {
772		if err := validatePolicyQualifierInfoList(v.PolicyQualifiers); err != nil {
773			invalidParams.AddNested("PolicyQualifiers", err.(smithy.InvalidParamsError))
774		}
775	}
776	if invalidParams.Len() > 0 {
777		return invalidParams
778	} else {
779		return nil
780	}
781}
782
783func validatePolicyQualifierInfo(v *types.PolicyQualifierInfo) error {
784	if v == nil {
785		return nil
786	}
787	invalidParams := smithy.InvalidParamsError{Context: "PolicyQualifierInfo"}
788	if len(v.PolicyQualifierId) == 0 {
789		invalidParams.Add(smithy.NewErrParamRequired("PolicyQualifierId"))
790	}
791	if v.Qualifier == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("Qualifier"))
793	} else if v.Qualifier != nil {
794		if err := validateQualifier(v.Qualifier); err != nil {
795			invalidParams.AddNested("Qualifier", err.(smithy.InvalidParamsError))
796		}
797	}
798	if invalidParams.Len() > 0 {
799		return invalidParams
800	} else {
801		return nil
802	}
803}
804
805func validatePolicyQualifierInfoList(v []types.PolicyQualifierInfo) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "PolicyQualifierInfoList"}
810	for i := range v {
811		if err := validatePolicyQualifierInfo(&v[i]); err != nil {
812			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
813		}
814	}
815	if invalidParams.Len() > 0 {
816		return invalidParams
817	} else {
818		return nil
819	}
820}
821
822func validateQualifier(v *types.Qualifier) error {
823	if v == nil {
824		return nil
825	}
826	invalidParams := smithy.InvalidParamsError{Context: "Qualifier"}
827	if v.CpsUri == nil {
828		invalidParams.Add(smithy.NewErrParamRequired("CpsUri"))
829	}
830	if invalidParams.Len() > 0 {
831		return invalidParams
832	} else {
833		return nil
834	}
835}
836
837func validateRevocationConfiguration(v *types.RevocationConfiguration) error {
838	if v == nil {
839		return nil
840	}
841	invalidParams := smithy.InvalidParamsError{Context: "RevocationConfiguration"}
842	if v.CrlConfiguration != nil {
843		if err := validateCrlConfiguration(v.CrlConfiguration); err != nil {
844			invalidParams.AddNested("CrlConfiguration", err.(smithy.InvalidParamsError))
845		}
846	}
847	if invalidParams.Len() > 0 {
848		return invalidParams
849	} else {
850		return nil
851	}
852}
853
854func validateTag(v *types.Tag) error {
855	if v == nil {
856		return nil
857	}
858	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
859	if v.Key == nil {
860		invalidParams.Add(smithy.NewErrParamRequired("Key"))
861	}
862	if invalidParams.Len() > 0 {
863		return invalidParams
864	} else {
865		return nil
866	}
867}
868
869func validateTagList(v []types.Tag) error {
870	if v == nil {
871		return nil
872	}
873	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
874	for i := range v {
875		if err := validateTag(&v[i]); err != nil {
876			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
877		}
878	}
879	if invalidParams.Len() > 0 {
880		return invalidParams
881	} else {
882		return nil
883	}
884}
885
886func validateValidity(v *types.Validity) error {
887	if v == nil {
888		return nil
889	}
890	invalidParams := smithy.InvalidParamsError{Context: "Validity"}
891	if v.Value == nil {
892		invalidParams.Add(smithy.NewErrParamRequired("Value"))
893	}
894	if len(v.Type) == 0 {
895		invalidParams.Add(smithy.NewErrParamRequired("Type"))
896	}
897	if invalidParams.Len() > 0 {
898		return invalidParams
899	} else {
900		return nil
901	}
902}
903
904func validateOpCreateCertificateAuthorityAuditReportInput(v *CreateCertificateAuthorityAuditReportInput) error {
905	if v == nil {
906		return nil
907	}
908	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateAuthorityAuditReportInput"}
909	if v.CertificateAuthorityArn == nil {
910		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
911	}
912	if v.S3BucketName == nil {
913		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
914	}
915	if len(v.AuditReportResponseFormat) == 0 {
916		invalidParams.Add(smithy.NewErrParamRequired("AuditReportResponseFormat"))
917	}
918	if invalidParams.Len() > 0 {
919		return invalidParams
920	} else {
921		return nil
922	}
923}
924
925func validateOpCreateCertificateAuthorityInput(v *CreateCertificateAuthorityInput) error {
926	if v == nil {
927		return nil
928	}
929	invalidParams := smithy.InvalidParamsError{Context: "CreateCertificateAuthorityInput"}
930	if v.CertificateAuthorityConfiguration == nil {
931		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityConfiguration"))
932	} else if v.CertificateAuthorityConfiguration != nil {
933		if err := validateCertificateAuthorityConfiguration(v.CertificateAuthorityConfiguration); err != nil {
934			invalidParams.AddNested("CertificateAuthorityConfiguration", err.(smithy.InvalidParamsError))
935		}
936	}
937	if v.RevocationConfiguration != nil {
938		if err := validateRevocationConfiguration(v.RevocationConfiguration); err != nil {
939			invalidParams.AddNested("RevocationConfiguration", err.(smithy.InvalidParamsError))
940		}
941	}
942	if len(v.CertificateAuthorityType) == 0 {
943		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityType"))
944	}
945	if v.Tags != nil {
946		if err := validateTagList(v.Tags); err != nil {
947			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
948		}
949	}
950	if invalidParams.Len() > 0 {
951		return invalidParams
952	} else {
953		return nil
954	}
955}
956
957func validateOpCreatePermissionInput(v *CreatePermissionInput) error {
958	if v == nil {
959		return nil
960	}
961	invalidParams := smithy.InvalidParamsError{Context: "CreatePermissionInput"}
962	if v.CertificateAuthorityArn == nil {
963		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
964	}
965	if v.Principal == nil {
966		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
967	}
968	if v.Actions == nil {
969		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
970	}
971	if invalidParams.Len() > 0 {
972		return invalidParams
973	} else {
974		return nil
975	}
976}
977
978func validateOpDeleteCertificateAuthorityInput(v *DeleteCertificateAuthorityInput) error {
979	if v == nil {
980		return nil
981	}
982	invalidParams := smithy.InvalidParamsError{Context: "DeleteCertificateAuthorityInput"}
983	if v.CertificateAuthorityArn == nil {
984		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
985	}
986	if invalidParams.Len() > 0 {
987		return invalidParams
988	} else {
989		return nil
990	}
991}
992
993func validateOpDeletePermissionInput(v *DeletePermissionInput) error {
994	if v == nil {
995		return nil
996	}
997	invalidParams := smithy.InvalidParamsError{Context: "DeletePermissionInput"}
998	if v.CertificateAuthorityArn == nil {
999		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1000	}
1001	if v.Principal == nil {
1002		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
1003	}
1004	if invalidParams.Len() > 0 {
1005		return invalidParams
1006	} else {
1007		return nil
1008	}
1009}
1010
1011func validateOpDeletePolicyInput(v *DeletePolicyInput) error {
1012	if v == nil {
1013		return nil
1014	}
1015	invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyInput"}
1016	if v.ResourceArn == nil {
1017		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1018	}
1019	if invalidParams.Len() > 0 {
1020		return invalidParams
1021	} else {
1022		return nil
1023	}
1024}
1025
1026func validateOpDescribeCertificateAuthorityAuditReportInput(v *DescribeCertificateAuthorityAuditReportInput) error {
1027	if v == nil {
1028		return nil
1029	}
1030	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificateAuthorityAuditReportInput"}
1031	if v.CertificateAuthorityArn == nil {
1032		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1033	}
1034	if v.AuditReportId == nil {
1035		invalidParams.Add(smithy.NewErrParamRequired("AuditReportId"))
1036	}
1037	if invalidParams.Len() > 0 {
1038		return invalidParams
1039	} else {
1040		return nil
1041	}
1042}
1043
1044func validateOpDescribeCertificateAuthorityInput(v *DescribeCertificateAuthorityInput) error {
1045	if v == nil {
1046		return nil
1047	}
1048	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificateAuthorityInput"}
1049	if v.CertificateAuthorityArn == nil {
1050		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1051	}
1052	if invalidParams.Len() > 0 {
1053		return invalidParams
1054	} else {
1055		return nil
1056	}
1057}
1058
1059func validateOpGetCertificateAuthorityCertificateInput(v *GetCertificateAuthorityCertificateInput) error {
1060	if v == nil {
1061		return nil
1062	}
1063	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateAuthorityCertificateInput"}
1064	if v.CertificateAuthorityArn == nil {
1065		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1066	}
1067	if invalidParams.Len() > 0 {
1068		return invalidParams
1069	} else {
1070		return nil
1071	}
1072}
1073
1074func validateOpGetCertificateAuthorityCsrInput(v *GetCertificateAuthorityCsrInput) error {
1075	if v == nil {
1076		return nil
1077	}
1078	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateAuthorityCsrInput"}
1079	if v.CertificateAuthorityArn == nil {
1080		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1081	}
1082	if invalidParams.Len() > 0 {
1083		return invalidParams
1084	} else {
1085		return nil
1086	}
1087}
1088
1089func validateOpGetCertificateInput(v *GetCertificateInput) error {
1090	if v == nil {
1091		return nil
1092	}
1093	invalidParams := smithy.InvalidParamsError{Context: "GetCertificateInput"}
1094	if v.CertificateAuthorityArn == nil {
1095		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1096	}
1097	if v.CertificateArn == nil {
1098		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
1099	}
1100	if invalidParams.Len() > 0 {
1101		return invalidParams
1102	} else {
1103		return nil
1104	}
1105}
1106
1107func validateOpGetPolicyInput(v *GetPolicyInput) error {
1108	if v == nil {
1109		return nil
1110	}
1111	invalidParams := smithy.InvalidParamsError{Context: "GetPolicyInput"}
1112	if v.ResourceArn == nil {
1113		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1114	}
1115	if invalidParams.Len() > 0 {
1116		return invalidParams
1117	} else {
1118		return nil
1119	}
1120}
1121
1122func validateOpImportCertificateAuthorityCertificateInput(v *ImportCertificateAuthorityCertificateInput) error {
1123	if v == nil {
1124		return nil
1125	}
1126	invalidParams := smithy.InvalidParamsError{Context: "ImportCertificateAuthorityCertificateInput"}
1127	if v.CertificateAuthorityArn == nil {
1128		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1129	}
1130	if v.Certificate == nil {
1131		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
1132	}
1133	if invalidParams.Len() > 0 {
1134		return invalidParams
1135	} else {
1136		return nil
1137	}
1138}
1139
1140func validateOpIssueCertificateInput(v *IssueCertificateInput) error {
1141	if v == nil {
1142		return nil
1143	}
1144	invalidParams := smithy.InvalidParamsError{Context: "IssueCertificateInput"}
1145	if v.ApiPassthrough != nil {
1146		if err := validateApiPassthrough(v.ApiPassthrough); err != nil {
1147			invalidParams.AddNested("ApiPassthrough", err.(smithy.InvalidParamsError))
1148		}
1149	}
1150	if v.CertificateAuthorityArn == nil {
1151		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1152	}
1153	if v.Csr == nil {
1154		invalidParams.Add(smithy.NewErrParamRequired("Csr"))
1155	}
1156	if len(v.SigningAlgorithm) == 0 {
1157		invalidParams.Add(smithy.NewErrParamRequired("SigningAlgorithm"))
1158	}
1159	if v.Validity == nil {
1160		invalidParams.Add(smithy.NewErrParamRequired("Validity"))
1161	} else if v.Validity != nil {
1162		if err := validateValidity(v.Validity); err != nil {
1163			invalidParams.AddNested("Validity", err.(smithy.InvalidParamsError))
1164		}
1165	}
1166	if v.ValidityNotBefore != nil {
1167		if err := validateValidity(v.ValidityNotBefore); err != nil {
1168			invalidParams.AddNested("ValidityNotBefore", err.(smithy.InvalidParamsError))
1169		}
1170	}
1171	if invalidParams.Len() > 0 {
1172		return invalidParams
1173	} else {
1174		return nil
1175	}
1176}
1177
1178func validateOpListPermissionsInput(v *ListPermissionsInput) error {
1179	if v == nil {
1180		return nil
1181	}
1182	invalidParams := smithy.InvalidParamsError{Context: "ListPermissionsInput"}
1183	if v.CertificateAuthorityArn == nil {
1184		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1185	}
1186	if invalidParams.Len() > 0 {
1187		return invalidParams
1188	} else {
1189		return nil
1190	}
1191}
1192
1193func validateOpListTagsInput(v *ListTagsInput) error {
1194	if v == nil {
1195		return nil
1196	}
1197	invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
1198	if v.CertificateAuthorityArn == nil {
1199		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1200	}
1201	if invalidParams.Len() > 0 {
1202		return invalidParams
1203	} else {
1204		return nil
1205	}
1206}
1207
1208func validateOpPutPolicyInput(v *PutPolicyInput) error {
1209	if v == nil {
1210		return nil
1211	}
1212	invalidParams := smithy.InvalidParamsError{Context: "PutPolicyInput"}
1213	if v.ResourceArn == nil {
1214		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1215	}
1216	if v.Policy == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
1218	}
1219	if invalidParams.Len() > 0 {
1220		return invalidParams
1221	} else {
1222		return nil
1223	}
1224}
1225
1226func validateOpRestoreCertificateAuthorityInput(v *RestoreCertificateAuthorityInput) error {
1227	if v == nil {
1228		return nil
1229	}
1230	invalidParams := smithy.InvalidParamsError{Context: "RestoreCertificateAuthorityInput"}
1231	if v.CertificateAuthorityArn == nil {
1232		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1233	}
1234	if invalidParams.Len() > 0 {
1235		return invalidParams
1236	} else {
1237		return nil
1238	}
1239}
1240
1241func validateOpRevokeCertificateInput(v *RevokeCertificateInput) error {
1242	if v == nil {
1243		return nil
1244	}
1245	invalidParams := smithy.InvalidParamsError{Context: "RevokeCertificateInput"}
1246	if v.CertificateAuthorityArn == nil {
1247		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1248	}
1249	if v.CertificateSerial == nil {
1250		invalidParams.Add(smithy.NewErrParamRequired("CertificateSerial"))
1251	}
1252	if len(v.RevocationReason) == 0 {
1253		invalidParams.Add(smithy.NewErrParamRequired("RevocationReason"))
1254	}
1255	if invalidParams.Len() > 0 {
1256		return invalidParams
1257	} else {
1258		return nil
1259	}
1260}
1261
1262func validateOpTagCertificateAuthorityInput(v *TagCertificateAuthorityInput) error {
1263	if v == nil {
1264		return nil
1265	}
1266	invalidParams := smithy.InvalidParamsError{Context: "TagCertificateAuthorityInput"}
1267	if v.CertificateAuthorityArn == nil {
1268		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1269	}
1270	if v.Tags == nil {
1271		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1272	} else if v.Tags != nil {
1273		if err := validateTagList(v.Tags); err != nil {
1274			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1275		}
1276	}
1277	if invalidParams.Len() > 0 {
1278		return invalidParams
1279	} else {
1280		return nil
1281	}
1282}
1283
1284func validateOpUntagCertificateAuthorityInput(v *UntagCertificateAuthorityInput) error {
1285	if v == nil {
1286		return nil
1287	}
1288	invalidParams := smithy.InvalidParamsError{Context: "UntagCertificateAuthorityInput"}
1289	if v.CertificateAuthorityArn == nil {
1290		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1291	}
1292	if v.Tags == nil {
1293		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1294	} else if v.Tags != nil {
1295		if err := validateTagList(v.Tags); err != nil {
1296			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1297		}
1298	}
1299	if invalidParams.Len() > 0 {
1300		return invalidParams
1301	} else {
1302		return nil
1303	}
1304}
1305
1306func validateOpUpdateCertificateAuthorityInput(v *UpdateCertificateAuthorityInput) error {
1307	if v == nil {
1308		return nil
1309	}
1310	invalidParams := smithy.InvalidParamsError{Context: "UpdateCertificateAuthorityInput"}
1311	if v.CertificateAuthorityArn == nil {
1312		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArn"))
1313	}
1314	if v.RevocationConfiguration != nil {
1315		if err := validateRevocationConfiguration(v.RevocationConfiguration); err != nil {
1316			invalidParams.AddNested("RevocationConfiguration", err.(smithy.InvalidParamsError))
1317		}
1318	}
1319	if invalidParams.Len() > 0 {
1320		return invalidParams
1321	} else {
1322		return nil
1323	}
1324}
1325