@discretion/core 0.1.0

package/src/generate/natidAsia.ts

@@ -0,0 +1,162 @@
+/**
+ * Valid-value generators for W2d national identifiers (South, Southeast and
+ * East Asia).
+ */
+
+import { toDigits, verhoeffCheckDigit, weightedSum, weightedMod, weightedModBy, mod11_2CheckChar } from '../checksums/index.js';
+import { myNumberCheckDigit } from '../detect/detectors/natid/jp.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+const pad2 = (n: number): string => String(n).padStart(2, '0');
+
+export function generateValidAadhaar(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = String(int(rng, 2, 9)) + digits(rng, 10);
+  return `${payload}${verhoeffCheckDigit(payload)!}`;
+}
+
+const PAN_TYPES = 'PCHFATBLJG';
+const AZ = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+export function generateValidPan(seed: number): string {
+  const rng = mulberry32(seed);
+  let s = '';
+  for (let i = 0; i < 3; i++) s += AZ[int(rng, 0, 25)];
+  s += pick(rng, [...PAN_TYPES]);
+  s += AZ[int(rng, 0, 25)];
+  s += digits(rng, 4);
+  s += AZ[int(rng, 0, 25)];
+  return s;
+}
+
+const CN_PROVINCES = ['11', '31', '44', '51', '33', '37', '42', '61', '21', '35'];
+
+export function generateValidRic(seed: number): string {
+  const rng = mulberry32(seed);
+  const seventeen =
+    pick(rng, CN_PROVINCES) + digits(rng, 4) +
+    String(int(rng, 1950, 2010)) + pad2(int(rng, 1, 12)) + pad2(int(rng, 1, 28)) +
+    digits(rng, 3);
+  return `${seventeen}${mod11_2CheckChar(seventeen)!}`;
+}
+
+const TW_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const TW_CODES: Readonly<Record<string, number>> = {
+  A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, G: 16, H: 17, I: 34, J: 18,
+  K: 19, L: 20, M: 21, N: 22, O: 35, P: 23, Q: 24, R: 25, S: 26, T: 27,
+  U: 28, V: 29, W: 32, X: 30, Y: 31, Z: 33,
+};
+
+export function generateValidTwId(seed: number): string {
+  const rng = mulberry32(seed);
+  const letter = TW_LETTERS[int(rng, 0, 25)]!;
+  const gender = pick(rng, ['1', '2']);
+  const body = digits(rng, 7);
+  const code = TW_CODES[letter]!;
+  let sum = Math.floor(code / 10) + (code % 10) * 9;
+  const eight = `${gender}${body}`;
+  const weights = [8, 7, 6, 5, 4, 3, 2, 1];
+  for (let i = 0; i < 8; i++) sum += Number(eight[i]) * weights[i]!;
+  const check = (10 - (sum % 10)) % 10;
+  return `${letter}${eight}${check}`;
+}
+
+export function generateValidMyNumber(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = toDigits(digits(rng, 11))!;
+  return `${payload.join('')}${myNumberCheckDigit(payload)}`;
+}
+
+export function generateValidKrRrn(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = `${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${int(rng, 1, 8)}${digits(rng, 5)}`;
+  const remainder = weightedMod(toDigits(body)!, [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5], 11)!;
+  const check = (11 - remainder) % 10;
+  return `${body.slice(0, 6)}-${body.slice(6)}${check}`;
+}
+
+const NRIC_TABLES: Readonly<Record<string, string>> = {
+  S: 'JZIHGFEDCBA', T: 'JZIHGFEDCBA', F: 'XWUTRQPNMLK', G: 'XWUTRQPNMLK', M: 'KLJNPQRTUWX',
+};
+
+export function generateValidNric(seed: number): string {
+  const rng = mulberry32(seed);
+  const series = pick(rng, ['S', 'T', 'F', 'G', 'M']);
+  const body = digits(rng, 7);
+  let sum = weightedSum(toDigits(body)!, [2, 7, 6, 5, 4, 3, 2])!;
+  if (series === 'T' || series === 'G') sum += 4;
+  if (series === 'M') sum += 3;
+  return `${series}${body}${NRIC_TABLES[series]![sum % 11]!}`;
+}
+
+export function generateValidHkid(seed: number): string {
+  const rng = mulberry32(seed);
+  const twoLetters = rng() < 0.4;
+  const prefix = twoLetters ? AZ[int(rng, 0, 25)]! + AZ[int(rng, 0, 25)]! : AZ[int(rng, 0, 25)]!;
+  const body = digits(rng, 6);
+  let sum = 0;
+  if (prefix.length === 2) {
+    sum += (prefix.charCodeAt(0) - 55) * 9 + (prefix.charCodeAt(1) - 55) * 8;
+  } else {
+    sum += 36 * 9 + (prefix.charCodeAt(0) - 55) * 8;
+  }
+  for (let i = 0; i < 6; i++) sum += Number(body[i]) * (7 - i);
+  const r = sum % 11;
+  const checkValue = (11 - r) % 11;
+  if (checkValue === 10) return generateValidHkid(seed + 1); // 'A' case: keep simple, redraw
+  return `${prefix}${body}${checkValue}`;
+}
+
+export function generateValidCnic(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${int(rng, 1, 9)}${digits(rng, 4)}-${digits(rng, 7)}-${int(rng, 0, 9)}`;
+}
+
+export function generateValidBdNid(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${int(rng, 1950, 2010)}${digits(rng, 13)}`;
+}
+
+export function generateValidMykad(seed: number): string {
+  const rng = mulberry32(seed);
+  let pb = int(rng, 1, 16);
+  if (rng() < 0.5) pb = int(rng, 21, 59);
+  return `${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}-${pad2(pb)}-${digits(rng, 4)}`;
+}
+
+export function generateValidNik(seed: number): string {
+  const rng = mulberry32(seed);
+  const day = int(rng, 1, 28) + (rng() < 0.5 ? 40 : 0);
+  return `${int(rng, 11, 94)}${pad2(int(rng, 1, 99))}${pad2(int(rng, 1, 99))}${pad2(day)}${pad2(int(rng, 1, 12))}${pad2(int(rng, 0, 99))}${String(int(rng, 1, 9999)).padStart(4, '0')}`;
+}
+
+export function generateValidThaiId(seed: number): string {
+  const rng = mulberry32(seed);
+  const twelve = `${int(rng, 1, 8)}${digits(rng, 11)}`;
+  const remainder = weightedModBy(toDigits(twelve)!, (i) => 13 - i, 11)!;
+  return `${twelve}${(11 - remainder) % 10}`;
+}
+
+export function generateValidCccd(seed: number): string {
+  const rng = mulberry32(seed);
+  return `0${pad2(int(rng, 1, 96)).slice(-2)}${int(rng, 0, 9)}${pad2(int(rng, 0, 99))}${digits(rng, 6)}`;
+}
+
+export function generateValidPsn(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${digits(rng, 4)}-${digits(rng, 4)}-${digits(rng, 4)}-${digits(rng, 4)}`;
+}

package/src/generate/natidCee.ts

@@ -0,0 +1,196 @@
+/**
+ * Valid-value generators for W2b national identifiers (Central, Eastern and
+ * Northern Europe). Each synthesizes with the shared checksum primitives.
+ */
+
+import {
+  luhnCheckDigit,
+  toDigits,
+  weightedMod,
+  weightedModBy,
+  cyclicWeightedMod,
+  mod11_10CheckDigit,
+} from '../checksums/index.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+const pad2 = (n: number): string => String(n).padStart(2, '0');
+const pad3 = (n: number): string => String(n).padStart(3, '0');
+
+export function generateValidPesel(seed: number): string {
+  const rng = mulberry32(seed);
+  const yy = pad2(int(rng, 0, 99));
+  const mm = pad2(int(rng, 1, 12) + pick(rng, [0, 20, 40, 60, 80]));
+  const dd = pad2(int(rng, 1, 28));
+  const serial = pad2(int(rng, 0, 99)) + pad2(int(rng, 0, 99)).slice(0, 2);
+  const ten = `${yy}${mm}${dd}${serial}`.slice(0, 10);
+  const sum = cyclicWeightedMod(toDigits(ten)!, [1, 3, 7, 9], 10)!;
+  return `${ten}${(10 - sum) % 10}`;
+}
+
+export function generateValidNip(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const nine = digits(rng, 9);
+    const remainder = weightedMod(toDigits(nine)!, [6, 5, 7, 2, 3, 4, 5, 6, 7], 11)!;
+    if (remainder === 10) continue;
+    return `${nine}${remainder}`;
+  }
+}
+
+export function generateValidRegon(seed: number): string {
+  const rng = mulberry32(seed);
+  const eight = digits(rng, 8);
+  let check = weightedMod(toDigits(eight)!, [8, 9, 2, 3, 4, 5, 6, 7], 11)!;
+  if (check === 10) check = 0;
+  return `${eight}${check}`;
+}
+
+export function generateValidPersonnummer(seed: number): string {
+  const rng = mulberry32(seed);
+  const yy = pad2(int(rng, 0, 99));
+  const mm = pad2(int(rng, 1, 12));
+  const dd = pad2(int(rng, 1, 28));
+  const nnn = pad3(int(rng, 0, 999));
+  const payload = `${yy}${mm}${dd}${nnn}`;
+  return `${yy}${mm}${dd}-${nnn}${luhnCheckDigit(payload)!}`;
+}
+
+export function generateValidFodselsnummer(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const dd = pad2(int(rng, 1, 28) + (rng() < 0.15 ? 40 : 0)); // sometimes D-number
+    const mm = pad2(int(rng, 1, 12));
+    const yy = pad2(int(rng, 0, 99));
+    const nnn = pad3(int(rng, 0, 499));
+    const nine = toDigits(`${dd}${mm}${yy}${nnn}`)!;
+    let k1 = 11 - weightedMod(nine, [3, 7, 6, 1, 8, 9, 4, 5, 2], 11)!;
+    if (k1 === 11) k1 = 0;
+    if (k1 === 10) continue;
+    const ten = [...nine, k1];
+    let k2 = 11 - weightedMod(ten, [5, 4, 3, 2, 7, 6, 5, 4, 3, 2], 11)!;
+    if (k2 === 11) k2 = 0;
+    if (k2 === 10) continue;
+    return `${dd}${mm}${yy}${nnn}${k1}${k2}`;
+  }
+}
+
+export function generateValidCpr(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${pad2(int(rng, 1, 28))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 0, 99))}-${digits(rng, 4)}`;
+}
+
+const HETU_ALPHABET = '0123456789ABCDEFHJKLMNPRSTUVWXY';
+
+export function generateValidHetu(seed: number): string {
+  const rng = mulberry32(seed);
+  const dd = pad2(int(rng, 1, 28));
+  const mm = pad2(int(rng, 1, 12));
+  const yy = pad2(int(rng, 0, 99));
+  const sign = pick(rng, ['-', '+', 'A', 'B', 'F', 'U', 'Y']);
+  const nnn = pad3(int(rng, 2, 899));
+  const check = HETU_ALPHABET[Number(`${dd}${mm}${yy}${nnn}`) % 31]!;
+  return `${dd}${mm}${yy}${sign}${nnn}${check}`;
+}
+
+export function generateValidKennitala(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const dd = pad2(int(rng, 1, 28) + (rng() < 0.1 ? 40 : 0));
+    const mm = pad2(int(rng, 1, 12));
+    const yy = pad2(int(rng, 0, 99));
+    const nn = pad2(int(rng, 20, 99));
+    const eight = toDigits(`${dd}${mm}${yy}${nn}`)!;
+    let check = 11 - weightedMod(eight, [3, 2, 7, 6, 5, 4, 3, 2], 11)!;
+    if (check === 11) check = 0;
+    if (check === 10) continue;
+    return `${dd}${mm}${yy}-${nn}${check}${pick(rng, ['9', '0', '8'])}`;
+  }
+}
+
+export function generateValidPtNif(seed: number): string {
+  const rng = mulberry32(seed);
+  const eight = String(int(rng, 1, 9)) + digits(rng, 7);
+  const remainder = weightedMod(toDigits(eight)!, [9, 8, 7, 6, 5, 4, 3, 2], 11)!;
+  const check = remainder < 2 ? 0 : 11 - remainder;
+  return `${eight}${check}`;
+}
+
+export function generateValidAfm(seed: number): string {
+  const rng = mulberry32(seed);
+  const eight = digits(rng, 8);
+  const sum = weightedModBy(toDigits(eight)!, (i) => 2 ** (8 - i), 11)!;
+  return `${eight}${sum % 10}`;
+}
+
+export function generateValidRodneCislo(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const yy = pad2(int(rng, 54, 99));
+    const mm = pad2(int(rng, 1, 12) + (rng() < 0.5 ? 50 : 0));
+    const dd = pad2(int(rng, 1, 28));
+    // Four-digit serial slot — a three-zero slot lets the serial carry into
+    // the day field, which a property run caught.
+    const base = Number(`${yy}${mm}${dd}0000`);
+    for (let serial = int(rng, 0, 9988); serial <= 9999; serial++) {
+      const candidate = base + serial;
+      if (candidate % 11 === 0) {
+        return String(candidate).replace(/^(\d{6})/, '$1/');
+      }
+    }
+  }
+}
+
+export function generateValidSzemelyi(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const ten = `${int(rng, 1, 8)}${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${pad3(int(rng, 0, 999))}`;
+    const remainder = weightedModBy(toDigits(ten)!, (i) => i + 1, 11)!;
+    if (remainder === 10) continue;
+    return `${ten}${remainder}`;
+  }
+}
+
+export function generateValidCnp(seed: number): string {
+  const rng = mulberry32(seed);
+  const twelve = `${int(rng, 1, 8)}${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${pad2(int(rng, 1, 52))}${pad3(int(rng, 1, 999))}`;
+  let check = weightedMod(toDigits(twelve)!, [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9], 11)!;
+  if (check === 10) check = 1;
+  return `${twelve}${check}`;
+}
+
+export function generateValidEgn(seed: number): string {
+  const rng = mulberry32(seed);
+  const nine = `${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12) + pick(rng, [0, 20, 40]))}${pad2(int(rng, 1, 28))}${pad3(int(rng, 0, 999))}`;
+  let check = weightedMod(toDigits(nine)!, [2, 4, 8, 5, 10, 9, 7, 3, 6], 11)!;
+  if (check === 10) check = 0;
+  return `${nine}${check}`;
+}
+
+export function generateValidOib(seed: number): string {
+  const rng = mulberry32(seed);
+  const ten = digits(rng, 10);
+  return `${ten}${mod11_10CheckDigit(ten)!}`;
+}
+
+export function generateValidEmso(seed: number): string {
+  const rng = mulberry32(seed);
+  const twelve = `${pad2(int(rng, 1, 28))}${pad2(int(rng, 1, 12))}${pad3(int(rng, 900, 999))}${pad2(int(rng, 50, 59))}${pad3(int(rng, 0, 999))}`;
+  const sum = cyclicWeightedMod(toDigits(twelve)!, [7, 6, 5, 4, 3, 2], 11)!;
+  let k = 11 - sum;
+  if (k >= 10) k = 0;
+  return `${twelve}${k}`;
+}

