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

package resiliencehub

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

type validateOpAddDraftAppVersionResourceMappings struct {
}

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

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

type validateOpCreateApp struct {
}

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

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

type validateOpCreateAppVersionAppComponent struct {
}

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

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

type validateOpCreateAppVersionResource struct {
}

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

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

type validateOpCreateRecommendationTemplate struct {
}

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

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

type validateOpCreateResiliencyPolicy struct {
}

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

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

type validateOpDeleteAppAssessment struct {
}

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

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

type validateOpDeleteApp struct {
}

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

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

type validateOpDeleteAppInputSource struct {
}

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

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

type validateOpDeleteAppVersionAppComponent struct {
}

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

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

type validateOpDeleteAppVersionResource struct {
}

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

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

type validateOpDeleteRecommendationTemplate struct {
}

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

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

type validateOpDeleteResiliencyPolicy struct {
}

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

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

type validateOpDescribeAppAssessment struct {
}

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

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

type validateOpDescribeApp struct {
}

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

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

type validateOpDescribeAppVersionAppComponent struct {
}

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

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

type validateOpDescribeAppVersion struct {
}

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

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

type validateOpDescribeAppVersionResource struct {
}

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

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

type validateOpDescribeAppVersionResourcesResolutionStatus struct {
}

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

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

type validateOpDescribeAppVersionTemplate struct {
}

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

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

type validateOpDescribeDraftAppVersionResourcesImportStatus struct {
}

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

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

type validateOpDescribeResiliencyPolicy struct {
}

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

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

type validateOpImportResourcesToDraftAppVersion struct {
}

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

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

type validateOpListAlarmRecommendations struct {
}

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

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

type validateOpListAppComponentCompliances struct {
}

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

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

type validateOpListAppComponentRecommendations struct {
}

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

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

type validateOpListAppInputSources struct {
}

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

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

type validateOpListAppVersionAppComponents struct {
}

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

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

type validateOpListAppVersionResourceMappings struct {
}

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

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

type validateOpListAppVersionResources struct {
}

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

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

type validateOpListAppVersions struct {
}

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

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

type validateOpListRecommendationTemplates struct {
}

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

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

type validateOpListSopRecommendations struct {
}

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

