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

package amplifyuibuilder

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

type validateOpCreateComponent struct {
}

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

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

type validateOpCreateForm struct {
}

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

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

type validateOpCreateTheme struct {
}

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

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

type validateOpDeleteComponent struct {
}

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

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

type validateOpDeleteForm struct {
}

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

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

type validateOpDeleteTheme struct {
}

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

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

type validateOpExchangeCodeForToken struct {
}

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

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

type validateOpExportComponents struct {
}

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

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

type validateOpExportForms struct {
}

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

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

type validateOpExportThemes struct {
}

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

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

type validateOpGetCodegenJob struct {
}

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

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

type validateOpGetComponent struct {
}

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

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

type validateOpGetForm struct {
}

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

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

type validateOpGetMetadata struct {
}

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

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

type validateOpGetTheme struct {
}

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

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

type validateOpListCodegenJobs struct {
}

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

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

type validateOpListComponents struct {
}

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

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

type validateOpListForms struct {
}

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

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

type validateOpListThemes struct {
}

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

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

type validateOpPutMetadataFlag struct {
}

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

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

type validateOpRefreshToken struct {
}

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

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

type validateOpStartCodegenJob struct {
}

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

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

type validateOpUpdateComponent struct {
}

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

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

type validateOpUpdateForm struct {
}

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

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

