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

package elasticloadbalancingv2

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

type validateOpAddListenerCertificates struct {
}

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

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

type validateOpAddTags struct {
}

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

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

type validateOpCreateListener struct {
}

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

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

type validateOpCreateLoadBalancer struct {
}

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

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

type validateOpCreateRule struct {
}

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

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

type validateOpCreateTargetGroup struct {
}

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

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

type validateOpDeleteListener struct {
}

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

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

type validateOpDeleteLoadBalancer struct {
}

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

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

type validateOpDeleteRule struct {
}

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

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

type validateOpDeleteTargetGroup struct {
}

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

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

type validateOpDeregisterTargets struct {
}

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

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

type validateOpDescribeListenerCertificates struct {
}

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

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

type validateOpDescribeLoadBalancerAttributes struct {
}

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

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

type validateOpDescribeTags struct {
}

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

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

type validateOpDescribeTargetGroupAttributes struct {
}

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

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

type validateOpDescribeTargetHealth struct {
}

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

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

type validateOpModifyListener struct {
}

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

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

type validateOpModifyLoadBalancerAttributes struct {
}

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

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

type validateOpModifyRule struct {
}

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

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

type validateOpModifyTargetGroupAttributes struct {
}

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

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

type validateOpModifyTargetGroup struct {
}

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

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

type validateOpRegisterTargets struct {
}

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

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

type validateOpRemoveListenerCertificates struct {
}

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

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

type validateOpRemoveTags struct {
}

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

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

type validateOpSetIpAddressType struct {
}

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

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

type validateOpSetRulePriorities struct {
}

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

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

type validateOpSetSecurityGroups struct {
}

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

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

type validateOpSetSubnets struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAction(v *types.Action) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Action"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.AuthenticateOidcConfig != nil {
		if err := validateAuthenticateOidcActionConfig(v.AuthenticateOidcConfig); err != nil {
			invalidParams.AddNested("AuthenticateOidcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.AuthenticateCognitoConfig != nil {
		if err := validateAuthenticateCognitoActionConfig(v.AuthenticateCognitoConfig); err != nil {
			invalidParams.AddNested("AuthenticateCognitoConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedirectConfig != nil {
		if err := validateRedirectActionConfig(v.RedirectConfig); err != nil {
			invalidParams.AddNested("RedirectConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.FixedResponseConfig != nil {
		if err := validateFixedResponseActionConfig(v.FixedResponseConfig); err != nil {
			invalidParams.AddNested("FixedResponseConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAuthenticateCognitoActionConfig(v *types.AuthenticateCognitoActionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthenticateCognitoActionConfig"}
	if v.UserPoolArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolArn"))
	}
	if v.UserPoolClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolClientId"))
	}
	if v.UserPoolDomain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolDomain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAuthenticateOidcActionConfig(v *types.AuthenticateOidcActionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthenticateOidcActionConfig"}
	if v.Issuer == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Issuer"))
	}
	if v.AuthorizationEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationEndpoint"))
	}
	if v.TokenEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TokenEndpoint"))
	}
	if v.UserInfoEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserInfoEndpoint"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedirectActionConfig(v *types.RedirectActionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedirectActionConfig"}
	if len(v.StatusCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
	}
	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 validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	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 validateTargetDescription(v *types.TargetDescription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetDescription"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAddListenerCertificatesInput(v *AddListenerCertificatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddListenerCertificatesInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.Certificates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Certificates"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateListenerInput(v *CreateListenerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateListenerInput"}
	if v.LoadBalancerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerArn"))
	}
	if v.DefaultActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultActions"))
	} else if v.DefaultActions != nil {
		if err := validateActions(v.DefaultActions); err != nil {
			invalidParams.AddNested("DefaultActions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateRuleInput(v *CreateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.Conditions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Conditions"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDeregisterTargetsInput(v *DeregisterTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterTargetsInput"}
	if v.TargetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupArn"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	} else if v.Targets != nil {
		if err := validateTargetDescriptions(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDescribeTargetHealthInput(v *DescribeTargetHealthInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTargetHealthInput"}
	if v.TargetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupArn"))
	}
	if v.Targets != nil {
		if err := validateTargetDescriptions(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyListenerInput(v *ModifyListenerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyListenerInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.DefaultActions != nil {
		if err := validateActions(v.DefaultActions); err != nil {
			invalidParams.AddNested("DefaultActions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyLoadBalancerAttributesInput(v *ModifyLoadBalancerAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyLoadBalancerAttributesInput"}
	if v.LoadBalancerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerArn"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyRuleInput(v *ModifyRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyRuleInput"}
	if v.RuleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleArn"))
	}
	if v.Actions != nil {
		if err := validateActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTargetGroupAttributesInput(v *ModifyTargetGroupAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTargetGroupAttributesInput"}
	if v.TargetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupArn"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRegisterTargetsInput(v *RegisterTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterTargetsInput"}
	if v.TargetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupArn"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	} else if v.Targets != nil {
		if err := validateTargetDescriptions(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveListenerCertificatesInput(v *RemoveListenerCertificatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveListenerCertificatesInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.Certificates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Certificates"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSetIpAddressTypeInput(v *SetIpAddressTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIpAddressTypeInput"}
	if v.LoadBalancerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerArn"))
	}
	if len(v.IpAddressType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddressType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSetSecurityGroupsInput(v *SetSecurityGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetSecurityGroupsInput"}
	if v.LoadBalancerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerArn"))
	}
	if v.SecurityGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroups"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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