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

package cloudformation

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

type validateOpActivateType struct {
}

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

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

type validateOpBatchDescribeTypeConfigurations struct {
}

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

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

type validateOpCancelUpdateStack struct {
}

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

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

type validateOpContinueUpdateRollback struct {
}

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

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

type validateOpCreateChangeSet struct {
}

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

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

type validateOpCreateGeneratedTemplate struct {
}

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

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

type validateOpCreateStack struct {
}

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

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

type validateOpCreateStackInstances struct {
}

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

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

type validateOpCreateStackRefactor struct {
}

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

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

type validateOpCreateStackSet struct {
}

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

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

type validateOpDeleteChangeSet struct {
}

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

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

type validateOpDeleteGeneratedTemplate struct {
}

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

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

type validateOpDeleteStack struct {
}

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

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

type validateOpDeleteStackInstances struct {
}

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

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

type validateOpDeleteStackSet struct {
}

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

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

type validateOpDescribeChangeSetHooks struct {
}

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

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

type validateOpDescribeChangeSet struct {
}

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

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

type validateOpDescribeGeneratedTemplate struct {
}

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

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

type validateOpDescribeResourceScan struct {
}

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

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

type validateOpDescribeStackDriftDetectionStatus struct {
}

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

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

type validateOpDescribeStackEvents struct {
}

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

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

type validateOpDescribeStackInstance struct {
}

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

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

type validateOpDescribeStackRefactor struct {
}

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

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

type validateOpDescribeStackResourceDrifts struct {
}

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

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

type validateOpDescribeStackResource struct {
}

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

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

type validateOpDescribeStackSet struct {
}

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

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

type validateOpDescribeStackSetOperation struct {
}

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

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

type validateOpDescribeTypeRegistration struct {
}

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

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

type validateOpDetectStackDrift struct {
}

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

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

type validateOpDetectStackResourceDrift struct {
}

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

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

type validateOpDetectStackSetDrift struct {
}

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

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

type validateOpExecuteChangeSet struct {
}

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

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

type validateOpExecuteStackRefactor struct {
}

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

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

type validateOpGetGeneratedTemplate struct {
}

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

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

type validateOpGetStackPolicy struct {
}

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

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

type validateOpImportStacksToStackSet struct {
}

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

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

type validateOpListChangeSets struct {
}

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

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

type validateOpListImports struct {
}

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

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

type validateOpListResourceScanRelatedResources struct {
}

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

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

type validateOpListResourceScanResources struct {
}

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

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

type validateOpListStackInstanceResourceDrifts struct {
}

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

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

type validateOpListStackInstances struct {
}

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

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

type validateOpListStackRefactorActions struct {
}

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

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

type validateOpListStackResources struct {
}

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

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

type validateOpListStackSetAutoDeploymentTargets struct {
}

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

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

type validateOpListStackSetOperationResults struct {
}

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

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

type validateOpListStackSetOperations struct {
}

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

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

type validateOpRecordHandlerProgress struct {
}

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

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

type validateOpRegisterType struct {
}

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

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

type validateOpRollbackStack struct {
}

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

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

type validateOpSetStackPolicy struct {
}

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

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

type validateOpSetTypeConfiguration struct {
}

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

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

type validateOpSignalResource struct {
}

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

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

type validateOpStopStackSetOperation struct {
}

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

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

type validateOpUpdateGeneratedTemplate struct {
}

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

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

type validateOpUpdateStack struct {
}

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

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

type validateOpUpdateStackInstances struct {
}

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

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

type validateOpUpdateStackSet struct {
}

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

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

