it

package
v0.20.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 3, 2026 License: MIT Imports: 15 Imported by: 0

Documentation

Overview

Package it contains validation constraints that are used to validate specific types of values.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsCountry added in v0.20.0 

func IsCountry() validation.StringFuncConstraint

IsCountry checks for a valid two-letter country or territory code. Nil and empty values are ignored; use IsNotBlank to require a value. Case is ignored and whitespace is not trimmed. The input is not modified. Uses x/text country data, including CLDR additions and historical codes; acceptance does not imply service availability. See github.com/muonsoft/validation/validate.Country for the full contract.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("EU", it.IsCountry()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid country or territory code."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("de", it.IsCountry()))
	fmt.Println(err)
}

Output:
<nil>

func IsCurrency added in v0.20.0 

func IsCurrency() validation.StringFuncConstraint

IsCurrency validates whether the value is a recognized ISO 4217 alphabetic currency code, as in Symfony\Component\Validator\Constraints\Currency. Recognition follows golang.org/x/text/currency.ParseISO (CLDR currency data).

See https://www.iso.org/iso-4217-currency-codes.html.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("ZZZ", it.IsCurrency()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid currency."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("CHF", it.IsCurrency()))
	fmt.Println(err)
}

Output:
<nil>

func IsEAN8 added in v0.8.0 

func IsEAN8() validation.StringFuncConstraint

IsEAN8 is used to validate EAN-8 value.

See https://en.wikipedia.org/wiki/EAN-8.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("42345670", it.IsEAN8()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid EAN-8."

func IsEAN13 added in v0.8.0 

func IsEAN13() validation.StringFuncConstraint

IsEAN13 is used to validate EAN-13 value.

See https://en.wikipedia.org/wiki/International_Article_Number.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("4006381333932", it.IsEAN13()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid EAN-13."

func IsEmail added in v0.2.0 

func IsEmail() validation.StringFuncConstraint

IsEmail is used for simplified validation of an email address. It allows all values with an "@" symbol in, and a "." in the second host part of the email address.

Example (InvalidEmail) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "user example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsEmail()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid email address."
Example (ValidEmail) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "user@example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsEmail()))
	fmt.Println(err)
}

Output:
<nil>

func IsHTML5Email added in v0.2.0 

func IsHTML5Email() validation.StringFuncConstraint

IsHTML5Email is used for validation of an email address based on pattern for HTML5 (see https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address).

Example (InvalidEmail) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "@example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsEmail()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid email address."
Example (ValidEmail) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "{}~!@example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsEmail()))
	fmt.Println(err)
}

Output:
<nil>

func IsHostname added in v0.2.0 

func IsHostname() validation.StringFuncConstraint

IsHostname validates that a value is a valid hostname. It checks that:

  • each label within a valid hostname may be no more than 63 octets long;
  • the total length of the hostname must not exceed 255 characters;
  • hostname is fully qualified and include its top-level domain name (for instance, example.com is valid but example is not);
  • checks for reserved top-level domains according to RFC 2606 (hostnames containing them are not considered valid: .example, .invalid, .localhost, and .test).

If you do not want to check for top-level domains use IsLooseHostname version of constraint.

Example (InvalidHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example-.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsHostname()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid hostname."
Example (ReservedHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example.localhost"
	err := validator.Validate(context.Background(), validation.String(v, it.IsHostname()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid hostname."
Example (ValidHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsHostname()))
	fmt.Println(err)
}

Output:
<nil>

func IsIBAN added in v0.20.0 

func IsIBAN() validation.StringFuncConstraint

IsIBAN validates whether the value is a valid International Bank Account Number (IBAN). Behavior is aligned with Symfony\Component\Validator\Constraints\Iban.

See https://en.wikipedia.org/wiki/International_Bank_Account_Number.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("DE89370400440532013001", it.IsIBAN()))
	fmt.Println(err)
}

Output:
violation: "This is not a valid International Bank Account Number (IBAN)."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("DE89370400440532013000", it.IsIBAN()))
	fmt.Println(err)
}

Output:
<nil>

func IsISIN added in v0.20.0 

func IsISIN() validation.StringFuncConstraint

IsISIN validates whether the value is a valid International Securities Identification Number (ISIN). See https://en.wikipedia.org/wiki/International_Securities_Identification_Number.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("XS2012239364", it.IsISIN()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid International Securities Identification Number (ISIN)."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("US0378331005", it.IsISIN()))
	fmt.Println(err)
}

Output:
<nil>

func IsISSN added in v0.20.0 

func IsISSN() validation.StringFuncConstraint

IsISSN validates whether the value is a valid International Standard Serial Number (ISSN). Behavior is aligned with Symfony\Component\Validator\Constraints\Issn.

See ISO 3297 and https://www.issn.org/understanding-the-issn/what-is-an-issn/.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("0317-8470", it.IsISSN()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid ISSN."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("0317-8471", it.IsISSN()))
	fmt.Println(err)
}

Output:
<nil>

func IsInteger added in v0.8.0 

func IsInteger() validation.StringFuncConstraint

IsInteger checks that string value is an integer.

Example (InvalidInteger) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.Validate(context.Background(), validation.String(v, it.IsInteger()))
	fmt.Println(err)
}

Output:
violation: "This value is not an integer."
Example (ValidInteger) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123"
	err := validator.Validate(context.Background(), validation.String(v, it.IsInteger()))
	fmt.Println(err)
}

Output:
<nil>

func IsJSON added in v0.2.0 

func IsJSON() validation.StringFuncConstraint

IsJSON validates that a value is a valid JSON.

Example (InvalidJSON) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := `"invalid": true`
	err := validator.Validate(context.Background(), validation.String(v, it.IsJSON()))
	fmt.Println(err)
}

Output:
violation: "This value should be valid JSON."
Example (ValidJSON) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := `{"valid": true}`
	err := validator.Validate(context.Background(), validation.String(v, it.IsJSON()))
	fmt.Println(err)
}

Output:
<nil>

func IsLUHN added in v0.20.0 

func IsLUHN() validation.StringFuncConstraint

IsLUHN validates whether the value passes the Luhn (mod 10) checksum, as in Symfony\Component\Validator\Constraints\Luhn.

See https://en.wikipedia.org/wiki/Luhn_algorithm.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("79927398710", it.IsLUHN()))
	fmt.Println(err)
}

Output:
violation: "Invalid card number."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("79927398713", it.IsLUHN()))
	fmt.Println(err)
}

Output:
<nil>

func IsLanguage added in v0.20.0 

func IsLanguage() validation.StringFuncConstraint

IsLanguage checks for a valid standalone two- or three-letter language code. Nil and empty values are ignored; use IsNotBlank to require a value. Case is ignored and whitespace is not trimmed. The input is not modified. Composite tags require IsLocale. Special and private-use codes recognized by x/text are accepted; acceptance does not imply translation availability. See github.com/muonsoft/validation/validate.Language for the full contract.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("en-US", it.IsLanguage()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid language code."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("eng", it.IsLanguage()))
	fmt.Println(err)
}

Output:
<nil>

func IsLocale added in v0.20.0 

func IsLocale() validation.StringFuncConstraint

IsLocale checks for a valid locale identifier. Nil and empty values are ignored; use IsNotBlank to require a value. Case is ignored and whitespace is not trimmed. The input is not modified. Accepts composite tags, underscore separators, special and private-use tags, and extensions supported by x/text; acceptance does not imply application support. See github.com/muonsoft/validation/validate.Locale for the full contract.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("en--US", it.IsLocale()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid locale identifier."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("zh_Hant_TW", it.IsLocale()))
	fmt.Println(err)
}

Output:
<nil>

func IsLooseHostname added in v0.2.0 

func IsLooseHostname() validation.StringFuncConstraint

IsLooseHostname validates that a value is a valid hostname. It checks that:

  • each label within a valid hostname may be no more than 63 octets long;
  • the total length of the hostname must not exceed 255 characters.
Example (InvalidHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example-.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsLooseHostname()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid hostname."
Example (ReservedHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example.localhost"
	err := validator.Validate(context.Background(), validation.String(v, it.IsLooseHostname()))
	fmt.Println(err)
}

Output:
<nil>
Example (ValidHostname) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsLooseHostname()))
	fmt.Println(err)
}

Output:
<nil>

func IsNumeric added in v0.8.0 

func IsNumeric() validation.StringFuncConstraint

IsNumeric checks that string value is a valid numeric (integer or float).

Example (InvalidNumeric) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo.bar"
	err := validator.Validate(context.Background(), validation.String(v, it.IsNumeric()))
	fmt.Println(err)
}

Output:
violation: "This value is not a numeric."
Example (ValidNumeric) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123.123"
	err := validator.Validate(context.Background(), validation.String(v, it.IsNumeric()))
	fmt.Println(err)
}

Output:
<nil>

func IsULID added in v0.17.0 

func IsULID() validation.StringFuncConstraint

IsULID validates whether the value is a valid ULID (Universally Unique Lexicographically Sortable Identifier). See https://github.com/ulid/spec for ULID specifications.

func IsUPCA added in v0.8.0 

func IsUPCA() validation.StringFuncConstraint

IsUPCA is used to validate UPC-A value.

See https://en.wikipedia.org/wiki/Universal_Product_Code.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("614141000037", it.IsUPCA()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid UPC-A."

func IsUPCE added in v0.8.0 

func IsUPCE() validation.StringFuncConstraint

IsUPCE is used to validate UPC-E value.

See https://en.wikipedia.org/wiki/Universal_Product_Code#UPC-E.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("01234501", it.IsUPCE()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid UPC-E."

func IsUTF8 added in v0.20.0 

func IsUTF8() validation.StringFuncConstraint

IsUTF8 checks that a string contains valid UTF-8 bytes. Go strings do not guarantee this. Use it to reject malformed or truncated text from imports or integrations before storage or further processing.

Nil and empty values are ignored; use IsNotBlank to require a value. Only UTF-8 is supported, unlike Symfony's configurable Charset constraint. This does not detect or convert encodings, normalize text, or check content safety. Validly encoded mojibake, U+FFFD, invisible characters, and HTML pass. Check original input before a decoder replaces malformed bytes with U+FFFD.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	// A truncated UTF-8 sequence, as might occur in an imported file.
	err := validator.Validate(context.Background(), validation.String("text\xe2\x82", it.IsUTF8()))
	fmt.Println(err)
}

Output:
violation: "This value is not valid UTF-8."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Привет, 日本語 🙂", it.IsUTF8()))
	fmt.Println(err)
}

Output:
<nil>

Types

type BICConstraint added in v0.20.0 

type BICConstraint struct {
	// contains filtered or unexported fields
}

BICConstraint validates whether a string value is a valid Business Identifier Code (BIC / SWIFT).

By default, validation is in strict mode (uppercase ASCII only), matching Symfony Bic::VALIDATION_MODE_STRICT. Use BICConstraint.CaseInsensitive for Symfony's case-insensitive mode.

Use BICConstraint.WithIBAN to assert that the BIC's country/territory matches the given IBAN's country code (Symfony Bic "iban" option).

Empty values are skipped; combine with [NotBlank] or similar to reject empty strings.

See https://en.wikipedia.org/wiki/ISO_9362.

func IsBIC added in v0.20.0 

func IsBIC() BICConstraint

IsBIC validates whether the value is a valid Business Identifier Code (BIC / SWIFT). Behavior is aligned with Symfony\Component\Validator\Constraints\Bic.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("deutdeff", it.IsBIC()))
	fmt.Println(err)
}

Output:
violation: "This is not a valid Business Identifier Code (BIC)."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("DEUTDEFF", it.IsBIC()))
	fmt.Println(err)
}

Output:
<nil>

func (BICConstraint) CaseInsensitive added in v0.20.0 

func (c BICConstraint) CaseInsensitive() BICConstraint

CaseInsensitive enables Symfony Bic::VALIDATION_MODE_CASE_INSENSITIVE (lowercase letters allowed).

func (BICConstraint) Validate added in v0.20.0 

func (c BICConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string].

func (BICConstraint) ValidateString added in v0.20.0 

func (c BICConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (BICConstraint) When added in v0.20.0 

func (c BICConstraint) When(condition bool) BICConstraint

When enables conditional validation of this constraint.

func (BICConstraint) WhenGroups added in v0.20.0 

func (c BICConstraint) WhenGroups(groups ...string) BICConstraint

WhenGroups enables conditional validation by validation groups.

func (BICConstraint) WithError added in v0.20.0 

func (c BICConstraint) WithError(err error) BICConstraint

WithError overrides the default error for the main BIC format violation. IBAN country mismatch still uses validation.ErrBICIBANCountryMismatch unless overridden via BICConstraint.WithIBANError.

func (BICConstraint) WithIBAN added in v0.20.0 

func (c BICConstraint) WithIBAN(iban string) BICConstraint

WithIBAN sets an IBAN to check that its country code matches the BIC (Symfony Bic "iban" option).

func (BICConstraint) WithIBANError added in v0.20.0 

func (c BICConstraint) WithIBANError(err error) BICConstraint

WithIBANError overrides the default error for BIC vs IBAN country mismatch.

func (BICConstraint) WithIBANMessage added in v0.20.0 

func (c BICConstraint) WithIBANMessage(template string, parameters ...validation.TemplateParameter) BICConstraint

WithIBANMessage sets the violation message template when the BIC does not match the configured IBAN. Default parameters: {{ value }}, {{ iban }}.

func (BICConstraint) WithMessage added in v0.20.0 

func (c BICConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) BICConstraint

WithMessage sets the violation message template for the main BIC format violation.

type BlankConstraint 

type BlankConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

BlankConstraint checks that a value is blank: equal to false, nil, zero, an empty string, an empty slice, array, or a map.

func IsBlank 

func IsBlank() BlankConstraint[string]

IsBlank creates a BlankConstraint for checking that value is empty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.String("foo", it.IsBlank())))
	fmt.Println(validator.Validate(context.Background(), validation.Countable(len([]string{"foo"}), it.IsBlank())))
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[string]("foo", it.IsBlank())))
}

Output:
violation: "This value should be blank."
violation: "This value should be blank."
violation: "This value should be blank."

func IsBlankComparable added in v0.10.0 

func IsBlankComparable[T comparable]() BlankConstraint[T]

IsBlankComparable creates a BlankConstraint for checking that comparable value is not empty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[int](1, it.IsBlankComparable[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[string]("foo", it.IsBlankComparable[string]())))
}

Output:
violation: "This value should be blank."
violation: "This value should be blank."

func IsBlankNumber added in v0.9.0 

func IsBlankNumber[T validation.Numeric]() BlankConstraint[T]

IsBlankNumber creates a BlankConstraint for checking that numeric value is nil or zero.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.Number[int](1, it.IsBlankNumber[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.Number[float64](1.1, it.IsBlankNumber[float64]())))
}

