Primitives

string

keywords

🚧 Coming soon ™️🚧

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.

string

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

fluent

const bounded = type({
	nonEmpty: type.string.moreThanLength(0),
	atLeastLength3: type.keywords.string.alphanumeric.atLeastLength(3),
	lessThanLength10: type.string.lessThanLength(10),
	atMostLength5: type.string.atMostLength(5)
})

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

string

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

fluent

const range = type({
	nonEmptyAtMostLength10: type.string.moreThanLength(0).atMostLength(10),
	integerStringWith2To5Digits: type.keywords.string.integer.root
		.atLeastLength(2)
		.lessThanLength(6)
})

number

keywords

🚧 Coming soon ™️🚧

literals

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

ranges

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

string

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

fluent

const bounded = type({
	positive: type.number.moreThan(0),
	atLeast3: type.keywords.number.integer.atLeast(3),
	lessThanPi: type.number.lessThan(3.14159),
	atMost5: type.number.atMost(5)
})

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

string

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

fluent

const range = type({
	positiveAtMostE: type.number.moreThan(0).atMost(2.71828),
	evenNumberAbsoluteValueLessThan50: type.number
		.divisibleBy(2)
		.moreThan(-50)
		.lessThan(50)
})

divisors

Constrain a number to a multiple of the specified integer.

string

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

fluent

const evens = type({
	key: type.number.divisibleBy(2)
})

bigint

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

string

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

fluent

const symbols = type({
	foo: type.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.

string

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

fluent

const symbols = type({
	key: type.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.

string

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

fluent

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

literals

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

string

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

fluent

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

null

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

string

const nullable = type({
	requiredKey: "number | null"
})

fluent

const nullable = type({
	requiredKey: type.number.or(type.null)
})

undefined

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

string

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

fluent

const myObj = type({
	requiredKey: type.number.or(type.undefined)
})

Allowing undefined as a value does not make the key optional!

In TypeScript, a required property that allows undefined must still be present for the type to be satisfied.

The same is true in ArkType.

See an example

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({})