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

package connectcases

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

type validateOpBatchGetField struct {
}

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

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

type validateOpBatchPutFieldOptions struct {
}

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

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

type validateOpCreateCase struct {
}

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

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

type validateOpCreateDomain struct {
}

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

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

type validateOpCreateField struct {
}

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

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

type validateOpCreateLayout struct {
}

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

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

type validateOpCreateRelatedItem struct {
}

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

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

type validateOpCreateTemplate struct {
}

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

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

type validateOpDeleteDomain struct {
}

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

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

type validateOpGetCaseEventConfiguration struct {
}

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

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

type validateOpGetCase struct {
}

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

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

type validateOpGetDomain struct {
}

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

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

type validateOpGetLayout struct {
}

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

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

type validateOpGetTemplate struct {
}

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

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

type validateOpListCasesForContact struct {
}

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

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

type validateOpListFieldOptions struct {
}

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

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

type validateOpListFields struct {
}

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

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

type validateOpListLayouts struct {
}

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

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

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

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

type validateOpPutCaseEventConfiguration struct {
}

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

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

type validateOpSearchCases struct {
}

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

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

type validateOpSearchRelatedItems struct {
}

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

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

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

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

type validateOpUpdateField struct {
}

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

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

type validateOpUpdateLayout struct {
}

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

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

type validateOpUpdateTemplate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSearchRelatedItemsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchRelatedItems{}, 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 addOpUpdateCaseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCase{}, middleware.After)
}

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

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

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

