validators.go

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

package wellarchitected

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

type validateOpAssociateLenses struct {
}

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

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

type validateOpAssociateProfiles struct {
}

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

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

type validateOpCreateLensShare struct {
}

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

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

type validateOpCreateLensVersion struct {
}

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

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

type validateOpCreateMilestone struct {
}

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

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

type validateOpCreateProfile struct {
}

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

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

type validateOpCreateProfileShare struct {
}

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

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

type validateOpCreateReviewTemplate struct {
}

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

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

type validateOpCreateTemplateShare struct {
}

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

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

type validateOpCreateWorkload struct {
}

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

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

type validateOpCreateWorkloadShare struct {
}

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

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

type validateOpDeleteLens struct {
}

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

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

type validateOpDeleteLensShare struct {
}

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

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

type validateOpDeleteProfile struct {
}

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

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

type validateOpDeleteProfileShare struct {
}

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

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

type validateOpDeleteReviewTemplate struct {
}

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

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

type validateOpDeleteTemplateShare struct {
}

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

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

type validateOpDeleteWorkload struct {
}

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

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

type validateOpDeleteWorkloadShare struct {
}

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

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

type validateOpDisassociateLenses struct {
}

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

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

type validateOpDisassociateProfiles struct {
}

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

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

type validateOpExportLens struct {
}

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

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

type validateOpGetAnswer struct {
}

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

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

type validateOpGetConsolidatedReport struct {
}

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

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

type validateOpGetLens struct {
}

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

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

type validateOpGetLensReview struct {
}

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

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

type validateOpGetLensReviewReport struct {
}

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

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

type validateOpGetLensVersionDifference struct {
}

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

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

type validateOpGetMilestone struct {
}

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

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

type validateOpGetProfile struct {
}

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

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

type validateOpGetReviewTemplateAnswer struct {
}

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

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

type validateOpGetReviewTemplate struct {
}

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

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

type validateOpGetReviewTemplateLensReview struct {
}

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

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

type validateOpGetWorkload struct {
}

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

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

type validateOpImportLens struct {
}

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

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

type validateOpListAnswers struct {
}

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

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

type validateOpListCheckDetails struct {
}

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

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

type validateOpListCheckSummaries struct {
}

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

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

type validateOpListLensReviewImprovements struct {
}

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

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

type validateOpListLensReviews struct {
}

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

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

type validateOpListLensShares struct {
}

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

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

type validateOpListMilestones struct {
}

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

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

type validateOpListProfileShares struct {
}

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

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

type validateOpListReviewTemplateAnswers struct {
}

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

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

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

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

type validateOpListWorkloadShares struct {
}

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

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

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

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

type validateOpUpdateLensReview struct {
}

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

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

type validateOpUpdateProfile struct {
}

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

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

type validateOpUpdateReviewTemplateAnswer struct {
}

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

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

type validateOpUpdateReviewTemplate struct {
}

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

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

type validateOpUpdateReviewTemplateLensReview struct {
}

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

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

type validateOpUpdateShareInvitation struct {
}

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

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

type validateOpUpdateWorkload struct {
}

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

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

type validateOpUpdateWorkloadShare struct {
}

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

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

type validateOpUpgradeLensReview struct {
}

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

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

type validateOpUpgradeProfileVersion struct {
}

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

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