type validateOpUpdateTheme struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateActionParameters(v *types.ActionParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActionParameters"}
	if v.Type != nil {
		if err := validateComponentProperty(v.Type); err != nil {
			invalidParams.AddNested("Type", err.(smithy.InvalidParamsError))
		}
	}
	if v.Url != nil {
		if err := validateComponentProperty(v.Url); err != nil {
			invalidParams.AddNested("Url", err.(smithy.InvalidParamsError))
		}
	}
	if v.Anchor != nil {
		if err := validateComponentProperty(v.Anchor); err != nil {
			invalidParams.AddNested("Anchor", err.(smithy.InvalidParamsError))
		}
	}
	if v.Target != nil {
		if err := validateComponentProperty(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if v.Global != nil {
		if err := validateComponentProperty(v.Global); err != nil {
			invalidParams.AddNested("Global", err.(smithy.InvalidParamsError))
		}
	}
	if v.Id != nil {
		if err := validateComponentProperty(v.Id); err != nil {
			invalidParams.AddNested("Id", err.(smithy.InvalidParamsError))
		}
	}
	if v.Fields != nil {
		if err := validateComponentProperties(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if v.State != nil {
		if err := validateMutationActionSetStateParameter(v.State); err != nil {
			invalidParams.AddNested("State", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCodegenGenericDataField(v *types.CodegenGenericDataField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodegenGenericDataField"}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if v.DataTypeValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataTypeValue"))
	}
	if v.Required == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Required"))
	}
	if v.ReadOnly == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReadOnly"))
	}
	if v.IsArray == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsArray"))
	}
	if v.Relationship != nil {
		if err := validateCodegenGenericDataRelationshipType(v.Relationship); err != nil {
			invalidParams.AddNested("Relationship", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCodegenGenericDataModel(v *types.CodegenGenericDataModel) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodegenGenericDataModel"}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateCodegenGenericDataFields(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCodegenGenericDataNonModel(v *types.CodegenGenericDataNonModel) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodegenGenericDataNonModel"}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateCodegenGenericDataNonModelFields(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCodegenJobGenericDataSchema(v *types.CodegenJobGenericDataSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodegenJobGenericDataSchema"}
	if len(v.DataSourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceType"))
	}
	if v.Models == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Models"))
	} else if v.Models != nil {
		if err := validateCodegenGenericDataModels(v.Models); err != nil {
			invalidParams.AddNested("Models", err.(smithy.InvalidParamsError))
		}
	}
	if v.Enums == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enums"))
	} else if v.Enums != nil {
		if err := validateCodegenGenericDataEnums(v.Enums); err != nil {
			invalidParams.AddNested("Enums", err.(smithy.InvalidParamsError))
		}
	}
	if v.NonModels == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NonModels"))
	} else if v.NonModels != nil {
		if err := validateCodegenGenericDataNonModels(v.NonModels); err != nil {
			invalidParams.AddNested("NonModels", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComponentChild(v *types.ComponentChild) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComponentChild"}
	if v.ComponentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComponentType"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Properties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Properties"))
	} else if v.Properties != nil {
		if err := validateComponentProperties(v.Properties); err != nil {
			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Children != nil {
		if err := validateComponentChildList(v.Children); err != nil {
			invalidParams.AddNested("Children", err.(smithy.InvalidParamsError))
		}
	}
	if v.Events != nil {
		if err := validateComponentEvents(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateComponentConditionProperty(v *types.ComponentConditionProperty) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComponentConditionProperty"}
	if v.Then != nil {
		if err := validateComponentProperty(v.Then); err != nil {
			invalidParams.AddNested("Then", err.(smithy.InvalidParamsError))
		}
	}
	if v.Else != nil {
		if err := validateComponentProperty(v.Else); err != nil {
			invalidParams.AddNested("Else", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComponentDataConfiguration(v *types.ComponentDataConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComponentDataConfiguration"}
	if v.Model == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Model"))
	}
	if v.Sort != nil {
		if err := validateSortPropertyList(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComponentEvent(v *types.ComponentEvent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComponentEvent"}
	if v.Parameters != nil {
		if err := validateActionParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateComponentProperty(v *types.ComponentProperty) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComponentProperty"}
	if v.BindingProperties != nil {
		if err := validateComponentPropertyBindingProperties(v.BindingProperties); err != nil {
			invalidParams.AddNested("BindingProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.CollectionBindingProperties != nil {
		if err := validateComponentPropertyBindingProperties(v.CollectionBindingProperties); err != nil {
			invalidParams.AddNested("CollectionBindingProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Bindings != nil {
		if err := validateFormBindings(v.Bindings); err != nil {
			invalidParams.AddNested("Bindings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Concat != nil {
		if err := validateComponentPropertyList(v.Concat); err != nil {
			invalidParams.AddNested("Concat", err.(smithy.InvalidParamsError))
		}
	}
	if v.Condition != nil {
		if err := validateComponentConditionProperty(v.Condition); err != nil {
			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCreateComponentData(v *types.CreateComponentData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateComponentData"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ComponentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComponentType"))
	}
	if v.Properties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Properties"))
	} else if v.Properties != nil {
		if err := validateComponentProperties(v.Properties); err != nil {
			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Children != nil {
		if err := validateComponentChildList(v.Children); err != nil {
			invalidParams.AddNested("Children", err.(smithy.InvalidParamsError))
		}
	}
	if v.Variants == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Variants"))
	}
	if v.Overrides == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Overrides"))
	}
	if v.BindingProperties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BindingProperties"))
	}
	if v.CollectionProperties != nil {
		if err := validateComponentCollectionProperties(v.CollectionProperties); err != nil {
			invalidParams.AddNested("CollectionProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Events != nil {
		if err := validateComponentEvents(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateFormData(v *types.CreateFormData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFormData"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DataType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	} else if v.DataType != nil {
		if err := validateFormDataTypeConfig(v.DataType); err != nil {
			invalidParams.AddNested("DataType", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.FormActionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FormActionType"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateFieldsMap(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if v.Style == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Style"))
	}
	if v.SectionalElements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SectionalElements"))
	} else if v.SectionalElements != nil {
		if err := validateSectionalElementMap(v.SectionalElements); err != nil {
			invalidParams.AddNested("SectionalElements", err.(smithy.InvalidParamsError))
		}
	}
	if v.SchemaVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateExchangeCodeForTokenRequestBody(v *types.ExchangeCodeForTokenRequestBody) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExchangeCodeForTokenRequestBody"}
	if v.Code == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Code"))
	}
	if v.RedirectUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RedirectUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldConfig(v *types.FieldConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldConfig"}
	if v.InputType != nil {
		if err := validateFieldInputConfig(v.InputType); err != nil {
			invalidParams.AddNested("InputType", err.(smithy.InvalidParamsError))
		}
	}
	if v.Validations != nil {
		if err := validateValidationsList(v.Validations); err != nil {
			invalidParams.AddNested("Validations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldInputConfig(v *types.FieldInputConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldInputConfig"}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.ValueMappings != nil {
		if err := validateValueMappings(v.ValueMappings); err != nil {
			invalidParams.AddNested("ValueMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.FileUploaderConfig != nil {
		if err := validateFileUploaderFieldConfig(v.FileUploaderConfig); err != nil {
			invalidParams.AddNested("FileUploaderConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFileUploaderFieldConfig(v *types.FileUploaderFieldConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FileUploaderFieldConfig"}
	if len(v.AccessLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AccessLevel"))
	}
	if v.AcceptedFileTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceptedFileTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFormBindingElement(v *types.FormBindingElement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormBindingElement"}
	if v.Element == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Element"))
	}
	if v.Property == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Property"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFormDataTypeConfig(v *types.FormDataTypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormDataTypeConfig"}
	if len(v.DataSourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceType"))
	}
	if v.DataTypeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataTypeName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFormInputValueProperty(v *types.FormInputValueProperty) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormInputValueProperty"}
	if v.BindingProperties != nil {
		if err := validateFormInputValuePropertyBindingProperties(v.BindingProperties); err != nil {
			invalidParams.AddNested("BindingProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Concat != nil {
		if err := validateFormInputValuePropertyList(v.Concat); err != nil {
			invalidParams.AddNested("Concat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMutationActionSetStateParameter(v *types.MutationActionSetStateParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MutationActionSetStateParameter"}
	if v.ComponentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComponentName"))
	}
	if v.Property == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Property"))
	}
	if v.Set == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Set"))
	} else if v.Set != nil {
		if err := validateComponentProperty(v.Set); err != nil {
			invalidParams.AddNested("Set", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateSortProperty(v *types.SortProperty) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SortProperty"}
	if v.Field == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Field"))
	}
	if len(v.Direction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Direction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStartCodegenJobData(v *types.StartCodegenJobData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCodegenJobData"}
	if v.RenderConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RenderConfig"))
	}
	if v.GenericDataSchema != nil {
		if err := validateCodegenJobGenericDataSchema(v.GenericDataSchema); err != nil {
			invalidParams.AddNested("GenericDataSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateComponentData(v *types.UpdateComponentData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateComponentData"}
	if v.Properties != nil {
		if err := validateComponentProperties(v.Properties); err != nil {
			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Children != nil {
		if err := validateComponentChildList(v.Children); err != nil {
			invalidParams.AddNested("Children", err.(smithy.InvalidParamsError))
		}
	}
	if v.CollectionProperties != nil {
		if err := validateComponentCollectionProperties(v.CollectionProperties); err != nil {
			invalidParams.AddNested("CollectionProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Events != nil {
		if err := validateComponentEvents(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateFormData(v *types.UpdateFormData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFormData"}
	if v.DataType != nil {
		if err := validateFormDataTypeConfig(v.DataType); err != nil {
			invalidParams.AddNested("DataType", err.(smithy.InvalidParamsError))
		}
	}
	if v.Fields != nil {
		if err := validateFieldsMap(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if v.SectionalElements != nil {
		if err := validateSectionalElementMap(v.SectionalElements); err != nil {
			invalidParams.AddNested("SectionalElements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateValueMapping(v *types.ValueMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ValueMapping"}
	if v.DisplayValue != nil {
		if err := validateFormInputValueProperty(v.DisplayValue); err != nil {
			invalidParams.AddNested("DisplayValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	} else if v.Value != nil {
		if err := validateFormInputValueProperty(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateValueMappings(v *types.ValueMappings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ValueMappings"}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	} else if v.Values != nil {
		if err := validateValueMappingList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateComponentInput(v *CreateComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateComponentInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.ComponentToCreate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComponentToCreate"))
	} else if v.ComponentToCreate != nil {
		if err := validateCreateComponentData(v.ComponentToCreate); err != nil {
			invalidParams.AddNested("ComponentToCreate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFormInput(v *CreateFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFormInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.FormToCreate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormToCreate"))
	} else if v.FormToCreate != nil {
		if err := validateCreateFormData(v.FormToCreate); err != nil {
			invalidParams.AddNested("FormToCreate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateThemeInput(v *CreateThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateThemeInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.ThemeToCreate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeToCreate"))
	} else if v.ThemeToCreate != nil {
		if err := validateCreateThemeData(v.ThemeToCreate); err != nil {
			invalidParams.AddNested("ThemeToCreate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteComponentInput(v *DeleteComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteComponentInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFormInput(v *DeleteFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFormInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteThemeInput(v *DeleteThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteThemeInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExchangeCodeForTokenInput(v *ExchangeCodeForTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExchangeCodeForTokenInput"}
	if len(v.Provider) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Provider"))
	}
	if v.Request == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Request"))
	} else if v.Request != nil {
		if err := validateExchangeCodeForTokenRequestBody(v.Request); err != nil {
			invalidParams.AddNested("Request", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportComponentsInput(v *ExportComponentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportComponentsInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportFormsInput(v *ExportFormsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportFormsInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportThemesInput(v *ExportThemesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportThemesInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCodegenJobInput(v *GetCodegenJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCodegenJobInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetComponentInput(v *GetComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetComponentInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFormInput(v *GetFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFormInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMetadataInput(v *GetMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMetadataInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetThemeInput(v *GetThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetThemeInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCodegenJobsInput(v *ListCodegenJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCodegenJobsInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListComponentsInput(v *ListComponentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListComponentsInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListFormsInput(v *ListFormsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFormsInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListThemesInput(v *ListThemesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListThemesInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutMetadataFlagInput(v *PutMetadataFlagInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutMetadataFlagInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.FeatureName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureName"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	} else if v.Body != nil {
		if err := validatePutMetadataFlagBody(v.Body); err != nil {
			invalidParams.AddNested("Body", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRefreshTokenInput(v *RefreshTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RefreshTokenInput"}
	if len(v.Provider) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Provider"))
	}
	if v.RefreshTokenBody == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshTokenBody"))
	} else if v.RefreshTokenBody != nil {
		if err := validateRefreshTokenRequestBody(v.RefreshTokenBody); err != nil {
			invalidParams.AddNested("RefreshTokenBody", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartCodegenJobInput(v *StartCodegenJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCodegenJobInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.CodegenJobToCreate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodegenJobToCreate"))
	} else if v.CodegenJobToCreate != nil {
		if err := validateStartCodegenJobData(v.CodegenJobToCreate); err != nil {
			invalidParams.AddNested("CodegenJobToCreate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateComponentInput(v *UpdateComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateComponentInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.UpdatedComponent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdatedComponent"))
	} else if v.UpdatedComponent != nil {
		if err := validateUpdateComponentData(v.UpdatedComponent); err != nil {
			invalidParams.AddNested("UpdatedComponent", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFormInput(v *UpdateFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFormInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.UpdatedForm == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdatedForm"))
	} else if v.UpdatedForm != nil {
		if err := validateUpdateFormData(v.UpdatedForm); err != nil {
			invalidParams.AddNested("UpdatedForm", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateThemeInput(v *UpdateThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemeInput"}
	if v.AppId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
	}
	if v.EnvironmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.UpdatedTheme == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdatedTheme"))
	} else if v.UpdatedTheme != nil {
		if err := validateUpdateThemeData(v.UpdatedTheme); err != nil {
			invalidParams.AddNested("UpdatedTheme", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}