ndlvr

type ArgumentParser interface {
	// Parses length from argument given.
	ParseLen(ctx context.Context, arg interface{}) (sz int, err error)
	ParsePrimitiveValue(ctx context.Context, arg interface{}) (pv *value.PrimitiveValue, err error)
	ParseListValue(ctx context.Context, arg interface{}) (lv value.ListValue, err error)

	ParseRulesSource(ctx context.Context, arg interface{}) (rules RulesSource, err error)
	ParseTopRulesSource(ctx context.Context, arg interface{}) (rules TopRulesSource, err error)
}

type DefaultArgumentParser struct{}

type DefaultValidator struct {
	Engine  Engine        // Required
	Wrapper value.Wrapper // Defaults to DefaultWrapper
}

type Engine interface {
	Validate(ctx context.Context, parentValue value.Value) (err error)
}

type ErrorBag struct {
	Errors []error
}

type Options struct {
	ValidationFactory ValidationFactory
}

type Parser struct{}

type RuleData struct {
	ValidationName     string
	ValidationArgument interface{}
}

type RuleParseError struct {
	Rule interface{}
}

type RuleReceiver = func(rd RuleData) (err error)

type RulesMap map[string]interface{}

type RulesSource interface {
	GetRules(recv func(rawRule interface{}) (err error)) (err error)
}

type SliceRules []interface{}

type TopLevelRuleData struct {
	FieldName string
	RuleData
}

type TopLevelRuleReceiver = func(rd TopLevelRuleData) (err error)

type TopRulesSource interface {
	// Note: each key may be yielded only once.
	GetRules(recv func(fieldName string, rawRule interface{}) (err error)) (err error)
}

type Validation interface {
	// Note: validate MUST NOT modify value.
	Validate(ctx context.Context, parentValue value.Value) (err error)
}

type ValidationAsFactory func(bctx ValidationBuildContext, value value.Value) (err error)

type ValidationBuildContext struct {
	Ctx context.Context

	Options *Options
	Parser  *Parser

	OPs            value.OPs
	ArgumentParser ArgumentParser

	Data ValidationBuildData
}

type ValidationBuildData struct {
	Target ValidationTarget

	ValidationName string
	Argument       interface{}
}

type ValidationCreateError struct {
	Msg string
}

type ValidationFactory interface {
	BuildValidation(bctx ValidationBuildContext) (val Validation, err error)
}

type ValidationFactoryFunc func(bctx ValidationBuildContext) (val Validation, err error)

type ValidationFactoryRegistry map[string]ValidationFactory

type ValidationFunc func(ctx context.Context, parentValue value.Value) (err error)

type ValidationNameMismatchError struct {
	Name         string
	ExpectedName string
}

type ValidationNotSupportedError struct {
	Name string
}

type ValidationTarget struct {
	FunctionalTarget func(v value.Value, recv func(child value.Value) (err error)) (err error)
	IsOrphanValue    bool   // ignored when FunctionalTarget
	IsListValue      bool   // ignored when FunctionalTarget or IsOrphanValue is set
	FieldName        string // ignored when FunctionalTarget or IsOrphanValue or IsListValue is set
}

type Validator interface {
	Validate(ctx context.Context, val interface{}) (err error)
}