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

package autoscaling

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

type validateOpAttachInstances struct {
}

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

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

type validateOpAttachLoadBalancers struct {
}

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

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

type validateOpAttachLoadBalancerTargetGroups struct {
}

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

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

type validateOpAttachTrafficSources struct {
}

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

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

type validateOpBatchDeleteScheduledAction struct {
}

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

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

type validateOpBatchPutScheduledUpdateGroupAction struct {
}

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

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

type validateOpCancelInstanceRefresh struct {
}

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

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

type validateOpCompleteLifecycleAction struct {
}

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

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

type validateOpCreateAutoScalingGroup struct {
}

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

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

type validateOpCreateLaunchConfiguration struct {
}

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

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

type validateOpCreateOrUpdateTags struct {
}

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

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

type validateOpDeleteAutoScalingGroup struct {
}

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

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

type validateOpDeleteLaunchConfiguration struct {
}

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

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

type validateOpDeleteLifecycleHook struct {
}

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

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

type validateOpDeleteNotificationConfiguration struct {
}

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

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

type validateOpDeletePolicy struct {
}

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

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

type validateOpDeleteScheduledAction struct {
}

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

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

type validateOpDeleteTags struct {
}

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

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

type validateOpDeleteWarmPool struct {
}

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

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

type validateOpDescribeInstanceRefreshes struct {
}

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

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

type validateOpDescribeLifecycleHooks struct {
}

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

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

type validateOpDescribeLoadBalancers struct {
}

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

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

type validateOpDescribeLoadBalancerTargetGroups struct {
}

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

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

type validateOpDescribeTrafficSources struct {
}

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

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

type validateOpDescribeWarmPool struct {
}

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

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

type validateOpDetachInstances struct {
}

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

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

type validateOpDetachLoadBalancers struct {
}

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

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

type validateOpDetachLoadBalancerTargetGroups struct {
}

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

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

type validateOpDetachTrafficSources struct {
}

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

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

type validateOpDisableMetricsCollection struct {
}

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

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

type validateOpEnableMetricsCollection struct {
}

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

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

type validateOpEnterStandby struct {
}

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

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

type validateOpExecutePolicy struct {
}

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

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

type validateOpExitStandby struct {
}

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

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

type validateOpGetPredictiveScalingForecast struct {
}

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

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

type validateOpLaunchInstances struct {
}

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

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

type validateOpPutLifecycleHook struct {
}

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

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

type validateOpPutNotificationConfiguration struct {
}

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

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

type validateOpPutScalingPolicy struct {
}

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

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

type validateOpPutScheduledUpdateGroupAction struct {
}

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

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

type validateOpPutWarmPool struct {
}

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

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

type validateOpRecordLifecycleActionHeartbeat struct {
}

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

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

type validateOpResumeProcesses struct {
}

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

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

type validateOpRollbackInstanceRefresh struct {
}

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

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

type validateOpSetDesiredCapacity struct {
}

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

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

type validateOpSetInstanceHealth struct {
}

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

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

type validateOpSetInstanceProtection struct {
}

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

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

type validateOpStartInstanceRefresh struct {
}

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

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

type validateOpSuspendProcesses struct {
}

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

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

type validateOpTerminateInstanceInAutoScalingGroup struct {
}

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

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

