validators.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package configservice

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/configservice/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpBatchGetAggregateResourceConfig struct {
}

func (*validateOpBatchGetAggregateResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpBatchGetAggregateResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*BatchGetAggregateResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpBatchGetAggregateResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpBatchGetResourceConfig struct {
}

func (*validateOpBatchGetResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpBatchGetResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*BatchGetResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpBatchGetResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteAggregationAuthorization struct {
}

func (*validateOpDeleteAggregationAuthorization) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteAggregationAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteAggregationAuthorizationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteAggregationAuthorizationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigRule struct {
}

func (*validateOpDeleteConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigurationAggregator struct {
}

func (*validateOpDeleteConfigurationAggregator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigurationAggregator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigurationAggregatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigurationAggregatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigurationRecorder struct {
}

func (*validateOpDeleteConfigurationRecorder) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigurationRecorderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigurationRecorderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConformancePack struct {
}

func (*validateOpDeleteConformancePack) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConformancePackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConformancePackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDeliveryChannel struct {
}

func (*validateOpDeleteDeliveryChannel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDeliveryChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDeliveryChannelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDeliveryChannelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteEvaluationResults struct {
}

func (*validateOpDeleteEvaluationResults) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteEvaluationResults) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteEvaluationResultsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteEvaluationResultsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteOrganizationConfigRule struct {
}

func (*validateOpDeleteOrganizationConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteOrganizationConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteOrganizationConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteOrganizationConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteOrganizationConformancePack struct {
}

func (*validateOpDeleteOrganizationConformancePack) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteOrganizationConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteOrganizationConformancePackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteOrganizationConformancePackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeletePendingAggregationRequest struct {
}

func (*validateOpDeletePendingAggregationRequest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeletePendingAggregationRequest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeletePendingAggregationRequestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeletePendingAggregationRequestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRemediationConfiguration struct {
}

func (*validateOpDeleteRemediationConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRemediationConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRemediationConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRemediationConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRemediationExceptions struct {
}

func (*validateOpDeleteRemediationExceptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRemediationExceptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRemediationExceptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRemediationExceptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteResourceConfig struct {
}

func (*validateOpDeleteResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRetentionConfiguration struct {
}

func (*validateOpDeleteRetentionConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRetentionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRetentionConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRetentionConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteStoredQuery struct {
}

func (*validateOpDeleteStoredQuery) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteStoredQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteStoredQueryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteStoredQueryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeliverConfigSnapshot struct {
}

func (*validateOpDeliverConfigSnapshot) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeliverConfigSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeliverConfigSnapshotInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeliverConfigSnapshotInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeAggregateComplianceByConfigRules struct {
}

func (*validateOpDescribeAggregateComplianceByConfigRules) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeAggregateComplianceByConfigRules) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeAggregateComplianceByConfigRulesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeAggregateComplianceByConfigRulesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeAggregateComplianceByConformancePacks struct {
}

func (*validateOpDescribeAggregateComplianceByConformancePacks) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeAggregateComplianceByConformancePacks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeAggregateComplianceByConformancePacksInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeAggregateComplianceByConformancePacksInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeConfigurationAggregatorSourcesStatus struct {
}

func (*validateOpDescribeConfigurationAggregatorSourcesStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeConfigurationAggregatorSourcesStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeConfigurationAggregatorSourcesStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeConfigurationAggregatorSourcesStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeConformancePackCompliance struct {
}

func (*validateOpDescribeConformancePackCompliance) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeConformancePackCompliance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeConformancePackComplianceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeConformancePackComplianceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeRemediationConfigurations struct {
}

func (*validateOpDescribeRemediationConfigurations) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeRemediationConfigurations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeRemediationConfigurationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeRemediationConfigurationsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeRemediationExceptions struct {
}

func (*validateOpDescribeRemediationExceptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeRemediationExceptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeRemediationExceptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeRemediationExceptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeRemediationExecutionStatus struct {
}

func (*validateOpDescribeRemediationExecutionStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeRemediationExecutionStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeRemediationExecutionStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeRemediationExecutionStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAggregateComplianceDetailsByConfigRule struct {
}

func (*validateOpGetAggregateComplianceDetailsByConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAggregateComplianceDetailsByConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAggregateComplianceDetailsByConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAggregateComplianceDetailsByConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAggregateConfigRuleComplianceSummary struct {
}

func (*validateOpGetAggregateConfigRuleComplianceSummary) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAggregateConfigRuleComplianceSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAggregateConfigRuleComplianceSummaryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAggregateConfigRuleComplianceSummaryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAggregateConformancePackComplianceSummary struct {
}

func (*validateOpGetAggregateConformancePackComplianceSummary) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAggregateConformancePackComplianceSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAggregateConformancePackComplianceSummaryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAggregateConformancePackComplianceSummaryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAggregateDiscoveredResourceCounts struct {
}

func (*validateOpGetAggregateDiscoveredResourceCounts) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAggregateDiscoveredResourceCounts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAggregateDiscoveredResourceCountsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAggregateDiscoveredResourceCountsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetAggregateResourceConfig struct {
}

func (*validateOpGetAggregateResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetAggregateResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetAggregateResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetAggregateResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetComplianceDetailsByConfigRule struct {
}

func (*validateOpGetComplianceDetailsByConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetComplianceDetailsByConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetComplianceDetailsByConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetComplianceDetailsByConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetConformancePackComplianceDetails struct {
}

func (*validateOpGetConformancePackComplianceDetails) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetConformancePackComplianceDetails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetConformancePackComplianceDetailsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetConformancePackComplianceDetailsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetConformancePackComplianceSummary struct {
}

func (*validateOpGetConformancePackComplianceSummary) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetConformancePackComplianceSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetConformancePackComplianceSummaryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetConformancePackComplianceSummaryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOrganizationConfigRuleDetailedStatus struct {
}

func (*validateOpGetOrganizationConfigRuleDetailedStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOrganizationConfigRuleDetailedStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOrganizationConfigRuleDetailedStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOrganizationConfigRuleDetailedStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOrganizationConformancePackDetailedStatus struct {
}

func (*validateOpGetOrganizationConformancePackDetailedStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOrganizationConformancePackDetailedStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOrganizationConformancePackDetailedStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOrganizationConformancePackDetailedStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetOrganizationCustomRulePolicy struct {
}

func (*validateOpGetOrganizationCustomRulePolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetOrganizationCustomRulePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetOrganizationCustomRulePolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetOrganizationCustomRulePolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResourceConfigHistory struct {
}

func (*validateOpGetResourceConfigHistory) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResourceConfigHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResourceConfigHistoryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResourceConfigHistoryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetResourceEvaluationSummary struct {
}

func (*validateOpGetResourceEvaluationSummary) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetResourceEvaluationSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetResourceEvaluationSummaryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetResourceEvaluationSummaryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetStoredQuery struct {
}

func (*validateOpGetStoredQuery) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetStoredQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetStoredQueryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetStoredQueryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListAggregateDiscoveredResources struct {
}

func (*validateOpListAggregateDiscoveredResources) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListAggregateDiscoveredResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListAggregateDiscoveredResourcesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListAggregateDiscoveredResourcesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListConformancePackComplianceScores struct {
}

func (*validateOpListConformancePackComplianceScores) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListConformancePackComplianceScores) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListConformancePackComplianceScoresInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListConformancePackComplianceScoresInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDiscoveredResources struct {
}

func (*validateOpListDiscoveredResources) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDiscoveredResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDiscoveredResourcesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDiscoveredResourcesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListTagsForResource struct {
}

func (*validateOpListTagsForResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListTagsForResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListTagsForResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutAggregationAuthorization struct {
}

func (*validateOpPutAggregationAuthorization) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutAggregationAuthorization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutAggregationAuthorizationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutAggregationAuthorizationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutConfigRule struct {
}

func (*validateOpPutConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutConfigurationAggregator struct {
}

func (*validateOpPutConfigurationAggregator) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutConfigurationAggregator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutConfigurationAggregatorInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutConfigurationAggregatorInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutConfigurationRecorder struct {
}

func (*validateOpPutConfigurationRecorder) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutConfigurationRecorderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutConfigurationRecorderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutConformancePack struct {
}

func (*validateOpPutConformancePack) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutConformancePackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutConformancePackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutDeliveryChannel struct {
}

func (*validateOpPutDeliveryChannel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutDeliveryChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutDeliveryChannelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutDeliveryChannelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutEvaluations struct {
}

func (*validateOpPutEvaluations) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutEvaluations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutEvaluationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutEvaluationsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutExternalEvaluation struct {
}

func (*validateOpPutExternalEvaluation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutExternalEvaluation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutExternalEvaluationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutExternalEvaluationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutOrganizationConfigRule struct {
}

func (*validateOpPutOrganizationConfigRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutOrganizationConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutOrganizationConfigRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutOrganizationConfigRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutOrganizationConformancePack struct {
}

func (*validateOpPutOrganizationConformancePack) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutOrganizationConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutOrganizationConformancePackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutOrganizationConformancePackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutRemediationConfigurations struct {
}

func (*validateOpPutRemediationConfigurations) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutRemediationConfigurations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutRemediationConfigurationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutRemediationConfigurationsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutRemediationExceptions struct {
}

func (*validateOpPutRemediationExceptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutRemediationExceptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutRemediationExceptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutRemediationExceptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutResourceConfig struct {
}

func (*validateOpPutResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutRetentionConfiguration struct {
}

func (*validateOpPutRetentionConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutRetentionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutRetentionConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutRetentionConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutStoredQuery struct {
}

func (*validateOpPutStoredQuery) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutStoredQuery) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutStoredQueryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutStoredQueryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSelectAggregateResourceConfig struct {
}

func (*validateOpSelectAggregateResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSelectAggregateResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SelectAggregateResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSelectAggregateResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSelectResourceConfig struct {
}

func (*validateOpSelectResourceConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSelectResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SelectResourceConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSelectResourceConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartConfigurationRecorder struct {
}

func (*validateOpStartConfigurationRecorder) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartConfigurationRecorderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartConfigurationRecorderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartRemediationExecution struct {
}

func (*validateOpStartRemediationExecution) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartRemediationExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartRemediationExecutionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartRemediationExecutionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartResourceEvaluation struct {
}

func (*validateOpStartResourceEvaluation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartResourceEvaluation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartResourceEvaluationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartResourceEvaluationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStopConfigurationRecorder struct {
}

func (*validateOpStopConfigurationRecorder) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStopConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StopConfigurationRecorderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStopConfigurationRecorderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpBatchGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBatchGetAggregateResourceConfig{}, middleware.After)
}

func addOpBatchGetResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBatchGetResourceConfig{}, middleware.After)
}

func addOpDeleteAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteAggregationAuthorization{}, middleware.After)
}

func addOpDeleteConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigRule{}, middleware.After)
}

func addOpDeleteConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigurationAggregator{}, middleware.After)
}

func addOpDeleteConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigurationRecorder{}, middleware.After)
}

func addOpDeleteConformancePackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConformancePack{}, middleware.After)
}

func addOpDeleteDeliveryChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDeliveryChannel{}, middleware.After)
}

func addOpDeleteEvaluationResultsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteEvaluationResults{}, middleware.After)
}

func addOpDeleteOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteOrganizationConfigRule{}, middleware.After)
}

func addOpDeleteOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteOrganizationConformancePack{}, middleware.After)
}

func addOpDeletePendingAggregationRequestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeletePendingAggregationRequest{}, middleware.After)
}

func addOpDeleteRemediationConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRemediationConfiguration{}, middleware.After)
}

func addOpDeleteRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRemediationExceptions{}, middleware.After)
}

func addOpDeleteResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteResourceConfig{}, middleware.After)
}

func addOpDeleteRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRetentionConfiguration{}, middleware.After)
}

func addOpDeleteStoredQueryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteStoredQuery{}, middleware.After)
}

func addOpDeliverConfigSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeliverConfigSnapshot{}, middleware.After)
}

func addOpDescribeAggregateComplianceByConfigRulesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeAggregateComplianceByConfigRules{}, middleware.After)
}

func addOpDescribeAggregateComplianceByConformancePacksValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeAggregateComplianceByConformancePacks{}, middleware.After)
}

func addOpDescribeConfigurationAggregatorSourcesStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeConfigurationAggregatorSourcesStatus{}, middleware.After)
}

func addOpDescribeConformancePackComplianceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeConformancePackCompliance{}, middleware.After)
}

func addOpDescribeRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeRemediationConfigurations{}, middleware.After)
}

func addOpDescribeRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeRemediationExceptions{}, middleware.After)
}

func addOpDescribeRemediationExecutionStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeRemediationExecutionStatus{}, middleware.After)
}

func addOpGetAggregateComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAggregateComplianceDetailsByConfigRule{}, middleware.After)
}

func addOpGetAggregateConfigRuleComplianceSummaryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAggregateConfigRuleComplianceSummary{}, middleware.After)
}

