validators.go

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

package kinesisanalyticsv2

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

type validateOpAddApplicationCloudWatchLoggingOption struct {
}

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

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

type validateOpAddApplicationInput struct {
}

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

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

type validateOpAddApplicationInputProcessingConfiguration struct {
}

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

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

type validateOpAddApplicationOutput struct {
}

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

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

type validateOpAddApplicationReferenceDataSource struct {
}

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

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

type validateOpAddApplicationVpcConfiguration struct {
}

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

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

type validateOpCreateApplication struct {
}

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

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

type validateOpCreateApplicationPresignedUrl struct {
}

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

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

type validateOpCreateApplicationSnapshot struct {
}

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

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

type validateOpDeleteApplicationCloudWatchLoggingOption struct {
}

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

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

type validateOpDeleteApplication struct {
}

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

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

type validateOpDeleteApplicationInputProcessingConfiguration struct {
}

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

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

type validateOpDeleteApplicationOutput struct {
}

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

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

type validateOpDeleteApplicationReferenceDataSource struct {
}

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

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

type validateOpDeleteApplicationSnapshot struct {
}

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

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

type validateOpDeleteApplicationVpcConfiguration struct {
}

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

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

type validateOpDescribeApplication struct {
}

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

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

type validateOpDescribeApplicationSnapshot struct {
}

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

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

type validateOpDescribeApplicationVersion struct {
}

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

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

type validateOpDiscoverInputSchema struct {
}

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

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

type validateOpListApplicationSnapshots struct {
}

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

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

type validateOpListApplicationVersions struct {
}

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

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

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

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

type validateOpStartApplication struct {
}

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

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

type validateOpStopApplication struct {
}

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

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

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

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

type validateOpUpdateApplicationMaintenanceConfiguration struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopApplicationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopApplication{}, 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 addOpUpdateApplicationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateApplication{}, middleware.After)
}

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

