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 AggregateError: 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 });

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

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

// 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<{ 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: nested.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))

// 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")