Output:
violation: "This value should be blank."
violation: "This value should be blank."

func (BlankConstraint[T]) Validate added in v0.19.0 

func (c BlankConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (BlankConstraint[T]) ValidateBool 

func (c BlankConstraint[T]) ValidateBool(ctx context.Context, validator *validation.Validator, value *bool) error

func (BlankConstraint[T]) ValidateComparable added in v0.10.0 

func (c BlankConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (BlankConstraint[T]) ValidateCountable 

func (c BlankConstraint[T]) ValidateCountable(ctx context.Context, validator *validation.Validator, count int) error

func (BlankConstraint[T]) ValidateNil 

func (c BlankConstraint[T]) ValidateNil(ctx context.Context, validator *validation.Validator, isNil bool) error

func (BlankConstraint[T]) ValidateNumber 

func (c BlankConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (BlankConstraint[T]) ValidateString 

func (c BlankConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (BlankConstraint[T]) ValidateTime 

func (c BlankConstraint[T]) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (BlankConstraint[T]) When 

func (c BlankConstraint[T]) When(condition bool) BlankConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (BlankConstraint[T]) WhenGroups added in v0.8.0 

func (c BlankConstraint[T]) WhenGroups(groups ...string) BlankConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (BlankConstraint[T]) WithError added in v0.13.0 

func (c BlankConstraint[T]) WithError(err error) BlankConstraint[T]

WithError overrides default error for produced violation.

func (BlankConstraint[T]) WithMessage added in v0.13.0 

func (c BlankConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) BlankConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type BoolConstraint 

type BoolConstraint struct {
	// contains filtered or unexported fields
}

BoolConstraint checks that a bool value in strictly equal to expected bool value.

func IsFalse 

func IsFalse() BoolConstraint

IsFalse creates a BoolConstraint to check that a value is not strictly equal to false.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.Bool(true, it.IsFalse()))
	fmt.Println(err)
}

Output:
violation: "This value should be false."

func IsTrue 

func IsTrue() BoolConstraint

IsTrue creates a BoolConstraint to check that a value is not strictly equal to true.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.Bool(false, it.IsTrue()))
	fmt.Println(err)
}

Output:
violation: "This value should be true."

func (BoolConstraint) Validate added in v0.19.0 

func (c BoolConstraint) Validate(ctx context.Context, validator *validation.Validator, v bool) error

Validate implements validation.Constraint[bool] so the constraint can be used with validation.Each and validation.This.

func (BoolConstraint) ValidateBool 

func (c BoolConstraint) ValidateBool(ctx context.Context, validator *validation.Validator, value *bool) error

func (BoolConstraint) When 

func (c BoolConstraint) When(condition bool) BoolConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (BoolConstraint) WhenGroups added in v0.8.0 

func (c BoolConstraint) WhenGroups(groups ...string) BoolConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (BoolConstraint) WithError added in v0.13.0 

func (c BoolConstraint) WithError(err error) BoolConstraint

WithError overrides default error for produced violation.

func (BoolConstraint) WithMessage added in v0.13.0 

func (c BoolConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) BoolConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type CIDRConstraint added in v0.20.0 

type CIDRConstraint struct {
	// contains filtered or unexported fields
}

CIDRConstraint validates a string as CIDR notation (IP/prefix), aligned with Symfony\Component\Validator\Constraints\Cidr.

By default both IPv4 and IPv6 are accepted, and the prefix length may be 0–128 (for IPv4 addresses the effective maximum is 32, matching Symfony's CidrValidator).

Use CIDRConstraint.IPv4Only, CIDRConstraint.IPv6Only, or CIDRConstraint.WithVersion to restrict the IP version. Use CIDRConstraint.WithNetmaskRange to set the allowed inclusive prefix range.

func IsCIDR added in v0.20.0 

func IsCIDR() CIDRConstraint

IsCIDR creates a CIDRConstraint that accepts IPv4 and IPv6 CIDR notation.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "192.168.0.0"
	err := validator.Validate(context.Background(), validation.String(v, it.IsCIDR()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid CIDR notation."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "192.168.0.0/24"
	err := validator.Validate(context.Background(), validation.String(v, it.IsCIDR()))
	fmt.Println(err)
}

Output:
<nil>

func (CIDRConstraint) IPv4Only added in v0.20.0 

func (c CIDRConstraint) IPv4Only() CIDRConstraint

IPv4Only restricts validation to IPv4 CIDR only (Symfony Ip::V4).

func (CIDRConstraint) IPv6Only added in v0.20.0 

func (c CIDRConstraint) IPv6Only() CIDRConstraint

IPv6Only restricts validation to IPv6 CIDR only (Symfony Ip::V6).

func (CIDRConstraint) Validate added in v0.20.0 

func (c CIDRConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (CIDRConstraint) ValidateString added in v0.20.0 

func (c CIDRConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (CIDRConstraint) When added in v0.20.0 

func (c CIDRConstraint) When(condition bool) CIDRConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (CIDRConstraint) WhenGroups added in v0.20.0 

func (c CIDRConstraint) WhenGroups(groups ...string) CIDRConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (CIDRConstraint) WithInvalidError added in v0.20.0 

func (c CIDRConstraint) WithInvalidError(err error) CIDRConstraint

WithInvalidError overrides the error for invalid CIDR notation or version mismatch.

func (CIDRConstraint) WithInvalidMessage added in v0.20.0 

func (c CIDRConstraint) WithInvalidMessage(template string, parameters ...validation.TemplateParameter) CIDRConstraint

WithInvalidMessage sets the violation message template when the value is not valid CIDR notation.

func (CIDRConstraint) WithNetmaskRange added in v0.20.0 

func (c CIDRConstraint) WithNetmaskRange(netmaskMin, netmaskMax int) CIDRConstraint

WithNetmaskRange sets the inclusive allowed range for the CIDR prefix length (Symfony netmaskMin/netmaskMax).

func (CIDRConstraint) WithOutOfRangeError added in v0.20.0 

func (c CIDRConstraint) WithOutOfRangeError(err error) CIDRConstraint

WithOutOfRangeError overrides the error for a prefix outside the allowed netmask range.

func (CIDRConstraint) WithOutOfRangeMessage added in v0.20.0 

func (c CIDRConstraint) WithOutOfRangeMessage(template string, parameters ...validation.TemplateParameter) CIDRConstraint

WithOutOfRangeMessage sets the violation message template when the prefix is out of range.

func (CIDRConstraint) WithVersion added in v0.20.0 

func (c CIDRConstraint) WithVersion(version string) CIDRConstraint

WithVersion sets the accepted IP version: "4", "6", or "all". Invalid values are ignored.

type CSSColorConstraint added in v0.20.0 

type CSSColorConstraint struct {
	// contains filtered or unexported fields
}

CSSColorConstraint checks whether a CSS color matches a selected format. Supported syntaxes follow Symfony 8.0; see validate.CSSColor. Nil and empty values are skipped. Use IsNotBlank to require a value.

func IsCSSColor added in v0.20.0 

func IsCSSColor(formats ...validate.CSSColorFormat) CSSColorConstraint

IsCSSColor creates a CSS color constraint. No formats selects all supported formats; use validate.CSSColor* constants to restrict them. Unknown formats produce a configuration error during validation, including for nil/empty input.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validate"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("red", it.IsCSSColor(validate.CSSColorRGB, validate.CSSColorRGBA)))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid CSS color."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("#AbCd", it.IsCSSColor()))
	fmt.Println(err)
}

Output:
<nil>

func (CSSColorConstraint) Validate added in v0.20.0 

func (c CSSColorConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint[string] for validation.This and validation.Each.

func (CSSColorConstraint) ValidateString added in v0.20.0 

func (c CSSColorConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString validates an optional CSS color against the configured formats.

func (CSSColorConstraint) When added in v0.20.0 

func (c CSSColorConstraint) When(condition bool) CSSColorConstraint

When disables validation when condition is false.

func (CSSColorConstraint) WhenGroups added in v0.20.0 

func (c CSSColorConstraint) WhenGroups(groups ...string) CSSColorConstraint

WhenGroups limits validation to the specified groups.

func (CSSColorConstraint) WithError added in v0.20.0 

func (c CSSColorConstraint) WithError(err error) CSSColorConstraint

WithError overrides the underlying error for a nonmatching CSS color.

func (CSSColorConstraint) WithMessage added in v0.20.0 

func (c CSSColorConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) CSSColorConstraint

WithMessage overrides the violation message; {{ value }} contains the input.

type CardSchemeConstraint added in v0.20.0 

type CardSchemeConstraint struct {
	// contains filtered or unexported fields
}

CardSchemeConstraint checks whether a card number matches a selected scheme. It checks prefixes and lengths only; combine with IsLUHN for a checksum. Nil and empty values are skipped. Use IsNotBlank to require a value.

func IsCardScheme added in v0.20.0 

func IsCardScheme(schemes ...validate.CardSchemeName) CardSchemeConstraint

IsCardScheme creates a constraint for one or more explicit payment card schemes. Use the validate.CardScheme* constants. Empty or unknown scheme selections produce a configuration error during validation, including for nil/empty input. See validate.CardScheme for the numbering rules.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validate"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("4111111111111111", it.IsCardScheme(validate.CardSchemeMastercard)))
	fmt.Println(err)
}

Output:
violation: "Unsupported card type or invalid card number."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validate"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("4111111111111111",
		it.IsCardScheme(validate.CardSchemeVisa, validate.CardSchemeMastercard), it.IsLUHN()))
	fmt.Println(err)
}

Output:
<nil>

func (CardSchemeConstraint) Validate added in v0.20.0 

func (c CardSchemeConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint[string] for validation.This and validation.Each.

func (CardSchemeConstraint) ValidateString added in v0.20.0 

func (c CardSchemeConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString validates an optional card number against the configured schemes.

func (CardSchemeConstraint) When added in v0.20.0 

func (c CardSchemeConstraint) When(condition bool) CardSchemeConstraint

When disables validation when condition is false.

func (CardSchemeConstraint) WhenGroups added in v0.20.0 

func (c CardSchemeConstraint) WhenGroups(groups ...string) CardSchemeConstraint

WhenGroups limits validation to the specified groups.

func (CardSchemeConstraint) WithError added in v0.20.0 

func (c CardSchemeConstraint) WithError(err error) CardSchemeConstraint

WithError overrides the underlying error for a nonmatching card number.

func (CardSchemeConstraint) WithMessage added in v0.20.0 

func (c CardSchemeConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) CardSchemeConstraint

WithMessage overrides the violation message; {{ value }} contains the input.

type ChoiceConstraint 

type ChoiceConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

ChoiceConstraint is used to ensure that the given value corresponds to one of the expected choices. Zero values (zero numbers or empty strings) are considered as valid. Use NotBlankConstraint to check that they are not empty. Also, in order for a blank value to be checked, use the ChoiceConstraint.WithoutBlank method.

func IsOneOf added in v0.9.0 

func IsOneOf[T comparable](values ...T) ChoiceConstraint[T]

IsOneOf creates a ChoiceConstraint for checking that values are in the expected list of values. Zero values (zero numbers or empty strings) are considered as valid. Use NotBlankConstraint to check that they are not empty. Also, in order for a blank value to be checked, use the ChoiceConstraint.WithoutBlank method.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparable[string]("foo", it.IsOneOf("one", "two", "three"))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.String("foo", it.IsOneOf("one", "two", "three"))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparable[int](1, it.IsOneOf(2, 3, 4))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsOneOf(2, 3, 4))),
	)
}

Output:
violation: "The value you selected is not a valid choice."
violation: "The value you selected is not a valid choice."
violation: "The value you selected is not a valid choice."
violation: "The value you selected is not a valid choice."

func (ChoiceConstraint[T]) Validate added in v0.19.0 

func (c ChoiceConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (ChoiceConstraint[T]) ValidateComparable added in v0.9.0 

func (c ChoiceConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (ChoiceConstraint[T]) ValidateNumber added in v0.10.0 

func (c ChoiceConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (ChoiceConstraint[T]) ValidateString 

func (c ChoiceConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *T) error

func (ChoiceConstraint[T]) When 

func (c ChoiceConstraint[T]) When(condition bool) ChoiceConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (ChoiceConstraint[T]) WhenGroups added in v0.8.0 

func (c ChoiceConstraint[T]) WhenGroups(groups ...string) ChoiceConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (ChoiceConstraint[T]) WithError added in v0.13.0 

func (c ChoiceConstraint[T]) WithError(err error) ChoiceConstraint[T]

WithError overrides default error for produced violation.

func (ChoiceConstraint[T]) WithMessage added in v0.13.0 

func (c ChoiceConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) ChoiceConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ choices }} - a comma-separated list of available choices;
{{ value }} - the current (invalid) value.

func (ChoiceConstraint[T]) WithoutBlank added in v0.13.2 

func (c ChoiceConstraint[T]) WithoutBlank() ChoiceConstraint[T]

WithoutBlank makes zero values valid.

type ComparisonConstraint added in v0.10.0 

type ComparisonConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

ComparisonConstraint is used for comparisons between comparable generic types.

func IsEqualTo added in v0.10.0 

func IsEqualTo[T comparable](value T) ComparisonConstraint[T]

IsEqualTo checks that the value is equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsEqualTo(2)),
	))
	fmt.Println(validator.Validate(
		context.Background(),
		validation.String("foo", it.IsEqualTo("bar")),
	))
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparable[string]("foo", it.IsEqualTo("bar")),
	))
}

Output:
violation: "This value should be equal to 2."
violation: "This value should be equal to "bar"."
violation: "This value should be equal to "bar"."

func IsNotEqualTo added in v0.10.0 

func IsNotEqualTo[T comparable](value T) ComparisonConstraint[T]

IsNotEqualTo checks that the value is not equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsNotEqualTo(1)),
	))
	fmt.Println(validator.Validate(
		context.Background(),
		validation.String("foo", it.IsNotEqualTo("foo")),
	))
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparable[string]("foo", it.IsNotEqualTo("foo")),
	))
}

Output:
violation: "This value should not be equal to 1."
violation: "This value should not be equal to "foo"."
violation: "This value should not be equal to "foo"."

func (ComparisonConstraint[T]) Validate added in v0.19.0 