type validateOpUpdateAutoScalingGroup struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCustomizedMetricSpecification(v *types.CustomizedMetricSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomizedMetricSpecification"}
	if v.Dimensions != nil {
		if err := validateMetricDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Metrics != nil {
		if err := validateTargetTrackingMetricDataQueries(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDesiredConfiguration(v *types.DesiredConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DesiredConfiguration"}
	if v.MixedInstancesPolicy != nil {
		if err := validateMixedInstancesPolicy(v.MixedInstancesPolicy); err != nil {
			invalidParams.AddNested("MixedInstancesPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceRequirements(v *types.InstanceRequirements) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceRequirements"}
	if v.VCpuCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VCpuCount"))
	} else if v.VCpuCount != nil {
		if err := validateVCpuCountRequest(v.VCpuCount); err != nil {
			invalidParams.AddNested("VCpuCount", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryMiB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryMiB"))
	} else if v.MemoryMiB != nil {
		if err := validateMemoryMiBRequest(v.MemoryMiB); err != nil {
			invalidParams.AddNested("MemoryMiB", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLaunchTemplate(v *types.LaunchTemplate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchTemplate"}
	if v.Overrides != nil {
		if err := validateOverrides(v.Overrides); err != nil {
			invalidParams.AddNested("Overrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLaunchTemplateOverrides(v *types.LaunchTemplateOverrides) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchTemplateOverrides"}
	if v.InstanceRequirements != nil {
		if err := validateInstanceRequirements(v.InstanceRequirements); err != nil {
			invalidParams.AddNested("InstanceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLifecycleHookSpecification(v *types.LifecycleHookSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LifecycleHookSpecification"}
	if v.LifecycleHookName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleHookName"))
	}
	if v.LifecycleTransition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleTransition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMetric(v *types.Metric) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Metric"}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.Dimensions != nil {
		if err := validateMetricDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricDataQuery(v *types.MetricDataQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricDataQuery"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.MetricStat != nil {
		if err := validateMetricStat(v.MetricStat); err != nil {
			invalidParams.AddNested("MetricStat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMetricStat(v *types.MetricStat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricStat"}
	if v.Metric == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	} else if v.Metric != nil {
		if err := validateMetric(v.Metric); err != nil {
			invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError))
		}
	}
	if v.Stat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Stat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMixedInstancesPolicy(v *types.MixedInstancesPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MixedInstancesPolicy"}
	if v.LaunchTemplate != nil {
		if err := validateLaunchTemplate(v.LaunchTemplate); err != nil {
			invalidParams.AddNested("LaunchTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePredictiveScalingConfiguration(v *types.PredictiveScalingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredictiveScalingConfiguration"}
	if v.MetricSpecifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricSpecifications"))
	} else if v.MetricSpecifications != nil {
		if err := validatePredictiveScalingMetricSpecifications(v.MetricSpecifications); err != nil {
			invalidParams.AddNested("MetricSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredictiveScalingCustomizedCapacityMetric(v *types.PredictiveScalingCustomizedCapacityMetric) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredictiveScalingCustomizedCapacityMetric"}
	if v.MetricDataQueries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricDataQueries"))
	} else if v.MetricDataQueries != nil {
		if err := validateMetricDataQueries(v.MetricDataQueries); err != nil {
			invalidParams.AddNested("MetricDataQueries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredictiveScalingCustomizedLoadMetric(v *types.PredictiveScalingCustomizedLoadMetric) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredictiveScalingCustomizedLoadMetric"}
	if v.MetricDataQueries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricDataQueries"))
	} else if v.MetricDataQueries != nil {
		if err := validateMetricDataQueries(v.MetricDataQueries); err != nil {
			invalidParams.AddNested("MetricDataQueries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredictiveScalingCustomizedScalingMetric(v *types.PredictiveScalingCustomizedScalingMetric) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredictiveScalingCustomizedScalingMetric"}
	if v.MetricDataQueries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricDataQueries"))
	} else if v.MetricDataQueries != nil {
		if err := validateMetricDataQueries(v.MetricDataQueries); err != nil {
			invalidParams.AddNested("MetricDataQueries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredictiveScalingMetricSpecification(v *types.PredictiveScalingMetricSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredictiveScalingMetricSpecification"}
	if v.TargetValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetValue"))
	}
	if v.PredefinedMetricPairSpecification != nil {
		if err := validatePredictiveScalingPredefinedMetricPair(v.PredefinedMetricPairSpecification); err != nil {
			invalidParams.AddNested("PredefinedMetricPairSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.PredefinedScalingMetricSpecification != nil {
		if err := validatePredictiveScalingPredefinedScalingMetric(v.PredefinedScalingMetricSpecification); err != nil {
			invalidParams.AddNested("PredefinedScalingMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.PredefinedLoadMetricSpecification != nil {
		if err := validatePredictiveScalingPredefinedLoadMetric(v.PredefinedLoadMetricSpecification); err != nil {
			invalidParams.AddNested("PredefinedLoadMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomizedScalingMetricSpecification != nil {
		if err := validatePredictiveScalingCustomizedScalingMetric(v.CustomizedScalingMetricSpecification); err != nil {
			invalidParams.AddNested("CustomizedScalingMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomizedLoadMetricSpecification != nil {
		if err := validatePredictiveScalingCustomizedLoadMetric(v.CustomizedLoadMetricSpecification); err != nil {
			invalidParams.AddNested("CustomizedLoadMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomizedCapacityMetricSpecification != nil {
		if err := validatePredictiveScalingCustomizedCapacityMetric(v.CustomizedCapacityMetricSpecification); err != nil {
			invalidParams.AddNested("CustomizedCapacityMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateTargetTrackingConfiguration(v *types.TargetTrackingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingConfiguration"}
	if v.PredefinedMetricSpecification != nil {
		if err := validatePredefinedMetricSpecification(v.PredefinedMetricSpecification); err != nil {
			invalidParams.AddNested("PredefinedMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomizedMetricSpecification != nil {
		if err := validateCustomizedMetricSpecification(v.CustomizedMetricSpecification); err != nil {
			invalidParams.AddNested("CustomizedMetricSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTargetTrackingMetricDataQuery(v *types.TargetTrackingMetricDataQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricDataQuery"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.MetricStat != nil {
		if err := validateTargetTrackingMetricStat(v.MetricStat); err != nil {
			invalidParams.AddNested("MetricStat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTargetTrackingMetricStat(v *types.TargetTrackingMetricStat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetTrackingMetricStat"}
	if v.Metric == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	} else if v.Metric != nil {
		if err := validateMetric(v.Metric); err != nil {
			invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError))
		}
	}
	if v.Stat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Stat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpAttachLoadBalancersInput(v *AttachLoadBalancersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachLoadBalancersInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.LoadBalancerNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachLoadBalancerTargetGroupsInput(v *AttachLoadBalancerTargetGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachLoadBalancerTargetGroupsInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TargetGroupARNs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupARNs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachTrafficSourcesInput(v *AttachTrafficSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachTrafficSourcesInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TrafficSources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficSources"))
	} else if v.TrafficSources != nil {
		if err := validateTrafficSources(v.TrafficSources); err != nil {
			invalidParams.AddNested("TrafficSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteScheduledActionInput(v *BatchDeleteScheduledActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteScheduledActionInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ScheduledActionNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchPutScheduledUpdateGroupActionInput(v *BatchPutScheduledUpdateGroupActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutScheduledUpdateGroupActionInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ScheduledUpdateGroupActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledUpdateGroupActions"))
	} else if v.ScheduledUpdateGroupActions != nil {
		if err := validateScheduledUpdateGroupActionRequests(v.ScheduledUpdateGroupActions); err != nil {
			invalidParams.AddNested("ScheduledUpdateGroupActions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCompleteLifecycleActionInput(v *CompleteLifecycleActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompleteLifecycleActionInput"}
	if v.LifecycleHookName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleHookName"))
	}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.LifecycleActionResult == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleActionResult"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAutoScalingGroupInput(v *CreateAutoScalingGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAutoScalingGroupInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.MixedInstancesPolicy != nil {
		if err := validateMixedInstancesPolicy(v.MixedInstancesPolicy); err != nil {
			invalidParams.AddNested("MixedInstancesPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.MinSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinSize"))
	}
	if v.MaxSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxSize"))
	}
	if v.LifecycleHookSpecificationList != nil {
		if err := validateLifecycleHookSpecifications(v.LifecycleHookSpecificationList); err != nil {
			invalidParams.AddNested("LifecycleHookSpecificationList", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrafficSources != nil {
		if err := validateTrafficSources(v.TrafficSources); err != nil {
			invalidParams.AddNested("TrafficSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLaunchConfigurationInput(v *CreateLaunchConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLaunchConfigurationInput"}
	if v.LaunchConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchConfigurationName"))
	}
	if v.BlockDeviceMappings != nil {
		if err := validateBlockDeviceMappings(v.BlockDeviceMappings); err != nil {
			invalidParams.AddNested("BlockDeviceMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateOrUpdateTagsInput(v *CreateOrUpdateTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateOrUpdateTagsInput"}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteLifecycleHookInput(v *DeleteLifecycleHookInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLifecycleHookInput"}
	if v.LifecycleHookName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleHookName"))
	}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNotificationConfigurationInput(v *DeleteNotificationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNotificationConfigurationInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TopicARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteScheduledActionInput(v *DeleteScheduledActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteScheduledActionInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ScheduledActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTagsInput(v *DeleteTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpDetachInstancesInput(v *DetachInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachInstancesInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ShouldDecrementDesiredCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShouldDecrementDesiredCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachLoadBalancersInput(v *DetachLoadBalancersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachLoadBalancersInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.LoadBalancerNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachLoadBalancerTargetGroupsInput(v *DetachLoadBalancerTargetGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachLoadBalancerTargetGroupsInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TargetGroupARNs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupARNs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachTrafficSourcesInput(v *DetachTrafficSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachTrafficSourcesInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TrafficSources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficSources"))
	} else if v.TrafficSources != nil {
		if err := validateTrafficSources(v.TrafficSources); err != nil {
			invalidParams.AddNested("TrafficSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpEnableMetricsCollectionInput(v *EnableMetricsCollectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableMetricsCollectionInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.Granularity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnterStandbyInput(v *EnterStandbyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnterStandbyInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ShouldDecrementDesiredCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShouldDecrementDesiredCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetPredictiveScalingForecastInput(v *GetPredictiveScalingForecastInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPredictiveScalingForecastInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.PolicyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpLaunchInstancesInput(v *LaunchInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchInstancesInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.RequestedCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestedCapacity"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutLifecycleHookInput(v *PutLifecycleHookInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLifecycleHookInput"}
	if v.LifecycleHookName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleHookName"))
	}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutNotificationConfigurationInput(v *PutNotificationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutNotificationConfigurationInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.TopicARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicARN"))
	}
	if v.NotificationTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NotificationTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutScalingPolicyInput(v *PutScalingPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutScalingPolicyInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.PolicyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
	}
	if v.StepAdjustments != nil {
		if err := validateStepAdjustments(v.StepAdjustments); err != nil {
			invalidParams.AddNested("StepAdjustments", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetTrackingConfiguration != nil {
		if err := validateTargetTrackingConfiguration(v.TargetTrackingConfiguration); err != nil {
			invalidParams.AddNested("TargetTrackingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PredictiveScalingConfiguration != nil {
		if err := validatePredictiveScalingConfiguration(v.PredictiveScalingConfiguration); err != nil {
			invalidParams.AddNested("PredictiveScalingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutScheduledUpdateGroupActionInput(v *PutScheduledUpdateGroupActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutScheduledUpdateGroupActionInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ScheduledActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRecordLifecycleActionHeartbeatInput(v *RecordLifecycleActionHeartbeatInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordLifecycleActionHeartbeatInput"}
	if v.LifecycleHookName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LifecycleHookName"))
	}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpSetDesiredCapacityInput(v *SetDesiredCapacityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetDesiredCapacityInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.DesiredCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DesiredCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetInstanceHealthInput(v *SetInstanceHealthInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetInstanceHealthInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.HealthStatus == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HealthStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetInstanceProtectionInput(v *SetInstanceProtectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetInstanceProtectionInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ProtectedFromScaleIn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedFromScaleIn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartInstanceRefreshInput(v *StartInstanceRefreshInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartInstanceRefreshInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.DesiredConfiguration != nil {
		if err := validateDesiredConfiguration(v.DesiredConfiguration); err != nil {
			invalidParams.AddNested("DesiredConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpTerminateInstanceInAutoScalingGroupInput(v *TerminateInstanceInAutoScalingGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateInstanceInAutoScalingGroupInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ShouldDecrementDesiredCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShouldDecrementDesiredCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAutoScalingGroupInput(v *UpdateAutoScalingGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAutoScalingGroupInput"}
	if v.AutoScalingGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.MixedInstancesPolicy != nil {
		if err := validateMixedInstancesPolicy(v.MixedInstancesPolicy); err != nil {
			invalidParams.AddNested("MixedInstancesPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
