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

package migrationhubstrategy

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

type validateOpGetApplicationComponentDetails struct {
}

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

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

type validateOpGetApplicationComponentStrategies struct {
}

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

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

type validateOpGetAssessment struct {
}

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

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

type validateOpGetImportFileTask struct {
}

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

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

type validateOpGetRecommendationReportDetails struct {
}

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

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

type validateOpGetServerDetails struct {
}

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

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

type validateOpGetServerStrategies struct {
}

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

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

type validateOpPutPortfolioPreferences struct {
}

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

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

type validateOpStartAssessment struct {
}

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

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

type validateOpStartImportFileTask struct {
}

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

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

type validateOpStopAssessment struct {
}

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

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

type validateOpUpdateApplicationComponentConfig struct {
}

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

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

type validateOpUpdateServerConfig struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateApplicationPreferences(v *types.ApplicationPreferences) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplicationPreferences"}
	if v.ManagementPreference != nil {
		if err := validateManagementPreference(v.ManagementPreference); err != nil {
			invalidParams.AddNested("ManagementPreference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssessmentTarget(v *types.AssessmentTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssessmentTarget"}
	if len(v.Condition) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Condition"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDatabaseMigrationPreference(v types.DatabaseMigrationPreference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatabaseMigrationPreference"}
	switch uv := v.(type) {
	case *types.DatabaseMigrationPreferenceMemberHeterogeneous:
		if err := validateHeterogeneous(&uv.Value); err != nil {
			invalidParams.AddNested("[heterogeneous]", err.(smithy.InvalidParamsError))
		}

	case *types.DatabaseMigrationPreferenceMemberNoPreference:
		if err := validateNoDatabaseMigrationPreference(&uv.Value); err != nil {
			invalidParams.AddNested("[noPreference]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatabasePreferences(v *types.DatabasePreferences) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatabasePreferences"}
	if v.DatabaseMigrationPreference != nil {
		if err := validateDatabaseMigrationPreference(v.DatabaseMigrationPreference); err != nil {
			invalidParams.AddNested("DatabaseMigrationPreference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateManagementPreference(v types.ManagementPreference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagementPreference"}
	switch uv := v.(type) {
	case *types.ManagementPreferenceMemberAwsManagedResources:
		if err := validateAwsManagedResources(&uv.Value); err != nil {
			invalidParams.AddNested("[awsManagedResources]", err.(smithy.InvalidParamsError))
		}

	case *types.ManagementPreferenceMemberNoPreference:
		if err := validateNoManagementPreference(&uv.Value); err != nil {
			invalidParams.AddNested("[noPreference]", err.(smithy.InvalidParamsError))
		}

	case *types.ManagementPreferenceMemberSelfManageResources:
		if err := validateSelfManageResources(&uv.Value); err != nil {
			invalidParams.AddNested("[selfManageResources]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpPutPortfolioPreferencesInput(v *PutPortfolioPreferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutPortfolioPreferencesInput"}
	if v.ApplicationPreferences != nil {
		if err := validateApplicationPreferences(v.ApplicationPreferences); err != nil {
			invalidParams.AddNested("ApplicationPreferences", err.(smithy.InvalidParamsError))
		}
	}
	if v.DatabasePreferences != nil {
		if err := validateDatabasePreferences(v.DatabasePreferences); err != nil {
			invalidParams.AddNested("DatabasePreferences", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartAssessmentInput(v *StartAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAssessmentInput"}
	if v.AssessmentTargets != nil {
		if err := validateAssessmentTargets(v.AssessmentTargets); err != nil {
			invalidParams.AddNested("AssessmentTargets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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