func (c ComparisonConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (ComparisonConstraint[T]) ValidateComparable added in v0.10.0 

func (c ComparisonConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (ComparisonConstraint[T]) ValidateNumber added in v0.10.0 

func (c ComparisonConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (ComparisonConstraint[T]) ValidateString added in v0.10.0 

func (c ComparisonConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *T) error

func (ComparisonConstraint[T]) When added in v0.10.0 

func (c ComparisonConstraint[T]) When(condition bool) ComparisonConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (ComparisonConstraint[T]) WhenGroups added in v0.10.0 

func (c ComparisonConstraint[T]) WhenGroups(groups ...string) ComparisonConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (ComparisonConstraint[T]) WithError added in v0.13.0 

func (c ComparisonConstraint[T]) WithError(err error) ComparisonConstraint[T]

WithError overrides default error for produced violation.

func (ComparisonConstraint[T]) WithMessage added in v0.13.0 

func (c ComparisonConstraint[T]) WithMessage(
	template string,
	parameters ...validation.TemplateParameter,
) ComparisonConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ comparedValue }} - the expected value;
{{ value }} - the current (invalid) value.

type ContentTypeConstraint added in v0.20.0 

type ContentTypeConstraint struct {
	// contains filtered or unexported fields
}

ContentTypeConstraint validates detected content types. See validate.ContentType for exact semantics. Nil and empty values are skipped; requiredness is separate.

func HasContentType added in v0.20.0 

func HasContentType(types ...string) ContentTypeConstraint

HasContentType creates a ContentTypeConstraint. See validate.ContentType.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	v, _ := validation.NewValidator()
	for _, data := range [][]byte{[]byte("hello"), {0, 1, 2}} {
		fmt.Println(v.Validate(context.Background(), validation.This(data, it.HasContentType("text/plain"))))
	}
}

Output:
<nil>
violation: "This content type is not allowed."

func (ContentTypeConstraint) Validate added in v0.20.0 

func (c ContentTypeConstraint) Validate(ctx context.Context, validator *validation.Validator, value []byte) error

Validate implements validation.Constraint for use with This and Each.

func (ContentTypeConstraint) When added in v0.20.0 

func (c ContentTypeConstraint) When(condition bool) ContentTypeConstraint

When enables or disables this constraint.

func (ContentTypeConstraint) WhenGroups added in v0.20.0 

func (c ContentTypeConstraint) WhenGroups(groups ...string) ContentTypeConstraint

WhenGroups restricts validation to the supplied groups.

func (ContentTypeConstraint) WithDetector added in v0.20.0 

func (c ContentTypeConstraint) WithDetector(detector validate.ContentTypeDetector) ContentTypeConstraint

WithDetector replaces content detection. Nil restores http.DetectContentType. The detector receives all supplied bytes, must not modify them, and must be safe for concurrent calls when the constraint is shared.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	v, _ := validation.NewValidator()
	rule := it.HasContentType("application/x-example").WithDetector(func(data []byte) string {
		if len(data) >= 4 && string(data[:4]) == "EXMP" {
			return "application/x-example"
		}
		return "application/octet-stream"
	})
	fmt.Println(v.Validate(context.Background(), validation.This([]byte("EXMP payload"), rule)))
}

Output:
<nil>

func (ContentTypeConstraint) WithError added in v0.20.0 

func (c ContentTypeConstraint) WithError(err error) ContentTypeConstraint

WithError overrides the error attached to a validation violation.

func (ContentTypeConstraint) WithMessage added in v0.20.0 

func (c ContentTypeConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) ContentTypeConstraint

WithMessage overrides the message and its parameters. Input values are not automatically included in messages or parameters.

type CountConstraint 

type CountConstraint struct {
	// contains filtered or unexported fields
}

CountConstraint checks that a given collection's (array, slice or a map) length is between some minimum and maximum value.

func HasCountBetween 

func HasCountBetween(vMin int, vMax int) CountConstraint

HasCountBetween creates a CountConstraint that checks the length of the iterable (slice, array, or map) is between the minimum and maximum values, inclusive.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []int{1, 2}
	err := validator.ValidateCountable(context.Background(), len(v), it.HasCountBetween(3, 10))
	fmt.Println(err)
}

Output:
violation: "This collection should contain 3 elements or more."

func HasCountDivisibleBy added in v0.17.0 

func HasCountDivisibleBy(divisor int) CountConstraint

HasCountDivisibleBy creates a CountConstraint that checks the length of the iterable (slice, array, or map) is divisible by the specific value. A zero divisor produces a constraint configuration error.

func HasExactCount 

func HasExactCount(count int) CountConstraint

HasExactCount creates a CountConstraint that checks the length of the iterable (slice, array, or map) has exact value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []int{1, 2}
	err := validator.ValidateCountable(context.Background(), len(v), it.HasExactCount(3))
	fmt.Println(err)
}

Output:
violation: "This collection should contain exactly 3 elements."

func HasMaxCount 

func HasMaxCount(vMax int) CountConstraint

HasMaxCount creates a CountConstraint that checks the length of the iterable (slice, array, or map) is less than or equal to the maximum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []int{1, 2}
	err := validator.ValidateCountable(context.Background(), len(v), it.HasMaxCount(1))
	fmt.Println(err)
}

Output:
violation: "This collection should contain 1 element or less."

func HasMinCount 

func HasMinCount(vMin int) CountConstraint

HasMinCount creates a CountConstraint that checks the length of the iterable (slice, array, or map) is greater than or equal to the minimum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := []int{1, 2}
	err := validator.ValidateCountable(context.Background(), len(v), it.HasMinCount(3))
	fmt.Println(err)
}

Output:
violation: "This collection should contain 3 elements or more."

func (CountConstraint) ValidateCountable 

func (c CountConstraint) ValidateCountable(ctx context.Context, validator *validation.Validator, count int) error

func (CountConstraint) When 

func (c CountConstraint) When(condition bool) CountConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (CountConstraint) WhenGroups added in v0.8.0 

func (c CountConstraint) WhenGroups(groups ...string) CountConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (CountConstraint) WithDivisibleError added in v0.17.0 

func (c CountConstraint) WithDivisibleError(err error) CountConstraint

WithDivisibleError overrides default underlying error for violation that will be shown the length of the collection is not divisible by specific value.

func (CountConstraint) WithDivisibleMessage added in v0.17.0 

func (c CountConstraint) WithDivisibleMessage(template string, parameters ...validation.TemplateParameter) CountConstraint

WithDivisibleMessage sets the violation message that will be shown if the length of the collection is not divisible by specific value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current collection size;
{{ divisibleBy }} - the divisor for the collection size.

func (CountConstraint) WithExactError added in v0.13.0 

func (c CountConstraint) WithExactError(err error) CountConstraint

WithExactError overrides default underlying error for violation that will be shown if minimum and maximum values are equal and the length of the collection is not exactly this value.

func (CountConstraint) WithExactMessage added in v0.13.0 

func (c CountConstraint) WithExactMessage(template string, parameters ...validation.TemplateParameter) CountConstraint

WithExactMessage sets the violation message that will be shown if minimum and maximum values are equal and the length of the collection is not exactly this value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current collection size;
{{ limit }} - the exact expected collection size.

func (CountConstraint) WithMaxError added in v0.13.0 

func (c CountConstraint) WithMaxError(err error) CountConstraint

WithMaxError overrides default underlying error for violation that will be shown if the collection length is greater than the maximum value.

func (CountConstraint) WithMaxMessage added in v0.13.0 

func (c CountConstraint) WithMaxMessage(template string, parameters ...validation.TemplateParameter) CountConstraint

WithMaxMessage sets the violation message that will be shown if the collection length is greater than the maximum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current collection size;
{{ limit }} - the upper limit.

func (CountConstraint) WithMinError added in v0.13.0 

func (c CountConstraint) WithMinError(err error) CountConstraint

WithMinError overrides default underlying error for violation that will be shown if the collection length is less than the minimum value.

func (CountConstraint) WithMinMessage added in v0.13.0 

func (c CountConstraint) WithMinMessage(template string, parameters ...validation.TemplateParameter) CountConstraint

WithMinMessage sets the violation message that will be shown if the collection length is less than the minimum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current collection size;
{{ limit }} - the lower limit.

type DateTimeConstraint added in v0.14.0 

type DateTimeConstraint struct {
	// contains filtered or unexported fields
}

DateTimeConstraint checks that the string value is a valid date and time value specified by a specific layout. The layout can be redefined using the DateTimeConstraint.WithLayout method.

func IsDate added in v0.14.0 

func IsDate() DateTimeConstraint

IsDate checks that the string value is a valid date. It uses "2006-01-02" layout. The layout can be redefined using the DateTimeConstraint.WithLayout method.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"#1 invalid:",
		validator.Validate(
			context.Background(),
			validation.String(`invalid`, it.IsDate()),
		),
	)
	fmt.Println(
		"#2 valid:",
		validator.Validate(
			context.Background(),
			validation.String(`2022-07-12`, it.IsDate()),
		),
	)
	fmt.Println(
		"#3 custom layout:",
		validator.Validate(
			context.Background(),
			validation.String(`12 Jul 22 12:34`, it.IsDate().WithLayout("02 Jan 06 15:04")),
		),
	)
}

Output:
#1 invalid: violation: "This value is not a valid date."
#2 valid: <nil>
#3 custom layout: <nil>

func IsDateTime added in v0.14.0 

func IsDateTime() DateTimeConstraint

IsDateTime checks that the string value is a valid date and time. By default, it uses time.RFC3339 layout. The layout can be redefined using the DateTimeConstraint.WithLayout method.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"#1 invalid:",
		validator.Validate(
			context.Background(),
			validation.String(`invalid`, it.IsDateTime()),
		),
	)
	fmt.Println(
		"#2 valid RFC3339:",
		validator.Validate(
			context.Background(),
			validation.String(`2022-07-12T12:34:56+00:00`, it.IsDateTime()),
		),
	)
	fmt.Println(
		"#3 custom layout:",
		validator.Validate(
			context.Background(),
			validation.String(`2022-07-12 12:34:56`, it.IsDateTime().WithLayout("2006-01-02 15:04:05")),
		),
	)
}

Output:
#1 invalid: violation: "This value is not a valid datetime."
#2 valid RFC3339: <nil>
#3 custom layout: <nil>

func IsTime added in v0.14.0 

func IsTime() DateTimeConstraint

IsTime checks that the string value is a valid time. It uses "15:04:05" layout. The layout can be redefined using the WithLayout method.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"#1 invalid:",
		validator.Validate(
			context.Background(),
			validation.String(`invalid`, it.IsTime()),
		),
	)
	fmt.Println(
		"#2 valid:",
		validator.Validate(
			context.Background(),
			validation.String(`12:34:56`, it.IsTime()),
		),
	)
	fmt.Println(
		"#3 custom layout:",
		validator.Validate(
			context.Background(),
			validation.String(`12:34:56+00:00`, it.IsTime().WithLayout("15:04:05Z07:00")),
		),
	)
}

Output:
#1 invalid: violation: "This value is not a valid time."
#2 valid: <nil>
#3 custom layout: <nil>

func (DateTimeConstraint) Validate added in v0.19.0 

func (c DateTimeConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (DateTimeConstraint) ValidateString added in v0.14.0 

func (c DateTimeConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (DateTimeConstraint) When added in v0.14.0 

func (c DateTimeConstraint) When(condition bool) DateTimeConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (DateTimeConstraint) WhenGroups added in v0.14.0 

func (c DateTimeConstraint) WhenGroups(groups ...string) DateTimeConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (DateTimeConstraint) WithError added in v0.14.0 

func (c DateTimeConstraint) WithError(err error) DateTimeConstraint

WithError overrides default error for produced violation.

func (DateTimeConstraint) WithLayout added in v0.14.0 

func (c DateTimeConstraint) WithLayout(layout string) DateTimeConstraint

WithLayout specifies the layout to be used for datetime parsing.

func (DateTimeConstraint) WithMessage added in v0.14.0 

func (c DateTimeConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) DateTimeConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ layout }} - date time layout used for parsing;
{{ value }} - the current (invalid) value.

type FileExtensionConstraint added in v0.20.0 

type FileExtensionConstraint struct {
	// contains filtered or unexported fields
}

FileExtensionConstraint validates file extensions. See validate.FileExtension for exact semantics. Nil and empty values are skipped; requiredness is separate.

func HasFileExtension added in v0.20.0 

func HasFileExtension(extensions ...string) FileExtensionConstraint

HasFileExtension creates a FileExtensionConstraint. See validate.FileExtension.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	v, _ := validation.NewValidator()
	for _, name := range []string{"backup.TAR.GZ", "backup.tar.gz.exe"} {
		fmt.Println(v.Validate(context.Background(), validation.String(name, it.HasFileExtension("tar.gz"))))
	}
}

Output:
<nil>
violation: "This file extension is not allowed."

func (FileExtensionConstraint) Validate added in v0.20.0 

func (c FileExtensionConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint for use with This and Each.

func (FileExtensionConstraint) ValidateString added in v0.20.0 

func (c FileExtensionConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString implements validation.StringConstraint.

func (FileExtensionConstraint) When added in v0.20.0 

func (c FileExtensionConstraint) When(condition bool) FileExtensionConstraint

When enables or disables this constraint.

func (FileExtensionConstraint) WhenGroups added in v0.20.0 

func (c FileExtensionConstraint) WhenGroups(groups ...string) FileExtensionConstraint

WhenGroups restricts validation to the supplied groups.

func (FileExtensionConstraint) WithError added in v0.20.0 

func (c FileExtensionConstraint) WithError(err error) FileExtensionConstraint

WithError overrides the error attached to a validation violation.

func (FileExtensionConstraint) WithMessage added in v0.20.0 

func (c FileExtensionConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) FileExtensionConstraint

WithMessage overrides the message and its parameters. Input values are not automatically included in messages or parameters.

type FileNameConstraint added in v0.20.0 

type FileNameConstraint struct {
	// contains filtered or unexported fields
}

FileNameConstraint validates file names. See validate.FileName for exact semantics. Nil and empty values are skipped; requiredness is separate.

func IsFileName added in v0.20.0 

func IsFileName() FileNameConstraint

IsFileName creates a FileNameConstraint. See validate.FileName.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	v, _ := validation.NewValidator()
	for _, name := range []string{"report.pdf", "CON.txt"} {
		fmt.Println(v.Validate(context.Background(), validation.String(name, it.IsFileName().WithWindowsRestrictions())))
	}
}

Output:
<nil>
violation: "This value is not a valid file name."

func (FileNameConstraint) Validate added in v0.20.0 

func (c FileNameConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint for use with This and Each.

func (FileNameConstraint) ValidateString added in v0.20.0 

func (c FileNameConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString implements validation.StringConstraint.

func (FileNameConstraint) When added in v0.20.0 

func (c FileNameConstraint) When(condition bool) FileNameConstraint

When enables or disables this constraint.

func (FileNameConstraint) WhenGroups added in v0.20.0 

func (c FileNameConstraint) WhenGroups(groups ...string) FileNameConstraint

WhenGroups restricts validation to the supplied groups.

func (FileNameConstraint) WithError added in v0.20.0 

func (c FileNameConstraint) WithError(err error) FileNameConstraint

WithError overrides the error attached to a validation violation.

func (FileNameConstraint) WithMessage added in v0.20.0 

func (c FileNameConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) FileNameConstraint

WithMessage overrides the message and its parameters. Input values are not automatically included in messages or parameters.

func (FileNameConstraint) WithWindowsRestrictions added in v0.20.0 

func (c FileNameConstraint) WithWindowsRestrictions() FileNameConstraint

WithWindowsRestrictions adds conservative Windows name restrictions on every OS.

type HasNoSuspiciousCharactersConstraint added in v0.20.0 

type HasNoSuspiciousCharactersConstraint struct {
	// contains filtered or unexported fields
}

HasNoSuspiciousCharactersConstraint requires that the string has no common Unicode spoofing patterns (invisible/format controls, mixed-script decimal digits, risky combining sequences, optional script/locale rules). Empty and nil strings are ignored; combine with IsNotBlank for required fields.

Behavior is inspired by Symfony’s NoSuspiciousCharacters (ICU Spoofchecker) but implemented without CGO; edge cases may differ from ICU.

Configure which checks run with HasNoSuspiciousCharactersConstraint.CheckInvisible, HasNoSuspiciousCharactersConstraint.CheckMixedNumbers, HasNoSuspiciousCharactersConstraint.CheckHiddenOverlay and the matching Without* methods (bitmask-based internally). If none of these are called, all standard checks run (same as Symfony default).

func HasNoSuspiciousCharacters added in v0.20.0 

func HasNoSuspiciousCharacters() HasNoSuspiciousCharactersConstraint

HasNoSuspiciousCharacters creates a constraint with default checks (invisible, mixed numbers, hidden overlay) and no locale/script restriction. Use Check* / Without* methods to customize the check bitmask, and HasNoSuspiciousCharactersConstraint.WithSuspiciousRestriction / HasNoSuspiciousCharactersConstraint.WithSuspiciousLocales for script rules.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("a\u200b", it.HasNoSuspiciousCharacters()))
	fmt.Println(err)
}

Output:
violation: "Using invisible characters is not allowed."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("alice", it.HasNoSuspiciousCharacters()))
	fmt.Println(err)
}