func addOpGetAggregateConformancePackComplianceSummaryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAggregateConformancePackComplianceSummary{}, middleware.After)
}

func addOpGetAggregateDiscoveredResourceCountsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAggregateDiscoveredResourceCounts{}, middleware.After)
}

func addOpGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAggregateResourceConfig{}, middleware.After)
}

func addOpGetComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetComplianceDetailsByConfigRule{}, middleware.After)
}

func addOpGetConformancePackComplianceDetailsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConformancePackComplianceDetails{}, middleware.After)
}

func addOpGetConformancePackComplianceSummaryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConformancePackComplianceSummary{}, middleware.After)
}

func addOpGetOrganizationConfigRuleDetailedStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOrganizationConfigRuleDetailedStatus{}, middleware.After)
}

func addOpGetOrganizationConformancePackDetailedStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOrganizationConformancePackDetailedStatus{}, middleware.After)
}

func addOpGetOrganizationCustomRulePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetOrganizationCustomRulePolicy{}, middleware.After)
}

func addOpGetResourceConfigHistoryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResourceConfigHistory{}, middleware.After)
}

func addOpGetResourceEvaluationSummaryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetResourceEvaluationSummary{}, middleware.After)
}

func addOpGetStoredQueryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetStoredQuery{}, middleware.After)
}

func addOpListAggregateDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListAggregateDiscoveredResources{}, middleware.After)
}

func addOpListConformancePackComplianceScoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListConformancePackComplianceScores{}, middleware.After)
}

func addOpListDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDiscoveredResources{}, middleware.After)
}

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}

func addOpPutAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutAggregationAuthorization{}, middleware.After)
}

func addOpPutConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConfigRule{}, middleware.After)
}

func addOpPutConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConfigurationAggregator{}, middleware.After)
}

func addOpPutConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConfigurationRecorder{}, middleware.After)
}

func addOpPutConformancePackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConformancePack{}, middleware.After)
}

func addOpPutDeliveryChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutDeliveryChannel{}, middleware.After)
}

func addOpPutEvaluationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutEvaluations{}, middleware.After)
}

func addOpPutExternalEvaluationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutExternalEvaluation{}, middleware.After)
}

func addOpPutOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutOrganizationConfigRule{}, middleware.After)
}

func addOpPutOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutOrganizationConformancePack{}, middleware.After)
}

func addOpPutRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutRemediationConfigurations{}, middleware.After)
}

func addOpPutRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutRemediationExceptions{}, middleware.After)
}

func addOpPutResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutResourceConfig{}, middleware.After)
}

func addOpPutRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutRetentionConfiguration{}, middleware.After)
}

func addOpPutStoredQueryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutStoredQuery{}, middleware.After)
}

func addOpSelectAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSelectAggregateResourceConfig{}, middleware.After)
}

func addOpSelectResourceConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSelectResourceConfig{}, middleware.After)
}

func addOpStartConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartConfigurationRecorder{}, middleware.After)
}

func addOpStartRemediationExecutionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartRemediationExecution{}, middleware.After)
}

func addOpStartResourceEvaluationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartResourceEvaluation{}, middleware.After)
}

func addOpStopConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopConfigurationRecorder{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func validateAccountAggregationSource(v *types.AccountAggregationSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSource"}
	if v.AccountIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAccountAggregationSourceList(v []types.AccountAggregationSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSourceList"}
	for i := range v {
		if err := validateAccountAggregationSource(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAggregateResourceIdentifier(v *types.AggregateResourceIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AggregateResourceIdentifier"}
	if v.SourceAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceAccountId"))
	}
	if v.SourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigRule(v *types.ConfigRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigRule"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigurationRecorder(v *types.ConfigurationRecorder) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigurationRecorder"}
	if v.RecordingMode != nil {
		if err := validateRecordingMode(v.RecordingMode); err != nil {
			invalidParams.AddNested("RecordingMode", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConformancePackComplianceScoresFilters(v *types.ConformancePackComplianceScoresFilters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConformancePackComplianceScoresFilters"}
	if v.ConformancePackNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConformancePackInputParameter(v *types.ConformancePackInputParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameter"}
	if v.ParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterName"))
	}
	if v.ParameterValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConformancePackInputParameters(v []types.ConformancePackInputParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameters"}
	for i := range v {
		if err := validateConformancePackInputParameter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomPolicyDetails(v *types.CustomPolicyDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomPolicyDetails"}
	if v.PolicyRuntime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyRuntime"))
	}
	if v.PolicyText == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyText"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluation(v *types.Evaluation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Evaluation"}
	if v.ComplianceResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceType"))
	}
	if v.ComplianceResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceId"))
	}
	if len(v.ComplianceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceType"))
	}
	if v.OrderingTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrderingTimestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluations(v []types.Evaluation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Evaluations"}
	for i := range v {
		if err := validateEvaluation(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExternalEvaluation(v *types.ExternalEvaluation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExternalEvaluation"}
	if v.ComplianceResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceType"))
	}
	if v.ComplianceResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceId"))
	}
	if len(v.ComplianceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComplianceType"))
	}
	if v.OrderingTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrderingTimestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrganizationAggregationSource(v *types.OrganizationAggregationSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrganizationAggregationSource"}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrganizationCustomPolicyRuleMetadata(v *types.OrganizationCustomPolicyRuleMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrganizationCustomPolicyRuleMetadata"}
	if v.PolicyRuntime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyRuntime"))
	}
	if v.PolicyText == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyText"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrganizationCustomRuleMetadata(v *types.OrganizationCustomRuleMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrganizationCustomRuleMetadata"}
	if v.LambdaFunctionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaFunctionArn"))
	}
	if v.OrganizationConfigRuleTriggerTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleTriggerTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrganizationManagedRuleMetadata(v *types.OrganizationManagedRuleMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrganizationManagedRuleMetadata"}
	if v.RuleIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecordingMode(v *types.RecordingMode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordingMode"}
	if len(v.RecordingFrequency) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecordingFrequency"))
	}
	if v.RecordingModeOverrides != nil {
		if err := validateRecordingModeOverrides(v.RecordingModeOverrides); err != nil {
			invalidParams.AddNested("RecordingModeOverrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecordingModeOverride(v *types.RecordingModeOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordingModeOverride"}
	if v.ResourceTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceTypes"))
	}
	if len(v.RecordingFrequency) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecordingFrequency"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecordingModeOverrides(v []types.RecordingModeOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordingModeOverrides"}
	for i := range v {
		if err := validateRecordingModeOverride(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemediationConfiguration(v *types.RemediationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemediationConfiguration"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if v.Parameters != nil {
		if err := validateRemediationParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemediationConfigurations(v []types.RemediationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemediationConfigurations"}
	for i := range v {
		if err := validateRemediationConfiguration(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemediationParameters(v map[string]types.RemediationParameterValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemediationParameters"}
	for key := range v {
		value := v[key]
		if err := validateRemediationParameterValue(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemediationParameterValue(v *types.RemediationParameterValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemediationParameterValue"}
	if v.ResourceValue != nil {
		if err := validateResourceValue(v.ResourceValue); err != nil {
			invalidParams.AddNested("ResourceValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.StaticValue != nil {
		if err := validateStaticValue(v.StaticValue); err != nil {
			invalidParams.AddNested("StaticValue", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceDetails(v *types.ResourceDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceDetails"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceIdentifiersList(v []types.AggregateResourceIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceIdentifiersList"}
	for i := range v {
		if err := validateAggregateResourceIdentifier(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceKey(v *types.ResourceKey) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceKey"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceKeys(v []types.ResourceKey) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceKeys"}
	for i := range v {
		if err := validateResourceKey(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceValue(v *types.ResourceValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceValue"}
	if len(v.Value) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSource(v *types.Source) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Source"}
	if len(v.Owner) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Owner"))
	}
	if v.CustomPolicyDetails != nil {
		if err := validateCustomPolicyDetails(v.CustomPolicyDetails); err != nil {
			invalidParams.AddNested("CustomPolicyDetails", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStaticValue(v *types.StaticValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StaticValue"}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStoredQuery(v *types.StoredQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StoredQuery"}
	if v.QueryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateSSMDocumentDetails(v *types.TemplateSSMDocumentDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateSSMDocumentDetails"}
	if v.DocumentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetAggregateResourceConfigInput(v *BatchGetAggregateResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAggregateResourceConfigInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if v.ResourceIdentifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifiers"))
	} else if v.ResourceIdentifiers != nil {
		if err := validateResourceIdentifiersList(v.ResourceIdentifiers); err != nil {
			invalidParams.AddNested("ResourceIdentifiers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetResourceConfigInput(v *BatchGetResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetResourceConfigInput"}
	if v.ResourceKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
	} else if v.ResourceKeys != nil {
		if err := validateResourceKeys(v.ResourceKeys); err != nil {
			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAggregationAuthorizationInput(v *DeleteAggregationAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAggregationAuthorizationInput"}
	if v.AuthorizedAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId"))
	}
	if v.AuthorizedAwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigRuleInput(v *DeleteConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigRuleInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigurationAggregatorInput(v *DeleteConfigurationAggregatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationAggregatorInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigurationRecorderInput(v *DeleteConfigurationRecorderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationRecorderInput"}
	if v.ConfigurationRecorderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConformancePackInput(v *DeleteConformancePackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConformancePackInput"}
	if v.ConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDeliveryChannelInput(v *DeleteDeliveryChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeliveryChannelInput"}
	if v.DeliveryChannelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEvaluationResultsInput(v *DeleteEvaluationResultsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEvaluationResultsInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteOrganizationConfigRuleInput(v *DeleteOrganizationConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConfigRuleInput"}
	if v.OrganizationConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteOrganizationConformancePackInput(v *DeleteOrganizationConformancePackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConformancePackInput"}
	if v.OrganizationConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePendingAggregationRequestInput(v *DeletePendingAggregationRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePendingAggregationRequestInput"}
	if v.RequesterAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequesterAccountId"))
	}
	if v.RequesterAwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequesterAwsRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRemediationConfigurationInput(v *DeleteRemediationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationConfigurationInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRemediationExceptionsInput(v *DeleteRemediationExceptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationExceptionsInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.ResourceKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteResourceConfigInput(v *DeleteResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceConfigInput"}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRetentionConfigurationInput(v *DeleteRetentionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRetentionConfigurationInput"}
	if v.RetentionConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetentionConfigurationName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStoredQueryInput(v *DeleteStoredQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStoredQueryInput"}
	if v.QueryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeliverConfigSnapshotInput(v *DeliverConfigSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeliverConfigSnapshotInput"}
	if v.DeliveryChannelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAggregateComplianceByConfigRulesInput(v *DescribeAggregateComplianceByConfigRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAggregateComplianceByConfigRulesInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAggregateComplianceByConformancePacksInput(v *DescribeAggregateComplianceByConformancePacksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAggregateComplianceByConformancePacksInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeConfigurationAggregatorSourcesStatusInput(v *DescribeConfigurationAggregatorSourcesStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConfigurationAggregatorSourcesStatusInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeConformancePackComplianceInput(v *DescribeConformancePackComplianceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConformancePackComplianceInput"}
	if v.ConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRemediationConfigurationsInput(v *DescribeRemediationConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationConfigurationsInput"}
	if v.ConfigRuleNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRemediationExceptionsInput(v *DescribeRemediationExceptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExceptionsInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRemediationExecutionStatusInput(v *DescribeRemediationExecutionStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExecutionStatusInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.ResourceKeys != nil {
		if err := validateResourceKeys(v.ResourceKeys); err != nil {
			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAggregateComplianceDetailsByConfigRuleInput(v *GetAggregateComplianceDetailsByConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateComplianceDetailsByConfigRuleInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.AwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAggregateConfigRuleComplianceSummaryInput(v *GetAggregateConfigRuleComplianceSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateConfigRuleComplianceSummaryInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAggregateConformancePackComplianceSummaryInput(v *GetAggregateConformancePackComplianceSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateConformancePackComplianceSummaryInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAggregateDiscoveredResourceCountsInput(v *GetAggregateDiscoveredResourceCountsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateDiscoveredResourceCountsInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAggregateResourceConfigInput(v *GetAggregateResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAggregateResourceConfigInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	} else if v.ResourceIdentifier != nil {
		if err := validateAggregateResourceIdentifier(v.ResourceIdentifier); err != nil {
			invalidParams.AddNested("ResourceIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetComplianceDetailsByConfigRuleInput(v *GetComplianceDetailsByConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailsByConfigRuleInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConformancePackComplianceDetailsInput(v *GetConformancePackComplianceDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceDetailsInput"}
	if v.ConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConformancePackComplianceSummaryInput(v *GetConformancePackComplianceSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceSummaryInput"}
	if v.ConformancePackNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOrganizationConfigRuleDetailedStatusInput(v *GetOrganizationConfigRuleDetailedStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConfigRuleDetailedStatusInput"}
	if v.OrganizationConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOrganizationConformancePackDetailedStatusInput(v *GetOrganizationConformancePackDetailedStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConformancePackDetailedStatusInput"}
	if v.OrganizationConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetOrganizationCustomRulePolicyInput(v *GetOrganizationCustomRulePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationCustomRulePolicyInput"}
	if v.OrganizationConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourceConfigHistoryInput(v *GetResourceConfigHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceConfigHistoryInput"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourceEvaluationSummaryInput(v *GetResourceEvaluationSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceEvaluationSummaryInput"}
	if v.ResourceEvaluationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceEvaluationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStoredQueryInput(v *GetStoredQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStoredQueryInput"}
	if v.QueryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAggregateDiscoveredResourcesInput(v *ListAggregateDiscoveredResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAggregateDiscoveredResourcesInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListConformancePackComplianceScoresInput(v *ListConformancePackComplianceScoresInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListConformancePackComplianceScoresInput"}
	if v.Filters != nil {
		if err := validateConformancePackComplianceScoresFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDiscoveredResourcesInput"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutAggregationAuthorizationInput(v *PutAggregationAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAggregationAuthorizationInput"}
	if v.AuthorizedAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId"))
	}
	if v.AuthorizedAwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutConfigRuleInput(v *PutConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConfigRuleInput"}
	if v.ConfigRule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRule"))
	} else if v.ConfigRule != nil {
		if err := validateConfigRule(v.ConfigRule); err != nil {
			invalidParams.AddNested("ConfigRule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutConfigurationAggregatorInput(v *PutConfigurationAggregatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationAggregatorInput"}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if v.AccountAggregationSources != nil {
		if err := validateAccountAggregationSourceList(v.AccountAggregationSources); err != nil {
			invalidParams.AddNested("AccountAggregationSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrganizationAggregationSource != nil {
		if err := validateOrganizationAggregationSource(v.OrganizationAggregationSource); err != nil {
			invalidParams.AddNested("OrganizationAggregationSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutConfigurationRecorderInput(v *PutConfigurationRecorderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationRecorderInput"}
	if v.ConfigurationRecorder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorder"))
	} else if v.ConfigurationRecorder != nil {
		if err := validateConfigurationRecorder(v.ConfigurationRecorder); err != nil {
			invalidParams.AddNested("ConfigurationRecorder", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutConformancePackInput(v *PutConformancePackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConformancePackInput"}
	if v.ConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName"))
	}
	if v.ConformancePackInputParameters != nil {
		if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil {
			invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.TemplateSSMDocumentDetails != nil {
		if err := validateTemplateSSMDocumentDetails(v.TemplateSSMDocumentDetails); err != nil {
			invalidParams.AddNested("TemplateSSMDocumentDetails", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutDeliveryChannelInput(v *PutDeliveryChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDeliveryChannelInput"}
	if v.DeliveryChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutEvaluationsInput(v *PutEvaluationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEvaluationsInput"}
	if v.Evaluations != nil {
		if err := validateEvaluations(v.Evaluations); err != nil {
			invalidParams.AddNested("Evaluations", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResultToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResultToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutExternalEvaluationInput(v *PutExternalEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutExternalEvaluationInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.ExternalEvaluation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExternalEvaluation"))
	} else if v.ExternalEvaluation != nil {
		if err := validateExternalEvaluation(v.ExternalEvaluation); err != nil {
			invalidParams.AddNested("ExternalEvaluation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutOrganizationConfigRuleInput(v *PutOrganizationConfigRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConfigRuleInput"}
	if v.OrganizationConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName"))
	}
	if v.OrganizationManagedRuleMetadata != nil {
		if err := validateOrganizationManagedRuleMetadata(v.OrganizationManagedRuleMetadata); err != nil {
			invalidParams.AddNested("OrganizationManagedRuleMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrganizationCustomRuleMetadata != nil {
		if err := validateOrganizationCustomRuleMetadata(v.OrganizationCustomRuleMetadata); err != nil {
			invalidParams.AddNested("OrganizationCustomRuleMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrganizationCustomPolicyRuleMetadata != nil {
		if err := validateOrganizationCustomPolicyRuleMetadata(v.OrganizationCustomPolicyRuleMetadata); err != nil {
			invalidParams.AddNested("OrganizationCustomPolicyRuleMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutOrganizationConformancePackInput(v *PutOrganizationConformancePackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConformancePackInput"}
	if v.OrganizationConformancePackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName"))
	}
	if v.ConformancePackInputParameters != nil {
		if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil {
			invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRemediationConfigurationsInput(v *PutRemediationConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRemediationConfigurationsInput"}
	if v.RemediationConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RemediationConfigurations"))
	} else if v.RemediationConfigurations != nil {
		if err := validateRemediationConfigurations(v.RemediationConfigurations); err != nil {
			invalidParams.AddNested("RemediationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRemediationExceptionsInput(v *PutRemediationExceptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRemediationExceptionsInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.ResourceKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutResourceConfigInput(v *PutResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutResourceConfigInput"}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.SchemaVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaVersionId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRetentionConfigurationInput(v *PutRetentionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRetentionConfigurationInput"}
	if v.RetentionPeriodInDays == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetentionPeriodInDays"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutStoredQueryInput(v *PutStoredQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutStoredQueryInput"}
	if v.StoredQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StoredQuery"))
	} else if v.StoredQuery != nil {
		if err := validateStoredQuery(v.StoredQuery); err != nil {
			invalidParams.AddNested("StoredQuery", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSelectAggregateResourceConfigInput(v *SelectAggregateResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SelectAggregateResourceConfigInput"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.ConfigurationAggregatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSelectResourceConfigInput(v *SelectResourceConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SelectResourceConfigInput"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartConfigurationRecorderInput(v *StartConfigurationRecorderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartConfigurationRecorderInput"}
	if v.ConfigurationRecorderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartRemediationExecutionInput(v *StartRemediationExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRemediationExecutionInput"}
	if v.ConfigRuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName"))
	}
	if v.ResourceKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys"))
	} else if v.ResourceKeys != nil {
		if err := validateResourceKeys(v.ResourceKeys); err != nil {
			invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartResourceEvaluationInput(v *StartResourceEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartResourceEvaluationInput"}
	if v.ResourceDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceDetails"))
	} else if v.ResourceDetails != nil {
		if err := validateResourceDetails(v.ResourceDetails); err != nil {
			invalidParams.AddNested("ResourceDetails", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.EvaluationMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopConfigurationRecorderInput(v *StopConfigurationRecorderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopConfigurationRecorderInput"}
	if v.ConfigurationRecorderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}