type validateOpUpdateTerminationProtection struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateLoggingConfig(v *types.LoggingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LoggingConfig"}
	if v.LogRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogRoleArn"))
	}
	if v.LogGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceDefinition(v *types.ResourceDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceDefinition"}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateResourceLocation(v *types.ResourceLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceLocation"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateResourceToImport(v *types.ResourceToImport) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceToImport"}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRollbackConfiguration(v *types.RollbackConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RollbackConfiguration"}
	if v.RollbackTriggers != nil {
		if err := validateRollbackTriggers(v.RollbackTriggers); err != nil {
			invalidParams.AddNested("RollbackTriggers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRollbackTrigger(v *types.RollbackTrigger) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RollbackTrigger"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScannedResourceIdentifier(v *types.ScannedResourceIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScannedResourceIdentifier"}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScannedResourceIdentifiers(v []types.ScannedResourceIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScannedResourceIdentifiers"}
	for i := range v {
		if err := validateScannedResourceIdentifier(&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 v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	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 validateOpActivateTypeInput(v *ActivateTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActivateTypeInput"}
	if v.LoggingConfig != nil {
		if err := validateLoggingConfig(v.LoggingConfig); err != nil {
			invalidParams.AddNested("LoggingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCreateChangeSetInput(v *CreateChangeSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChangeSetInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.RollbackConfiguration != nil {
		if err := validateRollbackConfiguration(v.RollbackConfiguration); err != nil {
			invalidParams.AddNested("RollbackConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeSetName"))
	}
	if v.ResourcesToImport != nil {
		if err := validateResourcesToImport(v.ResourcesToImport); err != nil {
			invalidParams.AddNested("ResourcesToImport", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGeneratedTemplateInput(v *CreateGeneratedTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGeneratedTemplateInput"}
	if v.Resources != nil {
		if err := validateResourceDefinitions(v.Resources); err != nil {
			invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError))
		}
	}
	if v.GeneratedTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeneratedTemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStackInput(v *CreateStackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStackInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.RollbackConfiguration != nil {
		if err := validateRollbackConfiguration(v.RollbackConfiguration); err != nil {
			invalidParams.AddNested("RollbackConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpCreateStackInstancesInput(v *CreateStackInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStackInstancesInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.Regions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Regions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStackRefactorInput(v *CreateStackRefactorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStackRefactorInput"}
	if v.ResourceMappings != nil {
		if err := validateResourceMappings(v.ResourceMappings); err != nil {
			invalidParams.AddNested("ResourceMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.StackDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackDefinitions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStackSetInput(v *CreateStackSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStackSetInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	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 validateOpDeleteChangeSetInput(v *DeleteChangeSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChangeSetInput"}
	if v.ChangeSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteStackInstancesInput(v *DeleteStackInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStackInstancesInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.Regions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Regions"))
	}
	if v.RetainStacks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetainStacks"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpDescribeStackInstanceInput(v *DescribeStackInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeStackInstanceInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.StackInstanceAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackInstanceAccount"))
	}
	if v.StackInstanceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackInstanceRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeStackResourceInput(v *DescribeStackResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeStackResourceInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeStackSetOperationInput(v *DescribeStackSetOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeStackSetOperationInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.OperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDetectStackResourceDriftInput(v *DetectStackResourceDriftInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetectStackResourceDriftInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpListResourceScanRelatedResourcesInput(v *ListResourceScanRelatedResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListResourceScanRelatedResourcesInput"}
	if v.ResourceScanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceScanId"))
	}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	} else if v.Resources != nil {
		if err := validateScannedResourceIdentifiers(v.Resources); err != nil {
			invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListStackInstanceResourceDriftsInput(v *ListStackInstanceResourceDriftsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStackInstanceResourceDriftsInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.StackInstanceAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackInstanceAccount"))
	}
	if v.StackInstanceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackInstanceRegion"))
	}
	if v.OperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListStackSetOperationResultsInput(v *ListStackSetOperationResultsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStackSetOperationResultsInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.OperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRecordHandlerProgressInput(v *RecordHandlerProgressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordHandlerProgressInput"}
	if v.BearerToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BearerToken"))
	}
	if len(v.OperationStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OperationStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterTypeInput(v *RegisterTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterTypeInput"}
	if v.TypeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeName"))
	}
	if v.SchemaHandlerPackage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaHandlerPackage"))
	}
	if v.LoggingConfig != nil {
		if err := validateLoggingConfig(v.LoggingConfig); err != nil {
			invalidParams.AddNested("LoggingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpSignalResourceInput(v *SignalResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalResourceInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	}
	if v.UniqueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UniqueId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopStackSetOperationInput(v *StopStackSetOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopStackSetOperationInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.OperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGeneratedTemplateInput(v *UpdateGeneratedTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGeneratedTemplateInput"}
	if v.GeneratedTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeneratedTemplateName"))
	}
	if v.AddResources != nil {
		if err := validateResourceDefinitions(v.AddResources); err != nil {
			invalidParams.AddNested("AddResources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStackInput(v *UpdateStackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInput"}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if v.RollbackConfiguration != nil {
		if err := validateRollbackConfiguration(v.RollbackConfiguration); err != nil {
			invalidParams.AddNested("RollbackConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpUpdateStackInstancesInput(v *UpdateStackInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInstancesInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	if v.Regions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Regions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStackSetInput(v *UpdateStackSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStackSetInput"}
	if v.StackSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackSetName"))
	}
	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 validateOpUpdateTerminationProtectionInput(v *UpdateTerminationProtectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTerminationProtectionInput"}
	if v.EnableTerminationProtection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnableTerminationProtection"))
	}
	if v.StackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