Output:
<nil>

func (HasNoSuspiciousCharactersConstraint) CheckHiddenOverlay added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) CheckHiddenOverlay() HasNoSuspiciousCharactersConstraint

CheckHiddenOverlay enables detection of risky combining overlay sequences (bit validate.CheckSuspiciousHiddenOverlay).

func (HasNoSuspiciousCharactersConstraint) CheckInvisible added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) CheckInvisible() HasNoSuspiciousCharactersConstraint

CheckInvisible enables detection of invisible and format-control characters (bit validate.CheckSuspiciousInvisible).

func (HasNoSuspiciousCharactersConstraint) CheckMixedNumbers added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) CheckMixedNumbers() HasNoSuspiciousCharactersConstraint

CheckMixedNumbers enables detection of mixed decimal digit scripts (bit validate.CheckSuspiciousMixedNumbers).

func (HasNoSuspiciousCharactersConstraint) ValidateString added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString implements validation.StringConstraint.

func (HasNoSuspiciousCharactersConstraint) When added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) When(condition bool) HasNoSuspiciousCharactersConstraint

When enables conditional validation of this constraint.

func (HasNoSuspiciousCharactersConstraint) WhenGroups added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WhenGroups(groups ...string) HasNoSuspiciousCharactersConstraint

WhenGroups enables conditional validation by validation groups.

func (HasNoSuspiciousCharactersConstraint) WithHiddenOverlayError added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithHiddenOverlayError(err error) HasNoSuspiciousCharactersConstraint

WithHiddenOverlayError overrides the error for hidden combining overlay sequences.

func (HasNoSuspiciousCharactersConstraint) WithHiddenOverlayMessage added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithHiddenOverlayMessage(template string, parameters ...validation.TemplateParameter) HasNoSuspiciousCharactersConstraint

WithHiddenOverlayMessage sets the violation template for hidden overlay sequences.

func (HasNoSuspiciousCharactersConstraint) WithInvisibleError added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithInvisibleError(err error) HasNoSuspiciousCharactersConstraint

WithInvisibleError overrides the error for invisible/format-control detection.

func (HasNoSuspiciousCharactersConstraint) WithInvisibleMessage added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithInvisibleMessage(template string, parameters ...validation.TemplateParameter) HasNoSuspiciousCharactersConstraint

WithInvisibleMessage sets the violation template for invisible/format-control detection.

func (HasNoSuspiciousCharactersConstraint) WithMixedNumbersError added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithMixedNumbersError(err error) HasNoSuspiciousCharactersConstraint

WithMixedNumbersError overrides the error for mixed decimal digit scripts.

func (HasNoSuspiciousCharactersConstraint) WithMixedNumbersMessage added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithMixedNumbersMessage(template string, parameters ...validation.TemplateParameter) HasNoSuspiciousCharactersConstraint

WithMixedNumbersMessage sets the violation template for mixed decimal digit scripts.

func (HasNoSuspiciousCharactersConstraint) WithRestrictionError added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithRestrictionError(err error) HasNoSuspiciousCharactersConstraint

WithRestrictionError overrides the error for locale/script restriction failures.

func (HasNoSuspiciousCharactersConstraint) WithRestrictionMessage added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithRestrictionMessage(template string, parameters ...validation.TemplateParameter) HasNoSuspiciousCharactersConstraint

WithRestrictionMessage sets the violation template for locale/script restriction failures.

func (HasNoSuspiciousCharactersConstraint) WithSuspiciousLocales added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithSuspiciousLocales(locales ...string) HasNoSuspiciousCharactersConstraint

WithSuspiciousLocales sets BCP 47 tags for validate.SuspiciousRestrictionLocales (e.g. "en", "ru-RU").

func (HasNoSuspiciousCharactersConstraint) WithSuspiciousRestriction added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithSuspiciousRestriction(r validate.SuspiciousRestriction) HasNoSuspiciousCharactersConstraint

WithSuspiciousRestriction sets script/locale restriction mode (validate.SuspiciousRestrictionLocales, validate.SuspiciousRestrictionSingleScript, or validate.SuspiciousRestrictionNone).

func (HasNoSuspiciousCharactersConstraint) WithoutHiddenOverlay added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithoutHiddenOverlay() HasNoSuspiciousCharactersConstraint

WithoutHiddenOverlay turns off hidden overlay detection (clears validate.CheckSuspiciousHiddenOverlay in the mask).

func (HasNoSuspiciousCharactersConstraint) WithoutInvisible added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithoutInvisible() HasNoSuspiciousCharactersConstraint

WithoutInvisible turns off invisible/format-control detection (clears validate.CheckSuspiciousInvisible in the mask).

func (HasNoSuspiciousCharactersConstraint) WithoutMixedNumbers added in v0.20.0 

func (c HasNoSuspiciousCharactersConstraint) WithoutMixedNumbers() HasNoSuspiciousCharactersConstraint

WithoutMixedNumbers turns off mixed decimal digit script detection (clears validate.CheckSuspiciousMixedNumbers in the mask).

type IPConstraint added in v0.2.0 

type IPConstraint struct {
	// contains filtered or unexported fields
}

IPConstraint is used to validate IP address. You can check for different versions and restrict some ranges by additional options.

func IsIP added in v0.2.0 

func IsIP() IPConstraint

IsIP creates an IPConstraint to validate an IP address (IPv4 or IPv6).

Example (InvalidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123.123.123.345"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIP()))
	fmt.Println(err)
}

Output:
violation: "This is not a valid IP address."
Example (ValidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123.123.123.123"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIP()))
	fmt.Println(err)
}

Output:
<nil>

func IsIPv4 added in v0.2.0 

func IsIPv4() IPConstraint

IsIPv4 creates an IPConstraint to validate an IPv4 address.

Example (InvalidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123.123.123.345"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIPv4()))
	fmt.Println(err)
}

Output:
violation: "This is not a valid IP address."
Example (ValidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "123.123.123.123"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIPv4()))
	fmt.Println(err)
}

Output:
<nil>

func IsIPv6 added in v0.2.0 

func IsIPv6() IPConstraint

IsIPv6 creates an IPConstraint to validate an IPv4 address.

Example (InvalidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "z001:0db8:85a3:0000:0000:8a2e:0370:7334"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIPv6()))
	fmt.Println(err)
}

Output:
violation: "This is not a valid IP address."
Example (ValidIP) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIPv6()))
	fmt.Println(err)
}

Output:
<nil>

func (IPConstraint) DenyIP added in v0.2.0 

func (c IPConstraint) DenyIP(restrict func(ip net.IP) bool) IPConstraint

DenyIP can be used to deny custom range of IP addresses.

Example 
package main

import (
	"context"
	"fmt"
	"net"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "127.0.0.1"
	err := validator.Validate(
		context.Background(),
		validation.String(
			v,
			it.IsIP().DenyIP(func(ip net.IP) bool {
				return ip.IsLoopback()
			}),
		),
	)
	fmt.Println(err)
}

Output:
violation: "This IP address is prohibited to use."

func (IPConstraint) DenyPrivateIP added in v0.2.0 

func (c IPConstraint) DenyPrivateIP() IPConstraint

DenyPrivateIP denies using of private IPs according to RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).

Example (RestrictedPrivateIPv4) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "192.168.1.0"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIP().DenyPrivateIP()))
	fmt.Println(err)
}

Output:
violation: "This IP address is prohibited to use."
Example (RestrictedPrivateIPv6) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "fdfe:dcba:9876:ffff:fdc6:c46b:bb8f:7d4c"
	err := validator.Validate(context.Background(), validation.String(v, it.IsIPv6().DenyPrivateIP()))
	fmt.Println(err)
}

Output:
violation: "This IP address is prohibited to use."

func (IPConstraint) Validate added in v0.19.0 

func (c IPConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (IPConstraint) ValidateString added in v0.2.0 

func (c IPConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (IPConstraint) When added in v0.2.0 

func (c IPConstraint) When(condition bool) IPConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (IPConstraint) WhenGroups added in v0.8.0 

func (c IPConstraint) WhenGroups(groups ...string) IPConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (IPConstraint) WithInvalidError added in v0.13.0 

func (c IPConstraint) WithInvalidError(err error) IPConstraint

WithInvalidError overrides default underlying error for violation produced on invalid IP case.

func (IPConstraint) WithInvalidMessage added in v0.13.0 

func (c IPConstraint) WithInvalidMessage(template string, parameters ...validation.TemplateParameter) IPConstraint

WithInvalidMessage sets the violation message template for invalid IP case. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (IPConstraint) WithProhibitedError added in v0.13.0 

func (c IPConstraint) WithProhibitedError(err error) IPConstraint

WithProhibitedError overrides default underlying error for violation produced on prohibited IP case.

func (IPConstraint) WithProhibitedMessage added in v0.13.0 

func (c IPConstraint) WithProhibitedMessage(template string, parameters ...validation.TemplateParameter) IPConstraint

WithProhibitedMessage sets the violation message template for prohibited IP case. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

type ISBNConstraint added in v0.20.0 

type ISBNConstraint struct {
	// contains filtered or unexported fields
}

ISBNConstraint validates whether a string value is a valid ISBN-10 or ISBN-13. Hyphens (U+002D) are stripped before validation, matching Symfony Isbn.

By default, either ISBN-10 or ISBN-13 is accepted. Use ISBNConstraint.Only10 or ISBNConstraint.Only13 to restrict the format.

Empty values are skipped; combine with [NotBlank] or similar to reject empty strings.

Behavior is aligned with Symfony\Component\Validator\Constraints\Isbn.

See https://en.wikipedia.org/wiki/ISBN.

func IsISBN added in v0.20.0 

func IsISBN() ISBNConstraint

IsISBN validates whether the value is a valid ISBN-10 or ISBN-13.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("978272344228", it.IsISBN()))
	fmt.Println(err)
}

Output:
violation: "This value is neither a valid ISBN-10 nor a valid ISBN-13."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("978-0451225245", it.IsISBN()))
	fmt.Println(err)
}

Output:
<nil>

func (ISBNConstraint) Only10 added in v0.20.0 

func (c ISBNConstraint) Only10() ISBNConstraint

Only10 restricts validation to ISBN-10 (Symfony Isbn::ISBN_10).

func (ISBNConstraint) Only13 added in v0.20.0 

func (c ISBNConstraint) Only13() ISBNConstraint

Only13 restricts validation to ISBN-13 (Symfony Isbn::ISBN_13).

func (ISBNConstraint) Validate added in v0.20.0 

func (c ISBNConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string].

func (ISBNConstraint) ValidateString added in v0.20.0 

func (c ISBNConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (ISBNConstraint) When added in v0.20.0 

func (c ISBNConstraint) When(condition bool) ISBNConstraint

When enables conditional validation of this constraint.

func (ISBNConstraint) WhenGroups added in v0.20.0 

func (c ISBNConstraint) WhenGroups(groups ...string) ISBNConstraint

WhenGroups enables conditional validation by validation groups.

func (ISBNConstraint) WithBothISBNError added in v0.20.0 

func (c ISBNConstraint) WithBothISBNError(err error) ISBNConstraint

WithBothISBNError overrides the error used when either ISBN-10 or ISBN-13 is accepted.

func (ISBNConstraint) WithBothISBNMessage added in v0.20.0 

func (c ISBNConstraint) WithBothISBNMessage(template string, parameters ...validation.TemplateParameter) ISBNConstraint

WithBothISBNMessage sets the message template when either format is accepted.

func (ISBNConstraint) WithError added in v0.20.0 

func (c ISBNConstraint) WithError(err error) ISBNConstraint

WithError overrides the default errors for all ISBN modes.

func (ISBNConstraint) WithISBN10Error added in v0.20.0 

func (c ISBNConstraint) WithISBN10Error(err error) ISBNConstraint

WithISBN10Error overrides the error used when validating as ISBN-10 only.

func (ISBNConstraint) WithISBN10Message added in v0.20.0 

func (c ISBNConstraint) WithISBN10Message(template string, parameters ...validation.TemplateParameter) ISBNConstraint

WithISBN10Message sets the message template for ISBN-10-only validation.

func (ISBNConstraint) WithISBN13Error added in v0.20.0 

func (c ISBNConstraint) WithISBN13Error(err error) ISBNConstraint

WithISBN13Error overrides the error used when validating as ISBN-13 only.

func (ISBNConstraint) WithISBN13Message added in v0.20.0 

func (c ISBNConstraint) WithISBN13Message(template string, parameters ...validation.TemplateParameter) ISBNConstraint

WithISBN13Message sets the message template for ISBN-13-only validation.

func (ISBNConstraint) WithMessage added in v0.20.0 

func (c ISBNConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) ISBNConstraint

WithMessage sets the message template for all ISBN modes.

type LengthConstraint 

type LengthConstraint struct {
	// contains filtered or unexported fields
}

LengthConstraint checks string length in Unicode code points (runes), not bytes or user-perceived characters. Bounds are inclusive; nil and empty strings are skipped. If you want to check the length of the array, slice or a map use CountConstraint.

func HasExactLength 

func HasExactLength(count int) LengthConstraint

HasExactLength creates a LengthConstraint that checks the length of the string has exact value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.ValidateString(context.Background(), v, it.HasExactLength(5))
	fmt.Println(err)
}

