validate

type And ¶

type And[T any, A Validator[T], B Validator[T]] struct{}

And is a meta validator that combines other validators with AND operator. Validators are called in the same order as specified by type parameters.

See also Or, Not

func (And[T, A, B]) Validate(value T) error

type Any ¶

type Any[T any] struct{}

Any accepts any value of T.

func (Any[T]) Validate(T) error

type Base64 ¶

type Base64[T constraint.Text] struct{}

Base64 accepts valid base64 encoded strings.

func (Base64[T]) Validate(value T) error

type CIDR ¶

type CIDR[T constraint.Text] struct{}

CIDR accepts CIDR notation IP address and prefix length, like "192.0.2.0/24" or "2001:db8::/32", as defined in RFC 4632 and RFC 4291.

func (CIDR[T]) Validate(value T) error

type Charset ¶

type Charset[T constraint.Text, F charset.Filter] struct{}

Charset accepts non-empty text which contains only runes acceptable by filter.

See also Charset0

func (Charset[T, F]) Validate(value T) error

type Charset0 ¶

type Charset0[T constraint.Text, F charset.Filter] struct{}

Charset0 accepts (possibly empty) text which contains only runes acceptable by filter.

See Charset for a non-empty variant.

func (Charset0[T, F]) Validate(value T) error

type CountryAlpha ¶

type CountryAlpha[T constraint.Text] struct {
	Or[T, CountryAlpha2[T], CountryAlpha3[T]]
}

CountryAlpha2 accepts either CountryAlpha2 or CountryAlpha3

type CountryAlpha2 ¶

type CountryAlpha2[T constraint.Text] struct{}

CountryAlpha2 accepts case-insensitive ISO 3166 2-letter country code

func (CountryAlpha2[T]) Validate(value T) error

type CountryAlpha3 ¶

type CountryAlpha3[T constraint.Text] struct{}

CountryAlpha2 accepts case-insensitive ISO 3166 3-letter country code

func (CountryAlpha3[T]) Validate(value T) error

type CurrencyAlpha ¶

type CurrencyAlpha[T constraint.Text] struct{}

CurrencyAlpha accepts case-insensitive ISO 4217 alphabetic currency code

func (CurrencyAlpha[T]) Validate(value T) error

type Email ¶

type Email[T constraint.Text] struct{}

Email accepts a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>".

func (Email[T]) Validate(value T) error

type Even ¶

type Even[T constraint.Integer] struct{}

Even accepts integers divisible by two.

func (Even[T]) Validate(value T) error

type HTTPURL ¶

type HTTPURL[T constraint.Text] struct{}

HTTPURL accepts a single http(s) url.

See also URL.

func (HTTPURL[T]) Validate(value T) error

type IP ¶

type IP[T constraint.Text] struct{}

IP accepts an IP address. The address can be in dotted decimal ("192.0.2.1"), IPv6 ("2001:db8::68"), or IPv6 with a scoped addressing zone ("fe80::1cc0:3e8c:119f:c2e1%ens18").

func (IP[T]) Validate(value T) error

type IPV4 ¶

type IPV4[T constraint.Text] struct{}

IP accepts an IP V4 address (e.g. "192.0.2.1").

func (IPV4[T]) Validate(value T) error

type IPV6 ¶

type IPV6[T constraint.Text] struct{}

IP accepts an IP V6 address, including IPv4-mapped IPv6 addresses. The address can be regular IPv6 ("2001:db8::68"), or IPv6 with a scoped addressing zone ("fe80::1cc0:3e8c:119f:c2e1%ens18").

func (IPV6[T]) Validate(value T) error

type InFuture ¶

type InFuture[T constraint.Time] struct{}

InFuture accepts any time after current timestamp

See also InPast

func (InFuture[T]) Validate(value T) error

type InPast ¶

type InPast[T constraint.Time] struct{}

InPast accepts any time before current timestamp

See also InFuture

func (InPast[T]) Validate(value T) error

type InvalidValidateError ¶

type InvalidValidateError struct {
	Type reflect.Type
}

InvalidValidateError describes an invalid argument passed to Validate. (The argument to Validate must be a non-nil pointer.)

func (e InvalidValidateError) Error() string

type JSON ¶

type JSON[T constraint.Text] struct{}

JSON accepts valid json encoded text

func (JSON[T]) Validate(value T) error

type LangAlpha ¶

type LangAlpha[T constraint.Text] struct {
	Or[T, LangAlpha2[T], LangAlpha3[T]]
}

LangAlpha accepts either LangAlpha2 or LangAlpha3

type LangAlpha2 ¶

type LangAlpha2[T constraint.Text] struct{}

LangAlpha2 accepts case-insesitive ISO 639 2-letter language code.

func (LangAlpha2[T]) Validate(value T) error

type LangAlpha3 ¶

type LangAlpha3[T constraint.Text] struct{}

LangAlpha3 accepts case-insesitive ISO 639 3-letter language code.

func (LangAlpha3[T]) Validate(value T) error

type Latitude ¶

type Latitude[T constraint.Real] struct{}

