API

Keywords

string

const keywords = type({
	string: "string",
	date: "Date",
	// Subtype keywords refine or transform their root type.
	dateFormattedString: "string.date",
	isoFormattedString: "string.date.iso",
	transformStringToDate: "string.date.parse"
})

fluent

const keywords = type({
	// Primitive keywords are exposed directly on `type`.
	string: type.string,
	// All builtin keywords and modules are available under `keywords`.
	date: type.keywords.Date,
	// Subtype keywords refine or transform their root type.
	// `.root` gets the base type of a subtyped module.
	dateFormattedString: type.keywords.string.date.root,
	isoFormattedString: type.keywords.string.date.iso.root,
	transformStringToDate: type.keywords.string.date.parse
})

Literals

string

const literals = type({
	number: "1337",
	bigint: "1337n",
	string: {
		singleQuoted: "'typescript'",
		doubleQuoted: '"arktype"'
	},
	date: {
    	// Date literals represent a Date instance with an exact value.
    	// They're primarily useful in ranges (see below).
    	singleQuoted: "d'01-01-1970'",
    	doubleQuoted: 'd"01-01-1970"'
    },
	keywords: ["true", "false", "null", "undefined"]
})

fluent

// `type.unit` creates a type that allows exactly one value (according to ===)
const exactValue = type.unit(1337)

// `type.enumerated` creates a type that allows a set of values (according to ===)
const exactValueFromSet = type.enumerated(1337, true, null)

Objects

const symbolicKey = Symbol()

const object = type({
	requiredKey: "string",
	"optionalKey?": "string.uuid",
	// Nested definitions don't require additional `type` calls.
	[symbolicKey]: {
		nested: "unknown"
	},
	// Index signatures are unlabeled and support arbitrary expressions.
	"[string]": "string"
})

Under Construction

We’re still working on our new docs, as evidenced by the fact that they are not done.

Check back soon for more!

Kitchen Sink (more comprehensive docs to come next week!)

export const currentTsSyntax = type({
	keyword: "null",
	stringLiteral: "'TS'",
	numberLiteral: "5",
	bigintLiteral: "5n",
	union: "string|number",
	intersection: "boolean&true",
	array: "Date[]",
	grouping: "(0|1)[]",
	objectLiteral: {
		nested: "string",
		"optional?": "number"
	},
	arrayOfObjectLiteral: [
		{
			name: "string"
		},
		"[]"
	],
	tuple: ["number", "number"],
	keyof: "keyof object",
	variadicTuples: ["true", "...", "false[]"],
	arrayOfObjectLiteralChained: type({ name: "string" }).array()
})

Constraints

// runtime-specific syntax and builtin keywords with great error messages

export const validationSyntax = type({
	keywords: "string.email | string.uuid | string.creditCard | number.integer", // and many more
	builtinParsers: "string.date.parse", // parses a Date from a string
	nativeRegexLiteral: /@arktype\.io/,
	embeddedRegexLiteral: "string.email & /@arktype\\.io/",
	divisibility: "number % 10", // a multiple of 10
	bound: "string.alpha > 10", // an alpha-only string with more than 10 characters
	range: "1 <= string.email[] < 100", // a list of 1 to 99 emails
	narrows: ["number", ":", n => n % 2 === 1], // an odd integer
	morphs: ["string", "=>", parseFloat] // validates a string input then parses it to a number
})

// root-level expressions

const intersected = type({ value: "string" }, "&", { format: "'bigint'" })

// chained expressions via .or, .and, .narrow, .pipe and much more
//  (these replace previous helper methods like union and intersection)

const user = type({
	name: "string",
	age: "number"
})

// type is fully introspectable and traversable
const parseUser = type("string").pipe(s => JSON.parse(s), user)

const maybeMe = parseUser('{ "name": "David" }')

if (maybeMe instanceof type.errors) {
	// "age must be a number (was missing)"
	console.log(maybeMe.summary)
}