Output:
violation: "This value should have exactly 5 characters."

func HasLengthBetween 

func HasLengthBetween(vMin int, vMax int) LengthConstraint

HasLengthBetween creates a LengthConstraint that checks the length of the string is between the minimum and maximum values, inclusive.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.ValidateString(context.Background(), v, it.HasLengthBetween(5, 10))
	fmt.Println(err)
}

Output:
violation: "This value is too short. It should have 5 characters or more."

func HasMaxLength 

func HasMaxLength(vMax int) LengthConstraint

HasMaxLength creates a LengthConstraint that checks the length of the string is less than or equal to the maximum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.ValidateString(context.Background(), v, it.HasMaxLength(2))
	fmt.Println(err)
}

Output:
violation: "This value is too long. It should have 2 characters or less."

func HasMinLength 

func HasMinLength(vMin int) LengthConstraint

HasMinLength creates a LengthConstraint that checks the length of the string is greater than or equal to the minimum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.ValidateString(context.Background(), v, it.HasMinLength(5))
	fmt.Println(err)
}

Output:
violation: "This value is too short. It should have 5 characters or more."

func (LengthConstraint) Validate added in v0.19.0 

func (c LengthConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (LengthConstraint) ValidateString 

func (c LengthConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (LengthConstraint) When 

func (c LengthConstraint) When(condition bool) LengthConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (LengthConstraint) WhenGroups added in v0.8.0 

func (c LengthConstraint) WhenGroups(groups ...string) LengthConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (LengthConstraint) WithExactError added in v0.13.0 

func (c LengthConstraint) WithExactError(err error) LengthConstraint

WithExactError overrides default underlying error for violation that will be shown if minimum and maximum values are equal and the length of the string is not exactly this value.

func (LengthConstraint) WithExactMessage added in v0.13.0 

func (c LengthConstraint) WithExactMessage(template string, parameters ...validation.TemplateParameter) LengthConstraint

WithExactMessage sets the violation message that will be shown if minimum and maximum values are equal and the length of the string is not exactly this value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ length }} - the current string length;
{{ limit }} - the lower limit;
{{ value }} - the current (invalid) value.

func (LengthConstraint) WithMaxError added in v0.13.0 

func (c LengthConstraint) WithMaxError(err error) LengthConstraint

WithMaxError overrides default underlying error for violation that will be shown if the string length is greater than the maximum value.

func (LengthConstraint) WithMaxMessage added in v0.13.0 

func (c LengthConstraint) WithMaxMessage(template string, parameters ...validation.TemplateParameter) LengthConstraint

WithMaxMessage sets the violation message that will be shown if the string length is greater than the maximum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ length }} - the current string length;
{{ limit }} - the lower limit;
{{ value }} - the current (invalid) value.

func (LengthConstraint) WithMinError added in v0.13.0 

func (c LengthConstraint) WithMinError(err error) LengthConstraint

WithMinError overrides default underlying error for violation that will be shown if the string length is less than the minimum value.

func (LengthConstraint) WithMinMessage added in v0.13.0 

func (c LengthConstraint) WithMinMessage(template string, parameters ...validation.TemplateParameter) LengthConstraint

WithMinMessage sets the violation message that will be shown if the string length is less than the minimum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ length }} - the current string length;
{{ limit }} - the lower limit;
{{ value }} - the current (invalid) value.

type MIMETypeConstraint added in v0.20.0 

type MIMETypeConstraint struct {
	// contains filtered or unexported fields
}

MIMETypeConstraint validates MIME metadata. See validate.MIMEType for exact semantics. Nil and empty values are skipped; requiredness is separate.

func IsMIMEType added in v0.20.0 

func IsMIMEType(types ...string) MIMETypeConstraint

IsMIMEType creates a MIMETypeConstraint. See validate.MIMEType.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
)

func main() {
	v, _ := validation.NewValidator()
	for _, metadata := range []string{"text/plain; charset=utf-8", "image/png"} {
		fmt.Println(v.Validate(context.Background(), validation.String(metadata, it.IsMIMEType("text/plain"))))
	}
}

Output:
<nil>
violation: "This MIME type is invalid or not allowed."

func (MIMETypeConstraint) Validate added in v0.20.0 

func (c MIMETypeConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint for use with This and Each.

func (MIMETypeConstraint) ValidateString added in v0.20.0 

func (c MIMETypeConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString implements validation.StringConstraint.

func (MIMETypeConstraint) When added in v0.20.0 

func (c MIMETypeConstraint) When(condition bool) MIMETypeConstraint

When enables or disables this constraint.

func (MIMETypeConstraint) WhenGroups added in v0.20.0 

func (c MIMETypeConstraint) WhenGroups(groups ...string) MIMETypeConstraint

WhenGroups restricts validation to the supplied groups.

func (MIMETypeConstraint) WithError added in v0.20.0 

func (c MIMETypeConstraint) WithError(err error) MIMETypeConstraint

WithError overrides the error attached to a validation violation.

func (MIMETypeConstraint) WithMessage added in v0.20.0 

func (c MIMETypeConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) MIMETypeConstraint

WithMessage overrides the message and its parameters. Input values are not automatically included in messages or parameters.

type MacAddressConstraint added in v0.20.0 

type MacAddressConstraint struct {
	// contains filtered or unexported fields
}

MacAddressConstraint validates a string as a 48-bit MAC address, aligned with Symfony\Component\Validator\Constraints\MacAddress.

Accepted input forms are those supported by net.ParseMAC for a 6-octet address (colon, hyphen, or dot separators). Use MacAddressConstraint.WithType to filter by unicast/multicast, local/universal, and broadcast, using the same type names as Symfony (see validate.MacAddressTypeAll and related constants).

func IsMacAddress added in v0.20.0 

func IsMacAddress() MacAddressConstraint

IsMacAddress creates a MacAddressConstraint with default type validate.MacAddressTypeAll.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "not-a-mac"
	err := validator.Validate(context.Background(), validation.String(v, it.IsMacAddress()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid MAC address."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "00:1a:2b:3c:4d:5e"
	err := validator.Validate(context.Background(), validation.String(v, it.IsMacAddress()))
	fmt.Println(err)
}

Output:
<nil>

func (MacAddressConstraint) Validate added in v0.20.0 

func (c MacAddressConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (MacAddressConstraint) ValidateString added in v0.20.0 

func (c MacAddressConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (MacAddressConstraint) When added in v0.20.0 

func (c MacAddressConstraint) When(condition bool) MacAddressConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (MacAddressConstraint) WhenGroups added in v0.20.0 

func (c MacAddressConstraint) WhenGroups(groups ...string) MacAddressConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (MacAddressConstraint) WithError added in v0.20.0 

func (c MacAddressConstraint) WithError(err error) MacAddressConstraint

WithError overrides the default error for produced violations.

func (MacAddressConstraint) WithMessage added in v0.20.0 

func (c MacAddressConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) MacAddressConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (MacAddressConstraint) WithType added in v0.20.0 

func (c MacAddressConstraint) WithType(macType validate.MacAddressType) MacAddressConstraint

WithType sets the Symfony-compatible MAC class filter (default validate.MacAddressTypeAll).

Allowed values are validate.MacAddressTypeAll, validate.MacAddressTypeAllNoBroadcast, validate.MacAddressTypeLocalAll, validate.MacAddressTypeLocalNoBroadcast, validate.MacAddressTypeLocalUnicast, validate.MacAddressTypeLocalMulticast, validate.MacAddressTypeLocalMulticastNoBroadcast, validate.MacAddressTypeUniversalAll, validate.MacAddressTypeUniversalUnicast, validate.MacAddressTypeUniversalMulticast, validate.MacAddressTypeUnicastAll, validate.MacAddressTypeMulticastAll, validate.MacAddressTypeMulticastNoBroadcast, and validate.MacAddressTypeBroadcast.

type NilConstraint 

type NilConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

NilConstraint checks that a value in strictly equal to nil. To check that values in blank use BlankConstraint.

func IsNil 

func IsNil() NilConstraint[string]

IsNil creates a NilConstraint to check that a value is strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	s := ""
	sp := &s
	fmt.Println(validator.Validate(context.Background(), validation.Nil(sp == nil, it.IsNil())))
	fmt.Println(validator.Validate(context.Background(), validation.NilString(&s, it.IsNil())))
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[string](&s, it.IsNil())))
}

Output:
violation: "This value should be nil."
violation: "This value should be nil."
violation: "This value should be nil."

func IsNilComparable added in v0.10.0 

func IsNilComparable[T comparable]() NilConstraint[T]

IsNilComparable creates a NilConstraint to check that a comparable value is strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	n := 0
	s := ""
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[int](&n, it.IsNilComparable[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[string](&s, it.IsNilComparable[string]())))
}

Output:
violation: "This value should be nil."
violation: "This value should be nil."

func IsNilNumber added in v0.10.0 

func IsNilNumber[T validation.Numeric]() NilConstraint[T]

IsNilNumber creates a NilConstraint to check that a numeric value is strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	n := 0
	f := 0.0
	fmt.Println(validator.Validate(context.Background(), validation.NilNumber[int](&n, it.IsNilNumber[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.NilNumber[float64](&f, it.IsNilNumber[float64]())))
}

Output:
violation: "This value should be nil."
violation: "This value should be nil."

func (NilConstraint[T]) Validate added in v0.19.0 

func (c NilConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (NilConstraint[T]) ValidateBool added in v0.4.0 

func (c NilConstraint[T]) ValidateBool(ctx context.Context, validator *validation.Validator, value *bool) error

func (NilConstraint[T]) ValidateComparable added in v0.10.0 

func (c NilConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (NilConstraint[T]) ValidateNil 

func (c NilConstraint[T]) ValidateNil(ctx context.Context, validator *validation.Validator, isNil bool) error

func (NilConstraint[T]) ValidateNumber 

func (c NilConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (NilConstraint[T]) ValidateString 

func (c NilConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (NilConstraint[T]) ValidateTime 

func (c NilConstraint[T]) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (NilConstraint[T]) When 

func (c NilConstraint[T]) When(condition bool) NilConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (NilConstraint[T]) WhenGroups added in v0.8.0 

func (c NilConstraint[T]) WhenGroups(groups ...string) NilConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (NilConstraint[T]) WithError added in v0.13.0 

func (c NilConstraint[T]) WithError(err error) NilConstraint[T]

WithError overrides default error for produced violation.

func (NilConstraint[T]) WithMessage added in v0.13.0 

func (c NilConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) NilConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type NotBlankConstraint 

type NotBlankConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

NotBlankConstraint checks that a value is not blank: an empty string, an empty countable (slice/array/map), an empty generic number, generic comparable, false or nil. Nil behavior is configurable via NotBlankConstraint.WithAllowedNil. To check that a value is not nil only use NotNilConstraint.

func IsNotBlank 

func IsNotBlank() NotBlankConstraint[string]

IsNotBlank creates a NotBlankConstraint for checking that value is not empty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.String("", it.IsNotBlank())))
	fmt.Println(validator.Validate(context.Background(), validation.Countable(len([]string{}), it.IsNotBlank())))
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[string]("", it.IsNotBlank())))
}

Output:
violation: "This value should not be blank."
violation: "This value should not be blank."
violation: "This value should not be blank."

func IsNotBlankComparable added in v0.10.0 

func IsNotBlankComparable[T comparable]() NotBlankConstraint[T]

IsNotBlankComparable creates a NotBlankConstraint for checking that comparable value is not empty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[int](0, it.IsNotBlankComparable[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.Comparable[string]("", it.IsNotBlankComparable[string]())))
}

Output:
violation: "This value should not be blank."
violation: "This value should not be blank."

func IsNotBlankNumber added in v0.9.0 

func IsNotBlankNumber[T validation.Numeric]() NotBlankConstraint[T]

IsNotBlankNumber creates a NotBlankConstraint for checking that numeric value is not empty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(context.Background(), validation.Number[int](0, it.IsNotBlankNumber[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.Number[float64](0.0, it.IsNotBlankNumber[float64]())))
}

Output:
violation: "This value should not be blank."
violation: "This value should not be blank."

func (NotBlankConstraint[T]) Validate added in v0.19.0 

func (c NotBlankConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (NotBlankConstraint[T]) ValidateBool 

func (c NotBlankConstraint[T]) ValidateBool(ctx context.Context, validator *validation.Validator, value *bool) error

func (NotBlankConstraint[T]) ValidateComparable added in v0.10.0 

func (c NotBlankConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (NotBlankConstraint[T]) ValidateCountable 

func (c NotBlankConstraint[T]) ValidateCountable(ctx context.Context, validator *validation.Validator, count int) error

func (NotBlankConstraint[T]) ValidateNil 

func (c NotBlankConstraint[T]) ValidateNil(ctx context.Context, validator *validation.Validator, isNil bool) error

func (NotBlankConstraint[T]) ValidateNumber 

func (c NotBlankConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (NotBlankConstraint[T]) ValidateString 

func (c NotBlankConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (NotBlankConstraint[T]) ValidateTime 

func (c NotBlankConstraint[T]) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (NotBlankConstraint[T]) When 

func (c NotBlankConstraint[T]) When(condition bool) NotBlankConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (NotBlankConstraint[T]) WhenGroups added in v0.8.0 

func (c NotBlankConstraint[T]) WhenGroups(groups ...string) NotBlankConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (NotBlankConstraint[T]) WithAllowedNil added in v0.13.0 

func (c NotBlankConstraint[T]) WithAllowedNil() NotBlankConstraint[T]

WithAllowedNil makes nil values valid.

func (NotBlankConstraint[T]) WithError added in v0.13.0 

func (c NotBlankConstraint[T]) WithError(err error) NotBlankConstraint[T]

WithError overrides default error for produced violation.

func (NotBlankConstraint[T]) WithMessage added in v0.13.0 

func (c NotBlankConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) NotBlankConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type NotNilConstraint 

type NotNilConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

NotNilConstraint checks that a value in not strictly equal to nil. To check that values in not blank use NotBlankConstraint.

func IsNotNil 

func IsNotNil() NotNilConstraint[string]

IsNotNil creates a NotNilConstraint to check that a value is not strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	var s *string
	fmt.Println(validator.Validate(context.Background(), validation.Nil(s == nil, it.IsNotNil())))
	fmt.Println(validator.Validate(context.Background(), validation.NilString(s, it.IsNotNil())))
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[string](s, it.IsNotNil())))
}

Output:
violation: "This value should not be nil."
violation: "This value should not be nil."
violation: "This value should not be nil."

func IsNotNilComparable added in v0.10.0 

func IsNotNilComparable[T comparable]() NotNilConstraint[T]

IsNotNilComparable creates a NotNilConstraint to check that a comparable value is not strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	var n *int
	var s *string
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[int](n, it.IsNotNilComparable[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.NilComparable[string](s, it.IsNotNilComparable[string]())))
}

