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

package swf

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

type validateOpCountClosedWorkflowExecutions struct {
}

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

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

type validateOpCountOpenWorkflowExecutions struct {
}

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

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

type validateOpCountPendingActivityTasks struct {
}

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

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

type validateOpCountPendingDecisionTasks struct {
}

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

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

type validateOpDeprecateActivityType struct {
}

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

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

type validateOpDeprecateDomain struct {
}

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

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

type validateOpDeprecateWorkflowType struct {
}

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

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

type validateOpDescribeActivityType struct {
}

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

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

type validateOpDescribeDomain struct {
}

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

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

type validateOpDescribeWorkflowExecution struct {
}

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

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

type validateOpDescribeWorkflowType struct {
}

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

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

type validateOpGetWorkflowExecutionHistory struct {
}

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

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

type validateOpListActivityTypes struct {
}

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

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

type validateOpListClosedWorkflowExecutions struct {
}

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

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

type validateOpListDomains struct {
}

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

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

type validateOpListOpenWorkflowExecutions struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpListWorkflowTypes struct {
}

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

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

type validateOpPollForActivityTask struct {
}

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

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

type validateOpPollForDecisionTask struct {
}

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

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

type validateOpRecordActivityTaskHeartbeat struct {
}

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

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

type validateOpRegisterActivityType struct {
}

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

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

type validateOpRegisterDomain struct {
}

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

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

type validateOpRegisterWorkflowType struct {
}

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

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

type validateOpRequestCancelWorkflowExecution struct {
}

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

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

type validateOpRespondActivityTaskCanceled struct {
}

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

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

type validateOpRespondActivityTaskCompleted struct {
}

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

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

type validateOpRespondActivityTaskFailed struct {
}

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

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

type validateOpRespondDecisionTaskCompleted struct {
}

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

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

type validateOpSignalWorkflowExecution struct {
}

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

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

type validateOpStartWorkflowExecution struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpTerminateWorkflowExecution struct {
}

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

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

type validateOpUndeprecateActivityType struct {
}

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

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

type validateOpUndeprecateDomain struct {
}

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

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