type validateOpUpgradeReviewTemplateLensReview struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListWorkloadSharesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListWorkloadShares{}, 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 addOpUpdateAnswerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAnswer{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpAssociateLensesInput(v *AssociateLensesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateLensesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAliases == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAliases"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateProfilesInput(v *AssociateProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateProfilesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.ProfileArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLensShareInput(v *CreateLensShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLensShareInput"}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.SharedWith == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SharedWith"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLensVersionInput(v *CreateLensVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLensVersionInput"}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.LensVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensVersion"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMilestoneInput(v *CreateMilestoneInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMilestoneInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.MilestoneName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MilestoneName"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProfileInput(v *CreateProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProfileInput"}
	if v.ProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileName"))
	}
	if v.ProfileDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileDescription"))
	}
	if v.ProfileQuestions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileQuestions"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProfileShareInput(v *CreateProfileShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProfileShareInput"}
	if v.ProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArn"))
	}
	if v.SharedWith == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SharedWith"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReviewTemplateInput(v *CreateReviewTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReviewTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.Lenses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Lenses"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateShareInput(v *CreateTemplateShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateShareInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.SharedWith == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SharedWith"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorkloadInput(v *CreateWorkloadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkloadInput"}
	if v.WorkloadName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadName"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if len(v.Environment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if v.Lenses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Lenses"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorkloadShareInput(v *CreateWorkloadShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkloadShareInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.SharedWith == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SharedWith"))
	}
	if len(v.PermissionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionType"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLensInput(v *DeleteLensInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLensInput"}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if len(v.LensStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LensStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLensShareInput(v *DeleteLensShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLensShareInput"}
	if v.ShareId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteProfileInput(v *DeleteProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProfileInput"}
	if v.ProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArn"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteProfileShareInput(v *DeleteProfileShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProfileShareInput"}
	if v.ShareId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareId"))
	}
	if v.ProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArn"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteReviewTemplateInput(v *DeleteReviewTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteReviewTemplateInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTemplateShareInput(v *DeleteTemplateShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateShareInput"}
	if v.ShareId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareId"))
	}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteWorkloadInput(v *DeleteWorkloadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkloadInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteWorkloadShareInput(v *DeleteWorkloadShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkloadShareInput"}
	if v.ShareId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareId"))
	}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateLensesInput(v *DisassociateLensesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateLensesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAliases == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAliases"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateProfilesInput(v *DisassociateProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateProfilesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.ProfileArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetAnswerInput(v *GetAnswerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAnswerInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConsolidatedReportInput(v *GetConsolidatedReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConsolidatedReportInput"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetLensReviewInput(v *GetLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLensReviewInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLensReviewReportInput(v *GetLensReviewReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLensReviewReportInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMilestoneInput(v *GetMilestoneInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMilestoneInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.MilestoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MilestoneNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetReviewTemplateAnswerInput(v *GetReviewTemplateAnswerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReviewTemplateAnswerInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetReviewTemplateLensReviewInput(v *GetReviewTemplateLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReviewTemplateLensReviewInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpImportLensInput(v *ImportLensInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportLensInput"}
	if v.JSONString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JSONString"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAnswersInput(v *ListAnswersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAnswersInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCheckDetailsInput(v *ListCheckDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCheckDetailsInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensArn"))
	}
	if v.PillarId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PillarId"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if v.ChoiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChoiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCheckSummariesInput(v *ListCheckSummariesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCheckSummariesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensArn"))
	}
	if v.PillarId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PillarId"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if v.ChoiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChoiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListLensReviewImprovementsInput(v *ListLensReviewImprovementsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLensReviewImprovementsInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListReviewTemplateAnswersInput(v *ListReviewTemplateAnswersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListReviewTemplateAnswersInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	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.WorkloadArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListWorkloadSharesInput(v *ListWorkloadSharesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkloadSharesInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	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.WorkloadArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadArn"))
	}
	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.WorkloadArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadArn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAnswerInput(v *UpdateAnswerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnswerInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if v.ChoiceUpdates != nil {
		if err := validateChoiceUpdates(v.ChoiceUpdates); err != nil {
			invalidParams.AddNested("ChoiceUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLensReviewInput(v *UpdateLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLensReviewInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateReviewTemplateAnswerInput(v *UpdateReviewTemplateAnswerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReviewTemplateAnswerInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.QuestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionId"))
	}
	if v.ChoiceUpdates != nil {
		if err := validateChoiceUpdates(v.ChoiceUpdates); err != nil {
			invalidParams.AddNested("ChoiceUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateReviewTemplateLensReviewInput(v *UpdateReviewTemplateLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReviewTemplateLensReviewInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateShareInvitationInput(v *UpdateShareInvitationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateShareInvitationInput"}
	if v.ShareInvitationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareInvitationId"))
	}
	if len(v.ShareInvitationAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ShareInvitationAction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateWorkloadShareInput(v *UpdateWorkloadShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkloadShareInput"}
	if v.ShareId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareId"))
	}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if len(v.PermissionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpgradeLensReviewInput(v *UpgradeLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpgradeLensReviewInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if v.MilestoneName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MilestoneName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpgradeProfileVersionInput(v *UpgradeProfileVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpgradeProfileVersionInput"}
	if v.WorkloadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadId"))
	}
	if v.ProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpgradeReviewTemplateLensReviewInput(v *UpgradeReviewTemplateLensReviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpgradeReviewTemplateLensReviewInput"}
	if v.TemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateArn"))
	}
	if v.LensAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LensAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}