Output:
violation: "This value should not be nil."
violation: "This value should not be nil."

func IsNotNilNumber added in v0.10.0 

func IsNotNilNumber[T validation.Numeric]() NotNilConstraint[T]

IsNotNilNumber creates a NotNilConstraint to check that a numeric value is not strictly equal to nil.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	var n *int
	var f *float64
	fmt.Println(validator.Validate(context.Background(), validation.NilNumber[int](n, it.IsNotNilNumber[int]())))
	fmt.Println(validator.Validate(context.Background(), validation.NilNumber[float64](f, it.IsNotNilNumber[float64]())))
}

Output:
violation: "This value should not be nil."
violation: "This value should not be nil."

func (NotNilConstraint[T]) Validate added in v0.19.0 

func (c NotNilConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (NotNilConstraint[T]) ValidateBool added in v0.4.0 

func (c NotNilConstraint[T]) ValidateBool(ctx context.Context, validator *validation.Validator, value *bool) error

func (NotNilConstraint[T]) ValidateComparable added in v0.10.0 

func (c NotNilConstraint[T]) ValidateComparable(ctx context.Context, validator *validation.Validator, value *T) error

func (NotNilConstraint[T]) ValidateNil 

func (c NotNilConstraint[T]) ValidateNil(ctx context.Context, validator *validation.Validator, isNil bool) error

func (NotNilConstraint[T]) ValidateNumber 

func (c NotNilConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (NotNilConstraint[T]) ValidateString 

func (c NotNilConstraint[T]) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (NotNilConstraint[T]) ValidateTime 

func (c NotNilConstraint[T]) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (NotNilConstraint[T]) When 

func (c NotNilConstraint[T]) When(condition bool) NotNilConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (NotNilConstraint[T]) WhenGroups added in v0.8.0 

func (c NotNilConstraint[T]) WhenGroups(groups ...string) NotNilConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (NotNilConstraint[T]) WithError added in v0.13.0 

func (c NotNilConstraint[T]) WithError(err error) NotNilConstraint[T]

WithError overrides default error for produced violation.

func (NotNilConstraint[T]) WithMessage added in v0.13.0 

func (c NotNilConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) NotNilConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type NumberComparisonConstraint 

type NumberComparisonConstraint[T validation.Numeric] struct {
	// contains filtered or unexported fields
}

NumberComparisonConstraint is used for various numeric comparisons between integer and float values.

func IsDivisibleBy added in v0.17.0 

func IsDivisibleBy[
	T ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64,
](
	divisor T,
) NumberComparisonConstraint[T]

IsDivisibleBy checks that an integer value is divisible by another value (divisor). It checks that the remainder is zero. A zero divisor produces a constraint configuration error.

func IsDivisibleByFloat added in v0.17.0 

func IsDivisibleByFloat[T ~float32 | ~float64](divisor T) NumberComparisonConstraint[T]

IsDivisibleByFloat checks that a float value is divisible by another value (divisor). It checks that the remainder is zero or almost zero with an error of 1e-12. A zero divisor produces a constraint configuration error.

func IsGreaterThan added in v0.9.0 

func IsGreaterThan[T validation.Numeric](value T) NumberComparisonConstraint[T]

IsGreaterThan checks that the number is greater than the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsGreaterThan(1))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsGreaterThan(1.1))),
	)
}

Output:
violation: "This value should be greater than 1."
violation: "This value should be greater than 1.1."

func IsGreaterThanOrEqual added in v0.9.0 

func IsGreaterThanOrEqual[T validation.Numeric](value T) NumberComparisonConstraint[T]

IsGreaterThanOrEqual checks that the number is greater than or equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsGreaterThanOrEqual(2))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsGreaterThanOrEqual(1.2))),
	)
}

Output:
violation: "This value should be greater than or equal to 2."
violation: "This value should be greater than or equal to 1.2."

func IsLessThan added in v0.9.0 

func IsLessThan[T validation.Numeric](value T) NumberComparisonConstraint[T]

IsLessThan checks that the number is less than the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsLessThan(1))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsLessThan(1.1))),
	)
}

Output:
violation: "This value should be less than 1."
violation: "This value should be less than 1.1."

func IsLessThanOrEqual added in v0.9.0 

func IsLessThanOrEqual[T validation.Numeric](value T) NumberComparisonConstraint[T]

IsLessThanOrEqual checks that the number is less than or equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsLessThanOrEqual(0))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsLessThanOrEqual(0.1))),
	)
}

Output:
violation: "This value should be less than or equal to 0."
violation: "This value should be less than or equal to 0.1."

func IsNegative 

func IsNegative[T validation.Numeric]() NumberComparisonConstraint[T]

IsNegative checks that the value is a negative number. Zero is neither positive nor negative. If you want to allow zero use IsNegativeOrZero comparison.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsNegative[int]())),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsNegative[float64]())),
	)
}

Output:
violation: "This value should be negative."
violation: "This value should be negative."

func IsNegativeOrZero 

func IsNegativeOrZero[T validation.Numeric]() NumberComparisonConstraint[T]

IsNegativeOrZero checks that the value is a negative number or equal to zero. If you don't want to allow zero as a valid value, use IsNegative comparison.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsNegativeOrZero[int]())),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsNegativeOrZero[float64]())),
	)
}

Output:
violation: "This value should be either negative or zero."
violation: "This value should be either negative or zero."

func IsPositive 

func IsPositive[T validation.Numeric]() NumberComparisonConstraint[T]

IsPositive checks that the value is a positive number. Zero is neither positive nor negative. If you want to allow zero use IsPositiveOrZero comparison.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](-1, it.IsPositive[int]())),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](-1.1, it.IsPositive[float64]())),
	)
}

Output:
violation: "This value should be positive."
violation: "This value should be positive."

func IsPositiveOrZero 

func IsPositiveOrZero[T validation.Numeric]() NumberComparisonConstraint[T]

IsPositiveOrZero checks that the value is a positive number or equal to zero. If you don't want to allow zero as a valid value, use IsPositive comparison.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](-1, it.IsPositiveOrZero[int]())),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](-1.1, it.IsPositiveOrZero[float64]())),
	)
}

Output:
violation: "This value should be either positive or zero."
violation: "This value should be either positive or zero."

func (NumberComparisonConstraint[T]) Validate added in v0.19.0 

func (c NumberComparisonConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (NumberComparisonConstraint[T]) ValidateNumber 

func (c NumberComparisonConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (NumberComparisonConstraint[T]) When 

func (c NumberComparisonConstraint[T]) When(condition bool) NumberComparisonConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (NumberComparisonConstraint[T]) WhenGroups added in v0.8.0 

func (c NumberComparisonConstraint[T]) WhenGroups(groups ...string) NumberComparisonConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (NumberComparisonConstraint[T]) WithError added in v0.13.0 

func (c NumberComparisonConstraint[T]) WithError(err error) NumberComparisonConstraint[T]

WithError overrides default error for produced violation.

func (NumberComparisonConstraint[T]) WithMessage added in v0.13.0 

func (c NumberComparisonConstraint[T]) WithMessage(
	template string,
	parameters ...validation.TemplateParameter,
) NumberComparisonConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ comparedValue }} - the expected value;
{{ value }} - the current (invalid) value.

type PasswordStrengthConstraint added in v0.20.0 

type PasswordStrengthConstraint struct {
	// contains filtered or unexported fields
}

PasswordStrengthConstraint checks a minimum heuristic password score. Nil values are skipped. Empty strings are evaluated, unlike most string constraints. Passwords are never automatically included in violation messages or parameters.

func HasPasswordStrength added in v0.20.0 

func HasPasswordStrength() PasswordStrengthConstraint

HasPasswordStrength requires at least Medium strength using Symfony's byte-based heuristic. See validate.EstimatePasswordStrength for its limitations.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validate"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("password", it.HasPasswordStrength().WithMinScore(validate.PasswordStrengthStrong)))
	fmt.Println(err)
}

Output:
violation: "The password strength is too low. Please use a stronger password."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Reasonable-pwd", it.HasPasswordStrength()))
	fmt.Println(err)
}

Output:
<nil>

func (PasswordStrengthConstraint) Validate added in v0.20.0 

func (c PasswordStrengthConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint[string] for validation.This and validation.Each.

func (PasswordStrengthConstraint) ValidateString added in v0.20.0 

func (c PasswordStrengthConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString validates an optional password without storing it in a violation.

func (PasswordStrengthConstraint) When added in v0.20.0 

func (c PasswordStrengthConstraint) When(condition bool) PasswordStrengthConstraint

When disables validation when condition is false.

func (PasswordStrengthConstraint) WhenGroups added in v0.20.0 

func (c PasswordStrengthConstraint) WhenGroups(groups ...string) PasswordStrengthConstraint

WhenGroups limits validation to the specified groups.

func (PasswordStrengthConstraint) WithError added in v0.20.0 

func (c PasswordStrengthConstraint) WithError(err error) PasswordStrengthConstraint

WithError overrides the error for a password below the required strength.

func (PasswordStrengthConstraint) WithEstimator added in v0.20.0 

func (c PasswordStrengthConstraint) WithEstimator(estimator validate.PasswordStrengthEstimator) PasswordStrengthConstraint

WithEstimator sets a custom estimator returning 0–4. Nil restores the default. A custom estimator must be safe for concurrent calls if the constraint is shared.

func (PasswordStrengthConstraint) WithMessage added in v0.20.0 

func (c PasswordStrengthConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) PasswordStrengthConstraint

WithMessage sets a custom message with {{ strength }} and {{ minScore }} parameters. There is no automatic {{ value }} parameter containing the password.

func (PasswordStrengthConstraint) WithMinScore added in v0.20.0 

func (c PasswordStrengthConstraint) WithMinScore(score validate.PasswordStrengthScore) PasswordStrengthConstraint

WithMinScore sets the inclusive minimum, from Weak (1) to VeryStrong (4).

type RangeConstraint 

type RangeConstraint[T validation.Numeric] struct {
	// contains filtered or unexported fields
}

RangeConstraint is used to check that a given number value is between some minimum and maximum.

func IsBetween added in v0.9.0 

func IsBetween[T validation.Numeric](vMin, vMax T) RangeConstraint[T]

IsBetween checks that the number is between specified minimum and maximum numeric values.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[int](1, it.IsBetween(10, 20))),
	)
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Number[float64](1.1, it.IsBetween(10.111, 20.222))),
	)
}

Output:
violation: "This value should be between 10 and 20."
violation: "This value should be between 10.111 and 20.222."

func (RangeConstraint[T]) Name 

func (c RangeConstraint[T]) Name() string

Name is the constraint name.

func (RangeConstraint[T]) Validate added in v0.19.0 

func (c RangeConstraint[T]) Validate(ctx context.Context, validator *validation.Validator, v T) error

Validate implements validation.Constraint[T] so the constraint can be used with validation.Each and validation.This.

func (RangeConstraint[T]) ValidateNumber 

func (c RangeConstraint[T]) ValidateNumber(ctx context.Context, validator *validation.Validator, value *T) error

func (RangeConstraint[T]) When 

func (c RangeConstraint[T]) When(condition bool) RangeConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (RangeConstraint[T]) WhenGroups added in v0.8.0 

func (c RangeConstraint[T]) WhenGroups(groups ...string) RangeConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (RangeConstraint[T]) WithError added in v0.13.0 

func (c RangeConstraint[T]) WithError(err error) RangeConstraint[T]

WithError overrides default error for produced violation.

func (RangeConstraint[T]) WithMessage added in v0.13.0 

func (c RangeConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) RangeConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ max }} - the upper limit;
{{ min }} - the lower limit;
{{ value }} - the current (invalid) value.

type RegexpConstraint added in v0.13.0 

type RegexpConstraint struct {
	// contains filtered or unexported fields
}

RegexpConstraint is used to ensure that the given value corresponds to regex pattern.

func DoesNotMatch 

func DoesNotMatch(regex *regexp.Regexp) RegexpConstraint

DoesNotMatch creates a RegexpConstraint for checking whether a value does not match a regular expression.

Example 
package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo"
	err := validator.ValidateString(context.Background(), v, it.DoesNotMatch(regexp.MustCompile("^[a-z]+$")))
	fmt.Println(err)
}

Output:
violation: "This value is not valid."

func Matches 

func Matches(regex *regexp.Regexp) RegexpConstraint

Matches creates a RegexpConstraint for checking whether a value matches a regular expression.

Example 
package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "foo123"
	err := validator.ValidateString(context.Background(), v, it.Matches(regexp.MustCompile("^[a-z]+$")))
	fmt.Println(err)
}

Output:
violation: "This value is not valid."

func (RegexpConstraint) Validate added in v0.19.0 

func (c RegexpConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (RegexpConstraint) ValidateString added in v0.13.0 

func (c RegexpConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (RegexpConstraint) When added in v0.13.0 

func (c RegexpConstraint) When(condition bool) RegexpConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (RegexpConstraint) WhenGroups added in v0.13.0 

func (c RegexpConstraint) WhenGroups(groups ...string) RegexpConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (RegexpConstraint) WithError added in v0.13.0 

func (c RegexpConstraint) WithError(err error) RegexpConstraint

WithError overrides default error for produced violation.

func (RegexpConstraint) WithMessage added in v0.13.0 

func (c RegexpConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) RegexpConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

type SkipUniqueItemFunc added in v0.19.0 

type SkipUniqueItemFunc[T any] func(item T) bool

SkipUniqueItemFunc determines whether a slice element should be skipped in uniqueness check.

type TimeComparisonConstraint 

type TimeComparisonConstraint struct {
	// contains filtered or unexported fields
}

TimeComparisonConstraint is used to compare time values.

func IsEarlierThan 

func IsEarlierThan(value time.Time) TimeComparisonConstraint

IsEarlierThan checks that the given time is earlier than the specified value.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t, _ := time.Parse(time.RFC3339, "2009-02-04T21:00:57-08:00")
	t2, _ := time.Parse(time.RFC3339, "2009-02-03T21:00:57-08:00")
	err := validator.ValidateTime(context.Background(), t, it.IsEarlierThan(t2))
	fmt.Println(err)
}

Output:
violation: "This value should be earlier than 2009-02-03T21:00:57-08:00."

func IsEarlierThanOrEqual 

func IsEarlierThanOrEqual(value time.Time) TimeComparisonConstraint

IsEarlierThanOrEqual checks that the given time is earlier or equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t, _ := time.Parse(time.RFC3339, "2009-02-04T21:00:57-08:00")
	t2, _ := time.Parse(time.RFC3339, "2009-02-03T21:00:57-08:00")
	err := validator.ValidateTime(context.Background(), t, it.IsEarlierThanOrEqual(t2))
	fmt.Println(err)
}

