1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package configservice
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/configservice/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpBatchGetAggregateResourceConfig struct {
14}
15
16func (*validateOpBatchGetAggregateResourceConfig) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpBatchGetAggregateResourceConfig) 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.(*BatchGetAggregateResourceConfigInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpBatchGetAggregateResourceConfigInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchGetResourceConfig struct {
34}
35
36func (*validateOpBatchGetResourceConfig) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchGetResourceConfig) 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.(*BatchGetResourceConfigInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchGetResourceConfigInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpDeleteAggregationAuthorization struct {
54}
55
56func (*validateOpDeleteAggregationAuthorization) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpDeleteAggregationAuthorization) 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.(*DeleteAggregationAuthorizationInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpDeleteAggregationAuthorizationInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteConfigRule struct {
74}
75
76func (*validateOpDeleteConfigRule) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteConfigRule) 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.(*DeleteConfigRuleInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteConfigRuleInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDeleteConfigurationAggregator struct {
94}
95
96func (*validateOpDeleteConfigurationAggregator) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDeleteConfigurationAggregator) 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.(*DeleteConfigurationAggregatorInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDeleteConfigurationAggregatorInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteConfigurationRecorder struct {
114}
115
116func (*validateOpDeleteConfigurationRecorder) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteConfigurationRecorder) 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.(*DeleteConfigurationRecorderInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteConfigurationRecorderInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteConformancePack struct {
134}
135
136func (*validateOpDeleteConformancePack) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteConformancePack) 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.(*DeleteConformancePackInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteConformancePackInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteDeliveryChannel struct {
154}
155
156func (*validateOpDeleteDeliveryChannel) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteDeliveryChannel) 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.(*DeleteDeliveryChannelInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteDeliveryChannelInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteEvaluationResults struct {
174}
175
176func (*validateOpDeleteEvaluationResults) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteEvaluationResults) 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.(*DeleteEvaluationResultsInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteEvaluationResultsInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteOrganizationConfigRule struct {
194}
195
196func (*validateOpDeleteOrganizationConfigRule) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteOrganizationConfigRule) 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.(*DeleteOrganizationConfigRuleInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteOrganizationConfigRuleInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteOrganizationConformancePack struct {
214}
215
216func (*validateOpDeleteOrganizationConformancePack) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteOrganizationConformancePack) 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.(*DeleteOrganizationConformancePackInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteOrganizationConformancePackInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeletePendingAggregationRequest struct {
234}
235
236func (*validateOpDeletePendingAggregationRequest) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeletePendingAggregationRequest) 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.(*DeletePendingAggregationRequestInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeletePendingAggregationRequestInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteRemediationConfiguration struct {
254}
255
256func (*validateOpDeleteRemediationConfiguration) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteRemediationConfiguration) 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.(*DeleteRemediationConfigurationInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteRemediationConfigurationInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteRemediationExceptions struct {
274}
275
276func (*validateOpDeleteRemediationExceptions) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteRemediationExceptions) 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.(*DeleteRemediationExceptionsInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteRemediationExceptionsInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteResourceConfig struct {
294}
295
296func (*validateOpDeleteResourceConfig) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteResourceConfig) 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.(*DeleteResourceConfigInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteResourceConfigInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteRetentionConfiguration struct {
314}
315
316func (*validateOpDeleteRetentionConfiguration) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteRetentionConfiguration) 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.(*DeleteRetentionConfigurationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteRetentionConfigurationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeliverConfigSnapshot struct {
334}
335
336func (*validateOpDeliverConfigSnapshot) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeliverConfigSnapshot) 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.(*DeliverConfigSnapshotInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeliverConfigSnapshotInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeAggregateComplianceByConfigRules struct {
354}
355
356func (*validateOpDescribeAggregateComplianceByConfigRules) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeAggregateComplianceByConfigRules) 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.(*DescribeAggregateComplianceByConfigRulesInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeAggregateComplianceByConfigRulesInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeConfigurationAggregatorSourcesStatus struct {
374}
375
376func (*validateOpDescribeConfigurationAggregatorSourcesStatus) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeConfigurationAggregatorSourcesStatus) 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.(*DescribeConfigurationAggregatorSourcesStatusInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeConfigurationAggregatorSourcesStatusInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeConformancePackCompliance struct {
394}
395
396func (*validateOpDescribeConformancePackCompliance) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeConformancePackCompliance) 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.(*DescribeConformancePackComplianceInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeConformancePackComplianceInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeRemediationConfigurations struct {
414}
415
416func (*validateOpDescribeRemediationConfigurations) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeRemediationConfigurations) 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.(*DescribeRemediationConfigurationsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeRemediationConfigurationsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeRemediationExceptions struct {
434}
435
436func (*validateOpDescribeRemediationExceptions) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeRemediationExceptions) 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.(*DescribeRemediationExceptionsInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeRemediationExceptionsInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDescribeRemediationExecutionStatus struct {
454}
455
456func (*validateOpDescribeRemediationExecutionStatus) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDescribeRemediationExecutionStatus) 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.(*DescribeRemediationExecutionStatusInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDescribeRemediationExecutionStatusInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpGetAggregateComplianceDetailsByConfigRule struct {
474}
475
476func (*validateOpGetAggregateComplianceDetailsByConfigRule) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpGetAggregateComplianceDetailsByConfigRule) 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.(*GetAggregateComplianceDetailsByConfigRuleInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpGetAggregateComplianceDetailsByConfigRuleInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpGetAggregateConfigRuleComplianceSummary struct {
494}
495
496func (*validateOpGetAggregateConfigRuleComplianceSummary) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpGetAggregateConfigRuleComplianceSummary) 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.(*GetAggregateConfigRuleComplianceSummaryInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpGetAggregateConfigRuleComplianceSummaryInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpGetAggregateDiscoveredResourceCounts struct {
514}
515
516func (*validateOpGetAggregateDiscoveredResourceCounts) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpGetAggregateDiscoveredResourceCounts) 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.(*GetAggregateDiscoveredResourceCountsInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpGetAggregateDiscoveredResourceCountsInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpGetAggregateResourceConfig struct {
534}
535
536func (*validateOpGetAggregateResourceConfig) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpGetAggregateResourceConfig) 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.(*GetAggregateResourceConfigInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpGetAggregateResourceConfigInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpGetComplianceDetailsByConfigRule struct {
554}
555
556func (*validateOpGetComplianceDetailsByConfigRule) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpGetComplianceDetailsByConfigRule) 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.(*GetComplianceDetailsByConfigRuleInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpGetComplianceDetailsByConfigRuleInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpGetComplianceDetailsByResource struct {
574}
575
576func (*validateOpGetComplianceDetailsByResource) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpGetComplianceDetailsByResource) 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.(*GetComplianceDetailsByResourceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpGetComplianceDetailsByResourceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpGetConformancePackComplianceDetails struct {
594}
595
596func (*validateOpGetConformancePackComplianceDetails) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpGetConformancePackComplianceDetails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
602) {
603	input, ok := in.Parameters.(*GetConformancePackComplianceDetailsInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpGetConformancePackComplianceDetailsInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpGetConformancePackComplianceSummary struct {
614}
615
616func (*validateOpGetConformancePackComplianceSummary) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpGetConformancePackComplianceSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
622) {
623	input, ok := in.Parameters.(*GetConformancePackComplianceSummaryInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpGetConformancePackComplianceSummaryInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpGetOrganizationConfigRuleDetailedStatus struct {
634}
635
636func (*validateOpGetOrganizationConfigRuleDetailedStatus) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpGetOrganizationConfigRuleDetailedStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
642) {
643	input, ok := in.Parameters.(*GetOrganizationConfigRuleDetailedStatusInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpGetOrganizationConfigRuleDetailedStatusInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpGetOrganizationConformancePackDetailedStatus struct {
654}
655
656func (*validateOpGetOrganizationConformancePackDetailedStatus) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpGetOrganizationConformancePackDetailedStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
662) {
663	input, ok := in.Parameters.(*GetOrganizationConformancePackDetailedStatusInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpGetOrganizationConformancePackDetailedStatusInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpGetResourceConfigHistory struct {
674}
675
676func (*validateOpGetResourceConfigHistory) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpGetResourceConfigHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
682) {
683	input, ok := in.Parameters.(*GetResourceConfigHistoryInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpGetResourceConfigHistoryInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpListAggregateDiscoveredResources struct {
694}
695
696func (*validateOpListAggregateDiscoveredResources) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpListAggregateDiscoveredResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
702) {
703	input, ok := in.Parameters.(*ListAggregateDiscoveredResourcesInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpListAggregateDiscoveredResourcesInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpListDiscoveredResources struct {
714}
715
716func (*validateOpListDiscoveredResources) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpListDiscoveredResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
722) {
723	input, ok := in.Parameters.(*ListDiscoveredResourcesInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpListDiscoveredResourcesInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpListTagsForResource struct {
734}
735
736func (*validateOpListTagsForResource) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
742) {
743	input, ok := in.Parameters.(*ListTagsForResourceInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpListTagsForResourceInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpPutAggregationAuthorization struct {
754}
755
756func (*validateOpPutAggregationAuthorization) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpPutAggregationAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
762) {
763	input, ok := in.Parameters.(*PutAggregationAuthorizationInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpPutAggregationAuthorizationInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpPutConfigRule struct {
774}
775
776func (*validateOpPutConfigRule) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpPutConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
782) {
783	input, ok := in.Parameters.(*PutConfigRuleInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpPutConfigRuleInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpPutConfigurationAggregator struct {
794}
795
796func (*validateOpPutConfigurationAggregator) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpPutConfigurationAggregator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*PutConfigurationAggregatorInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpPutConfigurationAggregatorInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpPutConfigurationRecorder struct {
814}
815
816func (*validateOpPutConfigurationRecorder) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpPutConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*PutConfigurationRecorderInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpPutConfigurationRecorderInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpPutConformancePack struct {
834}
835
836func (*validateOpPutConformancePack) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpPutConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*PutConformancePackInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpPutConformancePackInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpPutDeliveryChannel struct {
854}
855
856func (*validateOpPutDeliveryChannel) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpPutDeliveryChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*PutDeliveryChannelInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpPutDeliveryChannelInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpPutEvaluations struct {
874}
875
876func (*validateOpPutEvaluations) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpPutEvaluations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*PutEvaluationsInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpPutEvaluationsInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpPutOrganizationConfigRule struct {
894}
895
896func (*validateOpPutOrganizationConfigRule) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpPutOrganizationConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*PutOrganizationConfigRuleInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpPutOrganizationConfigRuleInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpPutOrganizationConformancePack struct {
914}
915
916func (*validateOpPutOrganizationConformancePack) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpPutOrganizationConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*PutOrganizationConformancePackInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpPutOrganizationConformancePackInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpPutRemediationConfigurations struct {
934}
935
936func (*validateOpPutRemediationConfigurations) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpPutRemediationConfigurations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*PutRemediationConfigurationsInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpPutRemediationConfigurationsInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpPutRemediationExceptions struct {
954}
955
956func (*validateOpPutRemediationExceptions) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpPutRemediationExceptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*PutRemediationExceptionsInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpPutRemediationExceptionsInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpPutResourceConfig struct {
974}
975
976func (*validateOpPutResourceConfig) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpPutResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*PutResourceConfigInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpPutResourceConfigInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpPutRetentionConfiguration struct {
994}
995
996func (*validateOpPutRetentionConfiguration) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpPutRetentionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*PutRetentionConfigurationInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpPutRetentionConfigurationInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpSelectAggregateResourceConfig struct {
1014}
1015
1016func (*validateOpSelectAggregateResourceConfig) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpSelectAggregateResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*SelectAggregateResourceConfigInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpSelectAggregateResourceConfigInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpSelectResourceConfig struct {
1034}
1035
1036func (*validateOpSelectResourceConfig) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpSelectResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*SelectResourceConfigInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpSelectResourceConfigInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpStartConfigurationRecorder struct {
1054}
1055
1056func (*validateOpStartConfigurationRecorder) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpStartConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*StartConfigurationRecorderInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpStartConfigurationRecorderInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpStartRemediationExecution struct {
1074}
1075
1076func (*validateOpStartRemediationExecution) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpStartRemediationExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*StartRemediationExecutionInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpStartRemediationExecutionInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpStopConfigurationRecorder struct {
1094}
1095
1096func (*validateOpStopConfigurationRecorder) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpStopConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*StopConfigurationRecorderInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpStopConfigurationRecorderInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpTagResource struct {
1114}
1115
1116func (*validateOpTagResource) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*TagResourceInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpTagResourceInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpUntagResource struct {
1134}
1135
1136func (*validateOpUntagResource) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*UntagResourceInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpUntagResourceInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153func addOpBatchGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpBatchGetAggregateResourceConfig{}, middleware.After)
1155}
1156
1157func addOpBatchGetResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpBatchGetResourceConfig{}, middleware.After)
1159}
1160
1161func addOpDeleteAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpDeleteAggregationAuthorization{}, middleware.After)
1163}
1164
1165func addOpDeleteConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1166	return stack.Initialize.Add(&validateOpDeleteConfigRule{}, middleware.After)
1167}
1168
1169func addOpDeleteConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error {
1170	return stack.Initialize.Add(&validateOpDeleteConfigurationAggregator{}, middleware.After)
1171}
1172
1173func addOpDeleteConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
1174	return stack.Initialize.Add(&validateOpDeleteConfigurationRecorder{}, middleware.After)
1175}
1176
1177func addOpDeleteConformancePackValidationMiddleware(stack *middleware.Stack) error {
1178	return stack.Initialize.Add(&validateOpDeleteConformancePack{}, middleware.After)
1179}
1180
1181func addOpDeleteDeliveryChannelValidationMiddleware(stack *middleware.Stack) error {
1182	return stack.Initialize.Add(&validateOpDeleteDeliveryChannel{}, middleware.After)
1183}
1184
1185func addOpDeleteEvaluationResultsValidationMiddleware(stack *middleware.Stack) error {
1186	return stack.Initialize.Add(&validateOpDeleteEvaluationResults{}, middleware.After)
1187}
1188
1189func addOpDeleteOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1190	return stack.Initialize.Add(&validateOpDeleteOrganizationConfigRule{}, middleware.After)
1191}
1192
1193func addOpDeleteOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error {
1194	return stack.Initialize.Add(&validateOpDeleteOrganizationConformancePack{}, middleware.After)
1195}
1196
1197func addOpDeletePendingAggregationRequestValidationMiddleware(stack *middleware.Stack) error {
1198	return stack.Initialize.Add(&validateOpDeletePendingAggregationRequest{}, middleware.After)
1199}
1200
1201func addOpDeleteRemediationConfigurationValidationMiddleware(stack *middleware.Stack) error {
1202	return stack.Initialize.Add(&validateOpDeleteRemediationConfiguration{}, middleware.After)
1203}
1204
1205func addOpDeleteRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
1206	return stack.Initialize.Add(&validateOpDeleteRemediationExceptions{}, middleware.After)
1207}
1208
1209func addOpDeleteResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1210	return stack.Initialize.Add(&validateOpDeleteResourceConfig{}, middleware.After)
1211}
1212
1213func addOpDeleteRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error {
1214	return stack.Initialize.Add(&validateOpDeleteRetentionConfiguration{}, middleware.After)
1215}
1216
1217func addOpDeliverConfigSnapshotValidationMiddleware(stack *middleware.Stack) error {
1218	return stack.Initialize.Add(&validateOpDeliverConfigSnapshot{}, middleware.After)
1219}
1220
1221func addOpDescribeAggregateComplianceByConfigRulesValidationMiddleware(stack *middleware.Stack) error {
1222	return stack.Initialize.Add(&validateOpDescribeAggregateComplianceByConfigRules{}, middleware.After)
1223}
1224
1225func addOpDescribeConfigurationAggregatorSourcesStatusValidationMiddleware(stack *middleware.Stack) error {
1226	return stack.Initialize.Add(&validateOpDescribeConfigurationAggregatorSourcesStatus{}, middleware.After)
1227}
1228
1229func addOpDescribeConformancePackComplianceValidationMiddleware(stack *middleware.Stack) error {
1230	return stack.Initialize.Add(&validateOpDescribeConformancePackCompliance{}, middleware.After)
1231}
1232
1233func addOpDescribeRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error {
1234	return stack.Initialize.Add(&validateOpDescribeRemediationConfigurations{}, middleware.After)
1235}
1236
1237func addOpDescribeRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
1238	return stack.Initialize.Add(&validateOpDescribeRemediationExceptions{}, middleware.After)
1239}
1240
1241func addOpDescribeRemediationExecutionStatusValidationMiddleware(stack *middleware.Stack) error {
1242	return stack.Initialize.Add(&validateOpDescribeRemediationExecutionStatus{}, middleware.After)
1243}
1244
1245func addOpGetAggregateComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1246	return stack.Initialize.Add(&validateOpGetAggregateComplianceDetailsByConfigRule{}, middleware.After)
1247}
1248
1249func addOpGetAggregateConfigRuleComplianceSummaryValidationMiddleware(stack *middleware.Stack) error {
1250	return stack.Initialize.Add(&validateOpGetAggregateConfigRuleComplianceSummary{}, middleware.After)
1251}
1252
1253func addOpGetAggregateDiscoveredResourceCountsValidationMiddleware(stack *middleware.Stack) error {
1254	return stack.Initialize.Add(&validateOpGetAggregateDiscoveredResourceCounts{}, middleware.After)
1255}
1256
1257func addOpGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1258	return stack.Initialize.Add(&validateOpGetAggregateResourceConfig{}, middleware.After)
1259}
1260
1261func addOpGetComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1262	return stack.Initialize.Add(&validateOpGetComplianceDetailsByConfigRule{}, middleware.After)
1263}
1264
1265func addOpGetComplianceDetailsByResourceValidationMiddleware(stack *middleware.Stack) error {
1266	return stack.Initialize.Add(&validateOpGetComplianceDetailsByResource{}, middleware.After)
1267}
1268
1269func addOpGetConformancePackComplianceDetailsValidationMiddleware(stack *middleware.Stack) error {
1270	return stack.Initialize.Add(&validateOpGetConformancePackComplianceDetails{}, middleware.After)
1271}
1272
1273func addOpGetConformancePackComplianceSummaryValidationMiddleware(stack *middleware.Stack) error {
1274	return stack.Initialize.Add(&validateOpGetConformancePackComplianceSummary{}, middleware.After)
1275}
1276
1277func addOpGetOrganizationConfigRuleDetailedStatusValidationMiddleware(stack *middleware.Stack) error {
1278	return stack.Initialize.Add(&validateOpGetOrganizationConfigRuleDetailedStatus{}, middleware.After)
1279}
1280
1281func addOpGetOrganizationConformancePackDetailedStatusValidationMiddleware(stack *middleware.Stack) error {
1282	return stack.Initialize.Add(&validateOpGetOrganizationConformancePackDetailedStatus{}, middleware.After)
1283}
1284
1285func addOpGetResourceConfigHistoryValidationMiddleware(stack *middleware.Stack) error {
1286	return stack.Initialize.Add(&validateOpGetResourceConfigHistory{}, middleware.After)
1287}
1288
1289func addOpListAggregateDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error {
1290	return stack.Initialize.Add(&validateOpListAggregateDiscoveredResources{}, middleware.After)
1291}
1292
1293func addOpListDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error {
1294	return stack.Initialize.Add(&validateOpListDiscoveredResources{}, middleware.After)
1295}
1296
1297func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1298	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1299}
1300
1301func addOpPutAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
1302	return stack.Initialize.Add(&validateOpPutAggregationAuthorization{}, middleware.After)
1303}
1304
1305func addOpPutConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1306	return stack.Initialize.Add(&validateOpPutConfigRule{}, middleware.After)
1307}
1308
1309func addOpPutConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error {
1310	return stack.Initialize.Add(&validateOpPutConfigurationAggregator{}, middleware.After)
1311}
1312
1313func addOpPutConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
1314	return stack.Initialize.Add(&validateOpPutConfigurationRecorder{}, middleware.After)
1315}
1316
1317func addOpPutConformancePackValidationMiddleware(stack *middleware.Stack) error {
1318	return stack.Initialize.Add(&validateOpPutConformancePack{}, middleware.After)
1319}
1320
1321func addOpPutDeliveryChannelValidationMiddleware(stack *middleware.Stack) error {
1322	return stack.Initialize.Add(&validateOpPutDeliveryChannel{}, middleware.After)
1323}
1324
1325func addOpPutEvaluationsValidationMiddleware(stack *middleware.Stack) error {
1326	return stack.Initialize.Add(&validateOpPutEvaluations{}, middleware.After)
1327}
1328
1329func addOpPutOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error {
1330	return stack.Initialize.Add(&validateOpPutOrganizationConfigRule{}, middleware.After)
1331}
1332
1333func addOpPutOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error {
1334	return stack.Initialize.Add(&validateOpPutOrganizationConformancePack{}, middleware.After)
1335}
1336
1337func addOpPutRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error {
1338	return stack.Initialize.Add(&validateOpPutRemediationConfigurations{}, middleware.After)
1339}
1340
1341func addOpPutRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
1342	return stack.Initialize.Add(&validateOpPutRemediationExceptions{}, middleware.After)
1343}
1344
1345func addOpPutResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1346	return stack.Initialize.Add(&validateOpPutResourceConfig{}, middleware.After)
1347}
1348
1349func addOpPutRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error {
1350	return stack.Initialize.Add(&validateOpPutRetentionConfiguration{}, middleware.After)
1351}
1352
1353func addOpSelectAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1354	return stack.Initialize.Add(&validateOpSelectAggregateResourceConfig{}, middleware.After)
1355}
1356
1357func addOpSelectResourceConfigValidationMiddleware(stack *middleware.Stack) error {
1358	return stack.Initialize.Add(&validateOpSelectResourceConfig{}, middleware.After)
1359}
1360
1361func addOpStartConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
1362	return stack.Initialize.Add(&validateOpStartConfigurationRecorder{}, middleware.After)
1363}
1364
1365func addOpStartRemediationExecutionValidationMiddleware(stack *middleware.Stack) error {
1366	return stack.Initialize.Add(&validateOpStartRemediationExecution{}, middleware.After)
1367}
1368
1369func addOpStopConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
1370	return stack.Initialize.Add(&validateOpStopConfigurationRecorder{}, middleware.After)
1371}
1372
1373func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1374	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1375}
1376
1377func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1378	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1379}
1380
1381func validateAccountAggregationSource(v *types.AccountAggregationSource) error {
1382	if v == nil {
1383		return nil
1384	}
1385	invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSource"}
1386	if v.AccountIds == nil {
1387		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1388	}
1389	if invalidParams.Len() > 0 {
1390		return invalidParams
1391	} else {
1392		return nil
1393	}
1394}
1395
1396func validateAccountAggregationSourceList(v []types.AccountAggregationSource) error {
1397	if v == nil {
1398		return nil
1399	}
1400	invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSourceList"}
1401	for i := range v {
1402		if err := validateAccountAggregationSource(&v[i]); err != nil {
1403			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1404		}
1405	}
1406	if invalidParams.Len() > 0 {
1407		return invalidParams
1408	} else {
1409		return nil
1410	}
1411}
1412
1413func validateAggregateResourceIdentifier(v *types.AggregateResourceIdentifier) error {
1414	if v == nil {
1415		return nil
1416	}
1417	invalidParams := smithy.InvalidParamsError{Context: "AggregateResourceIdentifier"}
1418	if v.SourceAccountId == nil {
1419		invalidParams.Add(smithy.NewErrParamRequired("SourceAccountId"))
1420	}
1421	if v.SourceRegion == nil {
1422		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
1423	}
1424	if v.ResourceId == nil {
1425		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1426	}
1427	if len(v.ResourceType) == 0 {
1428		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
1429	}
1430	if invalidParams.Len() > 0 {
1431		return invalidParams
1432	} else {
1433		return nil
1434	}
1435}
1436
1437func validateConfigRule(v *types.ConfigRule) error {
1438	if v == nil {
1439		return nil
1440	}
1441	invalidParams := smithy.InvalidParamsError{Context: "ConfigRule"}
1442	if v.Source == nil {
1443		invalidParams.Add(smithy.NewErrParamRequired("Source"))
1444	} else if v.Source != nil {
1445		if err := validateSource(v.Source); err != nil {
1446			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
1447		}
1448	}
1449	if invalidParams.Len() > 0 {
1450		return invalidParams
1451	} else {
1452		return nil
1453	}
1454}
1455
1456func validateConformancePackInputParameter(v *types.ConformancePackInputParameter) error {
1457	if v == nil {
1458		return nil
1459	}
1460	invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameter"}
1461	if v.ParameterName == nil {
1462		invalidParams.Add(smithy.NewErrParamRequired("ParameterName"))
1463	}
1464	if v.ParameterValue == nil {
1465		invalidParams.Add(smithy.NewErrParamRequired("ParameterValue"))
1466	}
1467	if invalidParams.Len() > 0 {
1468		return invalidParams
1469	} else {
1470		return nil
1471	}
1472}
1473
1474func validateConformancePackInputParameters(v []types.ConformancePackInputParameter) error {
1475	if v == nil {
1476		return nil
1477	}
1478	invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameters"}
1479	for i := range v {
1480		if err := validateConformancePackInputParameter(&v[i]); err != nil {
1481			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1482		}
1483	}
1484	if invalidParams.Len() > 0 {
1485		return invalidParams
1486	} else {
1487		return nil
1488	}
1489}
1490
1491func validateEvaluation(v *types.Evaluation) error {
1492	if v == nil {
1493		return nil
1494	}
1495	invalidParams := smithy.InvalidParamsError{Context: "Evaluation"}
1496	if v.ComplianceResourceType == nil {
1497		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceType"))
1498	}
1499	if v.ComplianceResourceId == nil {
1500		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceId"))
1501	}
1502	if len(v.ComplianceType) == 0 {
1503		invalidParams.Add(smithy.NewErrParamRequired("ComplianceType"))
1504	}
1505	if v.OrderingTimestamp == nil {
1506		invalidParams.Add(smithy.NewErrParamRequired("OrderingTimestamp"))
1507	}
1508	if invalidParams.Len() > 0 {
1509		return invalidParams
1510	} else {
1511		return nil
1512	}
1513}
1514
1515func validateEvaluations(v []types.Evaluation) error {
1516	if v == nil {
1517		return nil
1518	}
1519	invalidParams := smithy.InvalidParamsError{Context: "Evaluations"}
1520	for i := range v {
1521		if err := validateEvaluation(&v[i]); err != nil {
1522			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1523		}
1524	}
1525	if invalidParams.Len() > 0 {
1526		return invalidParams
1527	} else {
1528		return nil
1529	}
1530}
1531
1532func validateOrganizationAggregationSource(v *types.OrganizationAggregationSource) error {
1533	if v == nil {
1534		return nil
1535	}
1536	invalidParams := smithy.InvalidParamsError{Context: "OrganizationAggregationSource"}
1537	if v.RoleArn == nil {
1538		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
1539	}
1540	if invalidParams.Len() > 0 {
1541		return invalidParams
1542	} else {
1543		return nil
1544	}
1545}
1546
1547func validateOrganizationCustomRuleMetadata(v *types.OrganizationCustomRuleMetadata) error {
1548	if v == nil {
1549		return nil
1550	}
1551	invalidParams := smithy.InvalidParamsError{Context: "OrganizationCustomRuleMetadata"}
1552	if v.LambdaFunctionArn == nil {
1553		invalidParams.Add(smithy.NewErrParamRequired("LambdaFunctionArn"))
1554	}
1555	if v.OrganizationConfigRuleTriggerTypes == nil {
1556		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleTriggerTypes"))
1557	}
1558	if invalidParams.Len() > 0 {
1559		return invalidParams
1560	} else {
1561		return nil
1562	}
1563}
1564
1565func validateOrganizationManagedRuleMetadata(v *types.OrganizationManagedRuleMetadata) error {
1566	if v == nil {
1567		return nil
1568	}
1569	invalidParams := smithy.InvalidParamsError{Context: "OrganizationManagedRuleMetadata"}
1570	if v.RuleIdentifier == nil {
1571		invalidParams.Add(smithy.NewErrParamRequired("RuleIdentifier"))
1572	}
1573	if invalidParams.Len() > 0 {
1574		return invalidParams
1575	} else {
1576		return nil
1577	}
1578}
1579
1580func validateRemediationConfiguration(v *types.RemediationConfiguration) error {
1581	if v == nil {
1582		return nil
1583	}
1584	invalidParams := smithy.InvalidParamsError{Context: "RemediationConfiguration"}
1585	if v.ConfigRuleName == nil {
1586		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
1587	}
1588	if len(v.TargetType) == 0 {
1589		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
1590	}
1591	if v.TargetId == nil {
1592		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
1593	}
1594	if v.Parameters != nil {
1595		if err := validateRemediationParameters(v.Parameters); err != nil {
1596			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
1597		}
1598	}
1599	if invalidParams.Len() > 0 {
1600		return invalidParams
1601	} else {
1602		return nil
1603	}
1604}
1605
1606func validateRemediationConfigurations(v []types.RemediationConfiguration) error {
1607	if v == nil {
1608		return nil
1609	}
1610	invalidParams := smithy.InvalidParamsError{Context: "RemediationConfigurations"}
1611	for i := range v {
1612		if err := validateRemediationConfiguration(&v[i]); err != nil {
1613			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1614		}
1615	}
1616	if invalidParams.Len() > 0 {
1617		return invalidParams
1618	} else {
1619		return nil
1620	}
1621}
1622
1623func validateRemediationParameters(v map[string]types.RemediationParameterValue) error {
1624	if v == nil {
1625		return nil
1626	}
1627	invalidParams := smithy.InvalidParamsError{Context: "RemediationParameters"}
1628	for key := range v {
1629		value := v[key]
1630		if err := validateRemediationParameterValue(&value); err != nil {
1631			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1632		}
1633	}
1634	if invalidParams.Len() > 0 {
1635		return invalidParams
1636	} else {
1637		return nil
1638	}
1639}
1640
1641func validateRemediationParameterValue(v *types.RemediationParameterValue) error {
1642	if v == nil {
1643		return nil
1644	}
1645	invalidParams := smithy.InvalidParamsError{Context: "RemediationParameterValue"}
1646	if v.ResourceValue != nil {
1647		if err := validateResourceValue(v.ResourceValue); err != nil {
1648			invalidParams.AddNested("ResourceValue", err.(smithy.InvalidParamsError))
1649		}
1650	}
1651	if v.StaticValue != nil {
1652		if err := validateStaticValue(v.StaticValue); err != nil {
1653			invalidParams.AddNested("StaticValue", err.(smithy.InvalidParamsError))
1654		}
1655	}
1656	if invalidParams.Len() > 0 {
1657		return invalidParams
1658	} else {
1659		return nil
1660	}
1661}
1662
1663func validateResourceIdentifiersList(v []types.AggregateResourceIdentifier) error {
1664	if v == nil {
1665		return nil
1666	}
1667	invalidParams := smithy.InvalidParamsError{Context: "ResourceIdentifiersList"}
1668	for i := range v {
1669		if err := validateAggregateResourceIdentifier(&v[i]); err != nil {
1670			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1671		}
1672	}
1673	if invalidParams.Len() > 0 {
1674		return invalidParams
1675	} else {
1676		return nil
1677	}
1678}
1679
1680func validateResourceKey(v *types.ResourceKey) error {
1681	if v == nil {
1682		return nil
1683	}
1684	invalidParams := smithy.InvalidParamsError{Context: "ResourceKey"}
1685	if len(v.ResourceType) == 0 {
1686		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
1687	}
1688	if v.ResourceId == nil {
1689		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
1690	}
1691	if invalidParams.Len() > 0 {
1692		return invalidParams
1693	} else {
1694		return nil
1695	}
1696}
1697
1698func validateResourceKeys(v []types.ResourceKey) error {
1699	if v == nil {
1700		return nil
1701	}
1702	invalidParams := smithy.InvalidParamsError{Context: "ResourceKeys"}
1703	for i := range v {
1704		if err := validateResourceKey(&v[i]); err != nil {
1705			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1706		}
1707	}
1708	if invalidParams.Len() > 0 {
1709		return invalidParams
1710	} else {
1711		return nil
1712	}
1713}
1714
1715func validateResourceValue(v *types.ResourceValue) error {
1716	if v == nil {
1717		return nil
1718	}
1719	invalidParams := smithy.InvalidParamsError{Context: "ResourceValue"}
1720	if len(v.Value) == 0 {
1721		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1722	}
1723	if invalidParams.Len() > 0 {
1724		return invalidParams
1725	} else {
1726		return nil
1727	}
1728}
1729
1730func validateSource(v *types.Source) error {
1731	if v == nil {
1732		return nil
1733	}
1734	invalidParams := smithy.InvalidParamsError{Context: "Source"}
1735	if len(v.Owner) == 0 {
1736		invalidParams.Add(smithy.NewErrParamRequired("Owner"))
1737	}
1738	if v.SourceIdentifier == nil {
1739		invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier"))
1740	}
1741	if invalidParams.Len() > 0 {
1742		return invalidParams
1743	} else {
1744		return nil
1745	}
1746}
1747
1748func validateStaticValue(v *types.StaticValue) error {
1749	if v == nil {
1750		return nil
1751	}
1752	invalidParams := smithy.InvalidParamsError{Context: "StaticValue"}
1753	if v.Values == nil {
1754		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1755	}
1756	if invalidParams.Len() > 0 {
1757		return invalidParams
1758	} else {
1759		return nil
1760	}
1761}
1762
1763func validateOpBatchGetAggregateResourceConfigInput(v *BatchGetAggregateResourceConfigInput) error {
1764	if v == nil {
1765		return nil
1766	}
1767	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAggregateResourceConfigInput"}
1768	if v.ConfigurationAggregatorName == nil {
1769		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
1770	}
1771	if v.ResourceIdentifiers == nil {
1772		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifiers"))
1773	} else if v.ResourceIdentifiers != nil {
1774		if err := validateResourceIdentifiersList(v.ResourceIdentifiers); err != nil {
1775			invalidParams.AddNested("ResourceIdentifiers", err.(smithy.InvalidParamsError))
1776		}
1777	}
1778	if invalidParams.Len() > 0 {
1779		return invalidParams
1780	} else {
1781		return nil
1782	}
1783}
1784
1785func validateOpBatchGetResourceConfigInput(v *BatchGetResourceConfigInput) error {
1786	if v == nil {
1787		return nil
1788	}
1789	invalidParams := smithy.InvalidParamsError{Context: "BatchGetResourceConfigInput"}
1790	if v.ResourceKeys == nil {
1791		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
1792	} else if v.ResourceKeys != nil {
1793		if err := validateResourceKeys(v.ResourceKeys); err != nil {
1794			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
1795		}
1796	}
1797	if invalidParams.Len() > 0 {
1798		return invalidParams
1799	} else {
1800		return nil
1801	}
1802}
1803
1804func validateOpDeleteAggregationAuthorizationInput(v *DeleteAggregationAuthorizationInput) error {
1805	if v == nil {
1806		return nil
1807	}
1808	invalidParams := smithy.InvalidParamsError{Context: "DeleteAggregationAuthorizationInput"}
1809	if v.AuthorizedAccountId == nil {
1810		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId"))
1811	}
1812	if v.AuthorizedAwsRegion == nil {
1813		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion"))
1814	}
1815	if invalidParams.Len() > 0 {
1816		return invalidParams
1817	} else {
1818		return nil
1819	}
1820}
1821
1822func validateOpDeleteConfigRuleInput(v *DeleteConfigRuleInput) error {
1823	if v == nil {
1824		return nil
1825	}
1826	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigRuleInput"}
1827	if v.ConfigRuleName == nil {
1828		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
1829	}
1830	if invalidParams.Len() > 0 {
1831		return invalidParams
1832	} else {
1833		return nil
1834	}
1835}
1836
1837func validateOpDeleteConfigurationAggregatorInput(v *DeleteConfigurationAggregatorInput) error {
1838	if v == nil {
1839		return nil
1840	}
1841	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationAggregatorInput"}
1842	if v.ConfigurationAggregatorName == nil {
1843		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
1844	}
1845	if invalidParams.Len() > 0 {
1846		return invalidParams
1847	} else {
1848		return nil
1849	}
1850}
1851
1852func validateOpDeleteConfigurationRecorderInput(v *DeleteConfigurationRecorderInput) error {
1853	if v == nil {
1854		return nil
1855	}
1856	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationRecorderInput"}
1857	if v.ConfigurationRecorderName == nil {
1858		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
1859	}
1860	if invalidParams.Len() > 0 {
1861		return invalidParams
1862	} else {
1863		return nil
1864	}
1865}
1866
1867func validateOpDeleteConformancePackInput(v *DeleteConformancePackInput) error {
1868	if v == nil {
1869		return nil
1870	}
1871	invalidParams := smithy.InvalidParamsError{Context: "DeleteConformancePackInput"}
1872	if v.ConformancePackName == nil {
1873		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
1874	}
1875	if invalidParams.Len() > 0 {
1876		return invalidParams
1877	} else {
1878		return nil
1879	}
1880}
1881
1882func validateOpDeleteDeliveryChannelInput(v *DeleteDeliveryChannelInput) error {
1883	if v == nil {
1884		return nil
1885	}
1886	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeliveryChannelInput"}
1887	if v.DeliveryChannelName == nil {
1888		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName"))
1889	}
1890	if invalidParams.Len() > 0 {
1891		return invalidParams
1892	} else {
1893		return nil
1894	}
1895}
1896
1897func validateOpDeleteEvaluationResultsInput(v *DeleteEvaluationResultsInput) error {
1898	if v == nil {
1899		return nil
1900	}
1901	invalidParams := smithy.InvalidParamsError{Context: "DeleteEvaluationResultsInput"}
1902	if v.ConfigRuleName == nil {
1903		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
1904	}
1905	if invalidParams.Len() > 0 {
1906		return invalidParams
1907	} else {
1908		return nil
1909	}
1910}
1911
1912func validateOpDeleteOrganizationConfigRuleInput(v *DeleteOrganizationConfigRuleInput) error {
1913	if v == nil {
1914		return nil
1915	}
1916	invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConfigRuleInput"}
1917	if v.OrganizationConfigRuleName == nil {
1918		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
1919	}
1920	if invalidParams.Len() > 0 {
1921		return invalidParams
1922	} else {
1923		return nil
1924	}
1925}
1926
1927func validateOpDeleteOrganizationConformancePackInput(v *DeleteOrganizationConformancePackInput) error {
1928	if v == nil {
1929		return nil
1930	}
1931	invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConformancePackInput"}
1932	if v.OrganizationConformancePackName == nil {
1933		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
1934	}
1935	if invalidParams.Len() > 0 {
1936		return invalidParams
1937	} else {
1938		return nil
1939	}
1940}
1941
1942func validateOpDeletePendingAggregationRequestInput(v *DeletePendingAggregationRequestInput) error {
1943	if v == nil {
1944		return nil
1945	}
1946	invalidParams := smithy.InvalidParamsError{Context: "DeletePendingAggregationRequestInput"}
1947	if v.RequesterAccountId == nil {
1948		invalidParams.Add(smithy.NewErrParamRequired("RequesterAccountId"))
1949	}
1950	if v.RequesterAwsRegion == nil {
1951		invalidParams.Add(smithy.NewErrParamRequired("RequesterAwsRegion"))
1952	}
1953	if invalidParams.Len() > 0 {
1954		return invalidParams
1955	} else {
1956		return nil
1957	}
1958}
1959
1960func validateOpDeleteRemediationConfigurationInput(v *DeleteRemediationConfigurationInput) error {
1961	if v == nil {
1962		return nil
1963	}
1964	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationConfigurationInput"}
1965	if v.ConfigRuleName == nil {
1966		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
1967	}
1968	if invalidParams.Len() > 0 {
1969		return invalidParams
1970	} else {
1971		return nil
1972	}
1973}
1974
1975func validateOpDeleteRemediationExceptionsInput(v *DeleteRemediationExceptionsInput) error {
1976	if v == nil {
1977		return nil
1978	}
1979	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationExceptionsInput"}
1980	if v.ConfigRuleName == nil {
1981		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
1982	}
1983	if v.ResourceKeys == nil {
1984		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
1985	}
1986	if invalidParams.Len() > 0 {
1987		return invalidParams
1988	} else {
1989		return nil
1990	}
1991}
1992
1993func validateOpDeleteResourceConfigInput(v *DeleteResourceConfigInput) error {
1994	if v == nil {
1995		return nil
1996	}
1997	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceConfigInput"}
1998	if v.ResourceType == nil {
1999		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2000	}
2001	if v.ResourceId == nil {
2002		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2003	}
2004	if invalidParams.Len() > 0 {
2005		return invalidParams
2006	} else {
2007		return nil
2008	}
2009}
2010
2011func validateOpDeleteRetentionConfigurationInput(v *DeleteRetentionConfigurationInput) error {
2012	if v == nil {
2013		return nil
2014	}
2015	invalidParams := smithy.InvalidParamsError{Context: "DeleteRetentionConfigurationInput"}
2016	if v.RetentionConfigurationName == nil {
2017		invalidParams.Add(smithy.NewErrParamRequired("RetentionConfigurationName"))
2018	}
2019	if invalidParams.Len() > 0 {
2020		return invalidParams
2021	} else {
2022		return nil
2023	}
2024}
2025
2026func validateOpDeliverConfigSnapshotInput(v *DeliverConfigSnapshotInput) error {
2027	if v == nil {
2028		return nil
2029	}
2030	invalidParams := smithy.InvalidParamsError{Context: "DeliverConfigSnapshotInput"}
2031	if v.DeliveryChannelName == nil {
2032		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName"))
2033	}
2034	if invalidParams.Len() > 0 {
2035		return invalidParams
2036	} else {
2037		return nil
2038	}
2039}
2040
2041func validateOpDescribeAggregateComplianceByConfigRulesInput(v *DescribeAggregateComplianceByConfigRulesInput) error {
2042	if v == nil {
2043		return nil
2044	}
2045	invalidParams := smithy.InvalidParamsError{Context: "DescribeAggregateComplianceByConfigRulesInput"}
2046	if v.ConfigurationAggregatorName == nil {
2047		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2048	}
2049	if invalidParams.Len() > 0 {
2050		return invalidParams
2051	} else {
2052		return nil
2053	}
2054}
2055
2056func validateOpDescribeConfigurationAggregatorSourcesStatusInput(v *DescribeConfigurationAggregatorSourcesStatusInput) error {
2057	if v == nil {
2058		return nil
2059	}
2060	invalidParams := smithy.InvalidParamsError{Context: "DescribeConfigurationAggregatorSourcesStatusInput"}
2061	if v.ConfigurationAggregatorName == nil {
2062		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2063	}
2064	if invalidParams.Len() > 0 {
2065		return invalidParams
2066	} else {
2067		return nil
2068	}
2069}
2070
2071func validateOpDescribeConformancePackComplianceInput(v *DescribeConformancePackComplianceInput) error {
2072	if v == nil {
2073		return nil
2074	}
2075	invalidParams := smithy.InvalidParamsError{Context: "DescribeConformancePackComplianceInput"}
2076	if v.ConformancePackName == nil {
2077		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
2078	}
2079	if invalidParams.Len() > 0 {
2080		return invalidParams
2081	} else {
2082		return nil
2083	}
2084}
2085
2086func validateOpDescribeRemediationConfigurationsInput(v *DescribeRemediationConfigurationsInput) error {
2087	if v == nil {
2088		return nil
2089	}
2090	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationConfigurationsInput"}
2091	if v.ConfigRuleNames == nil {
2092		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleNames"))
2093	}
2094	if invalidParams.Len() > 0 {
2095		return invalidParams
2096	} else {
2097		return nil
2098	}
2099}
2100
2101func validateOpDescribeRemediationExceptionsInput(v *DescribeRemediationExceptionsInput) error {
2102	if v == nil {
2103		return nil
2104	}
2105	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExceptionsInput"}
2106	if v.ConfigRuleName == nil {
2107		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2108	}
2109	if invalidParams.Len() > 0 {
2110		return invalidParams
2111	} else {
2112		return nil
2113	}
2114}
2115
2116func validateOpDescribeRemediationExecutionStatusInput(v *DescribeRemediationExecutionStatusInput) error {
2117	if v == nil {
2118		return nil
2119	}
2120	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExecutionStatusInput"}
2121	if v.ConfigRuleName == nil {
2122		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2123	}
2124	if v.ResourceKeys != nil {
2125		if err := validateResourceKeys(v.ResourceKeys); err != nil {
2126			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
2127		}
2128	}
2129	if invalidParams.Len() > 0 {
2130		return invalidParams
2131	} else {
2132		return nil
2133	}
2134}
2135
2136func validateOpGetAggregateComplianceDetailsByConfigRuleInput(v *GetAggregateComplianceDetailsByConfigRuleInput) error {
2137	if v == nil {
2138		return nil
2139	}
2140	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateComplianceDetailsByConfigRuleInput"}
2141	if v.ConfigurationAggregatorName == nil {
2142		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2143	}
2144	if v.ConfigRuleName == nil {
2145		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2146	}
2147	if v.AccountId == nil {
2148		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
2149	}
2150	if v.AwsRegion == nil {
2151		invalidParams.Add(smithy.NewErrParamRequired("AwsRegion"))
2152	}
2153	if invalidParams.Len() > 0 {
2154		return invalidParams
2155	} else {
2156		return nil
2157	}
2158}
2159
2160func validateOpGetAggregateConfigRuleComplianceSummaryInput(v *GetAggregateConfigRuleComplianceSummaryInput) error {
2161	if v == nil {
2162		return nil
2163	}
2164	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateConfigRuleComplianceSummaryInput"}
2165	if v.ConfigurationAggregatorName == nil {
2166		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2167	}
2168	if invalidParams.Len() > 0 {
2169		return invalidParams
2170	} else {
2171		return nil
2172	}
2173}
2174
2175func validateOpGetAggregateDiscoveredResourceCountsInput(v *GetAggregateDiscoveredResourceCountsInput) error {
2176	if v == nil {
2177		return nil
2178	}
2179	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateDiscoveredResourceCountsInput"}
2180	if v.ConfigurationAggregatorName == nil {
2181		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2182	}
2183	if invalidParams.Len() > 0 {
2184		return invalidParams
2185	} else {
2186		return nil
2187	}
2188}
2189
2190func validateOpGetAggregateResourceConfigInput(v *GetAggregateResourceConfigInput) error {
2191	if v == nil {
2192		return nil
2193	}
2194	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateResourceConfigInput"}
2195	if v.ConfigurationAggregatorName == nil {
2196		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2197	}
2198	if v.ResourceIdentifier == nil {
2199		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
2200	} else if v.ResourceIdentifier != nil {
2201		if err := validateAggregateResourceIdentifier(v.ResourceIdentifier); err != nil {
2202			invalidParams.AddNested("ResourceIdentifier", err.(smithy.InvalidParamsError))
2203		}
2204	}
2205	if invalidParams.Len() > 0 {
2206		return invalidParams
2207	} else {
2208		return nil
2209	}
2210}
2211
2212func validateOpGetComplianceDetailsByConfigRuleInput(v *GetComplianceDetailsByConfigRuleInput) error {
2213	if v == nil {
2214		return nil
2215	}
2216	invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailsByConfigRuleInput"}
2217	if v.ConfigRuleName == nil {
2218		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2219	}
2220	if invalidParams.Len() > 0 {
2221		return invalidParams
2222	} else {
2223		return nil
2224	}
2225}
2226
2227func validateOpGetComplianceDetailsByResourceInput(v *GetComplianceDetailsByResourceInput) error {
2228	if v == nil {
2229		return nil
2230	}
2231	invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailsByResourceInput"}
2232	if v.ResourceType == nil {
2233		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2234	}
2235	if v.ResourceId == nil {
2236		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2237	}
2238	if invalidParams.Len() > 0 {
2239		return invalidParams
2240	} else {
2241		return nil
2242	}
2243}
2244
2245func validateOpGetConformancePackComplianceDetailsInput(v *GetConformancePackComplianceDetailsInput) error {
2246	if v == nil {
2247		return nil
2248	}
2249	invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceDetailsInput"}
2250	if v.ConformancePackName == nil {
2251		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
2252	}
2253	if invalidParams.Len() > 0 {
2254		return invalidParams
2255	} else {
2256		return nil
2257	}
2258}
2259
2260func validateOpGetConformancePackComplianceSummaryInput(v *GetConformancePackComplianceSummaryInput) error {
2261	if v == nil {
2262		return nil
2263	}
2264	invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceSummaryInput"}
2265	if v.ConformancePackNames == nil {
2266		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackNames"))
2267	}
2268	if invalidParams.Len() > 0 {
2269		return invalidParams
2270	} else {
2271		return nil
2272	}
2273}
2274
2275func validateOpGetOrganizationConfigRuleDetailedStatusInput(v *GetOrganizationConfigRuleDetailedStatusInput) error {
2276	if v == nil {
2277		return nil
2278	}
2279	invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConfigRuleDetailedStatusInput"}
2280	if v.OrganizationConfigRuleName == nil {
2281		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
2282	}
2283	if invalidParams.Len() > 0 {
2284		return invalidParams
2285	} else {
2286		return nil
2287	}
2288}
2289
2290func validateOpGetOrganizationConformancePackDetailedStatusInput(v *GetOrganizationConformancePackDetailedStatusInput) error {
2291	if v == nil {
2292		return nil
2293	}
2294	invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConformancePackDetailedStatusInput"}
2295	if v.OrganizationConformancePackName == nil {
2296		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
2297	}
2298	if invalidParams.Len() > 0 {
2299		return invalidParams
2300	} else {
2301		return nil
2302	}
2303}
2304
2305func validateOpGetResourceConfigHistoryInput(v *GetResourceConfigHistoryInput) error {
2306	if v == nil {
2307		return nil
2308	}
2309	invalidParams := smithy.InvalidParamsError{Context: "GetResourceConfigHistoryInput"}
2310	if len(v.ResourceType) == 0 {
2311		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2312	}
2313	if v.ResourceId == nil {
2314		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2315	}
2316	if invalidParams.Len() > 0 {
2317		return invalidParams
2318	} else {
2319		return nil
2320	}
2321}
2322
2323func validateOpListAggregateDiscoveredResourcesInput(v *ListAggregateDiscoveredResourcesInput) error {
2324	if v == nil {
2325		return nil
2326	}
2327	invalidParams := smithy.InvalidParamsError{Context: "ListAggregateDiscoveredResourcesInput"}
2328	if v.ConfigurationAggregatorName == nil {
2329		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2330	}
2331	if len(v.ResourceType) == 0 {
2332		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2333	}
2334	if invalidParams.Len() > 0 {
2335		return invalidParams
2336	} else {
2337		return nil
2338	}
2339}
2340
2341func validateOpListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput) error {
2342	if v == nil {
2343		return nil
2344	}
2345	invalidParams := smithy.InvalidParamsError{Context: "ListDiscoveredResourcesInput"}
2346	if len(v.ResourceType) == 0 {
2347		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2348	}
2349	if invalidParams.Len() > 0 {
2350		return invalidParams
2351	} else {
2352		return nil
2353	}
2354}
2355
2356func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
2357	if v == nil {
2358		return nil
2359	}
2360	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
2361	if v.ResourceArn == nil {
2362		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2363	}
2364	if invalidParams.Len() > 0 {
2365		return invalidParams
2366	} else {
2367		return nil
2368	}
2369}
2370
2371func validateOpPutAggregationAuthorizationInput(v *PutAggregationAuthorizationInput) error {
2372	if v == nil {
2373		return nil
2374	}
2375	invalidParams := smithy.InvalidParamsError{Context: "PutAggregationAuthorizationInput"}
2376	if v.AuthorizedAccountId == nil {
2377		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId"))
2378	}
2379	if v.AuthorizedAwsRegion == nil {
2380		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion"))
2381	}
2382	if invalidParams.Len() > 0 {
2383		return invalidParams
2384	} else {
2385		return nil
2386	}
2387}
2388
2389func validateOpPutConfigRuleInput(v *PutConfigRuleInput) error {
2390	if v == nil {
2391		return nil
2392	}
2393	invalidParams := smithy.InvalidParamsError{Context: "PutConfigRuleInput"}
2394	if v.ConfigRule == nil {
2395		invalidParams.Add(smithy.NewErrParamRequired("ConfigRule"))
2396	} else if v.ConfigRule != nil {
2397		if err := validateConfigRule(v.ConfigRule); err != nil {
2398			invalidParams.AddNested("ConfigRule", err.(smithy.InvalidParamsError))
2399		}
2400	}
2401	if invalidParams.Len() > 0 {
2402		return invalidParams
2403	} else {
2404		return nil
2405	}
2406}
2407
2408func validateOpPutConfigurationAggregatorInput(v *PutConfigurationAggregatorInput) error {
2409	if v == nil {
2410		return nil
2411	}
2412	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationAggregatorInput"}
2413	if v.ConfigurationAggregatorName == nil {
2414		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2415	}
2416	if v.AccountAggregationSources != nil {
2417		if err := validateAccountAggregationSourceList(v.AccountAggregationSources); err != nil {
2418			invalidParams.AddNested("AccountAggregationSources", err.(smithy.InvalidParamsError))
2419		}
2420	}
2421	if v.OrganizationAggregationSource != nil {
2422		if err := validateOrganizationAggregationSource(v.OrganizationAggregationSource); err != nil {
2423			invalidParams.AddNested("OrganizationAggregationSource", err.(smithy.InvalidParamsError))
2424		}
2425	}
2426	if invalidParams.Len() > 0 {
2427		return invalidParams
2428	} else {
2429		return nil
2430	}
2431}
2432
2433func validateOpPutConfigurationRecorderInput(v *PutConfigurationRecorderInput) error {
2434	if v == nil {
2435		return nil
2436	}
2437	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationRecorderInput"}
2438	if v.ConfigurationRecorder == nil {
2439		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorder"))
2440	}
2441	if invalidParams.Len() > 0 {
2442		return invalidParams
2443	} else {
2444		return nil
2445	}
2446}
2447
2448func validateOpPutConformancePackInput(v *PutConformancePackInput) error {
2449	if v == nil {
2450		return nil
2451	}
2452	invalidParams := smithy.InvalidParamsError{Context: "PutConformancePackInput"}
2453	if v.ConformancePackName == nil {
2454		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
2455	}
2456	if v.ConformancePackInputParameters != nil {
2457		if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil {
2458			invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError))
2459		}
2460	}
2461	if invalidParams.Len() > 0 {
2462		return invalidParams
2463	} else {
2464		return nil
2465	}
2466}
2467
2468func validateOpPutDeliveryChannelInput(v *PutDeliveryChannelInput) error {
2469	if v == nil {
2470		return nil
2471	}
2472	invalidParams := smithy.InvalidParamsError{Context: "PutDeliveryChannelInput"}
2473	if v.DeliveryChannel == nil {
2474		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannel"))
2475	}
2476	if invalidParams.Len() > 0 {
2477		return invalidParams
2478	} else {
2479		return nil
2480	}
2481}
2482
2483func validateOpPutEvaluationsInput(v *PutEvaluationsInput) error {
2484	if v == nil {
2485		return nil
2486	}
2487	invalidParams := smithy.InvalidParamsError{Context: "PutEvaluationsInput"}
2488	if v.Evaluations != nil {
2489		if err := validateEvaluations(v.Evaluations); err != nil {
2490			invalidParams.AddNested("Evaluations", err.(smithy.InvalidParamsError))
2491		}
2492	}
2493	if v.ResultToken == nil {
2494		invalidParams.Add(smithy.NewErrParamRequired("ResultToken"))
2495	}
2496	if invalidParams.Len() > 0 {
2497		return invalidParams
2498	} else {
2499		return nil
2500	}
2501}
2502
2503func validateOpPutOrganizationConfigRuleInput(v *PutOrganizationConfigRuleInput) error {
2504	if v == nil {
2505		return nil
2506	}
2507	invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConfigRuleInput"}
2508	if v.OrganizationConfigRuleName == nil {
2509		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
2510	}
2511	if v.OrganizationManagedRuleMetadata != nil {
2512		if err := validateOrganizationManagedRuleMetadata(v.OrganizationManagedRuleMetadata); err != nil {
2513			invalidParams.AddNested("OrganizationManagedRuleMetadata", err.(smithy.InvalidParamsError))
2514		}
2515	}
2516	if v.OrganizationCustomRuleMetadata != nil {
2517		if err := validateOrganizationCustomRuleMetadata(v.OrganizationCustomRuleMetadata); err != nil {
2518			invalidParams.AddNested("OrganizationCustomRuleMetadata", err.(smithy.InvalidParamsError))
2519		}
2520	}
2521	if invalidParams.Len() > 0 {
2522		return invalidParams
2523	} else {
2524		return nil
2525	}
2526}
2527
2528func validateOpPutOrganizationConformancePackInput(v *PutOrganizationConformancePackInput) error {
2529	if v == nil {
2530		return nil
2531	}
2532	invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConformancePackInput"}
2533	if v.OrganizationConformancePackName == nil {
2534		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
2535	}
2536	if v.ConformancePackInputParameters != nil {
2537		if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil {
2538			invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError))
2539		}
2540	}
2541	if invalidParams.Len() > 0 {
2542		return invalidParams
2543	} else {
2544		return nil
2545	}
2546}
2547
2548func validateOpPutRemediationConfigurationsInput(v *PutRemediationConfigurationsInput) error {
2549	if v == nil {
2550		return nil
2551	}
2552	invalidParams := smithy.InvalidParamsError{Context: "PutRemediationConfigurationsInput"}
2553	if v.RemediationConfigurations == nil {
2554		invalidParams.Add(smithy.NewErrParamRequired("RemediationConfigurations"))
2555	} else if v.RemediationConfigurations != nil {
2556		if err := validateRemediationConfigurations(v.RemediationConfigurations); err != nil {
2557			invalidParams.AddNested("RemediationConfigurations", err.(smithy.InvalidParamsError))
2558		}
2559	}
2560	if invalidParams.Len() > 0 {
2561		return invalidParams
2562	} else {
2563		return nil
2564	}
2565}
2566
2567func validateOpPutRemediationExceptionsInput(v *PutRemediationExceptionsInput) error {
2568	if v == nil {
2569		return nil
2570	}
2571	invalidParams := smithy.InvalidParamsError{Context: "PutRemediationExceptionsInput"}
2572	if v.ConfigRuleName == nil {
2573		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2574	}
2575	if v.ResourceKeys == nil {
2576		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
2577	}
2578	if invalidParams.Len() > 0 {
2579		return invalidParams
2580	} else {
2581		return nil
2582	}
2583}
2584
2585func validateOpPutResourceConfigInput(v *PutResourceConfigInput) error {
2586	if v == nil {
2587		return nil
2588	}
2589	invalidParams := smithy.InvalidParamsError{Context: "PutResourceConfigInput"}
2590	if v.ResourceType == nil {
2591		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
2592	}
2593	if v.SchemaVersionId == nil {
2594		invalidParams.Add(smithy.NewErrParamRequired("SchemaVersionId"))
2595	}
2596	if v.ResourceId == nil {
2597		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
2598	}
2599	if v.Configuration == nil {
2600		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
2601	}
2602	if invalidParams.Len() > 0 {
2603		return invalidParams
2604	} else {
2605		return nil
2606	}
2607}
2608
2609func validateOpPutRetentionConfigurationInput(v *PutRetentionConfigurationInput) error {
2610	if v == nil {
2611		return nil
2612	}
2613	invalidParams := smithy.InvalidParamsError{Context: "PutRetentionConfigurationInput"}
2614	if invalidParams.Len() > 0 {
2615		return invalidParams
2616	} else {
2617		return nil
2618	}
2619}
2620
2621func validateOpSelectAggregateResourceConfigInput(v *SelectAggregateResourceConfigInput) error {
2622	if v == nil {
2623		return nil
2624	}
2625	invalidParams := smithy.InvalidParamsError{Context: "SelectAggregateResourceConfigInput"}
2626	if v.Expression == nil {
2627		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
2628	}
2629	if v.ConfigurationAggregatorName == nil {
2630		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
2631	}
2632	if invalidParams.Len() > 0 {
2633		return invalidParams
2634	} else {
2635		return nil
2636	}
2637}
2638
2639func validateOpSelectResourceConfigInput(v *SelectResourceConfigInput) error {
2640	if v == nil {
2641		return nil
2642	}
2643	invalidParams := smithy.InvalidParamsError{Context: "SelectResourceConfigInput"}
2644	if v.Expression == nil {
2645		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
2646	}
2647	if invalidParams.Len() > 0 {
2648		return invalidParams
2649	} else {
2650		return nil
2651	}
2652}
2653
2654func validateOpStartConfigurationRecorderInput(v *StartConfigurationRecorderInput) error {
2655	if v == nil {
2656		return nil
2657	}
2658	invalidParams := smithy.InvalidParamsError{Context: "StartConfigurationRecorderInput"}
2659	if v.ConfigurationRecorderName == nil {
2660		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
2661	}
2662	if invalidParams.Len() > 0 {
2663		return invalidParams
2664	} else {
2665		return nil
2666	}
2667}
2668
2669func validateOpStartRemediationExecutionInput(v *StartRemediationExecutionInput) error {
2670	if v == nil {
2671		return nil
2672	}
2673	invalidParams := smithy.InvalidParamsError{Context: "StartRemediationExecutionInput"}
2674	if v.ConfigRuleName == nil {
2675		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
2676	}
2677	if v.ResourceKeys == nil {
2678		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
2679	} else if v.ResourceKeys != nil {
2680		if err := validateResourceKeys(v.ResourceKeys); err != nil {
2681			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
2682		}
2683	}
2684	if invalidParams.Len() > 0 {
2685		return invalidParams
2686	} else {
2687		return nil
2688	}
2689}
2690
2691func validateOpStopConfigurationRecorderInput(v *StopConfigurationRecorderInput) error {
2692	if v == nil {
2693		return nil
2694	}
2695	invalidParams := smithy.InvalidParamsError{Context: "StopConfigurationRecorderInput"}
2696	if v.ConfigurationRecorderName == nil {
2697		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
2698	}
2699	if invalidParams.Len() > 0 {
2700		return invalidParams
2701	} else {
2702		return nil
2703	}
2704}
2705
2706func validateOpTagResourceInput(v *TagResourceInput) error {
2707	if v == nil {
2708		return nil
2709	}
2710	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2711	if v.ResourceArn == nil {
2712		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2713	}
2714	if v.Tags == nil {
2715		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2716	}
2717	if invalidParams.Len() > 0 {
2718		return invalidParams
2719	} else {
2720		return nil
2721	}
2722}
2723
2724func validateOpUntagResourceInput(v *UntagResourceInput) error {
2725	if v == nil {
2726		return nil
2727	}
2728	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2729	if v.ResourceArn == nil {
2730		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2731	}
2732	if v.TagKeys == nil {
2733		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2734	}
2735	if invalidParams.Len() > 0 {
2736		return invalidParams
2737	} else {
2738		return nil
2739	}
2740}
2741