vee

type CheckSemantic int

type Checkable interface {
	Check() error
}

type CheckableValue[T any] interface {
	Checkable
	SetValue(value T) // TODO: consider returning CheckableValue[T]
}

type ContainsConstraint struct {
	Value string
	Str   string
	Any   bool
}

type ContainsPredicateConstraint struct {
	Value        string
	ErrorMessage string
	Predicate    func(rune) bool
}

type EachConstraint[T ~[]E, E any] struct {
	Value      T
	Constraint CheckableValue[E]
}

type ErrField struct {
	FieldName string
	Err       error
}

type ErrList []error

type FieldConstraint[T any] struct {
	Constraint CheckableValue[T]
	FieldName  string
}

type FuncConstraint struct {
	Func func() error
}

type IfConstraint[T any] struct {
	Value      T
	Predicate  func() bool
	Constraint CheckableValue[T]
}

type IfNotBlankConstraint struct {
	Value      string
	Constraint CheckableValue[string]
}

type IfNotNilConstraint[T ~*E, E any] struct {
	Value      T
	Constraint CheckableValue[E]
}

type InConstraint[T comparable] struct {
	Value       T
	ValidValues map[T]bool
}

type LenConstraint[T any] struct {
	Value T
	Min   int
	Max   int
}

type MaxConstraint[T constraints.Ordered] struct {
	Value T
	Max   T
}

type MinConstraint[T constraints.Ordered] struct {
	Value T
	Min   T
}

type NotBlankConstraint struct {
	Value string
}

type NotInConstraint[T comparable] struct {
	Value         T
	InvalidValues map[T]bool
}

type RangeConstraint[T constraints.Ordered] struct {
	Value T
	Min   T
	Max   T
}

type RegexConstraint struct {
	Value string
	Error string
	Regex *regexp.Regexp
}

type RequiredConstraint[T any] struct {
	Value T
}

type SchemaConstraint struct {
	Constraints []Checkable
}

type StrLenConstraint struct {
	Value     string
	MinLength int
	MaxLength int
}

type StrMaxLenConstraint struct {
	Value     string
	MaxLength int
}

type StrMinLenConstraint struct {
	Value     string
	MinLength int
}

type Validatable interface {
	Validate() error
}

type ValueConstraint[T any] struct {
	Value      T
	Constraint CheckableValue[T]
}

type ValueConstraints[T any] struct {
	Value       T
	Constraints []CheckableValue[T]
	Semantic    CheckSemantic
}