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

package lambda

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

type validateOpAddLayerVersionPermission struct {
}

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

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

type validateOpAddPermission struct {
}

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

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

type validateOpCreateAlias struct {
}

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

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

type validateOpCreateCodeSigningConfig struct {
}

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

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

type validateOpCreateEventSourceMapping struct {
}

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

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

type validateOpCreateFunction struct {
}

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

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

type validateOpCreateFunctionUrlConfig struct {
}

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

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

type validateOpDeleteAlias struct {
}

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

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

type validateOpDeleteCodeSigningConfig struct {
}

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

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

type validateOpDeleteEventSourceMapping struct {
}

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

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

type validateOpDeleteFunctionCodeSigningConfig struct {
}

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

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

type validateOpDeleteFunctionConcurrency struct {
}

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

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

type validateOpDeleteFunctionEventInvokeConfig struct {
}

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

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

type validateOpDeleteFunction struct {
}

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

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

type validateOpDeleteFunctionUrlConfig struct {
}

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

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

type validateOpDeleteLayerVersion struct {
}

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

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

type validateOpDeleteProvisionedConcurrencyConfig struct {
}

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

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

type validateOpGetAlias struct {
}

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

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

type validateOpGetCodeSigningConfig struct {
}

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

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

type validateOpGetEventSourceMapping struct {
}

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

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

type validateOpGetFunctionCodeSigningConfig struct {
}

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

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

type validateOpGetFunctionConcurrency struct {
}

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

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

type validateOpGetFunctionConfiguration struct {
}

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

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

type validateOpGetFunctionEventInvokeConfig struct {
}

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

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

type validateOpGetFunction struct {
}

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

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

type validateOpGetFunctionUrlConfig struct {
}

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

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

type validateOpGetLayerVersionByArn struct {
}

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

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

type validateOpGetLayerVersion struct {
}

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

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

type validateOpGetLayerVersionPolicy struct {
}

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

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

type validateOpGetPolicy struct {
}

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

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

type validateOpGetProvisionedConcurrencyConfig struct {
}

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

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

type validateOpGetRuntimeManagementConfig struct {
}

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

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

type validateOpInvokeAsync struct {
}

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

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

type validateOpInvoke struct {
}

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

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

type validateOpInvokeWithResponseStream struct {
}

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

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

type validateOpListAliases struct {
}

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

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

type validateOpListFunctionEventInvokeConfigs struct {
}

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

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

type validateOpListFunctionsByCodeSigningConfig struct {
}

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

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

type validateOpListFunctionUrlConfigs struct {
}

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

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

type validateOpListLayerVersions struct {
}

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

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

type validateOpListProvisionedConcurrencyConfigs struct {
}

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

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

type validateOpListTags struct {
}

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

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

type validateOpListVersionsByFunction struct {
}

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

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

type validateOpPublishLayerVersion struct {
}

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

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

type validateOpPublishVersion struct {
}

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

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

type validateOpPutFunctionCodeSigningConfig struct {
}

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

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

type validateOpPutFunctionConcurrency struct {
}

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

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

type validateOpPutFunctionEventInvokeConfig struct {
}

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

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

type validateOpPutProvisionedConcurrencyConfig struct {
}

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

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

type validateOpPutRuntimeManagementConfig struct {
}

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

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

type validateOpRemoveLayerVersionPermission struct {
}

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

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

type validateOpRemovePermission struct {
}

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

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

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

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

type validateOpUpdateCodeSigningConfig struct {
}

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

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

type validateOpUpdateEventSourceMapping struct {
}

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

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

type validateOpUpdateFunctionCode struct {
}

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

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

type validateOpUpdateFunctionConfiguration struct {
}

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

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

type validateOpUpdateFunctionEventInvokeConfig struct {
}

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

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

type validateOpUpdateFunctionUrlConfig struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpRemovePermissionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRemovePermission{}, 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 addOpUpdateAliasValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAlias{}, middleware.After)
}

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

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

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

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

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

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

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

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

func validateFileSystemConfig(v *types.FileSystemConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FileSystemConfig"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.LocalMountPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalMountPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAddLayerVersionPermissionInput(v *AddLayerVersionPermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddLayerVersionPermissionInput"}
	if v.LayerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LayerName"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	if v.Action == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddPermissionInput(v *AddPermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddPermissionInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	if v.Action == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateCodeSigningConfigInput(v *CreateCodeSigningConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCodeSigningConfigInput"}
	if v.AllowedPublishers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowedPublishers"))
	} else if v.AllowedPublishers != nil {
		if err := validateAllowedPublishers(v.AllowedPublishers); err != nil {
			invalidParams.AddNested("AllowedPublishers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFunctionInput(v *CreateFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.Code == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Code"))
	}
	if v.FileSystemConfigs != nil {
		if err := validateFileSystemConfigList(v.FileSystemConfigs); err != nil {
			invalidParams.AddNested("FileSystemConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.EphemeralStorage != nil {
		if err := validateEphemeralStorage(v.EphemeralStorage); err != nil {
			invalidParams.AddNested("EphemeralStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFunctionUrlConfigInput(v *CreateFunctionUrlConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFunctionUrlConfigInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if len(v.AuthType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpDeleteProvisionedConcurrencyConfigInput(v *DeleteProvisionedConcurrencyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProvisionedConcurrencyConfigInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Qualifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Qualifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetProvisionedConcurrencyConfigInput(v *GetProvisionedConcurrencyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProvisionedConcurrencyConfigInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Qualifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Qualifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpInvokeAsyncInput(v *InvokeAsyncInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeAsyncInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.InvokeArgs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InvokeArgs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpPublishLayerVersionInput(v *PublishLayerVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PublishLayerVersionInput"}
	if v.LayerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LayerName"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutFunctionCodeSigningConfigInput(v *PutFunctionCodeSigningConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFunctionCodeSigningConfigInput"}
	if v.CodeSigningConfigArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodeSigningConfigArn"))
	}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutFunctionConcurrencyInput(v *PutFunctionConcurrencyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFunctionConcurrencyInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.ReservedConcurrentExecutions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedConcurrentExecutions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutProvisionedConcurrencyConfigInput(v *PutProvisionedConcurrencyConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutProvisionedConcurrencyConfigInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Qualifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Qualifier"))
	}
	if v.ProvisionedConcurrentExecutions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedConcurrentExecutions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRuntimeManagementConfigInput(v *PutRuntimeManagementConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRuntimeManagementConfigInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if len(v.UpdateRuntimeOn) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateRuntimeOn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveLayerVersionPermissionInput(v *RemoveLayerVersionPermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveLayerVersionPermissionInput"}
	if v.LayerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LayerName"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemovePermissionInput(v *RemovePermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemovePermissionInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	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.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	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.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateCodeSigningConfigInput(v *UpdateCodeSigningConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCodeSigningConfigInput"}
	if v.CodeSigningConfigArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodeSigningConfigArn"))
	}
	if v.AllowedPublishers != nil {
		if err := validateAllowedPublishers(v.AllowedPublishers); err != nil {
			invalidParams.AddNested("AllowedPublishers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateFunctionConfigurationInput(v *UpdateFunctionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFunctionConfigurationInput"}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.FileSystemConfigs != nil {
		if err := validateFileSystemConfigList(v.FileSystemConfigs); err != nil {
			invalidParams.AddNested("FileSystemConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.EphemeralStorage != nil {
		if err := validateEphemeralStorage(v.EphemeralStorage); err != nil {
			invalidParams.AddNested("EphemeralStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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