type validateOpUndeprecateWorkflowType struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateContinueAsNewWorkflowExecutionDecisionAttributes(v *types.ContinueAsNewWorkflowExecutionDecisionAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContinueAsNewWorkflowExecutionDecisionAttributes"}
	if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDecision(v *types.Decision) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Decision"}
	if len(v.DecisionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DecisionType"))
	}
	if v.ScheduleActivityTaskDecisionAttributes != nil {
		if err := validateScheduleActivityTaskDecisionAttributes(v.ScheduleActivityTaskDecisionAttributes); err != nil {
			invalidParams.AddNested("ScheduleActivityTaskDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequestCancelActivityTaskDecisionAttributes != nil {
		if err := validateRequestCancelActivityTaskDecisionAttributes(v.RequestCancelActivityTaskDecisionAttributes); err != nil {
			invalidParams.AddNested("RequestCancelActivityTaskDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContinueAsNewWorkflowExecutionDecisionAttributes != nil {
		if err := validateContinueAsNewWorkflowExecutionDecisionAttributes(v.ContinueAsNewWorkflowExecutionDecisionAttributes); err != nil {
			invalidParams.AddNested("ContinueAsNewWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.RecordMarkerDecisionAttributes != nil {
		if err := validateRecordMarkerDecisionAttributes(v.RecordMarkerDecisionAttributes); err != nil {
			invalidParams.AddNested("RecordMarkerDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.StartTimerDecisionAttributes != nil {
		if err := validateStartTimerDecisionAttributes(v.StartTimerDecisionAttributes); err != nil {
			invalidParams.AddNested("StartTimerDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.CancelTimerDecisionAttributes != nil {
		if err := validateCancelTimerDecisionAttributes(v.CancelTimerDecisionAttributes); err != nil {
			invalidParams.AddNested("CancelTimerDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.SignalExternalWorkflowExecutionDecisionAttributes != nil {
		if err := validateSignalExternalWorkflowExecutionDecisionAttributes(v.SignalExternalWorkflowExecutionDecisionAttributes); err != nil {
			invalidParams.AddNested("SignalExternalWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequestCancelExternalWorkflowExecutionDecisionAttributes != nil {
		if err := validateRequestCancelExternalWorkflowExecutionDecisionAttributes(v.RequestCancelExternalWorkflowExecutionDecisionAttributes); err != nil {
			invalidParams.AddNested("RequestCancelExternalWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.StartChildWorkflowExecutionDecisionAttributes != nil {
		if err := validateStartChildWorkflowExecutionDecisionAttributes(v.StartChildWorkflowExecutionDecisionAttributes); err != nil {
			invalidParams.AddNested("StartChildWorkflowExecutionDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScheduleLambdaFunctionDecisionAttributes != nil {
		if err := validateScheduleLambdaFunctionDecisionAttributes(v.ScheduleLambdaFunctionDecisionAttributes); err != nil {
			invalidParams.AddNested("ScheduleLambdaFunctionDecisionAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateScheduleActivityTaskDecisionAttributes(v *types.ScheduleActivityTaskDecisionAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduleActivityTaskDecisionAttributes"}
	if v.ActivityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivityType"))
	} else if v.ActivityType != nil {
		if err := validateActivityType(v.ActivityType); err != nil {
			invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError))
		}
	}
	if v.ActivityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivityId"))
	}
	if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSignalExternalWorkflowExecutionDecisionAttributes(v *types.SignalExternalWorkflowExecutionDecisionAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalExternalWorkflowExecutionDecisionAttributes"}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if v.SignalName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SignalName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStartChildWorkflowExecutionDecisionAttributes(v *types.StartChildWorkflowExecutionDecisionAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartChildWorkflowExecutionDecisionAttributes"}
	if v.WorkflowType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowType"))
	} else if v.WorkflowType != nil {
		if err := validateWorkflowType(v.WorkflowType); err != nil {
			invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError))
		}
	}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStartTimerDecisionAttributes(v *types.StartTimerDecisionAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTimerDecisionAttributes"}
	if v.TimerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimerId"))
	}
	if v.StartToFireTimeout == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartToFireTimeout"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateWorkflowExecution(v *types.WorkflowExecution) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WorkflowExecution"}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCountClosedWorkflowExecutionsInput(v *CountClosedWorkflowExecutionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountClosedWorkflowExecutionsInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.StartTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil {
			invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloseTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.CloseTimeFilter); err != nil {
			invalidParams.AddNested("CloseTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExecutionFilter != nil {
		if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil {
			invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TypeFilter != nil {
		if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil {
			invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloseStatusFilter != nil {
		if err := validateCloseStatusFilter(v.CloseStatusFilter); err != nil {
			invalidParams.AddNested("CloseStatusFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCountOpenWorkflowExecutionsInput(v *CountOpenWorkflowExecutionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountOpenWorkflowExecutionsInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.StartTimeFilter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTimeFilter"))
	} else if v.StartTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil {
			invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TypeFilter != nil {
		if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil {
			invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExecutionFilter != nil {
		if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil {
			invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCountPendingActivityTasksInput(v *CountPendingActivityTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountPendingActivityTasksInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.TaskList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskList"))
	} else if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCountPendingDecisionTasksInput(v *CountPendingDecisionTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountPendingDecisionTasksInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.TaskList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskList"))
	} else if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeprecateActivityTypeInput(v *DeprecateActivityTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprecateActivityTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.ActivityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivityType"))
	} else if v.ActivityType != nil {
		if err := validateActivityType(v.ActivityType); err != nil {
			invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeprecateWorkflowTypeInput(v *DeprecateWorkflowTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprecateWorkflowTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowType"))
	} else if v.WorkflowType != nil {
		if err := validateWorkflowType(v.WorkflowType); err != nil {
			invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeActivityTypeInput(v *DescribeActivityTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeActivityTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.ActivityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivityType"))
	} else if v.ActivityType != nil {
		if err := validateActivityType(v.ActivityType); err != nil {
			invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeWorkflowExecutionInput(v *DescribeWorkflowExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkflowExecutionInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.Execution == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Execution"))
	} else if v.Execution != nil {
		if err := validateWorkflowExecution(v.Execution); err != nil {
			invalidParams.AddNested("Execution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeWorkflowTypeInput(v *DescribeWorkflowTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkflowTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowType"))
	} else if v.WorkflowType != nil {
		if err := validateWorkflowType(v.WorkflowType); err != nil {
			invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetWorkflowExecutionHistoryInput(v *GetWorkflowExecutionHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWorkflowExecutionHistoryInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.Execution == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Execution"))
	} else if v.Execution != nil {
		if err := validateWorkflowExecution(v.Execution); err != nil {
			invalidParams.AddNested("Execution", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListActivityTypesInput(v *ListActivityTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListActivityTypesInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if len(v.RegistrationStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RegistrationStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListClosedWorkflowExecutionsInput(v *ListClosedWorkflowExecutionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListClosedWorkflowExecutionsInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.StartTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil {
			invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloseTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.CloseTimeFilter); err != nil {
			invalidParams.AddNested("CloseTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExecutionFilter != nil {
		if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil {
			invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloseStatusFilter != nil {
		if err := validateCloseStatusFilter(v.CloseStatusFilter); err != nil {
			invalidParams.AddNested("CloseStatusFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TypeFilter != nil {
		if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil {
			invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListOpenWorkflowExecutionsInput(v *ListOpenWorkflowExecutionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOpenWorkflowExecutionsInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.StartTimeFilter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTimeFilter"))
	} else if v.StartTimeFilter != nil {
		if err := validateExecutionTimeFilter(v.StartTimeFilter); err != nil {
			invalidParams.AddNested("StartTimeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TypeFilter != nil {
		if err := validateWorkflowTypeFilter(v.TypeFilter); err != nil {
			invalidParams.AddNested("TypeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExecutionFilter != nil {
		if err := validateWorkflowExecutionFilter(v.ExecutionFilter); err != nil {
			invalidParams.AddNested("ExecutionFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListWorkflowTypesInput(v *ListWorkflowTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkflowTypesInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if len(v.RegistrationStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RegistrationStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPollForActivityTaskInput(v *PollForActivityTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PollForActivityTaskInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.TaskList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskList"))
	} else if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPollForDecisionTaskInput(v *PollForDecisionTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PollForDecisionTaskInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.TaskList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskList"))
	} else if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRegisterActivityTypeInput(v *RegisterActivityTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterActivityTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if v.DefaultTaskList != nil {
		if err := validateTaskList(v.DefaultTaskList); err != nil {
			invalidParams.AddNested("DefaultTaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRegisterWorkflowTypeInput(v *RegisterWorkflowTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterWorkflowTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if v.DefaultTaskList != nil {
		if err := validateTaskList(v.DefaultTaskList); err != nil {
			invalidParams.AddNested("DefaultTaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRequestCancelWorkflowExecutionInput(v *RequestCancelWorkflowExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestCancelWorkflowExecutionInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpRespondDecisionTaskCompletedInput(v *RespondDecisionTaskCompletedInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RespondDecisionTaskCompletedInput"}
	if v.TaskToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskToken"))
	}
	if v.Decisions != nil {
		if err := validateDecisionList(v.Decisions); err != nil {
			invalidParams.AddNested("Decisions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSignalWorkflowExecutionInput(v *SignalWorkflowExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalWorkflowExecutionInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if v.SignalName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SignalName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartWorkflowExecutionInput(v *StartWorkflowExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartWorkflowExecutionInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if v.WorkflowType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowType"))
	} else if v.WorkflowType != nil {
		if err := validateWorkflowType(v.WorkflowType); err != nil {
			invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskList != nil {
		if err := validateTaskList(v.TaskList); err != nil {
			invalidParams.AddNested("TaskList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpTerminateWorkflowExecutionInput(v *TerminateWorkflowExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateWorkflowExecutionInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUndeprecateActivityTypeInput(v *UndeprecateActivityTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UndeprecateActivityTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.ActivityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivityType"))
	} else if v.ActivityType != nil {
		if err := validateActivityType(v.ActivityType); err != nil {
			invalidParams.AddNested("ActivityType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUndeprecateWorkflowTypeInput(v *UndeprecateWorkflowTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UndeprecateWorkflowTypeInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.WorkflowType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowType"))
	} else if v.WorkflowType != nil {
		if err := validateWorkflowType(v.WorkflowType); err != nil {
			invalidParams.AddNested("WorkflowType", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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