func validateApplicationCodeConfiguration(v *types.ApplicationCodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplicationCodeConfiguration"}
	if v.CodeContent != nil {
		if err := validateCodeContent(v.CodeContent); err != nil {
			invalidParams.AddNested("CodeContent", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.CodeContentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CodeContentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateApplicationConfiguration(v *types.ApplicationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplicationConfiguration"}
	if v.SqlApplicationConfiguration != nil {
		if err := validateSqlApplicationConfiguration(v.SqlApplicationConfiguration); err != nil {
			invalidParams.AddNested("SqlApplicationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FlinkApplicationConfiguration != nil {
		if err := validateFlinkApplicationConfiguration(v.FlinkApplicationConfiguration); err != nil {
			invalidParams.AddNested("FlinkApplicationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnvironmentProperties != nil {
		if err := validateEnvironmentProperties(v.EnvironmentProperties); err != nil {
			invalidParams.AddNested("EnvironmentProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationCodeConfiguration != nil {
		if err := validateApplicationCodeConfiguration(v.ApplicationCodeConfiguration); err != nil {
			invalidParams.AddNested("ApplicationCodeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationSnapshotConfiguration != nil {
		if err := validateApplicationSnapshotConfiguration(v.ApplicationSnapshotConfiguration); err != nil {
			invalidParams.AddNested("ApplicationSnapshotConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfigurations != nil {
		if err := validateVpcConfigurations(v.VpcConfigurations); err != nil {
			invalidParams.AddNested("VpcConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.ZeppelinApplicationConfiguration != nil {
		if err := validateZeppelinApplicationConfiguration(v.ZeppelinApplicationConfiguration); err != nil {
			invalidParams.AddNested("ZeppelinApplicationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateApplicationConfigurationUpdate(v *types.ApplicationConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplicationConfigurationUpdate"}
	if v.SqlApplicationConfigurationUpdate != nil {
		if err := validateSqlApplicationConfigurationUpdate(v.SqlApplicationConfigurationUpdate); err != nil {
			invalidParams.AddNested("SqlApplicationConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnvironmentPropertyUpdates != nil {
		if err := validateEnvironmentPropertyUpdates(v.EnvironmentPropertyUpdates); err != nil {
			invalidParams.AddNested("EnvironmentPropertyUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationSnapshotConfigurationUpdate != nil {
		if err := validateApplicationSnapshotConfigurationUpdate(v.ApplicationSnapshotConfigurationUpdate); err != nil {
			invalidParams.AddNested("ApplicationSnapshotConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfigurationUpdates != nil {
		if err := validateVpcConfigurationUpdates(v.VpcConfigurationUpdates); err != nil {
			invalidParams.AddNested("VpcConfigurationUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ZeppelinApplicationConfigurationUpdate != nil {
		if err := validateZeppelinApplicationConfigurationUpdate(v.ZeppelinApplicationConfigurationUpdate); err != nil {
			invalidParams.AddNested("ZeppelinApplicationConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateCatalogConfiguration(v *types.CatalogConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CatalogConfiguration"}
	if v.GlueDataCatalogConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlueDataCatalogConfiguration"))
	} else if v.GlueDataCatalogConfiguration != nil {
		if err := validateGlueDataCatalogConfiguration(v.GlueDataCatalogConfiguration); err != nil {
			invalidParams.AddNested("GlueDataCatalogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCatalogConfigurationUpdate(v *types.CatalogConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CatalogConfigurationUpdate"}
	if v.GlueDataCatalogConfigurationUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlueDataCatalogConfigurationUpdate"))
	} else if v.GlueDataCatalogConfigurationUpdate != nil {
		if err := validateGlueDataCatalogConfigurationUpdate(v.GlueDataCatalogConfigurationUpdate); err != nil {
			invalidParams.AddNested("GlueDataCatalogConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateCodeContent(v *types.CodeContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeContent"}
	if v.S3ContentLocation != nil {
		if err := validateS3ContentLocation(v.S3ContentLocation); err != nil {
			invalidParams.AddNested("S3ContentLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCSVMappingParameters(v *types.CSVMappingParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CSVMappingParameters"}
	if v.RecordRowDelimiter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordRowDelimiter"))
	}
	if v.RecordColumnDelimiter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordColumnDelimiter"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomArtifactConfiguration(v *types.CustomArtifactConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomArtifactConfiguration"}
	if len(v.ArtifactType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ArtifactType"))
	}
	if v.S3ContentLocation != nil {
		if err := validateS3ContentLocation(v.S3ContentLocation); err != nil {
			invalidParams.AddNested("S3ContentLocation", err.(smithy.InvalidParamsError))
		}
	}
	if v.MavenReference != nil {
		if err := validateMavenReference(v.MavenReference); err != nil {
			invalidParams.AddNested("MavenReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDeployAsApplicationConfiguration(v *types.DeployAsApplicationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeployAsApplicationConfiguration"}
	if v.S3ContentLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3ContentLocation"))
	} else if v.S3ContentLocation != nil {
		if err := validateS3ContentBaseLocation(v.S3ContentLocation); err != nil {
			invalidParams.AddNested("S3ContentLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEnvironmentProperties(v *types.EnvironmentProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentProperties"}
	if v.PropertyGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyGroups"))
	} else if v.PropertyGroups != nil {
		if err := validatePropertyGroups(v.PropertyGroups); err != nil {
			invalidParams.AddNested("PropertyGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEnvironmentPropertyUpdates(v *types.EnvironmentPropertyUpdates) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentPropertyUpdates"}
	if v.PropertyGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyGroups"))
	} else if v.PropertyGroups != nil {
		if err := validatePropertyGroups(v.PropertyGroups); err != nil {
			invalidParams.AddNested("PropertyGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFlinkApplicationConfiguration(v *types.FlinkApplicationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlinkApplicationConfiguration"}
	if v.CheckpointConfiguration != nil {
		if err := validateCheckpointConfiguration(v.CheckpointConfiguration); err != nil {
			invalidParams.AddNested("CheckpointConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoringConfiguration != nil {
		if err := validateMonitoringConfiguration(v.MonitoringConfiguration); err != nil {
			invalidParams.AddNested("MonitoringConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParallelismConfiguration != nil {
		if err := validateParallelismConfiguration(v.ParallelismConfiguration); err != nil {
			invalidParams.AddNested("ParallelismConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateInput(v *types.Input) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Input"}
	if v.NamePrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NamePrefix"))
	}
	if v.InputProcessingConfiguration != nil {
		if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil {
			invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisStreamsInput != nil {
		if err := validateKinesisStreamsInput(v.KinesisStreamsInput); err != nil {
			invalidParams.AddNested("KinesisStreamsInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseInput != nil {
		if err := validateKinesisFirehoseInput(v.KinesisFirehoseInput); err != nil {
			invalidParams.AddNested("KinesisFirehoseInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputSchema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputSchema"))
	} else if v.InputSchema != nil {
		if err := validateSourceSchema(v.InputSchema); err != nil {
			invalidParams.AddNested("InputSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateInputProcessingConfiguration(v *types.InputProcessingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputProcessingConfiguration"}
	if v.InputLambdaProcessor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputLambdaProcessor"))
	} else if v.InputLambdaProcessor != nil {
		if err := validateInputLambdaProcessor(v.InputLambdaProcessor); err != nil {
			invalidParams.AddNested("InputLambdaProcessor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputProcessingConfigurationUpdate(v *types.InputProcessingConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputProcessingConfigurationUpdate"}
	if v.InputLambdaProcessorUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputLambdaProcessorUpdate"))
	} else if v.InputLambdaProcessorUpdate != nil {
		if err := validateInputLambdaProcessorUpdate(v.InputLambdaProcessorUpdate); err != nil {
			invalidParams.AddNested("InputLambdaProcessorUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateInputSchemaUpdate(v *types.InputSchemaUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputSchemaUpdate"}
	if v.RecordFormatUpdate != nil {
		if err := validateRecordFormat(v.RecordFormatUpdate); err != nil {
			invalidParams.AddNested("RecordFormatUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.RecordColumnUpdates != nil {
		if err := validateRecordColumns(v.RecordColumnUpdates); err != nil {
			invalidParams.AddNested("RecordColumnUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputUpdate(v *types.InputUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputUpdate"}
	if v.InputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputId"))
	}
	if v.InputProcessingConfigurationUpdate != nil {
		if err := validateInputProcessingConfigurationUpdate(v.InputProcessingConfigurationUpdate); err != nil {
			invalidParams.AddNested("InputProcessingConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisStreamsInputUpdate != nil {
		if err := validateKinesisStreamsInputUpdate(v.KinesisStreamsInputUpdate); err != nil {
			invalidParams.AddNested("KinesisStreamsInputUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseInputUpdate != nil {
		if err := validateKinesisFirehoseInputUpdate(v.KinesisFirehoseInputUpdate); err != nil {
			invalidParams.AddNested("KinesisFirehoseInputUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputSchemaUpdate != nil {
		if err := validateInputSchemaUpdate(v.InputSchemaUpdate); err != nil {
			invalidParams.AddNested("InputSchemaUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputParallelismUpdate != nil {
		if err := validateInputParallelismUpdate(v.InputParallelismUpdate); err != nil {
			invalidParams.AddNested("InputParallelismUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateMappingParameters(v *types.MappingParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MappingParameters"}
	if v.JSONMappingParameters != nil {
		if err := validateJSONMappingParameters(v.JSONMappingParameters); err != nil {
			invalidParams.AddNested("JSONMappingParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.CSVMappingParameters != nil {
		if err := validateCSVMappingParameters(v.CSVMappingParameters); err != nil {
			invalidParams.AddNested("CSVMappingParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMavenReference(v *types.MavenReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MavenReference"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if v.ArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ArtifactId"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOutput(v *types.Output) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Output"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.KinesisStreamsOutput != nil {
		if err := validateKinesisStreamsOutput(v.KinesisStreamsOutput); err != nil {
			invalidParams.AddNested("KinesisStreamsOutput", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseOutput != nil {
		if err := validateKinesisFirehoseOutput(v.KinesisFirehoseOutput); err != nil {
			invalidParams.AddNested("KinesisFirehoseOutput", err.(smithy.InvalidParamsError))
		}
	}
	if v.LambdaOutput != nil {
		if err := validateLambdaOutput(v.LambdaOutput); err != nil {
			invalidParams.AddNested("LambdaOutput", err.(smithy.InvalidParamsError))
		}
	}
	if v.DestinationSchema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationSchema"))
	} else if v.DestinationSchema != nil {
		if err := validateDestinationSchema(v.DestinationSchema); err != nil {
			invalidParams.AddNested("DestinationSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOutputUpdate(v *types.OutputUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputUpdate"}
	if v.OutputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputId"))
	}
	if v.KinesisStreamsOutputUpdate != nil {
		if err := validateKinesisStreamsOutputUpdate(v.KinesisStreamsOutputUpdate); err != nil {
			invalidParams.AddNested("KinesisStreamsOutputUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseOutputUpdate != nil {
		if err := validateKinesisFirehoseOutputUpdate(v.KinesisFirehoseOutputUpdate); err != nil {
			invalidParams.AddNested("KinesisFirehoseOutputUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.LambdaOutputUpdate != nil {
		if err := validateLambdaOutputUpdate(v.LambdaOutputUpdate); err != nil {
			invalidParams.AddNested("LambdaOutputUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.DestinationSchemaUpdate != nil {
		if err := validateDestinationSchema(v.DestinationSchemaUpdate); err != nil {
			invalidParams.AddNested("DestinationSchemaUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePropertyGroup(v *types.PropertyGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PropertyGroup"}
	if v.PropertyGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyGroupId"))
	}
	if v.PropertyMap == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyMap"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateRecordFormat(v *types.RecordFormat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordFormat"}
	if len(v.RecordFormatType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecordFormatType"))
	}
	if v.MappingParameters != nil {
		if err := validateMappingParameters(v.MappingParameters); err != nil {
			invalidParams.AddNested("MappingParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReferenceDataSource(v *types.ReferenceDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceDataSource"}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.ReferenceSchema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceSchema"))
	} else if v.ReferenceSchema != nil {
		if err := validateSourceSchema(v.ReferenceSchema); err != nil {
			invalidParams.AddNested("ReferenceSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateReferenceDataSourceUpdate(v *types.ReferenceDataSourceUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceDataSourceUpdate"}
	if v.ReferenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceId"))
	}
	if v.ReferenceSchemaUpdate != nil {
		if err := validateSourceSchema(v.ReferenceSchemaUpdate); err != nil {
			invalidParams.AddNested("ReferenceSchemaUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRunConfiguration(v *types.RunConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunConfiguration"}
	if v.SqlRunConfigurations != nil {
		if err := validateSqlRunConfigurations(v.SqlRunConfigurations); err != nil {
			invalidParams.AddNested("SqlRunConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationRestoreConfiguration != nil {
		if err := validateApplicationRestoreConfiguration(v.ApplicationRestoreConfiguration); err != nil {
			invalidParams.AddNested("ApplicationRestoreConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRunConfigurationUpdate(v *types.RunConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunConfigurationUpdate"}
	if v.ApplicationRestoreConfiguration != nil {
		if err := validateApplicationRestoreConfiguration(v.ApplicationRestoreConfiguration); err != nil {
			invalidParams.AddNested("ApplicationRestoreConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3Configuration(v *types.S3Configuration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Configuration"}
	if v.BucketARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketARN"))
	}
	if v.FileKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateS3ContentLocation(v *types.S3ContentLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3ContentLocation"}
	if v.BucketARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketARN"))
	}
	if v.FileKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSourceSchema(v *types.SourceSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SourceSchema"}
	if v.RecordFormat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordFormat"))
	} else if v.RecordFormat != nil {
		if err := validateRecordFormat(v.RecordFormat); err != nil {
			invalidParams.AddNested("RecordFormat", err.(smithy.InvalidParamsError))
		}
	}
	if v.RecordColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordColumns"))
	} else if v.RecordColumns != nil {
		if err := validateRecordColumns(v.RecordColumns); err != nil {
			invalidParams.AddNested("RecordColumns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlApplicationConfiguration(v *types.SqlApplicationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlApplicationConfiguration"}
	if v.Inputs != nil {
		if err := validateInputs(v.Inputs); err != nil {
			invalidParams.AddNested("Inputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.Outputs != nil {
		if err := validateOutputs(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceDataSources != nil {
		if err := validateReferenceDataSources(v.ReferenceDataSources); err != nil {
			invalidParams.AddNested("ReferenceDataSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlApplicationConfigurationUpdate(v *types.SqlApplicationConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlApplicationConfigurationUpdate"}
	if v.InputUpdates != nil {
		if err := validateInputUpdates(v.InputUpdates); err != nil {
			invalidParams.AddNested("InputUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputUpdates != nil {
		if err := validateOutputUpdates(v.OutputUpdates); err != nil {
			invalidParams.AddNested("OutputUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceDataSourceUpdates != nil {
		if err := validateReferenceDataSourceUpdates(v.ReferenceDataSourceUpdates); err != nil {
			invalidParams.AddNested("ReferenceDataSourceUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlRunConfiguration(v *types.SqlRunConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlRunConfiguration"}
	if v.InputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputId"))
	}
	if v.InputStartingPositionConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputStartingPositionConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateVpcConfiguration(v *types.VpcConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VpcConfiguration"}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateZeppelinApplicationConfiguration(v *types.ZeppelinApplicationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ZeppelinApplicationConfiguration"}
	if v.MonitoringConfiguration != nil {
		if err := validateZeppelinMonitoringConfiguration(v.MonitoringConfiguration); err != nil {
			invalidParams.AddNested("MonitoringConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogConfiguration != nil {
		if err := validateCatalogConfiguration(v.CatalogConfiguration); err != nil {
			invalidParams.AddNested("CatalogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeployAsApplicationConfiguration != nil {
		if err := validateDeployAsApplicationConfiguration(v.DeployAsApplicationConfiguration); err != nil {
			invalidParams.AddNested("DeployAsApplicationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomArtifactsConfiguration != nil {
		if err := validateCustomArtifactsConfigurationList(v.CustomArtifactsConfiguration); err != nil {
			invalidParams.AddNested("CustomArtifactsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateZeppelinApplicationConfigurationUpdate(v *types.ZeppelinApplicationConfigurationUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ZeppelinApplicationConfigurationUpdate"}
	if v.MonitoringConfigurationUpdate != nil {
		if err := validateZeppelinMonitoringConfigurationUpdate(v.MonitoringConfigurationUpdate); err != nil {
			invalidParams.AddNested("MonitoringConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogConfigurationUpdate != nil {
		if err := validateCatalogConfigurationUpdate(v.CatalogConfigurationUpdate); err != nil {
			invalidParams.AddNested("CatalogConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomArtifactsConfigurationUpdate != nil {
		if err := validateCustomArtifactsConfigurationList(v.CustomArtifactsConfigurationUpdate); err != nil {
			invalidParams.AddNested("CustomArtifactsConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAddApplicationCloudWatchLoggingOptionInput(v *AddApplicationCloudWatchLoggingOptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationCloudWatchLoggingOptionInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CloudWatchLoggingOption == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLoggingOption"))
	} else if v.CloudWatchLoggingOption != nil {
		if err := validateCloudWatchLoggingOption(v.CloudWatchLoggingOption); err != nil {
			invalidParams.AddNested("CloudWatchLoggingOption", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddApplicationInputInput(v *AddApplicationInputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationInputInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.Input == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Input"))
	} else if v.Input != nil {
		if err := validateInput(v.Input); err != nil {
			invalidParams.AddNested("Input", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddApplicationInputProcessingConfigurationInput(v *AddApplicationInputProcessingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationInputProcessingConfigurationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.InputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputId"))
	}
	if v.InputProcessingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputProcessingConfiguration"))
	} else if v.InputProcessingConfiguration != nil {
		if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil {
			invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddApplicationOutputInput(v *AddApplicationOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationOutputInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.Output == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Output"))
	} else if v.Output != nil {
		if err := validateOutput(v.Output); err != nil {
			invalidParams.AddNested("Output", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddApplicationReferenceDataSourceInput(v *AddApplicationReferenceDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationReferenceDataSourceInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.ReferenceDataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceDataSource"))
	} else if v.ReferenceDataSource != nil {
		if err := validateReferenceDataSource(v.ReferenceDataSource); err != nil {
			invalidParams.AddNested("ReferenceDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddApplicationVpcConfigurationInput(v *AddApplicationVpcConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddApplicationVpcConfigurationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.VpcConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration"))
	} else if v.VpcConfiguration != nil {
		if err := validateVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateApplicationInput(v *CreateApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if len(v.RuntimeEnvironment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuntimeEnvironment"))
	}
	if v.ServiceExecutionRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceExecutionRole"))
	}
	if v.ApplicationConfiguration != nil {
		if err := validateApplicationConfiguration(v.ApplicationConfiguration); err != nil {
			invalidParams.AddNested("ApplicationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloudWatchLoggingOptions != nil {
		if err := validateCloudWatchLoggingOptions(v.CloudWatchLoggingOptions); err != nil {
			invalidParams.AddNested("CloudWatchLoggingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateApplicationPresignedUrlInput(v *CreateApplicationPresignedUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationPresignedUrlInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if len(v.UrlType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UrlType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateApplicationSnapshotInput(v *CreateApplicationSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationSnapshotInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.SnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationCloudWatchLoggingOptionInput(v *DeleteApplicationCloudWatchLoggingOptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationCloudWatchLoggingOptionInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CloudWatchLoggingOptionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLoggingOptionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationInput(v *DeleteApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CreateTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreateTimestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationInputProcessingConfigurationInput(v *DeleteApplicationInputProcessingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationInputProcessingConfigurationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.InputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationOutputInput(v *DeleteApplicationOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationOutputInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.OutputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationReferenceDataSourceInput(v *DeleteApplicationReferenceDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationReferenceDataSourceInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if v.ReferenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationSnapshotInput(v *DeleteApplicationSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationSnapshotInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.SnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
	}
	if v.SnapshotCreationTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotCreationTimestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteApplicationVpcConfigurationInput(v *DeleteApplicationVpcConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationVpcConfigurationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.VpcConfigurationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcConfigurationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeApplicationSnapshotInput(v *DescribeApplicationSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeApplicationSnapshotInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.SnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeApplicationVersionInput(v *DescribeApplicationVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeApplicationVersionInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.ApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationVersionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDiscoverInputSchemaInput(v *DiscoverInputSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DiscoverInputSchemaInput"}
	if v.ServiceExecutionRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceExecutionRole"))
	}
	if v.S3Configuration != nil {
		if err := validateS3Configuration(v.S3Configuration); err != nil {
			invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputProcessingConfiguration != nil {
		if err := validateInputProcessingConfiguration(v.InputProcessingConfiguration); err != nil {
			invalidParams.AddNested("InputProcessingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListApplicationVersionsInput(v *ListApplicationVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListApplicationVersionsInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	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 validateOpRollbackApplicationInput(v *RollbackApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RollbackApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.CurrentApplicationVersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentApplicationVersionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartApplicationInput(v *StartApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.RunConfiguration != nil {
		if err := validateRunConfiguration(v.RunConfiguration); err != nil {
			invalidParams.AddNested("RunConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopApplicationInput(v *StopApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	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 := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", 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
	}
}

func validateOpUpdateApplicationInput(v *UpdateApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.ApplicationConfigurationUpdate != nil {
		if err := validateApplicationConfigurationUpdate(v.ApplicationConfigurationUpdate); err != nil {
			invalidParams.AddNested("ApplicationConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.RunConfigurationUpdate != nil {
		if err := validateRunConfigurationUpdate(v.RunConfigurationUpdate); err != nil {
			invalidParams.AddNested("RunConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloudWatchLoggingOptionUpdates != nil {
		if err := validateCloudWatchLoggingOptionUpdates(v.CloudWatchLoggingOptionUpdates); err != nil {
			invalidParams.AddNested("CloudWatchLoggingOptionUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApplicationMaintenanceConfigurationInput(v *UpdateApplicationMaintenanceConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationMaintenanceConfigurationInput"}
	if v.ApplicationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationName"))
	}
	if v.ApplicationMaintenanceConfigurationUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationMaintenanceConfigurationUpdate"))
	} else if v.ApplicationMaintenanceConfigurationUpdate != nil {
		if err := validateApplicationMaintenanceConfigurationUpdate(v.ApplicationMaintenanceConfigurationUpdate); err != nil {
			invalidParams.AddNested("ApplicationMaintenanceConfigurationUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}