Latitude accepts any number in the range [-90; 90]

See also Longitude

func (Latitude[T]) Validate(value T) error

type Longitude ¶

type Longitude[T constraint.Real] struct{}

Longitude accepts any number in the range [-180; 180]

See also Latitude

func (Longitude[T]) Validate(value T) error

type MAC ¶

type MAC[T constraint.Text] struct{}

MAC accepts an IEEE 802 MAC-48, EUI-48, EUI-64, or a 20-octet IP over InfiniBand link-layer address.

func (MAC[T]) Validate(value T) error

type MIME ¶

type MIME[T constraint.Text] struct{}

MIME accepts RFC 1521 mime type string

func (MIME[T]) Validate(value T) error

type Negative ¶

type Negative[T constraint.Real] struct{}

Negative accepts all negative real numbers excluding zero.

See Negative0 for zero including variant.

func (Negative[T]) Validate(value T) error

type Negative0 ¶

type Negative0[T constraint.Real] struct {
	Or[T, Negative[T], Zero[T]]
}

Negative0 accepts all negative real numbers including zero.

See Negative for zero excluding variant.

type NonEmpty ¶

type NonEmpty[S ~[]T, T any] struct{}

NonEmpty accepts a non-empty slice-like (len > 0)

See NonEmptySlice for a slice shortcut

func (NonEmpty[S, T]) Validate(value S) error

type NonEmptySlice ¶

type NonEmptySlice[T any] struct {
	NonEmpty[[]T, T]
}

NonEmpty accepts a non-empty slice (len > 0)

See NonEmpty for a more generic version

type NonZero ¶

type NonZero[T comparable] struct{}

NonZero accepts all non-zero values.

The zero value is: - 0 for numeric types, - false for the boolean type, and - "" (the empty string) for strings.

See Zero

func (NonZero[T]) Validate(value T) error

type Not ¶

type Not[T any, V Validator[T]] struct{}

Not is a meta validator that inverts given validator.

See also And, Or

func (Not[T, V]) Validate(value T) error

type Odd ¶

type Odd[T constraint.Integer] struct{}

Odd accepts integers not divisible by two.

func (Odd[T]) Validate(value T) error

type Or ¶

type Or[T any, A Validator[T], B Validator[T]] struct{}

And is a meta validator that combines other validators with OR operator. Validators are called in the same order as type parameters.

See also And, Not

func (Or[T, A, B]) Validate(value T) error

type Positive ¶

type Positive[T constraint.Real] struct{}

Positive accepts all positive real numbers excluding zero.

See Positive0 for zero inlcuding variant.

func (Positive[T]) Validate(value T) error

type Positive0 ¶

type Positive0[T constraint.Real] struct {
	Or[T, Positive[T], Zero[T]]
}

Positive0 accepts all positive real numbers including zero.

See Positive for zero excluding variant.

type TypeValidateable ¶

type TypeValidateable interface {
	TypeValidate() error
}

TypeValidateable is an interface for types that can validate their types. This is used by required and optional fields so that they can validate if contained values satisfy the schema enforced by Validator backed type.

TL;DR: do not implement nor use this method directly (codegen is exception).

See Validateable interface if you want to implement custom validation

type URL ¶

type URL[T constraint.Text] struct{}

URL accepts a single url. The url may be relative (a path, without a host) or absolute (starting with a scheme).

See also HTTPURL.

func (URL[T]) Validate(value T) error

type UUID ¶

type UUID[T constraint.Text] struct{}

UUID accepts a properly formatted UUID in one of the following formats:

xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

func (UUID[T]) Validate(value T) error

type Unique ¶

type Unique[S ~[]T, T comparable] struct{}

Unique accepts a slice-like of unique values

See UniqueSlice for a slice shortcut

func (Unique[S, T]) Validate(value S) error

type UniqueSlice ¶

type UniqueSlice[T comparable] struct {
	Unique[[]T, T]
}

Unique accepts a slice of unique values

See Unique for a more generic version

type Validateable ¶

type Validateable interface {
	Validate() error
}

Validateable is an interface for types that can perform validation logic after type validation (by TypeValidateable) has been called without errors.

Primary usecase is custom cross-field validation. E.g. if X is true then Y cannot be empty

type ValidationError ¶

type ValidationError struct {
	Msg   string
	Inner error
	// contains filtered or unexported fields
}

ValidationError describes validation error occured at validate.Validate

func (e ValidationError) Error() string

func (e ValidationError) Path() string

func (e ValidationError) Unwrap() error

func (e ValidationError) WithPath(path string) ValidationError

type Validator ¶

type Validator[T any] interface {
	Validate(value T) error
}

Validator is an interface that validators must implement. It's a special empty (struct{}) type that is invoked in a form of (*new(V)).Validate(...). Therefore it should not depend on inner state (fields).

type Zero ¶

type Zero[T comparable] struct{}

Zero accepts all zero values.

The zero value is: - 0 for numeric types, - false for the boolean type, and - "" (the empty string) for strings.

See NonZero

func (Zero[T]) Validate(value T) error