Type API

const parseNumber = type("string").pipe(s => Number.parseInt(s))
type ParsedNumber = typeof parseNumber.infer // number

const parseNumber = type("string").pipe(s => Number.parseInt(s))
type UnparsedNumber = typeof parseNumber.inferIn // string

const N = type("0 < number <= 100")
console.log(N.description) // positive and at most 100

const Loc = type({ coords: ["number", "number"] })
console.log(Loc.expression) // { coords: [number, number] }

const CriticalPayload = type({
    superImportantValue: "string"
})
// throws TraversalError: superImportantValue must be a string (was missing)
const data = CriticalPayload.assert({ irrelevantValue: "whoops" })
console.log(data.superImportantValue) // valid output can be accessed directly

const Numeric = type("number | bigint")
// [0, 2n]
const numerics = [0, "one", 2n].filter(Numeric.allows)

const NotOdd = type("number % 2").configure({ description: "not odd" })
// all constraints at the root are affected
const odd = NotOdd(3) // must be not odd (was 3)
const nonNumber = NotOdd("two") // must be not odd (was "two")

const NotOddBox = type({
   // we should have referenced notOdd or added meta here
   notOdd: "number % 2",
// but instead chained from the root object
}).configure({ description: "not odd" })
// error message at path notOdd is not affected
const oddProp = NotOddBox({ notOdd: 3 }) // notOdd must be even (was 3)
// error message at root is affected, leading to a misleading description
const nonObject = NotOddBox(null) // must be not odd (was null)

const AToZ = type(/^a.*z$/).describe("a string like 'a...z'")
const good = AToZ("alcatraz") // "alcatraz"
// ArkErrors: must be a string like 'a...z' (was "albatross")
const badPattern = AToZ("albatross")

const T = type({ foo: "string" });
// TypeScript: foo must be a string (was 5)
const data = T.from({ foo: 5 });

const Palindrome = type("string")
    .narrow(s => s === [...s].reverse().join(""))
    .brand("palindrome")
// Brand<string, "palindrome">
const out = Palindrome.assert("racecar")

// Type<{ rebmun: number }[]>
const T = type({ rebmun: "number" }).array();

const Prop = type({ foo: "number" })
// Type<{ bar?: { foo: number } }>
const Obj = type({ bar: Prop.optional() })

// Type<{ count: Default<number, 0> }>
const State = type({ count: type.number.default(0) })
const Prop = type({ nested: "boolean" })
const ForObj = type({
    key: Prop.default(() => ({ nested: false }))
})

const stringifyUser = type({ name: "string" }).pipe(user => JSON.stringify(user))
const stringifySafe = stringifyUser.filter(user => user.name !== "Bobby Tables")
// Type<(In: `${string}Z`) => To<Date>>
const WithPredicate = type("string.date.parse").filter((s): s is `${string}Z` =>
    s.endsWith("Z")
)

const Palindrome = type("string").narrow(s => s === [...s].reverse().join(""))

const PalindromicEmail = type("string.date.parse").narrow((date, ctx) =>
		date.getFullYear() === 2025 || ctx.mustBe("the current year")
)
// Type<`${string}.tsx`>
const WithPredicate = type("string").narrow((s): s is `${string}.tsx` => /\.tsx?$/.test(s))

const User = type({ name: "string" })

// parse a string and validate that the result as a user
const parseUser = type("string").pipe(s => JSON.parse(s), user)

// parse a string and validate that the result as a user
const parseUser = type("string").pipe(s => JSON.parse(s)).to({ name: "string" })

// ["blue", "red"]
const values = type("'red' | 'blue'").select("unit").map(u => u.unit)

// Type<`LEEEEEEEE${string}ROY`>
const Leeroy = type(/^LE{8,}ROY$/).as<`LEEEEEEEE${string}ROY`>()

// Type<{ foo: number; bar: string }>
const T = type({ foo: "number" }).and({ bar: "string" })
// ParseError: Intersection at foo of number and string results in an unsatisfiable type
const Bad = type({ foo: "number" }).and({ foo: "string" })

// Type<string | { box: string }>
const T = type("string").or({ box: "string" })

// Type<{ foo: number; bar: string }>
const T = type({ foo: "number" }).intersect({ bar: "string" })
const Bad = type("number > 10").intersect("number < 5")
// logs "Intersection of > 10 and < 5 results in an unsatisfiable type"
if (Bad instanceof Disjoint) console.log(`${bad.summary}`)

const DivisibleBy6 = type.number.divisibleBy(6).moreThan(0)
// false (left side must also be positive)
DivisibleBy6.equals("number % 6")
// false (right side has an additional <100 constraint)
console.log(DivisibleBy6.equals("0 < (number % 6) < 100"))
const ThirdTry = type("(number % 2) > 0").divisibleBy(3)
// true (types are normalized and reduced)
console.log(DivisibleBy6.equals(ThirdTry))

const N = type.raw(`${Math.random()}`)
// Type<0.5> | undefined
const Ez = N.ifEquals("0.5")

type.string.extends("unknown") // true
type.string.extends(/^a.*z$/) // false

const N = type(Math.random() > 0.5 ? "true" : "0") // Type<0 | true>
const Ez = N.ifExtends("boolean") // Type<true> | undefined

type.string.overlaps("string | number") // true (e.g. "foo")
type("string | number").overlaps("1") // true (1)
type("number > 0").overlaps("number < 0") // false (no values exist)

const NoAt = type("string").narrow(s => !s.includes("@"))
NoAt.overlaps("string.email") // true (no values exist, but not provable)

// Type<true | 0 | 2>
const T = type("boolean | 0 | 'one' | 2 | bigint").extract("number | 0n | true")

// Type<false | 'one' | bigint>
const T = type("boolean | 0 | 'one' | 2 | bigint").exclude("number | 0n | true")