TypeScript type-level unsigned integer addition – add together two number literals.

nat.ts

declare const Zero: unique symbol;
type Zero = { [Zero]: true };

declare const Succ: unique symbol;
type Succ<T> = { [Succ]: T };

type FirstElementOrZero<Arr extends any[]>
    = Arr extends []
    ? Zero
    : Arr[0];

type EncodeNat<n extends number, Acc extends any[] = []>
    = Acc['length'] extends n
    ? FirstElementOrZero<Acc>
    : EncodeNat<n, [Succ<FirstElementOrZero<Acc>>, ...Acc]>;

type DecodeNat<N, Acc extends any[] = []>
    = N extends Succ<infer M>
    ? DecodeNat<M, [0, ...Acc]>
    : Acc['length'];

type AddEncoded<L, R>
    = L extends Succ<infer M>
    ? AddEncoded<M, Succ<R>>
    : R;

type Add<l extends number, r extends number>
    = l extends any ? r extends any ?
    DecodeNat<
        AddEncoded<
            EncodeNat<l>,
            EncodeNat<r>
        >
    >
    : never : never;


const _: Add<5, 1 | 2> = 7;

Playground link