Output:
violation: "This value should be earlier than or equal to 2009-02-03T21:00:57-08:00."

func IsLaterThan 

func IsLaterThan(value time.Time) TimeComparisonConstraint

IsLaterThan checks that the given time is later than the specified value.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t, _ := time.Parse(time.RFC3339, "2009-02-04T21:00:57-08:00")
	t2, _ := time.Parse(time.RFC3339, "2009-02-05T21:00:57-08:00")
	err := validator.ValidateTime(context.Background(), t, it.IsLaterThan(t2))
	fmt.Println(err)
}

Output:
violation: "This value should be later than 2009-02-05T21:00:57-08:00."

func IsLaterThanOrEqual 

func IsLaterThanOrEqual(value time.Time) TimeComparisonConstraint

IsLaterThanOrEqual checks that the given time is later or equal to the specified value.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t, _ := time.Parse(time.RFC3339, "2009-02-04T21:00:57-08:00")
	t2, _ := time.Parse(time.RFC3339, "2009-02-05T21:00:57-08:00")
	err := validator.ValidateTime(context.Background(), t, it.IsLaterThanOrEqual(t2))
	fmt.Println(err)
}

Output:
violation: "This value should be later than or equal to 2009-02-05T21:00:57-08:00."

func (TimeComparisonConstraint) Validate added in v0.19.0 

func (c TimeComparisonConstraint) Validate(ctx context.Context, validator *validation.Validator, v time.Time) error

Validate implements validation.Constrainttime.Time so the constraint can be used with validation.Each and validation.This.

func (TimeComparisonConstraint) ValidateTime 

func (c TimeComparisonConstraint) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (TimeComparisonConstraint) When 

func (c TimeComparisonConstraint) When(condition bool) TimeComparisonConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (TimeComparisonConstraint) WhenGroups added in v0.8.0 

func (c TimeComparisonConstraint) WhenGroups(groups ...string) TimeComparisonConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (TimeComparisonConstraint) WithError added in v0.13.0 

func (c TimeComparisonConstraint) WithError(err error) TimeComparisonConstraint

WithError overrides default error for produced violation.

func (TimeComparisonConstraint) WithLayout added in v0.13.0 

func (c TimeComparisonConstraint) WithLayout(layout string) TimeComparisonConstraint

WithLayout can be used to set the layout that is used to format time values.

func (TimeComparisonConstraint) WithMessage added in v0.13.0 

func (c TimeComparisonConstraint) WithMessage(
	template string,
	parameters ...validation.TemplateParameter,
) TimeComparisonConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ comparedValue }} - the expected value;
{{ value }} - the current (invalid) value.

All values are formatted by the layout that can be defined by the TimeComparisonConstraint.WithLayout method. Default layout is time.RFC3339.

type TimeRangeConstraint 

type TimeRangeConstraint struct {
	// contains filtered or unexported fields
}

TimeRangeConstraint is used to check that a given time value is between some minimum and maximum.

func IsBetweenTime 

func IsBetweenTime(vMin, vMax time.Time) TimeRangeConstraint

IsBetweenTime checks that the time is between specified minimum and maximum time values.

Example 
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	t, _ := time.Parse(time.RFC3339, "2009-02-04T21:00:57-08:00")
	after, _ := time.Parse(time.RFC3339, "2009-02-05T21:00:57-08:00")
	before, _ := time.Parse(time.RFC3339, "2009-02-06T21:00:57-08:00")
	err := validator.ValidateTime(context.Background(), t, it.IsBetweenTime(after, before))
	fmt.Println(err)
}

Output:
violation: "This value should be between 2009-02-05T21:00:57-08:00 and 2009-02-06T21:00:57-08:00."

func (TimeRangeConstraint) Validate added in v0.19.0 

func (c TimeRangeConstraint) Validate(ctx context.Context, validator *validation.Validator, v time.Time) error

Validate implements validation.Constrainttime.Time so the constraint can be used with validation.Each and validation.This.

func (TimeRangeConstraint) ValidateTime 

func (c TimeRangeConstraint) ValidateTime(ctx context.Context, validator *validation.Validator, value *time.Time) error

func (TimeRangeConstraint) When 

func (c TimeRangeConstraint) When(condition bool) TimeRangeConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (TimeRangeConstraint) WhenGroups added in v0.8.0 

func (c TimeRangeConstraint) WhenGroups(groups ...string) TimeRangeConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (TimeRangeConstraint) WithError added in v0.13.0 

func (c TimeRangeConstraint) WithError(err error) TimeRangeConstraint

WithError overrides default error for produced violation.

func (TimeRangeConstraint) WithLayout added in v0.13.0 

func (c TimeRangeConstraint) WithLayout(layout string) TimeRangeConstraint

WithLayout can be used to set the layout that is used to format time values.

func (TimeRangeConstraint) WithMessage added in v0.13.0 

func (c TimeRangeConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) TimeRangeConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ max }} - the upper limit;
{{ min }} - the lower limit;
{{ value }} - the current (invalid) value.

All values are formatted by the layout that can be defined by the TimeRangeConstraint.WithLayout method. Default layout is time.RFC3339.

type TimezoneConstraint added in v0.20.0 

type TimezoneConstraint struct {
	// contains filtered or unexported fields
}

TimezoneConstraint validates whether the string value is a known IANA timezone identifier. See validate.Timezone for the supported identifiers. Use TimezoneConstraint.WithZone to restrict identifiers to a geographical region.

func IsTimezone added in v0.20.0 

func IsTimezone() TimezoneConstraint

IsTimezone validates whether the string value is a known IANA timezone identifier. See TimezoneConstraint for configuration options.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("EST", it.IsTimezone()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid timezone."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Europe/Berlin", it.IsTimezone()))
	fmt.Println(err)
}

Output:
<nil>

func (TimezoneConstraint) Validate added in v0.20.0 

func (c TimezoneConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (TimezoneConstraint) ValidateString added in v0.20.0 

func (c TimezoneConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (TimezoneConstraint) When added in v0.20.0 

func (c TimezoneConstraint) When(condition bool) TimezoneConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (TimezoneConstraint) WhenGroups added in v0.20.0 

func (c TimezoneConstraint) WhenGroups(groups ...string) TimezoneConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (TimezoneConstraint) WithError added in v0.20.0 

func (c TimezoneConstraint) WithError(err error) TimezoneConstraint

WithError overrides default error for produced violation.

func (TimezoneConstraint) WithMessage added in v0.20.0 

func (c TimezoneConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) TimezoneConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (TimezoneConstraint) WithZone added in v0.20.0 

func (c TimezoneConstraint) WithZone(zone validate.TimezoneZone) TimezoneConstraint

WithZone restricts valid timezone identifiers to the given geographical region (default accepts any IANA zone). Allowed values are validate.TimezoneZoneAll, validate.TimezoneZoneAfrica, validate.TimezoneZoneAmerica, validate.TimezoneZoneAntarctica, validate.TimezoneZoneArctic, validate.TimezoneZoneAsia, validate.TimezoneZoneAtlantic, validate.TimezoneZoneAustralia, validate.TimezoneZoneEurope, validate.TimezoneZoneIndian, and validate.TimezoneZonePacific.

type URLConstraint added in v0.2.0 

type URLConstraint struct {
	// contains filtered or unexported fields
}

URLConstraint is used to validate URL string. This constraint doesn’t check that the host of the given URL really exists, because the information of the DNS records is not reliable.

This constraint doesn't check the length of the URL. Use LengthConstraint to check the length of the given value.

func IsURL added in v0.2.0 

func IsURL() URLConstraint

IsURL creates a URLConstraint to validate an URL. By default, constraint checks only for the http:// and https:// schemas. Use the WithSchemas method to configure the list of expected schemas. Also, you can use WithRelativeSchema to enable support of the relative schema (without schema, e.g. "//example.com").

Example (InvalidURL) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsURL()))
	fmt.Println(err)
}

Output:
violation: "This value is not a valid URL."
Example (ValidURL) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "http://example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsURL()))
	fmt.Println(err)
}

Output:
<nil>

func (URLConstraint) Validate added in v0.19.0 

func (c URLConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (URLConstraint) ValidateString added in v0.2.0 

func (c URLConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (URLConstraint) When added in v0.2.0 

func (c URLConstraint) When(condition bool) URLConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (URLConstraint) WhenGroups added in v0.8.0 

func (c URLConstraint) WhenGroups(groups ...string) URLConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (URLConstraint) WithError added in v0.13.0 

func (c URLConstraint) WithError(err error) URLConstraint

WithError overrides default error for produced violation.

func (URLConstraint) WithHostMatches added in v0.14.0 

func (c URLConstraint) WithHostMatches(pattern *regexp.Regexp) URLConstraint

WithHostMatches is used to set up restricted host validation by regexp pattern. If pattern is nil, then validation will be ignored.

Example 
package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"valid:",
		validator.Validate(
			context.Background(),
			validation.String("https://sub.example.com", it.IsURL().WithHostMatches(regexp.MustCompile(`^.*\.example\.com`))),
		),
	)
	fmt.Println(
		"invalid:",
		validator.Validate(
			context.Background(),
			validation.String("https://sub.sample.com", it.IsURL().WithHostMatches(regexp.MustCompile(`^.*\.example\.com`))),
		),
	)
}

Output:
valid: <nil>
invalid: violation: "This URL is prohibited to use."

func (URLConstraint) WithHosts added in v0.14.0 

func (c URLConstraint) WithHosts(hosts ...string) URLConstraint

WithHosts is used to set up a list of accepted hosts. If the list is empty, then any host will be treated as valid.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"valid:",
		validator.Validate(
			context.Background(),
			validation.String("https://example.com", it.IsURL().WithHosts("example.com")),
		),
	)
	fmt.Println(
		"invalid:",
		validator.Validate(
			context.Background(),
			validation.String("https://sample.com", it.IsURL().WithHosts("example.com")),
		),
	)
}

Output:
valid: <nil>
invalid: violation: "This URL is prohibited to use."

func (URLConstraint) WithMessage added in v0.13.0 

func (c URLConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) URLConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (URLConstraint) WithProhibitedError added in v0.14.0 

func (c URLConstraint) WithProhibitedError(err error) URLConstraint

WithProhibitedError overrides default error for produced violation on a prohibited value.

func (URLConstraint) WithProhibitedMessage added in v0.14.0 

func (c URLConstraint) WithProhibitedMessage(template string, parameters ...validation.TemplateParameter) URLConstraint

WithProhibitedMessage sets the violation message template for violation on a prohibited value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (URLConstraint) WithRelativeSchema added in v0.2.0 

func (c URLConstraint) WithRelativeSchema() URLConstraint

WithRelativeSchema enables support of relative URL schema, which means that URL value may be treated as relative (without schema, e.g. "//example.com").

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "//example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsURL().WithRelativeSchema()))
	fmt.Println(err)
}

Output:
<nil>

func (URLConstraint) WithRestriction added in v0.14.0 

func (c URLConstraint) WithRestriction(isAllowed func(u *url.URL) bool) URLConstraint

WithRestriction is used to additionally check parsed URL by callback function.

Example 
package main

import (
	"context"
	"fmt"
	"net/url"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	fmt.Println(
		"valid:",
		validator.Validate(
			context.Background(),
			validation.String("https://example.com", it.IsURL().WithRestriction(func(u *url.URL) bool {
				return u.Host == "example.com"
			})),
		),
	)
	fmt.Println(
		"invalid:",
		validator.Validate(
			context.Background(),
			validation.String("https://sample.com", it.IsURL().WithRestriction(func(u *url.URL) bool {
				return u.Host == "example.com"
			})),
		),
	)
}

Output:
valid: <nil>
invalid: violation: "This URL is prohibited to use."

func (URLConstraint) WithSchemas added in v0.2.0 

func (c URLConstraint) WithSchemas(schemas ...string) URLConstraint

WithSchemas is used to set up a list of accepted schemas. For example, if you also consider the ftp:// type URLs to be valid, redefine the schemas list, listing http, https, and also ftp. If the list is empty, then an error will be returned.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	v := "ftp://example.com"
	err := validator.Validate(context.Background(), validation.String(v, it.IsURL().WithSchemas("http", "https", "ftp")))
	fmt.Println(err)
}

Output:
<nil>

type UUIDConstraint added in v0.17.0 

type UUIDConstraint struct {
	// contains filtered or unexported fields
}

UUIDConstraint validates whether a string value is a valid UUID (also known as GUID).

By default, it uses strict mode and checks the UUID as specified in RFC 4122. To parse additional formats, use the UUIDConstraint.NonCanonical method.

In addition, it checks if the UUID version matches one of the registered versions: 1, 2, 3, 4, 5, 6 or 7. Use UUIDConstraint.WithVersions to validate for a specific set of versions.

Nil UUID ("00000000-0000-0000-0000-000000000000") values are considered as valid. Use UUIDConstraint.NotNil to disallow nil value.

See http://tools.ietf.org/html/rfc4122 for specifications.

func IsUUID added in v0.17.0 

func IsUUID() UUIDConstraint

IsUUID validates whether a string value is a valid UUID (also known as GUID). See UUIDConstraint for more info.

func (UUIDConstraint) NonCanonical added in v0.17.0 

func (c UUIDConstraint) NonCanonical() UUIDConstraint

NonCanonical used to enable parsing UUID value from non-canonical formats.

Following formats are supported:

  • "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
  • "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
  • "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
  • "6ba7b8109dad11d180b400c04fd430c8"
  • "{6ba7b8109dad11d180b400c04fd430c8}",
  • "urn:uuid:6ba7b8109dad11d180b400c04fd430c8".

func (UUIDConstraint) NotNil added in v0.17.0 

func (c UUIDConstraint) NotNil() UUIDConstraint

NotNil used to treat nil UUID ("00000000-0000-0000-0000-000000000000") value as invalid.

func (UUIDConstraint) Validate added in v0.19.0 