package/src/generate/natidMeCis.ts

@@ -0,0 +1,131 @@
+/**
+ * Valid-value generators for W2c national identifiers (Turkey, CIS, Middle
+ * East), synthesized with the shared checksum primitives.
+ */
+
+import { luhnCheckDigit, toDigits, weightedMod, weightedModBy } from '../checksums/index.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+const pad2 = (n: number): string => String(n).padStart(2, '0');
+
+export function generateValidTckn(seed: number): string {
+  const rng = mulberry32(seed);
+  const first9 = String(int(rng, 1, 9)) + digits(rng, 8);
+  const d = toDigits(first9)!;
+  const odd = d[0]! + d[2]! + d[4]! + d[6]! + d[8]!;
+  const even = d[1]! + d[3]! + d[5]! + d[7]!;
+  const d10 = (((odd * 7 - even) % 10) + 10) % 10;
+  const d11 = (d.reduce((a, b) => a + b, 0) + d10) % 10;
+  return `${first9}${d10}${d11}`;
+}
+
+export function generateValidVkn(seed: number): string {
+  const rng = mulberry32(seed);
+  const nine = digits(rng, 9);
+  const d = toDigits(nine)!;
+  let sum = 0;
+  for (let p = 1; p <= 9; p++) {
+    const tmp = (d[p - 1]! + 10 - p) % 10;
+    sum += tmp === 9 ? 9 : (tmp * 2 ** (10 - p)) % 9;
+  }
+  return `${nine}${(10 - (sum % 10)) % 10}`;
+}
+
+export function generateValidInn10(seed: number): string {
+  const rng = mulberry32(seed);
+  const nine = digits(rng, 9);
+  const check = weightedMod(toDigits(nine)!, [2, 4, 10, 3, 5, 9, 4, 6, 8], 11)! % 10;
+  return `${nine}${check}`;
+}
+
+export function generateValidInn12(seed: number): string {
+  const rng = mulberry32(seed);
+  const ten = digits(rng, 10);
+  const c11 = weightedMod(toDigits(ten)!, [7, 2, 4, 10, 3, 5, 9, 4, 6, 8], 11)! % 10;
+  const c12 = weightedMod(toDigits(`${ten}${c11}`)!, [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8], 11)! % 10;
+  return `${ten}${c11}${c12}`;
+}
+
+export function generateValidSnils(seed: number): string {
+  const rng = mulberry32(seed);
+  const nine = digits(rng, 9);
+  const d = toDigits(nine)!;
+  let sum = 0;
+  for (let i = 0; i < 9; i++) sum += d[i]! * (9 - i);
+  let check = sum % 101;
+  if (check === 100) check = 0;
+  return `${nine.slice(0, 3)}-${nine.slice(3, 6)}-${nine.slice(6)} ${pad2(check)}`;
+}
+
+export function generateValidRnokpp(seed: number): string {
+  const rng = mulberry32(seed);
+  const nine = digits(rng, 9);
+  const d = toDigits(nine)!;
+  const weights = [-1, 5, 7, 9, 4, 6, 10, 5, 7];
+  let sum = 0;
+  for (let i = 0; i < 9; i++) sum += d[i]! * weights[i]!;
+  const check = ((sum % 11) + 11) % 11 % 10;
+  return `${nine}${check}`;
+}
+
+export function generateValidIin(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const eleven = `${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${int(rng, 1, 6)}${digits(rng, 4)}`;
+    const d = toDigits(eleven)!;
+    let check = weightedModBy(d, (i) => i + 1, 11)!;
+    if (check === 10) {
+      check = weightedModBy(d, (i) => ((i + 2) % 11) + 1, 11)!;
+      if (check === 10) continue;
+    }
+    return `${eleven}${check}`;
+  }
+}
+
+export function generateValidTeudatZehut(seed: number): string {
+  const rng = mulberry32(seed);
+  const eight = digits(rng, 8);
+  return `${eight}${luhnCheckDigit(eight)!}`;
+}
+
+export function generateValidSaudiId(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = pick(rng, ['1', '2']) + digits(rng, 8);
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+export function generateValidEmiratesId(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = `784${int(rng, 1940, 2020)}${digits(rng, 7)}`;
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+export function generateValidQid(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${pick(rng, ['2', '3'])}${pad2(int(rng, 40, 99))}${digits(rng, 8)}`;
+}
+
+export function generateValidKwCivilId(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const eleven = `${pick(rng, ['1', '2', '3'])}${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${digits(rng, 4)}`;
+    const remainder = weightedMod(toDigits(eleven)!, [2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 3], 11)!;
+    const check = 11 - remainder;
+    if (check >= 10) continue;
+    return `${eleven}${check}`;
+  }
+}

package/src/generate/natidWest.ts

@@ -0,0 +1,208 @@
+/**
+ * Valid-value generators for W2a national identifiers (North America and
+ * Western Europe), each synthesizing with the same shared checksum
+ * primitives the validators verify with.
+ */
+
+import {
+  luhnCheckDigit,
+  toDigits,
+  weightedSum,
+  weightedMod,
+  mod11_10CheckDigit,
+  mrzCheckDigit,
+  modString,
+} from '../checksums/index.js';
+import { codiceFiscaleCin } from '../detect/detectors/natid/it.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+const pad2 = (n: number): string => String(n).padStart(2, '0');
+
+/** A rule-valid delimited SSN (not from the advertising/test ranges). */
+export function generateValidSsn(seed: number): string {
+  const rng = mulberry32(seed);
+  let area = int(rng, 1, 899);
+  if (area === 666) area = 667;
+  return `${String(area).padStart(3, '0')}-${pad2(int(rng, 1, 99))}-${String(int(rng, 1, 9999)).padStart(4, '0')}`;
+}
+
+/** A Luhn-valid Canadian SIN. */
+export function generateValidSin(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = String(pick(rng, [1, 2, 3, 4, 5, 6, 7, 9])) + digits(rng, 7);
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+const NINO_FIRST = 'ABCEGHJKLMNOPRSTWXYZ'; // minus D F I Q U V
+const NINO_SECOND = 'ABCEGHJKLMNPRSTWXYZ'; // additionally minus O
+const NINO_BANNED = new Set(['BG', 'GB', 'NK', 'KN', 'TN', 'NT', 'ZZ']);
+
+/** A prefix-valid NINO. */
+export function generateValidNino(seed: number): string {
+  const rng = mulberry32(seed);
+  let prefix = '';
+  do {
+    prefix = pick(rng, [...NINO_FIRST]) + pick(rng, [...NINO_SECOND]);
+  } while (NINO_BANNED.has(prefix));
+  return `${prefix}${digits(rng, 6)}${pick(rng, ['A', 'B', 'C', 'D'])}`;
+}
+
+const NHS_WEIGHTS = [10, 9, 8, 7, 6, 5, 4, 3, 2];
+
+/** A mod-11-valid NHS number (outside the 999 test range). */
+export function generateValidNhs(seed: number): string {
+  const rng = mulberry32(seed);
+  for (let attempt = 0; ; attempt++) {
+    const payload = String(int(rng, 1, 8)) + digits(rng, 8);
+    const remainder = weightedMod(toDigits(payload)!, NHS_WEIGHTS, 11)!;
+    let check = 11 - remainder;
+    if (check === 11) check = 0;
+    if (check === 10) continue; // never issued; draw again
+    return `${payload}${check}`;
+  }
+}
+
+const PPS_WEIGHTS = [8, 7, 6, 5, 4, 3, 2];
+const MOD23 = 'WABCDEFGHIJKLMNOPQRSTUV';
+
+/** A mod-23-valid Irish PPS number (old and new formats). */
+export function generateValidPps(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = digits(rng, 7);
+  const second = rng() < 0.4 ? pick(rng, ['A', 'H']) : undefined;
+  let sum = weightedSum(toDigits(body)!, PPS_WEIGHTS)!;
+  if (second !== undefined) sum += 9 * (second.charCodeAt(0) - 64);
+  return `${body}${MOD23[sum % 23]!}${second ?? ''}`;
+}
+
+/** A Steuer-ID satisfying the frequency rule and MOD 11,10. */
+export function generateValidSteuerId(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    // Ten digits: nine distinct + one repeat of an earlier digit.
+    const pool = [...'0123456789'];
+    for (let i = pool.length - 1; i > 0; i--) {
+      const j = Math.floor(rng() * (i + 1));
+      [pool[i], pool[j]] = [pool[j]!, pool[i]!];
+    }
+    const nine = pool.slice(0, 9);
+    const repeat = nine[int(rng, 0, 8)]!;
+    const position = int(rng, 1, 9);
+    const ten = [...nine.slice(0, position), repeat, ...nine.slice(position)].slice(0, 10);
+    const body = ten.join('');
+    if (body[0] === '0') continue;
+    const check = mod11_10CheckDigit(body)!;
+    return `${body}${check}`;
+  }
+}
+
+const AUSWEIS_CHARS = 'CFGHJKLMNPRTVWXYZ';
+
+/** A Personalausweis number with its ICAO check digit. */
+export function generateValidAusweis(seed: number): string {
+  const rng = mulberry32(seed);
+  // At least one letter (validator requires it); mix letters and digits.
+  let payload = pick(rng, [...AUSWEIS_CHARS]);
+  for (let i = 0; i < 8; i++) {
+    payload += rng() < 0.5 ? pick(rng, [...AUSWEIS_CHARS]) : String(int(rng, 0, 9));
+  }
+  return `${payload}${mrzCheckDigit(payload)!}`;
+}
+
+/** A NIR with its mod-97 key (occasionally Corsican). */
+export function generateValidNir(seed: number): string {
+  const rng = mulberry32(seed);
+  const sex = pick(rng, ['1', '2']);
+  const yy = pad2(int(rng, 0, 99));
+  const mm = pad2(int(rng, 1, 12));
+  const corsica = rng() < 0.1;
+  const dept = corsica ? pick(rng, ['2A', '2B']) : pad2(int(rng, 1, 95));
+  const commune = String(int(rng, 1, 999)).padStart(3, '0');
+  const order = String(int(rng, 1, 999)).padStart(3, '0');
+  let thirteen = `${sex}${yy}${mm}${dept}${commune}${order}`;
+  let offset = 0n;
+  if (dept === '2A') {
+    thirteen = thirteen.replace('A', '0');
+    offset = 1_000_000n;
+  } else if (dept === '2B') {
+    thirteen = thirteen.replace('B', '0');
+    offset = 2_000_000n;
+  }
+  const key = 97n - ((BigInt(thirteen) - offset) % 97n);
+  return `${sex} ${yy} ${mm} ${dept} ${commune} ${order} ${String(key).padStart(2, '0')}`;
+}
+
+const DNI_LETTERS = 'TRWAGMYFPDXBNJZSQVHLCKE';
+
+/** A DNI with its mod-23 letter. */
+export function generateValidDni(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = digits(rng, 8);
+  return `${body}${DNI_LETTERS[Number(body) % 23]!}`;
+}
+
+/** A NIE with its mod-23 letter. */
+export function generateValidNie(seed: number): string {
+  const rng = mulberry32(seed);
+  const prefix = pick(rng, ['X', 'Y', 'Z']);
+  const body = digits(rng, 7);
+  const numeric = Number(`${{ X: '0', Y: '1', Z: '2' }[prefix as 'X' | 'Y' | 'Z']}${body}`);
+  return `${prefix}${body}${DNI_LETTERS[numeric % 23]!}`;
+}
+
+const CF_MONTHS = 'ABCDEHLMPRST';
+const CONSONANTS = 'BCDFGHJKLMNPQRSTVWXYZ';
+
+/** A Codice Fiscale with a valid month/day and correct CIN. */
+export function generateValidCodiceFiscale(seed: number): string {
+  const rng = mulberry32(seed);
+  let s = '';
+  for (let i = 0; i < 6; i++) s += pick(rng, [...CONSONANTS]);
+  s += pad2(int(rng, 0, 99));
+  s += pick(rng, [...CF_MONTHS]);
+  s += pad2(rng() < 0.5 ? int(rng, 1, 28) : int(rng, 41, 68));
+  s += pick(rng, [...'ABDEFGHILMZ']) + String(int(rng, 0, 9)) + String(int(rng, 0, 9)) + String(int(rng, 0, 9));
+  return `${s}${codiceFiscaleCin(s)!}`;
+}
+
+/** A BSN passing the 11-proef. */
+export function generateValidBsn(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const eight = digits(rng, 8);
+    const d = toDigits(eight)!;
+    let sum = 0;
+    for (let i = 0; i < 8; i++) sum += d[i]! * (9 - i);
+    const d9 = sum % 11;
+    if (d9 === 10) continue;
+    return `${eight}${d9}`;
+  }
+}
+
+/** A Belgian RRN, either century. */
+export function generateValidBeRrn(seed: number): string {
+  const rng = mulberry32(seed);
+  const born2000 = rng() < 0.4;
+  const yy = pad2(int(rng, 0, 99));
+  const mm = pad2(int(rng, 1, 12));
+  const dd = pad2(int(rng, 1, 28));
+  const serial = String(int(rng, 1, 998)).padStart(3, '0');
+  const nine = `${yy}${mm}${dd}${serial}`;
+  const base = born2000 ? `2${nine}` : nine;
+  const check = 97 - modString(base, 97)!;
+  return `${yy}.${mm}.${dd}-${serial}.${pad2(check)}`;
+}