Primitives

string

keywords

The following keywords can be referenced in any definition, e.g.:

const email = type("string.email")

const user = type({
	data: "string.json.parse",
	ids: "string.uuid.v4[]"
})

literals

const literals = type({
	singleQuoted: "'typescript'",
	doubleQuoted: '"arktype"'
})

patterns

Regex literals specify an unanchored regular expression that an input string must match.

They can either be string-embedded or refer directly to a RegExp instance.

const literals = type({
	stringEmbedded: "/^a.*z$/",
	regexLiteral: /^a.*z$/
})

lengths

Constrain a string with an inclusive or exclusive min or max length.

const bounded = type({
	nonEmpty: "string > 0",
	atLeastLength3: "string.alphanumeric >= 3",
	lessThanLength10: "string < 10",
	atMostLength5: "string <= 5"
})

Range expressions allow you to specify both a min and max length and use the same syntax for exclusivity.

const range = type({
	nonEmptyAtMostLength10: "0 < string <= 10",
	integerStringWith2To5Digits: "2 <= string.integer < 6"
})

number

keywords

The following keywords can be referenced in any definition, e.g.:

const user = type({
	createdAt: "number.epoch",
	age: "number.integer >= 0"
})

literals

const literals = type({
	number: "1337"
})

ranges

Constrain a number with an inclusive or exclusive min or max.

const bounded = type({
	positive: "number > 0",
	atLeast3: "number.integer >= 3",
	lessThanPi: "number < 3.14159",
	atMost5: "number <= 5"
})

Range expressions allow you to specify both a min and max and use the same syntax for exclusivity.

const range = type({
	positiveAtMostE: "0 < number <= 2.71828",
	evenNumberAbsoluteValueLessThan50: "-50 < (number % 2) < 50"
})

divisors

Constrain a number to a multiple of the specified integer.

const evens = type({
	key: "number % 2"
})

bigint

To allow any bigint value, use the "bigint" keyword.

const bigints = type({
	foo: "bigint"
})

literals

To require an exact bigint value in your type, you can use add the suffix n to a string-embedded number literal to make it a bigint.

const literals = type({
	bigint: "1337n"
})

You may also use a unit expression to define bigint literals.

symbol

To allow any symbol value, use the "symbol" keyword.

const symbols = type({
	key: "symbol"
})

To reference a specific symbol in your definition, use a unit expression.

No special syntax is required to define symbolic properties like { [mySymbol]: "string" }. For more information and examples of how to combine symbolic keys with other syntax like optionality, see properties.

boolean

To allow true or false, use the "boolean" keyword.

const booleans = type({
	key: "boolean"
})

literals

To require a specific boolean value, use the corresponding literal.

const booleans = type({
	a: "true",
	b: "false",
	// equivalent to the "boolean" keyword
	c: "true | false"
})

null

The "null" keyword can be used to allow the exact value null, generally as part of a union.

const myObj = type({
	foo: "number | null"
})

undefined

The "undefined" keyword can be used to allow the exact value undefined, generally as part of a union.

const myObj = type({
	requiredKey: "number | undefined",
	"optionalKey?": "number | undefined"
})

const myObj = type({
	key: "number | undefined"
})

// valid data
const validResult = myObj({ key: undefined })

// Error: name must be a number or undefined (was missing)
const errorResult = myObj({})