// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 addOpDescribeStackDriftDetectionStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeStackDriftDetectionStatus{}, middleware.After)
}

func addOpDescribeStackInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeStackInstance{}, 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 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 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 addOpListStackResourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListStackResources{}, 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
	}
}