func (c UUIDConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (UUIDConstraint) ValidateString added in v0.17.0 

func (c UUIDConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

func (UUIDConstraint) When added in v0.17.0 

func (c UUIDConstraint) When(condition bool) UUIDConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (UUIDConstraint) WhenGroups added in v0.17.0 

func (c UUIDConstraint) WhenGroups(groups ...string) UUIDConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (UUIDConstraint) WithError added in v0.17.0 

func (c UUIDConstraint) WithError(err error) UUIDConstraint

WithError overrides default error for produced violation.

func (UUIDConstraint) WithMessage added in v0.17.0 

func (c UUIDConstraint) WithMessage(template string, parameters ...validation.TemplateParameter) UUIDConstraint

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ value }} - the current (invalid) value.

func (UUIDConstraint) WithVersions added in v0.17.0 

func (c UUIDConstraint) WithVersions(versions ...byte) UUIDConstraint

WithVersions used to set valid versions of the UUID value. By default, the UUID will be checked for compliance with the default registered versions: 1, 2, 3, 4, 5, 6 or 7.

type UniqueByConstraint added in v0.19.0 

type UniqueByConstraint[T any, K comparable] struct {
	// contains filtered or unexported fields
}

UniqueByConstraint is used to check that all elements of the given slice are unique by key. Use HasUniqueValuesBy to create it. The constraint implements validation.SliceConstraint.

func HasUniqueValuesBy added in v0.19.0 

func HasUniqueValuesBy[T any, K comparable](keyFunc UniqueItemKeyFunc[T, K]) UniqueByConstraint[T, K]

HasUniqueValuesBy checks that all elements of the given slice are unique by the key returned by keyFunc. Use with validation.Slice or validation.SliceProperty.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	type item struct {
		ID string
	}
	items := []item{{ID: "a"}, {ID: "b"}, {ID: "a"}}

	err := validator.Validate(
		context.Background(),
		validation.Slice(items, it.HasUniqueValuesBy(func(x item) string { return x.ID })),
	)

	fmt.Println(err)
}

Output:
violations: #0 at "[0]": "This collection should contain only unique elements."; #1 at "[2]": "This collection should contain only unique elements."
Example (SkipEmptyKeys) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	type item struct {
		ID string
	}
	// Elements with empty key are excluded from the uniqueness check.
	items := []item{{ID: ""}, {ID: "a"}, {ID: "b"}, {ID: ""}}

	err := validator.Validate(
		context.Background(),
		validation.Slice(items, it.HasUniqueValuesBy(func(x item) string { return x.ID }).SkipEmptyKeys()),
	)

	fmt.Println(err)
}

Output:
<nil>
Example (SkipWhen) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	type item struct {
		ID string
	}
	// Empty ID items are skipped; only "a" and "b" are checked for uniqueness.
	items := []item{{ID: ""}, {ID: "a"}, {ID: "b"}, {ID: ""}}

	err := validator.Validate(
		context.Background(),
		validation.Slice(items, it.HasUniqueValuesBy(func(x item) string { return x.ID }).
			SkipWhen(func(x item) bool { return x.ID == "" })),
	)

	fmt.Println(err)
}

Output:
<nil>

func (UniqueByConstraint[T, K]) At added in v0.19.0 

func (c UniqueByConstraint[T, K]) At(propertyPath ...validation.PropertyPathElement) UniqueByConstraint[T, K]

At appends elements to the property path of produced violations (e.g. for nested paths).

func (UniqueByConstraint[T, K]) SkipEmptyKeys added in v0.20.0 

func (c UniqueByConstraint[T, K]) SkipEmptyKeys() UniqueByConstraint[T, K]

SkipEmptyKeys makes the constraint ignore elements whose key is the zero value for K. Such elements are excluded from the uniqueness check and do not cause violations.

func (UniqueByConstraint[T, K]) SkipWhen added in v0.19.0 

func (c UniqueByConstraint[T, K]) SkipWhen(skip SkipUniqueItemFunc[T]) UniqueByConstraint[T, K]

SkipWhen sets a function to skip elements that should not participate in the uniqueness check.

func (UniqueByConstraint[T, K]) ValidateSlice added in v0.19.0 

func (c UniqueByConstraint[T, K]) ValidateSlice(ctx context.Context, validator *validation.Validator, items []T) error

ValidateSlice implements validation.SliceConstraint[T].

func (UniqueByConstraint[T, K]) When added in v0.19.0 

func (c UniqueByConstraint[T, K]) When(condition bool) UniqueByConstraint[T, K]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (UniqueByConstraint[T, K]) WhenGroups added in v0.19.0 

func (c UniqueByConstraint[T, K]) WhenGroups(groups ...string) UniqueByConstraint[T, K]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (UniqueByConstraint[T, K]) WithError added in v0.19.0 

func (c UniqueByConstraint[T, K]) WithError(err error) UniqueByConstraint[T, K]

WithError overrides default error for produced violation.

func (UniqueByConstraint[T, K]) WithMessage added in v0.19.0 

func (c UniqueByConstraint[T, K]) WithMessage(template string, parameters ...validation.TemplateParameter) UniqueByConstraint[T, K]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type UniqueConstraint added in v0.4.0 

type UniqueConstraint[T comparable] struct {
	// contains filtered or unexported fields
}

UniqueConstraint is used to check that all elements of the given collection are unique.

func HasUniqueValues added in v0.4.0 

func HasUniqueValues[T comparable]() UniqueConstraint[T]

HasUniqueValues checks that all elements of the given collection are unique (none of them is present more than once).

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	strings := []string{"foo", "bar", "baz", "foo"}
	ints := []int{1, 2, 3, 1}
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparables[string](strings, it.HasUniqueValues[string]()),
	))
	fmt.Println(validator.Validate(
		context.Background(),
		validation.Comparables[int](ints, it.HasUniqueValues[int]()),
	))
}

Output:
violation: "This collection should contain only unique elements."
violation: "This collection should contain only unique elements."

func (UniqueConstraint[T]) ValidateComparables added in v0.9.0 

func (c UniqueConstraint[T]) ValidateComparables(ctx context.Context, validator *validation.Validator, values []T) error

func (UniqueConstraint[T]) When added in v0.4.0 

func (c UniqueConstraint[T]) When(condition bool) UniqueConstraint[T]

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (UniqueConstraint[T]) WhenGroups added in v0.8.0 

func (c UniqueConstraint[T]) WhenGroups(groups ...string) UniqueConstraint[T]

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (UniqueConstraint[T]) WithError added in v0.13.0 

func (c UniqueConstraint[T]) WithError(err error) UniqueConstraint[T]

WithError overrides default error for produced violation.

func (UniqueConstraint[T]) WithMessage added in v0.13.0 

func (c UniqueConstraint[T]) WithMessage(template string, parameters ...validation.TemplateParameter) UniqueConstraint[T]

WithMessage sets the violation message template. You can set custom template parameters for injecting its values into the final message.

type UniqueItemKeyFunc added in v0.19.0 

type UniqueItemKeyFunc[T any, K comparable] func(item T) (key K)

UniqueItemKeyFunc extracts a comparable key from a slice element for uniqueness check.

type WeekConstraint added in v0.20.0 

type WeekConstraint struct {
	// contains filtered or unexported fields
}

WeekConstraint validates ISO weeks with optional inclusive bounds. See validate.Week for the format and literal year range 0000–9999. Nil and empty values are ignored. Use IsNotBlank to require a value.

func IsWeek added in v0.20.0 

func IsWeek() WeekConstraint

IsWeek creates a constraint for ISO weeks in YYYY-Www format. WithMin and WithMax restrict the range; malformed or reversed bounds produce a constraint configuration error during validation.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("2021-W53", it.IsWeek()))
	fmt.Println(err)
}

Output:
violation: "Week 2021-W53 does not exist in its ISO year."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("2020-W53", it.IsWeek().WithMin("2020-W01").WithMax("2021-W01")))
	fmt.Println(err)
}

Output:
<nil>

func (WeekConstraint) Validate added in v0.20.0 

func (c WeekConstraint) Validate(ctx context.Context, validator *validation.Validator, value string) error

Validate implements validation.Constraint[string] for validation.This and validation.Each.

func (WeekConstraint) ValidateString added in v0.20.0 

func (c WeekConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString validates an optional ISO week string.

func (WeekConstraint) When added in v0.20.0 

func (c WeekConstraint) When(condition bool) WeekConstraint

When disables validation when condition is false.

func (WeekConstraint) WhenGroups added in v0.20.0 

func (c WeekConstraint) WhenGroups(groups ...string) WeekConstraint

WhenGroups limits validation to the specified groups.

func (WeekConstraint) WithFormatError added in v0.20.0 

func (c WeekConstraint) WithFormatError(err error) WeekConstraint

WithFormatError overrides the underlying error for the format check.

func (WeekConstraint) WithFormatMessage added in v0.20.0 

func (c WeekConstraint) WithFormatMessage(template string, parameters ...validation.TemplateParameter) WeekConstraint

WithFormatMessage overrides the message for the format check. Available parameters are {{ value }}, {{ min }}, and {{ max }}.

func (WeekConstraint) WithMax added in v0.20.0 

func (c WeekConstraint) WithMax(value string) WeekConstraint

WithMax sets the inclusive maximum ISO week; empty removes the bound.

func (WeekConstraint) WithMaxError added in v0.20.0 

func (c WeekConstraint) WithMaxError(err error) WeekConstraint

WithMaxError overrides the underlying error for the max check.

func (WeekConstraint) WithMaxMessage added in v0.20.0 

func (c WeekConstraint) WithMaxMessage(template string, parameters ...validation.TemplateParameter) WeekConstraint

WithMaxMessage overrides the message for the max check. Available parameters are {{ value }}, {{ min }}, and {{ max }}.

func (WeekConstraint) WithMin added in v0.20.0 

func (c WeekConstraint) WithMin(value string) WeekConstraint

WithMin sets the inclusive minimum ISO week; empty removes the bound.

func (WeekConstraint) WithMinError added in v0.20.0 

func (c WeekConstraint) WithMinError(err error) WeekConstraint

WithMinError overrides the underlying error for the min check.

func (WeekConstraint) WithMinMessage added in v0.20.0 

func (c WeekConstraint) WithMinMessage(template string, parameters ...validation.TemplateParameter) WeekConstraint

WithMinMessage overrides the message for the min check. Available parameters are {{ value }}, {{ min }}, and {{ max }}.

func (WeekConstraint) WithWeekNumberError added in v0.20.0 

func (c WeekConstraint) WithWeekNumberError(err error) WeekConstraint

WithWeekNumberError overrides the underlying error for the number check.

func (WeekConstraint) WithWeekNumberMessage added in v0.20.0 

func (c WeekConstraint) WithWeekNumberMessage(template string, parameters ...validation.TemplateParameter) WeekConstraint

WithWeekNumberMessage overrides the message for the number check. Available parameters are {{ value }}, {{ min }}, and {{ max }}.

type WordCountConstraint added in v0.20.0 

type WordCountConstraint struct {
	// contains filtered or unexported fields
}

WordCountConstraint checks inclusive bounds on the number of words in a string. A word starts with a Unicode letter or number and continues with letters, numbers, or combining marks. Internal ASCII and curly apostrophes join words; other punctuation (including hyphens and underscores) separates them. Symbols and emoji do not count as words. Adjacent letters in scripts without spaces count as one word: this is not locale-aware ICU word segmentation. Nil and empty strings are ignored; whitespace-only strings have zero words. Use IsNotBlank as well when a value is required. Bounds must be non-negative, and minimum must not exceed maximum; invalid bounds produce a constraint configuration error during validation.

func HasMaxWordCount added in v0.20.0 

func HasMaxWordCount(vMax int) WordCountConstraint

HasMaxWordCount creates a WordCountConstraint that checks the number of words is at most the maximum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Hello world", it.HasMaxWordCount(1)))
	fmt.Println(err)
}

Output:
violation: "This value should contain at most 1 word."

func HasMinWordCount added in v0.20.0 

func HasMinWordCount(vMin int) WordCountConstraint

HasMinWordCount creates a WordCountConstraint that checks the number of words is at least the minimum value.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Hello", it.HasMinWordCount(2)))
	fmt.Println(err)
}

Output:
violation: "This value should contain at least 2 words."

func HasWordCountBetween added in v0.20.0 

func HasWordCountBetween(vMin int, vMax int) WordCountConstraint

HasWordCountBetween creates a WordCountConstraint that checks the number of words is between the inclusive minimum and maximum values.

Example (Invalid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Hello", it.HasWordCountBetween(2, 5)))
	fmt.Println(err)
}

Output:
violation: "This value should contain at least 2 words."
Example (Valid) 
package main

import (
	"context"
	"fmt"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/it"
	"github.com/muonsoft/validation/validator"
)

func main() {
	err := validator.Validate(context.Background(), validation.String("Привет, мир!", it.HasWordCountBetween(2, 5)))
	fmt.Println(err)
}

Output:
<nil>

func (WordCountConstraint) Validate added in v0.20.0 

func (c WordCountConstraint) Validate(ctx context.Context, validator *validation.Validator, v string) error

Validate implements validation.Constraint[string] so the constraint can be used with validation.Each and validation.This.

func (WordCountConstraint) ValidateString added in v0.20.0 

func (c WordCountConstraint) ValidateString(ctx context.Context, validator *validation.Validator, value *string) error

ValidateString validates a string pointer against the configured word count bounds.

func (WordCountConstraint) When added in v0.20.0 

func (c WordCountConstraint) When(condition bool) WordCountConstraint

When enables conditional validation of this constraint. If the expression evaluates to false, then the constraint will be ignored.

func (WordCountConstraint) WhenGroups added in v0.20.0 

func (c WordCountConstraint) WhenGroups(groups ...string) WordCountConstraint

WhenGroups enables conditional validation of the constraint by using the validation groups.

func (WordCountConstraint) WithMaxError added in v0.20.0 

func (c WordCountConstraint) WithMaxError(err error) WordCountConstraint

WithMaxError overrides default underlying error for violation that will be shown if the word count is greater than the maximum value.

func (WordCountConstraint) WithMaxMessage added in v0.20.0 

func (c WordCountConstraint) WithMaxMessage(template string, parameters ...validation.TemplateParameter) WordCountConstraint

WithMaxMessage sets the violation message that will be shown if the word count is greater than the maximum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current word count;
{{ limit }} - the bound;
{{ value }} - the current (invalid) value.

func (WordCountConstraint) WithMinError added in v0.20.0 

func (c WordCountConstraint) WithMinError(err error) WordCountConstraint

WithMinError overrides default underlying error for violation that will be shown if the word count is less than the minimum value.

func (WordCountConstraint) WithMinMessage added in v0.20.0 

func (c WordCountConstraint) WithMinMessage(template string, parameters ...validation.TemplateParameter) WordCountConstraint

WithMinMessage sets the violation message that will be shown if the word count is less than the minimum value. You can set custom template parameters for injecting its values into the final message. Also, you can use default parameters: 

{{ count }} - the current word count;
{{ limit }} - the bound;
{{ value }} - the current (invalid) value.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.