func validateBasicLayout(v *types.BasicLayout) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BasicLayout"}
	if v.TopPanel != nil {
		if err := validateLayoutSections(v.TopPanel); err != nil {
			invalidParams.AddNested("TopPanel", err.(smithy.InvalidParamsError))
		}
	}
	if v.MoreInfo != nil {
		if err := validateLayoutSections(v.MoreInfo); err != nil {
			invalidParams.AddNested("MoreInfo", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCaseFilter(v types.CaseFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaseFilter"}
	switch uv := v.(type) {
	case *types.CaseFilterMemberAndAll:
		if err := validateCaseFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[andAll]", err.(smithy.InvalidParamsError))
		}

	case *types.CaseFilterMemberField:
		if err := validateFieldFilter(uv.Value); err != nil {
			invalidParams.AddNested("[field]", err.(smithy.InvalidParamsError))
		}

	case *types.CaseFilterMemberNot:
		if err := validateCaseFilter(uv.Value); err != nil {
			invalidParams.AddNested("[not]", err.(smithy.InvalidParamsError))
		}

	case *types.CaseFilterMemberOrAll:
		if err := validateCaseFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[orAll]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCommentContent(v *types.CommentContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CommentContent"}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if len(v.ContentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEventBridgeConfiguration(v *types.EventBridgeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventBridgeConfiguration"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if v.IncludedData != nil {
		if err := validateEventIncludedData(v.IncludedData); err != nil {
			invalidParams.AddNested("IncludedData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventIncludedData(v *types.EventIncludedData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventIncludedData"}
	if v.CaseData != nil {
		if err := validateCaseEventIncludedData(v.CaseData); err != nil {
			invalidParams.AddNested("CaseData", err.(smithy.InvalidParamsError))
		}
	}
	if v.RelatedItemData != nil {
		if err := validateRelatedItemEventIncludedData(v.RelatedItemData); err != nil {
			invalidParams.AddNested("RelatedItemData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldFilter(v types.FieldFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldFilter"}
	switch uv := v.(type) {
	case *types.FieldFilterMemberContains:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[contains]", err.(smithy.InvalidParamsError))
		}

	case *types.FieldFilterMemberEqualTo:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[equalTo]", err.(smithy.InvalidParamsError))
		}

	case *types.FieldFilterMemberGreaterThan:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[greaterThan]", err.(smithy.InvalidParamsError))
		}

	case *types.FieldFilterMemberGreaterThanOrEqualTo:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[greaterThanOrEqualTo]", err.(smithy.InvalidParamsError))
		}

	case *types.FieldFilterMemberLessThan:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[lessThan]", err.(smithy.InvalidParamsError))
		}

	case *types.FieldFilterMemberLessThanOrEqualTo:
		if err := validateFieldValue(&uv.Value); err != nil {
			invalidParams.AddNested("[lessThanOrEqualTo]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateLayoutContent(v types.LayoutContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LayoutContent"}
	switch uv := v.(type) {
	case *types.LayoutContentMemberBasic:
		if err := validateBasicLayout(&uv.Value); err != nil {
			invalidParams.AddNested("[basic]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLayoutSections(v *types.LayoutSections) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LayoutSections"}
	if v.Sections != nil {
		if err := validateSectionsList(v.Sections); err != nil {
			invalidParams.AddNested("Sections", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRelatedItemInputContent(v types.RelatedItemInputContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelatedItemInputContent"}
	switch uv := v.(type) {
	case *types.RelatedItemInputContentMemberComment:
		if err := validateCommentContent(&uv.Value); err != nil {
			invalidParams.AddNested("[comment]", err.(smithy.InvalidParamsError))
		}

	case *types.RelatedItemInputContentMemberContact:
		if err := validateContact(&uv.Value); err != nil {
			invalidParams.AddNested("[contact]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSection(v types.Section) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Section"}
	switch uv := v.(type) {
	case *types.SectionMemberFieldGroup:
		if err := validateFieldGroup(&uv.Value); err != nil {
			invalidParams.AddNested("[fieldGroup]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSort(v *types.Sort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Sort"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if len(v.SortOrder) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SortOrder"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchGetFieldInput(v *BatchGetFieldInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetFieldInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateBatchGetFieldIdentifierList(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchPutFieldOptionsInput(v *BatchPutFieldOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutFieldOptionsInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Options == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Options"))
	} else if v.Options != nil {
		if err := validateFieldOptionsList(v.Options); err != nil {
			invalidParams.AddNested("Options", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCaseInput(v *CreateCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCaseInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateFieldValueList(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFieldInput(v *CreateFieldInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFieldInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLayoutInput(v *CreateLayoutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLayoutInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateLayoutContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRelatedItemInput(v *CreateRelatedItemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRelatedItemInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.CaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaseId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateRelatedItemInputContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateInput(v *CreateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RequiredFields != nil {
		if err := validateRequiredFieldList(v.RequiredFields); err != nil {
			invalidParams.AddNested("RequiredFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetCaseInput(v *GetCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCaseInput"}
	if v.CaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaseId"))
	}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateFieldIdentifierList(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetLayoutInput(v *GetLayoutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLayoutInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.LayoutId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LayoutId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTemplateInput(v *GetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTemplateInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCasesForContactInput(v *ListCasesForContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCasesForContactInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.ContactArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListFieldOptionsInput(v *ListFieldOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFieldOptionsInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListLayoutsInput(v *ListLayoutsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLayoutsInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutCaseEventConfigurationInput(v *PutCaseEventConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutCaseEventConfigurationInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.EventBridge == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventBridge"))
	} else if v.EventBridge != nil {
		if err := validateEventBridgeConfiguration(v.EventBridge); err != nil {
			invalidParams.AddNested("EventBridge", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchCasesInput(v *SearchCasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchCasesInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.Filter != nil {
		if err := validateCaseFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sorts != nil {
		if err := validateSortList(v.Sorts); err != nil {
			invalidParams.AddNested("Sorts", err.(smithy.InvalidParamsError))
		}
	}
	if v.Fields != nil {
		if err := validateFieldIdentifierList(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchRelatedItemsInput(v *SearchRelatedItemsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchRelatedItemsInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.CaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaseId"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCaseInput(v *UpdateCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCaseInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.CaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaseId"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateFieldValueList(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFieldInput(v *UpdateFieldInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFieldInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLayoutInput(v *UpdateLayoutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLayoutInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.LayoutId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LayoutId"))
	}
	if v.Content != nil {
		if err := validateLayoutContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTemplateInput(v *UpdateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.RequiredFields != nil {
		if err := validateRequiredFieldList(v.RequiredFields); err != nil {
			invalidParams.AddNested("RequiredFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}