Validators

Validators accept or reject extracted token values. If validation fails, the tokenizer continues searching the input for another match — this is how validators act as filters.

String Checks

Validator	Arguments	Description
`IsNotEmpty()`	—	Rejects null, empty, or whitespace-only values
`Contains('text')`	substring	Value must contain the specified text
`StartsWith('prefix')`	prefix	Value must start with the specified text
`EndsWith('suffix')`	suffix	Value must end with the specified text
`MinLength(n)`	min length	Value must be at least n characters
`MaxLength(n)`	max length	Value must be at most n characters
`IsAlphanumeric()`	—	Value must contain only letters and digits
`MatchesRegex('pattern')`	regex pattern	Value must match the regex (1s timeout)

IsNotEmpty

var template = "Name: {Name:IsNotEmpty()}";
// Rejects null, empty, or whitespace-only values

Contains

var template = "Email: {Email:Contains('@')}";
// Only accepts values containing "@"

StartsWith

var template = "Id: {Id:StartsWith('USR-')}";
// Only accepts values beginning with "USR-"

EndsWith

var template = "File: {File:EndsWith('.csv')}";
// Only accepts values ending with ".csv"

MinLength

var template = "Password: {Pass:MinLength(8)}";
// Rejects values shorter than 8 characters

MaxLength

var template = "Code: {Code:MaxLength(6)}";
// Rejects values longer than 6 characters

IsAlphanumeric

var template = "Token: {Token:IsAlphanumeric()}";
// Rejects values containing spaces, punctuation, or symbols

MatchesRegex

var template = "Code: {Code:MatchesRegex('^[A-Z]{3}[0-9]{3}$')}";
// Accepts codes like "ABC123", rejects "abc" or "12345"

Type Checks

Validator	Arguments	Description
`IsInteger()`	—	Value must be a valid integer
`IsNumeric()`	—	Value must be parseable as a number
`IsDateTime('format',...)`	format strings	Value must be a valid date in one of the specified formats
`IsGuid()`	—	Value must be a valid GUID

IsInteger

var template = "Port: {Port:IsInteger()}";
// Rejects non-integer values like "abc" or "3.14"

IsNumeric

var template = "Amount: {Amount:IsNumeric()}";
// Accepts integers and decimals, rejects non-numeric text

IsDateTime

var template = "Date: {Date:IsDateTime('yyyy-MM-dd','dd/MM/yyyy')}";
// Only accepts dates matching at least one of the specified formats

IsGuid

var template = "Id: {Id:IsGuid()}";
// Only accepts well-formed GUIDs

Format Checks

Validator	Arguments	Description
`IsEmail()`	—	Value must be a valid email address
`IsUrl()`	—	Value must be an absolute, well-formed URL
`IsLooseUrl()`	—	Relative or absolute URL (tries http:// prefix)
`IsLooseAbsoluteUrl()`	—	URL-like string (tries http:// prefix)
`IsDomainName()`	—	Value must be a valid domain name
`IsIpAddress()`	—	Value must be a valid IPv4 or IPv6 address
`IsPhoneNumber()`	—	Value must look like a phone number (6+ digits)

IsEmail

var template = "Contact: {Email:IsEmail()}";
// Only accepts valid email addresses

IsUrl

var template = "Link: {Url:IsUrl()}";
// Only accepts absolute, well-formed URLs (must include scheme)

IsLooseUrl

var template = "Link: {Url:IsLooseUrl()}";
// Accepts relative or absolute URLs; tries http:// prefix if no scheme

IsLooseAbsoluteUrl

var template = "Site: {Site:IsLooseAbsoluteUrl()}";
// Accepts URL-like strings; tries http:// prefix if no scheme given

IsDomainName

var template = "Host: {Host:IsDomainName()}";
// Only accepts valid domain names

IsIpAddress

var template = "Ip: {Ip:IsIpAddress()}";
// Accepts valid IPv4 or IPv6 addresses

IsPhoneNumber

var template = "Phone: {Phone:IsPhoneNumber()}";
// Accepts values that look like a phone number (6+ digits)

Range & Comparison

Validator	Arguments	Description
`IsInRange(min,max)`	min, max	Numeric value must be within range (inclusive)
`IsNot('value')`	compare value	Value must not equal the specified string

IsInRange

var template = "Age: {Age:IsInRange(0,150)}";
// Only accepts values between 0 and 150

IsNot

var template = "Status: {Status:IsNot('unknown')}";
// Rejects the value "unknown"; accepts anything else

Validation Behavior

When a validator rejects a value, the tokenizer doesn't fail immediately. Instead, it continues searching the input for another match. This makes validators powerful filters:

var template = "Value: {Number*:IsInteger()}";
var input = "Value: abc\nValue: 42\nValue: xyz";
// Skips "abc" (not integer), matches "42", skips "xyz"

Combine validators with transformers in the same chain. Transformers run first, then validators check the transformed value:

var template = "Port: {Port:Trim(),ToInt(),IsInRange(1,65535)}";
// 1. Trim → 2. Convert to int → 3. Validate range