func (m *validateOpListSopRecommendations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListSopRecommendationsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListSopRecommendationsInput(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 validateOpListTestRecommendations struct {
}

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

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

type validateOpListUnsupportedAppVersionResources struct {
}

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

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

type validateOpPublishAppVersion struct {
}

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

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

type validateOpPutDraftAppVersionTemplate struct {
}

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

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

type validateOpRemoveDraftAppVersionResourceMappings struct {
}

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

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

type validateOpResolveAppVersionResources struct {
}

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

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

type validateOpStartAppAssessment struct {
}

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

func (m *validateOpStartAppAssessment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartAppAssessmentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartAppAssessmentInput(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 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)
}

type validateOpUpdateApp struct {
}

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

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

type validateOpUpdateAppVersionAppComponent struct {
}

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

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

type validateOpUpdateAppVersion struct {
}

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

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

type validateOpUpdateAppVersionResource struct {
}

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

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

type validateOpUpdateResiliencyPolicy struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateDisruptionPolicy(v map[string]types.FailurePolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisruptionPolicy"}
	for key := range v {
		value := v[key]
		if err := validateFailurePolicy(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEksSource(v *types.EksSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EksSource"}
	if v.EksClusterArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EksClusterArn"))
	}
	if v.Namespaces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespaces"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEksSourceClusterNamespace(v *types.EksSourceClusterNamespace) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EksSourceClusterNamespace"}
	if v.EksClusterArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EksClusterArn"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFailurePolicy(v *types.FailurePolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailurePolicy"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePhysicalResourceId(v *types.PhysicalResourceId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PhysicalResourceId"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpAddDraftAppVersionResourceMappingsInput(v *AddDraftAppVersionResourceMappingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddDraftAppVersionResourceMappingsInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.ResourceMappings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceMappings"))
	} else if v.ResourceMappings != nil {
		if err := validateResourceMappingList(v.ResourceMappings); err != nil {
			invalidParams.AddNested("ResourceMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateAppVersionResourceInput(v *CreateAppVersionResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppVersionResourceInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.LogicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId"))
	} else if v.LogicalResourceId != nil {
		if err := validateLogicalResourceId(v.LogicalResourceId); err != nil {
			invalidParams.AddNested("LogicalResourceId", err.(smithy.InvalidParamsError))
		}
	}
	if v.PhysicalResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhysicalResourceId"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.AppComponents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppComponents"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateResiliencyPolicyInput(v *CreateResiliencyPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResiliencyPolicyInput"}
	if v.PolicyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
	}
	if len(v.Tier) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Tier"))
	}
	if v.Policy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
	} else if v.Policy != nil {
		if err := validateDisruptionPolicy(v.Policy); err != nil {
			invalidParams.AddNested("Policy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteAppInputSourceInput(v *DeleteAppInputSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInputSourceInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.TerraformSource != nil {
		if err := validateTerraformSource(v.TerraformSource); err != nil {
			invalidParams.AddNested("TerraformSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.EksSourceClusterNamespace != nil {
		if err := validateEksSourceClusterNamespace(v.EksSourceClusterNamespace); err != nil {
			invalidParams.AddNested("EksSourceClusterNamespace", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAppVersionResourceInput(v *DeleteAppVersionResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppVersionResourceInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.LogicalResourceId != nil {
		if err := validateLogicalResourceId(v.LogicalResourceId); err != nil {
			invalidParams.AddNested("LogicalResourceId", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDescribeAppVersionInput(v *DescribeAppVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppVersionInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAppVersionResourceInput(v *DescribeAppVersionResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppVersionResourceInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if v.LogicalResourceId != nil {
		if err := validateLogicalResourceId(v.LogicalResourceId); err != nil {
			invalidParams.AddNested("LogicalResourceId", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAppVersionResourcesResolutionStatusInput(v *DescribeAppVersionResourcesResolutionStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppVersionResourcesResolutionStatusInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAppVersionTemplateInput(v *DescribeAppVersionTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppVersionTemplateInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpImportResourcesToDraftAppVersionInput(v *ImportResourcesToDraftAppVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportResourcesToDraftAppVersionInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.TerraformSources != nil {
		if err := validateTerraformSourceList(v.TerraformSources); err != nil {
			invalidParams.AddNested("TerraformSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.EksSources != nil {
		if err := validateEksSourceList(v.EksSources); err != nil {
			invalidParams.AddNested("EksSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListAppInputSourcesInput(v *ListAppInputSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAppInputSourcesInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAppVersionAppComponentsInput(v *ListAppVersionAppComponentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAppVersionAppComponentsInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAppVersionResourceMappingsInput(v *ListAppVersionResourceMappingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAppVersionResourceMappingsInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAppVersionResourcesInput(v *ListAppVersionResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAppVersionResourcesInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListSopRecommendationsInput(v *ListSopRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSopRecommendationsInput"}
	if v.AssessmentArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentArn"))
	}
	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 validateOpListTestRecommendationsInput(v *ListTestRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTestRecommendationsInput"}
	if v.AssessmentArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUnsupportedAppVersionResourcesInput(v *ListUnsupportedAppVersionResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUnsupportedAppVersionResourcesInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutDraftAppVersionTemplateInput(v *PutDraftAppVersionTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDraftAppVersionTemplateInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppTemplateBody == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppTemplateBody"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpResolveAppVersionResourcesInput(v *ResolveAppVersionResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResolveAppVersionResourcesInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartAppAssessmentInput(v *StartAppAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAppAssessmentInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.AppVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppVersion"))
	}
	if v.AssessmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentName"))
	}
	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"))
	}
	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
	}
}

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

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

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

func validateOpUpdateAppVersionResourceInput(v *UpdateAppVersionResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAppVersionResourceInput"}
	if v.AppArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppArn"))
	}
	if v.LogicalResourceId != nil {
		if err := validateLogicalResourceId(v.LogicalResourceId); err != nil {
			invalidParams.AddNested("LogicalResourceId", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResiliencyPolicyInput(v *UpdateResiliencyPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResiliencyPolicyInput"}
	if v.PolicyArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyArn"))
	}
	if v.Policy != nil {
		if err := validateDisruptionPolicy(v.Policy); err != nil {
			invalidParams.AddNested("Policy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}