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

package evidently

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

type validateOpBatchEvaluateFeature struct {
}

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

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

type validateOpCreateExperiment struct {
}

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

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

type validateOpCreateFeature struct {
}

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

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

type validateOpCreateLaunch struct {
}

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

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

type validateOpCreateProject struct {
}

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

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

type validateOpCreateSegment struct {
}

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

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

type validateOpDeleteExperiment struct {
}

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

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

type validateOpDeleteFeature struct {
}

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

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

type validateOpDeleteLaunch struct {
}

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

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

type validateOpDeleteProject struct {
}

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

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

type validateOpDeleteSegment struct {
}

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

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

type validateOpEvaluateFeature struct {
}

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

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

type validateOpGetExperiment struct {
}

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

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

type validateOpGetExperimentResults struct {
}

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

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

type validateOpGetFeature struct {
}

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

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

type validateOpGetLaunch struct {
}

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

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

type validateOpGetProject struct {
}

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

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

type validateOpGetSegment struct {
}

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

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

type validateOpListExperiments struct {
}

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

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

type validateOpListFeatures struct {
}

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

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

type validateOpListLaunches struct {
}

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

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

type validateOpListSegmentReferences struct {
}

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

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

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

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

type validateOpStartExperiment struct {
}

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

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

type validateOpStartLaunch struct {
}

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

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

type validateOpStopExperiment struct {
}

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

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

type validateOpStopLaunch struct {
}

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

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

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

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

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

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

type validateOpUpdateFeature struct {
}

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

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

type validateOpUpdateLaunch struct {
}

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

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

type validateOpUpdateProjectDataDelivery struct {
}

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

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

type validateOpUpdateProject struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateEvaluationRequest(v *types.EvaluationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationRequest"}
	if v.Feature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if v.EntityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateMetricGoalConfig(v *types.MetricGoalConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricGoalConfig"}
	if v.MetricDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricDefinition"))
	} else if v.MetricDefinition != nil {
		if err := validateMetricDefinitionConfig(v.MetricDefinition); err != nil {
			invalidParams.AddNested("MetricDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricMonitorConfig(v *types.MetricMonitorConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricMonitorConfig"}
	if v.MetricDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricDefinition"))
	} else if v.MetricDefinition != nil {
		if err := validateMetricDefinitionConfig(v.MetricDefinition); err != nil {
			invalidParams.AddNested("MetricDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScheduledSplitConfig(v *types.ScheduledSplitConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduledSplitConfig"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.GroupWeights == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupWeights"))
	}
	if v.SegmentOverrides != nil {
		if err := validateSegmentOverridesList(v.SegmentOverrides); err != nil {
			invalidParams.AddNested("SegmentOverrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScheduledSplitsLaunchConfig(v *types.ScheduledSplitsLaunchConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduledSplitsLaunchConfig"}
	if v.Steps == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Steps"))
	} else if v.Steps != nil {
		if err := validateScheduledSplitConfigList(v.Steps); err != nil {
			invalidParams.AddNested("Steps", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentOverride(v *types.SegmentOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentOverride"}
	if v.Segment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Segment"))
	}
	if v.EvaluationOrder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationOrder"))
	}
	if v.Weights == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Weights"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpBatchEvaluateFeatureInput(v *BatchEvaluateFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchEvaluateFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Requests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Requests"))
	} else if v.Requests != nil {
		if err := validateEvaluationRequestsList(v.Requests); err != nil {
			invalidParams.AddNested("Requests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateExperimentInput(v *CreateExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Treatments == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Treatments"))
	} else if v.Treatments != nil {
		if err := validateTreatmentConfigList(v.Treatments); err != nil {
			invalidParams.AddNested("Treatments", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricGoals == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricGoals"))
	} else if v.MetricGoals != nil {
		if err := validateMetricGoalConfigList(v.MetricGoals); err != nil {
			invalidParams.AddNested("MetricGoals", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFeatureInput(v *CreateFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Variations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Variations"))
	} else if v.Variations != nil {
		if err := validateVariationConfigsList(v.Variations); err != nil {
			invalidParams.AddNested("Variations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLaunchInput(v *CreateLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ScheduledSplitsConfig != nil {
		if err := validateScheduledSplitsLaunchConfig(v.ScheduledSplitsConfig); err != nil {
			invalidParams.AddNested("ScheduledSplitsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricMonitors != nil {
		if err := validateMetricMonitorConfigList(v.MetricMonitors); err != nil {
			invalidParams.AddNested("MetricMonitors", err.(smithy.InvalidParamsError))
		}
	}
	if v.Groups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Groups"))
	} else if v.Groups != nil {
		if err := validateLaunchGroupConfigList(v.Groups); err != nil {
			invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteExperimentInput(v *DeleteExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFeatureInput(v *DeleteFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Feature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLaunchInput(v *DeleteLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Launch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Launch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpEvaluateFeatureInput(v *EvaluateFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluateFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Feature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if v.EntityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetExperimentInput(v *GetExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetExperimentResultsInput(v *GetExperimentResultsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetExperimentResultsInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if v.MetricNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricNames"))
	}
	if v.TreatmentNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TreatmentNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFeatureInput(v *GetFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Feature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLaunchInput(v *GetLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Launch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Launch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpListSegmentReferencesInput(v *ListSegmentReferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSegmentReferencesInput"}
	if v.Segment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Segment"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	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 validateOpPutProjectEventsInput(v *PutProjectEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutProjectEventsInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Events == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Events"))
	} else if v.Events != nil {
		if err := validateEventList(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartExperimentInput(v *StartExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if v.AnalysisCompleteTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisCompleteTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartLaunchInput(v *StartLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Launch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Launch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopExperimentInput(v *StopExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopLaunchInput(v *StopLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Launch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Launch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpTestSegmentPatternInput(v *TestSegmentPatternInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSegmentPatternInput"}
	if v.Pattern == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Pattern"))
	}
	if v.Payload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
	}
	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 validateOpUpdateExperimentInput(v *UpdateExperimentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateExperimentInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Experiment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Experiment"))
	}
	if v.Treatments != nil {
		if err := validateTreatmentConfigList(v.Treatments); err != nil {
			invalidParams.AddNested("Treatments", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricGoals != nil {
		if err := validateMetricGoalConfigList(v.MetricGoals); err != nil {
			invalidParams.AddNested("MetricGoals", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFeatureInput(v *UpdateFeatureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFeatureInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Feature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if v.AddOrUpdateVariations != nil {
		if err := validateVariationConfigsList(v.AddOrUpdateVariations); err != nil {
			invalidParams.AddNested("AddOrUpdateVariations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLaunchInput(v *UpdateLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLaunchInput"}
	if v.Project == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Project"))
	}
	if v.Launch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Launch"))
	}
	if v.Groups != nil {
		if err := validateLaunchGroupConfigList(v.Groups); err != nil {
			invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricMonitors != nil {
		if err := validateMetricMonitorConfigList(v.MetricMonitors); err != nil {
			invalidParams.AddNested("MetricMonitors", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScheduledSplitsConfig != nil {
		if err := validateScheduledSplitsLaunchConfig(v.ScheduledSplitsConfig); err != nil {
			invalidParams.AddNested("ScheduledSplitsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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