@przeslijmi/real-fake-data-playwright 0.1.0 → 1.1.0

package/README.md

@@ -1,11 +1,16 @@
 # @przeslijmi/real-fake-data-playwright
 
-Playwright fixtures for [Real Fake Data](https://github.com/przeslijmi/rfd) — realistic, synthetic **Polish** test data with one line per record: valid PESELs (correct checksums), NIPs, REGONs, IBANs, addresses drawn from real cities and streets, people, company names, and vehicle plates.
+Playwright fixtures for [Real Fake Data](https://github.com/przeslijmi/rfd) — **136 generators** of realistic, synthetic test data, one typed method per record:
+
+- **Person and company names across 27 EU countries** — `dePersonName`, `itCompanyName`, `frPersonName`, … in the local script and inflection, plus multi-country `personName`/`companyName` that draw from any mix of countries.
+- **National identifiers and VAT / company numbers for every EU member state** — French `frNir`/`frSiren`, Italian `itCodiceFiscale`, Spanish `esDni`/`esNie`, Danish `dkCpr`, Swedish `sePersonnummer`, Dutch `nlBsn`, German `deSteuerId`/`deUstIdnr`, and 60+ more — each with correct checksums and the same `invalid`/`edge` triggers.
+- **The full Polish national set** — valid PESELs (correct checksums), NIPs, REGONs, IBANs, KRS and land-register numbers, ID cards, passports, driving licences, addresses drawn from real cities and streets, and vehicle plates.
+- **Locale-agnostic** — emails and lorem ipsum.
 
 Output _looks_ real but is fake — safe for staging, demos, and seed data.
 
 - **Seeded and reproducible by default.** Each test derives a stable seed from its title, so a failing test replays the exact same data on the next run — no flakiness, trivial repro.
-- **Typed end to end.** One method per generator, fully typed inputs and results.
+- **Typed end to end.** Two methods per generator (one record, or a batch), fully typed inputs and results.
 - **Zero ceremony.** A `fakeData` fixture; no manual client wiring.
 
 ## Install
@@ -24,10 +29,10 @@ Point the fixture at a Real Fake Data API instance, then pull data inside any te
 ```ts
 import { test, expect } from '@przeslijmi/real-fake-data-playwright';
 
-test.use({ realFakeData: { baseUrl: 'https://api.real-fake-data.example' } });
+test.use({ realFakeData: { baseUrl: 'https://realfakedata-api.onrender.com' } });
 
 test('registers a new customer', async ({ page, fakeData }) => {
-  const person = await fakeData.person({ sex: 'f' });
+  const person = await fakeData.plPerson({ sex: 'f' });
 
   await page.goto('/signup');
   await page.getByLabel('First name').fill(person.name);
@@ -47,7 +52,7 @@ Set options with `test.use({ realFakeData: { … } })`, at any scope (file, `des
 
 | Option    | Type                     | Description                                                                                              |
 | --------- | ------------------------ | ------------------------------------------------------------------------------------------------------- |
-| `baseUrl` | `string` (required)      | Base URL of the Real Fake Data API, e.g. `https://api.example.com`.                                      |
+| `baseUrl` | `string` (required)      | Base URL of the Real Fake Data API, e.g. `https://realfakedata-api.onrender.com`.                                      |
 | `seed`    | `number`                 | Base seed for the test. Omit to derive a stable seed from the test title (reproducible-by-default).      |
 | `headers` | `Record<string, string>` | Extra headers sent with every request (e.g. an API key once your plan requires one).                    |
 
@@ -61,26 +66,280 @@ test.use({ realFakeData: { baseUrl, seed: 42 } }); // pin this file to a fixed d
 
 ## Generators
 
-Every method returns a typed result and accepts optional constraints. Pass `seed` on any call to override that call's automatic seed.
+Each generator exposes a **singular** method returning one record and a **plural** taking `count` as its first argument and returning an array of that many. Method names are locale-prefixed (`plPesel`, `dePersonName`, …) so generators for different countries never collide; locale-agnostic generators (`email`, `lorem`) and the multi-country aggregates (`personName`, `companyName`) carry no prefix.
+
+Every method accepts optional constraints. Pass `seed` on any call to override that call's automatic seed.
+
+#### Names across 27 EU countries
+
+Every country listed below exposes `<cc>PersonName`/`<cc>PersonNames` and `<cc>CompanyName`/`<cc>CompanyNames`, where `<cc>` is its ISO 3166 code: `at`, `be`, `bg`, `cy`, `cz`, `de`, `dk`, `ee`, `es`, `fi`, `fr`, `gr`, `hr`, `hu`, `ie`, `it`, `lt`, `lu`, `lv`, `mt`, `nl`, `pl`, `pt`, `ro`, `se`, `si`, `sk`.
+
+| Singular                | Plural                          | Returns (singular)                          | Options                                |
+| ----------------------- | ------------------------------- | ------------------------------------------- | -------------------------------------- |
+| `<cc>PersonName(opts?)` | `<cc>PersonNames(count, opts?)` | `{ name, surname, initials, sex }`          | `sex`, `edge`, `caseStrict`            |
+| `<cc>CompanyName(opts?)`| `<cc>CompanyNames(count, opts?)`| `{ value, legalForm, strategy }`            | `strategy`, `legalForm`, `edge`        |
+| `personName(opts?)`     | `personNames(count, opts?)`     | `{ name, surname, initials, sex, country }` | `sex`, `edge`, `caseStrict`, `countries` |
+| `companyName(opts?)`    | `companyNames(count, opts?)`    | `{ value, legalForm, strategy, country }`   | `strategy`, `edge`, `countries`        |
+
+```ts
+const ceo = await fakeData.dePersonName({ sex: 'f' });        // German given name + surname
+const vendor = await fakeData.itCompanyName({ edge: true });  // edge-case Italian company name
+const eu = await fakeData.personName({ countries: ['pl', 'sk', 'it'] }); // drawn from one of the three
+```
+
+`countries` (on the prefix-less `personName`/`companyName` only) is an array of ISO codes; each record is generated by one country picked from the list. Omit it to draw from all 27. The per-country `legalForm` values differ by country (e.g. `GmbH`, `S.r.l.`, `S.A.`), so they are typed as `string`; pass `'any'` for a weighted-random one or `'none'` to omit it.
+
+#### Polish national generators
+
+| Singular                       | Plural                                 | Returns (singular)                                          | Common options                                                        |
+| ------------------------------ | -------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------- |
+| `plPesel(opts?)`               | `plPesels(count, opts?)`               | `{ value, birthDate, sex }`                                | `sex`, `atAge`, `olderThan`, `youngerThan`, `bornOn/Before/After`, `invalid` |
+| `plPerson(opts?)`              | `plPeople(count, opts?)`               | `{ name, surname, initials, birthDate, pesel }`            | same as `plPesel`                                                     |
+| `plAddress(opts?)`             | `plAddresses(count, opts?)`            | `{ buildingNumber, postalCode, cityName, …, terytCodes }` | `teryt` (1–7 digit prefix)                                            |
+| `plNip(opts?)`                 | `plNips(count, opts?)`                 | `{ value, digits }`                                        | `format`, `invalid`                                                   |
+| `plIban(opts?)`                | `plIbans(count, opts?)`                | `{ value, electronicFormat, bankCode, bankName }`         | `format`, `bankCode`, `bankName`, `invalid`                          |
+| `plRegon(opts?)`               | `plRegons(count, opts?)`               | `{ value, variant }`                                       | `variant` (`short`/`long`/`any`), `invalid`                          |
+| `plCompany(opts?)`             | `plCompanies(count, opts?)`            | `{ name, legalForm, nip, regon, krs }`                    | `strategy`, `legalForm`, `activityPrefix`, `format`, `edge`, `invalid` |
+| `plCompanyName(opts?)`         | `plCompanyNames(count, opts?)`         | `{ value, legalForm, strategy }`                           | `strategy`, `legalForm`, `activityPrefix`, `edge`                   |
+| `plIdCard(opts?)`              | `plIdCards(count, opts?)`              | `{ value, series, number, expirationDate }`                | `format`, `expired`, `invalid`                                       |
+| `plPassport(opts?)`            | `plPassports(count, opts?)`            | `{ value, series, number }`                                | `format`, `invalid`                                                   |
+| `plKrs(opts?)`                 | `plKrsNumbers(count, opts?)`           | `{ value, number }`                                        | `format`                                                             |
+| `plLandRegister(opts?)`        | `plLandRegisters(count, opts?)`        | `{ value, courtCode, number, checkDigit, court? }`         | `format`, `court`, `invalid`                                         |
+| `plDrivingLicense(opts?)`      | `plDrivingLicenses(count, opts?)`      | `{ value, serial, year, suffix }`                          | `format`, `year`                                                     |
+| `plVehicleRegistration(opts?)` | `plVehicleRegistrations(count, opts?)` | `{ value, prefix, individualPart, type, … }`              | `type`, `voivodeship`, `county`, `format`                           |
+
+A Polish person name on its own (no PESEL/birth date) is `plPersonName` — part of the 27-country table above.
+
+#### EU national identifiers
+
+Every EU member state exposes its core national-person identifier and its business / VAT numbers. Numbers that encode a birth date and/or sex accept the same person constraints as `plPesel` (`sex`, `atAge`, `olderThan`, `youngerThan`, `bornOn`/`bornBefore`/`bornAfter`); the rest expose only their own knobs. Every checksum-bearing number takes `invalid` (deliberately wrong check digit) and `edge` (rare-corner values); generators with a VAT/intra-EU rendering take `format: 'national' | 'vat'` (some use a generator-specific enum — see each row).
+
+**France (`fr`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `frSiren(opts?)` | `frSirens(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+| `frNir(opts?)` | `frNirs(count, opts?)` | `{ value, digits, sex, birthYear, birthMonth }` | `sex`, age/birth filters, `invalid`, `edge` |
+
+**Austria (`at`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `atSvnr(opts?)` | `atSvnrs(count, opts?)` | `{ value, digits, birthDate }` | age/birth filters, `invalid`, `edge` |
+| `atUid(opts?)` | `atUids(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+| `atFirmenbuchnummer(opts?)` | `atFirmenbuchnummers(count, opts?)` | `{ value, number, letter }` | `invalid`, `edge` |
+| `atSteuernummer(opts?)` | `atSteuernummers(count, opts?)` | `{ value, digits }` | `edge` |
+
+**Belgium (`be`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `beRijksregisternummer(opts?)` | `beRijksregisternummers(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `kind`, `invalid`, `edge` |
+| `beOndernemingsnummer(opts?)` | `beOndernemingsnummers(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Bulgaria (`bg`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `bgEgn(opts?)` | `bgEgns(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `bgEik(opts?)` | `bgEiks(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Croatia (`hr`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `hrOib(opts?)` | `hrOibs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+| `hrJmbg(opts?)` | `hrJmbgs(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+
+**Cyprus (`cy`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `cyTic(opts?)` | `cyTics(count, opts?)` | `{ value, digits, letter }` | `format`, `invalid`, `edge` |
+
+**Czechia (`cz`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `czRodneCislo(opts?)` | `czRodneCislos(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `format`, `invalid`, `edge` |
+| `czIco(opts?)` | `czIcos(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Denmark (`dk`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `dkCpr(opts?)` | `dkCprs(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `checksum`, `format`, `invalid`, `edge` |
+| `dkCvr(opts?)` | `dkCvrs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Estonia (`ee`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `eeIsikukood(opts?)` | `eeIsikukoods(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `eeRegistrikood(opts?)` | `eeRegistrikoods(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `eeKmkr(opts?)` | `eeKmkrs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Finland (`fi`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `fiHenkilotunnus(opts?)` | `fiHenkilotunnuss(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `fiYTunnus(opts?)` | `fiYTunnuss(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Germany (`de`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `deSteuerId(opts?)` | `deSteuerIds(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `deUstIdnr(opts?)` | `deUstIdnrs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+| `deHandelsregisternummer(opts?)` | `deHandelsregisternummers(count, opts?)` | `{ value, division, court, number }` | `division`, `edge` |
+| `deWirtschaftsIdnr(opts?)` | `deWirtschaftsIdnrs(count, opts?)` | `{ value, digits, suffix }` | `suffix`, `invalid`, `edge` |
+| `dePersonalausweis(opts?)` | `dePersonalausweiss(count, opts?)` | `{ value, serial, checkDigit }` | `invalid`, `edge` |
+
+**Greece (`gr`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `grAmka(opts?)` | `grAmkas(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `grAfm(opts?)` | `grAfms(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
 
-| Method                            | Returns                                                       | Common options                                                        |
-| --------------------------------- | ------------------------------------------------------------ | --------------------------------------------------------------------- |
-| `fakeData.pesel(opts?)`           | `{ value, birthDate, sex }`                                   | `sex`, `atAge`, `olderThan`, `youngerThan`, `bornOn/Before/After`, `invalid` |
-| `fakeData.person(opts?)`          | `{ name, surname, initials, birthDate, pesel }`              | same as `pesel`                                                       |
-| `fakeData.address(opts?)`         | `{ buildingNumber, postalCode, cityName, …, terytCodes }`   | `teryt` (1–7 digit prefix)                                            |
-| `fakeData.nip(opts?)`             | `{ value, digits }`                                           | `format`, `invalid`                                                   |
-| `fakeData.iban(opts?)`            | `{ value, electronicFormat, bankCode, bankName }`           | `format`, `bankCode`, `bankName`, `invalid`                          |
-| `fakeData.regon(opts?)`           | `{ value, variant }`                                          | `variant` (`short`/`long`/`any`), `invalid`                          |
-| `fakeData.companyName(opts?)`     | `{ value, legalForm, strategy }`                             | `strategy`, `legalForm`, `activityPrefix`                            |
-| `fakeData.vehicleRegistration(opts?)` | `{ value, prefix, individualPart, type, … }`            | `type`, `voivodeship`, `county`, `format`                           |
+**Hungary (`hu`)**
 
-### Testing your validators
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `huAdoazonositoJel(opts?)` | `huAdoazonositoJels(count, opts?)` | `{ value, digits, birthDate }` | age/birth filters, `invalid`, `edge` |
+| `huTaj(opts?)` | `huTajs(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `huSzemelyiAzonosito(opts?)` | `huSzemelyiAzonositos(count, opts?)` | `{ value, digits, birthDate, sex, standard }` | `sex`, age/birth filters, `standard`, `invalid`, `edge` |
+| `huAdoszam(opts?)` | `huAdoszams(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+| `huCegjegyzekszam(opts?)` | `huCegjegyzekszams(count, opts?)` | `{ value, court, form, serial, digits }` | `edge` |
 
-Every checksum generator accepts `invalid: true` to produce a value with a **deliberately wrong check digit** (the rest stays well-formed) — for asserting that your own validators reject bad input:
+**Ireland (`ie`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `iePpsn(opts?)` | `iePpsns(count, opts?)` | `{ value, digits, checkLetter, secondLetter? }` | `standard`, `invalid`, `edge` |
+| `ieVat(opts?)` | `ieVats(count, opts?)` | `{ value, digits }` | `format`, `standard`, `invalid`, `edge` |
+| `ieCro(opts?)` | `ieCros(count, opts?)` | `{ value, digits }` | `edge` |
+
+**Italy (`it`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `itCodiceFiscale(opts?)` | `itCodiceFiscales(count, opts?)` | `{ value, surnameCode, nameCode, birthDate, sex }` | `sex`, age/birth filters, `surname`, `name`, `invalid`, `edge` |
+| `itPartitaIva(opts?)` | `itPartitaIvas(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Latvia (`lv`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `lvPersonasKods(opts?)` | `lvPersonasKodss(count, opts?)` | `{ value, digits, birthDate? }` | age/birth filters, `standard`, `format`, `invalid`, `edge` |
+| `lvRegistracijasNumurs(opts?)` | `lvRegistracijasNumurss(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Lithuania (`lt`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `ltAsmensKodas(opts?)` | `ltAsmensKodass(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `ltImonesKodas(opts?)` | `ltImonesKodass(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `ltPvm(opts?)` | `ltPvms(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Luxembourg (`lu`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `luMatricule(opts?)` | `luMatricules(count, opts?)` | `{ value, digits, birthDate }` | age/birth filters, `invalid`, `edge` |
+| `luTva(opts?)` | `luTvas(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Malta (`mt`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `mtIdCard(opts?)` | `mtIdCards(count, opts?)` | `{ value, digits, category }` | `category`, `edge` |
+| `mtVat(opts?)` | `mtVats(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Netherlands (`nl`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `nlBsn(opts?)` | `nlBsns(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `nlRsin(opts?)` | `nlRsins(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `nlBtwId(opts?)` | `nlBtwIds(count, opts?)` | `{ value, digits, standard }` | `standard`, `invalid`, `edge` |
+| `nlKvk(opts?)` | `nlKvks(count, opts?)` | `{ value, digits }` | `edge` |
+
+**Portugal (`pt`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `ptNif(opts?)` | `ptNifs(count, opts?)` | `{ value, digits, entity }` | `entity`, `format`, `invalid`, `edge` |
+| `ptCartaoCidadao(opts?)` | `ptCartaoCidadaos(count, opts?)` | `{ value, nic, version }` | `invalid`, `edge` |
+
+**Romania (`ro`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `roCnp(opts?)` | `roCnps(count, opts?)` | `{ value, digits, birthDate, sex, county }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `roCui(opts?)` | `roCuis(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Slovakia (`sk`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `skRodneCislo(opts?)` | `skRodneCislos(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `format`, `invalid`, `edge` |
+| `skIco(opts?)` | `skIcos(count, opts?)` | `{ value, digits }` | `invalid`, `edge` |
+| `skIcDph(opts?)` | `skIcDphs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Slovenia (`si`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `siEmso(opts?)` | `siEmsos(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `invalid`, `edge` |
+| `siDavcnaStevilka(opts?)` | `siDavcnaStevilkas(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Spain (`es`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `esDni(opts?)` | `esDnis(count, opts?)` | `{ value, digits, letter }` | `invalid`, `edge` |
+| `esNie(opts?)` | `esNies(count, opts?)` | `{ value, prefix, digits, letter }` | `invalid`, `edge` |
+| `esCif(opts?)` | `esCifs(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+**Sweden (`se`)**
+
+| Singular | Plural | Returns (singular) | Options |
+| -------- | ------ | ------------------ | ------- |
+| `sePersonnummer(opts?)` | `sePersonnummers(count, opts?)` | `{ value, digits, birthDate, sex }` | `sex`, age/birth filters, `format`, `kind`, `invalid`, `edge` |
+| `seOrganisationsnummer(opts?)` | `seOrganisationsnummers(count, opts?)` | `{ value, digits }` | `format`, `invalid`, `edge` |
+
+#### Locale-agnostic
+
+| Singular                       | Plural                                 | Returns (singular)                                          | Common options                                                        |
+| ------------------------------ | -------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------- |
+| `email(opts?)`                 | `emails(count, opts?)`                 | `{ value, localPart, domain, pattern, plusTag }`          | `domain`, `domainCategory`, `pattern`, `plusTag`, `exotic`           |
+| `lorem(opts?)`                 | `lorems(count, opts?)`                 | `{ value, words, chars, bytes, paragraphs, startedWithLorem }` | `bytes`, `chars`, `words`, `paragraphs`, `startWithLorem`      |
+
+### Generating many records at once
+
+Every plural takes `count` as its first argument and returns an array. The bound (10 by default, raised by paid tiers) is enforced by the API — an out-of-range `count` throws a `RealFakeDataError` (HTTP 400), never a silent clamp. A plural is a single request seeded once, so it consumes one slot of the per-test seed sequence just like a singular call.
 
 ```ts
-const bad = await fakeData.nip({ invalid: true });
+const team = await fakeData.plPeople(5, { sex: 'f' }); // PolishPersonData[] of length 5
+const inboxes = await fakeData.emails(3); // EmailData[] of length 3
+```
+
+### Special triggers
+
+Three opt-in flags steer generators toward the cases real-world data throws at your code:
+
+- **`invalid: true`** — on every checksum generator (`plPesel`, `plNip`, `plRegon`, `plIban`, `plCompany`, `plIdCard`, `plPassport`, `plLandRegister`), produces a value with a **deliberately wrong check digit** while the rest stays well-formed. For asserting that your own validators reject bad input. When set, the response `meta.invalid` is `true` so a batch can tell the broken record apart.
+- **`edge: true`** — on the name generators (`<cc>PersonName`, `<cc>CompanyName`, `personName`, `companyName`, `plCompany`), biases toward **edge-case shapes**: second given names, double-barrelled surnames, very short names, punctuation-heavy or unusually long company names. The corners that break naïve form validation and layout.
+- **`caseStrict: false`** — on the person-name generators, **deliberately mangles the casing** of name and surname (all-lower, all-upper, or random); initials stay proper uppercase. Defaults to `true` (proper casing). For testing case-insensitive matching and normalisation.
+
+```ts
+const bad = await fakeData.plNip({ invalid: true });
 await expect(submitNip(bad.value)).rejects.toThrow('invalid checksum');
+
+const messy = await fakeData.dePersonName({ caseStrict: false }); // e.g. { name: 'hANS', surname: 'müller' }
+const tricky = await fakeData.itCompanyName({ edge: true });      // punctuation-heavy / long-form name
 ```
 
 ## Error handling
@@ -91,7 +350,7 @@ A non-2xx API response throws a `RealFakeDataError` carrying `status` (HTTP code
 import { RealFakeDataError } from '@przeslijmi/real-fake-data-playwright';
 
 try {
-  await fakeData.address({ teryt: 'not-digits' });
+  await fakeData.plAddress({ teryt: 'not-digits' });
 } catch (error) {
   if (error instanceof RealFakeDataError) {
     console.log(error.status, error.code, error.details);
@@ -107,10 +366,10 @@ The fixture is a thin wrapper over a provider and a facade you can use directly
 ```ts
 import { CloudFakeDataProvider, createFakeData } from '@przeslijmi/real-fake-data-playwright';
 
-const provider = new CloudFakeDataProvider({ baseUrl: 'https://api.example.com' });
+const provider = new CloudFakeDataProvider({ baseUrl: 'https://realfakedata-api.onrender.com' });
 const fakeData = createFakeData(provider, { seed: 42 });
 
-const company = await fakeData.companyName({ legalForm: 'S.A.' });
+const company = await fakeData.plCompanyName({ legalForm: 'S.A.' });
 ```
 
 The `FakeDataProvider` interface is the swap point: the cloud provider talks HTTP to the hosted API, and the same facade can run against other backends.
@@ -118,3 +377,9 @@ The `FakeDataProvider` interface is the swap point: the cloud provider talks HTT
 ## License
 
 MIT
+
+---
+
+> **This repository is auto-generated** from a private upstream monorepo. Open
+> **issues** here, but code changes are made upstream and re-synced — pull
+> requests against this repo are applied upstream, not merged directly.

package/dist/fake-data.d.ts

@@ -1,16 +1,212 @@
 import type { FakeDataProvider } from './fake-data-provider.js';
-import type { AddressOptions, CompanyNameOptions, IbanOptions, NipOptions, PeselOptions, PersonOptions, PolishAddressData, PolishCompanyNameData, PolishIbanData, PolishNipData, PolishPeselData, PolishPersonData, PolishRegonData, PolishVehicleRegistrationData, RegonOptions, VehicleRegistrationOptions } from './types.js';
-/** The typed surface tests use; one method per Real Fake Data generator. */
-export interface FakeData {
-    pesel(options?: PeselOptions): Promise<PolishPeselData>;
-    person(options?: PersonOptions): Promise<PolishPersonData>;
-    address(options?: AddressOptions): Promise<PolishAddressData>;
-    nip(options?: NipOptions): Promise<PolishNipData>;
-    iban(options?: IbanOptions): Promise<PolishIbanData>;
-    regon(options?: RegonOptions): Promise<PolishRegonData>;
-    companyName(options?: CompanyNameOptions): Promise<PolishCompanyNameData>;
-    vehicleRegistration(options?: VehicleRegistrationOptions): Promise<PolishVehicleRegistrationData>;
-}
+import type { AddressOptions, AnyCompanyNameData, AnyCompanyNameOptions, AnyPersonNameData, AnyPersonNameOptions, AtFirmenbuchnummerData, AtFirmenbuchnummerOptions, AtSteuernummerData, AtSteuernummerOptions, AtSvnrData, AtSvnrOptions, AtUidData, AtUidOptions, BeOndernemingsnummerData, BeOndernemingsnummerOptions, BeRijksregisternummerData, BeRijksregisternummerOptions, BgEgnData, BgEgnOptions, BgEikData, BgEikOptions, CompanyNameOptions, CompanyOptions, CountryCode, CyTicData, CyTicOptions, CzIcoData, CzIcoOptions, CzRodneCisloData, CzRodneCisloOptions, DeHandelsregisternummerData, DeHandelsregisternummerOptions, DePersonalausweisData, DePersonalausweisOptions, DeSteuerIdData, DeSteuerIdOptions, DeUstIdnrData, DeUstIdnrOptions, DeWirtschaftsIdnrData, DeWirtschaftsIdnrOptions, DkCprData, DkCprOptions, DkCvrData, DkCvrOptions, DrivingLicenseOptions, EeIsikukoodData, EeIsikukoodOptions, EeKmkrData, EeKmkrOptions, EeRegistrikoodData, EeRegistrikoodOptions, EmailData, EmailOptions, EsCifData, EsCifOptions, EsDniData, EsDniOptions, EsNieData, EsNieOptions, FiHenkilotunnusData, FiHenkilotunnusOptions, FiYTunnusData, FiYTunnusOptions, FrNirData, FrNirOptions, FrSirenData, FrSirenOptions, GrAfmData, GrAfmOptions, GrAmkaData, GrAmkaOptions, HrJmbgData, HrJmbgOptions, HrOibData, HrOibOptions, HuAdoazonositoJelData, HuAdoazonositoJelOptions, HuAdoszamData, HuAdoszamOptions, HuCegjegyzekszamData, HuCegjegyzekszamOptions, HuSzemelyiAzonositoData, HuSzemelyiAzonositoOptions, HuTajData, HuTajOptions, IbanOptions, IdCardOptions, IeCroData, IeCroOptions, IePpsnData, IePpsnOptions, IeVatData, IeVatOptions, ItCodiceFiscaleData, ItCodiceFiscaleOptions, ItPartitaIvaData, ItPartitaIvaOptions, KrsOptions, LandRegisterOptions, LocaleCompanyNameData, LocaleCompanyNameOptions, LoremData, LoremOptions, LtAsmensKodasData, LtAsmensKodasOptions, LtImonesKodasData, LtImonesKodasOptions, LtPvmData, LtPvmOptions, LuMatriculeData, LuMatriculeOptions, LuTvaData, LuTvaOptions, LvPersonasKodsData, LvPersonasKodsOptions, LvRegistracijasNumursData, LvRegistracijasNumursOptions, MtIdCardData, MtIdCardOptions, MtVatData, MtVatOptions, NipOptions, NlBsnData, NlBsnOptions, NlBtwIdData, NlBtwIdOptions, NlKvkData, NlKvkOptions, NlRsinData, NlRsinOptions, PassportOptions, PersonNameData, PersonNameOptions, PersonOptions, PeselOptions, PolishAddressData, PolishCompanyData, PolishCompanyNameData, PolishDrivingLicenseData, PolishIbanData, PolishIdCardData, PolishKrsData, PolishLandRegisterData, PolishNipData, PolishPassportData, PolishPersonData, PolishPeselData, PolishRegonData, PolishVehicleRegistrationData, PtCartaoCidadaoData, PtCartaoCidadaoOptions, PtNifData, PtNifOptions, RegonOptions, RoCnpData, RoCnpOptions, RoCuiData, RoCuiOptions, SeOrganisationsnummerData, SeOrganisationsnummerOptions, SePersonnummerData, SePersonnummerOptions, SiDavcnaStevilkaData, SiDavcnaStevilkaOptions, SiEmsoData, SiEmsoOptions, SkIcDphData, SkIcDphOptions, SkIcoData, SkIcoOptions, SkRodneCisloData, SkRodneCisloOptions, VehicleRegistrationOptions } from './types.js';
+/**
+ * Singular + plural method pair every country's `person-name` generator
+ * contributes: `dePersonName`/`dePersonNames`, `plPersonName`/`plPersonNames`,
+ * and so on for all 27 country codes.
+ */
+type PersonNameMethods = {
+    [Country in CountryCode as `${Country}PersonName`]: (options?: PersonNameOptions) => Promise<PersonNameData>;
+} & {
+    [Country in CountryCode as `${Country}PersonNames`]: (count: number, options?: PersonNameOptions) => Promise<PersonNameData[]>;
+};
+/**
+ * `company-name` method pair for every country *except* Poland — `plCompanyName`
+ * is declared explicitly below because it carries the typed Polish `legalForm`.
+ */
+type LocaleCompanyNameMethods = {
+    [Country in Exclude<CountryCode, 'pl'> as `${Country}CompanyName`]: (options?: LocaleCompanyNameOptions) => Promise<LocaleCompanyNameData>;
+} & {
+    [Country in Exclude<CountryCode, 'pl'> as `${Country}CompanyNames`]: (count: number, options?: LocaleCompanyNameOptions) => Promise<LocaleCompanyNameData[]>;
+};
+/**
+ * The typed surface tests use. Each generator exposes a singular method
+ * returning one record and a plural returning an array of `count` records.
+ *
+ * Method names are locale-prefixed (`plPesel`, `dePersonName`, …) so generators
+ * for different countries never collide; the locale-agnostic generators
+ * (`email`, `lorem`) and the multi-country aggregates (`personName`,
+ * `companyName`) carry no prefix. Plurals take `count` as their first positional
+ * argument; its bounds are enforced by the API (out-of-range → a
+ * {@link RealFakeDataError} 400), so paid tiers can raise the ceiling without
+ * a client change.
+ *
+ * Beyond the Polish national set below, every one of the 27 supported EU
+ * countries adds a `<cc>PersonName` and `<cc>CompanyName` pair (see
+ * {@link PersonNameMethods} and {@link LocaleCompanyNameMethods}).
+ */
+export type FakeData = PersonNameMethods & LocaleCompanyNameMethods & {
+    plPesel(options?: PeselOptions): Promise<PolishPeselData>;
+    plPesels(count: number, options?: PeselOptions): Promise<PolishPeselData[]>;
+    plPerson(options?: PersonOptions): Promise<PolishPersonData>;
+    plPeople(count: number, options?: PersonOptions): Promise<PolishPersonData[]>;
+    plAddress(options?: AddressOptions): Promise<PolishAddressData>;
+    plAddresses(count: number, options?: AddressOptions): Promise<PolishAddressData[]>;
+    plNip(options?: NipOptions): Promise<PolishNipData>;
+    plNips(count: number, options?: NipOptions): Promise<PolishNipData[]>;
+    plIban(options?: IbanOptions): Promise<PolishIbanData>;
+    plIbans(count: number, options?: IbanOptions): Promise<PolishIbanData[]>;
+    plRegon(options?: RegonOptions): Promise<PolishRegonData>;
+    plRegons(count: number, options?: RegonOptions): Promise<PolishRegonData[]>;
+    plCompany(options?: CompanyOptions): Promise<PolishCompanyData>;
+    plCompanies(count: number, options?: CompanyOptions): Promise<PolishCompanyData[]>;
+    plCompanyName(options?: CompanyNameOptions): Promise<PolishCompanyNameData>;
+    plCompanyNames(count: number, options?: CompanyNameOptions): Promise<PolishCompanyNameData[]>;
+    plVehicleRegistration(options?: VehicleRegistrationOptions): Promise<PolishVehicleRegistrationData>;
+    plVehicleRegistrations(count: number, options?: VehicleRegistrationOptions): Promise<PolishVehicleRegistrationData[]>;
+    plIdCard(options?: IdCardOptions): Promise<PolishIdCardData>;
+    plIdCards(count: number, options?: IdCardOptions): Promise<PolishIdCardData[]>;
+    plPassport(options?: PassportOptions): Promise<PolishPassportData>;
+    plPassports(count: number, options?: PassportOptions): Promise<PolishPassportData[]>;
+    plKrs(options?: KrsOptions): Promise<PolishKrsData>;
+    plKrsNumbers(count: number, options?: KrsOptions): Promise<PolishKrsData[]>;
+    plLandRegister(options?: LandRegisterOptions): Promise<PolishLandRegisterData>;
+    plLandRegisters(count: number, options?: LandRegisterOptions): Promise<PolishLandRegisterData[]>;
+    plDrivingLicense(options?: DrivingLicenseOptions): Promise<PolishDrivingLicenseData>;
+    plDrivingLicenses(count: number, options?: DrivingLicenseOptions): Promise<PolishDrivingLicenseData[]>;
+    /** Multi-country person name: each record is drawn from one of `countries` (default: all 27). */
+    personName(options?: AnyPersonNameOptions): Promise<AnyPersonNameData>;
+    personNames(count: number, options?: AnyPersonNameOptions): Promise<AnyPersonNameData[]>;
+    /** Multi-country company name: each record is drawn from one of `countries` (default: all 27). */
+    companyName(options?: AnyCompanyNameOptions): Promise<AnyCompanyNameData>;
+    companyNames(count: number, options?: AnyCompanyNameOptions): Promise<AnyCompanyNameData[]>;
+    email(options?: EmailOptions): Promise<EmailData>;
+    emails(count: number, options?: EmailOptions): Promise<EmailData[]>;
+    lorem(options?: LoremOptions): Promise<LoremData>;
+    lorems(count: number, options?: LoremOptions): Promise<LoremData[]>;
+    frSiren(options?: FrSirenOptions): Promise<FrSirenData>;
+    frSirens(count: number, options?: FrSirenOptions): Promise<FrSirenData[]>;
+    frNir(options?: FrNirOptions): Promise<FrNirData>;
+    frNirs(count: number, options?: FrNirOptions): Promise<FrNirData[]>;
+    atSvnr(options?: AtSvnrOptions): Promise<AtSvnrData>;
+    atSvnrs(count: number, options?: AtSvnrOptions): Promise<AtSvnrData[]>;
+    atUid(options?: AtUidOptions): Promise<AtUidData>;
+    atUids(count: number, options?: AtUidOptions): Promise<AtUidData[]>;
+    atFirmenbuchnummer(options?: AtFirmenbuchnummerOptions): Promise<AtFirmenbuchnummerData>;
+    atFirmenbuchnummers(count: number, options?: AtFirmenbuchnummerOptions): Promise<AtFirmenbuchnummerData[]>;
+    atSteuernummer(options?: AtSteuernummerOptions): Promise<AtSteuernummerData>;
+    atSteuernummers(count: number, options?: AtSteuernummerOptions): Promise<AtSteuernummerData[]>;
+    beRijksregisternummer(options?: BeRijksregisternummerOptions): Promise<BeRijksregisternummerData>;
+    beRijksregisternummers(count: number, options?: BeRijksregisternummerOptions): Promise<BeRijksregisternummerData[]>;
+    beOndernemingsnummer(options?: BeOndernemingsnummerOptions): Promise<BeOndernemingsnummerData>;
+    beOndernemingsnummers(count: number, options?: BeOndernemingsnummerOptions): Promise<BeOndernemingsnummerData[]>;
+    bgEgn(options?: BgEgnOptions): Promise<BgEgnData>;
+    bgEgns(count: number, options?: BgEgnOptions): Promise<BgEgnData[]>;
+    bgEik(options?: BgEikOptions): Promise<BgEikData>;
+    bgEiks(count: number, options?: BgEikOptions): Promise<BgEikData[]>;
+    hrOib(options?: HrOibOptions): Promise<HrOibData>;
+    hrOibs(count: number, options?: HrOibOptions): Promise<HrOibData[]>;
+    hrJmbg(options?: HrJmbgOptions): Promise<HrJmbgData>;
+    hrJmbgs(count: number, options?: HrJmbgOptions): Promise<HrJmbgData[]>;
+    cyTic(options?: CyTicOptions): Promise<CyTicData>;
+    cyTics(count: number, options?: CyTicOptions): Promise<CyTicData[]>;
+    czRodneCislo(options?: CzRodneCisloOptions): Promise<CzRodneCisloData>;
+    czRodneCislos(count: number, options?: CzRodneCisloOptions): Promise<CzRodneCisloData[]>;
+    czIco(options?: CzIcoOptions): Promise<CzIcoData>;
+    czIcos(count: number, options?: CzIcoOptions): Promise<CzIcoData[]>;
+    dkCpr(options?: DkCprOptions): Promise<DkCprData>;
+    dkCprs(count: number, options?: DkCprOptions): Promise<DkCprData[]>;
+    dkCvr(options?: DkCvrOptions): Promise<DkCvrData>;
+    dkCvrs(count: number, options?: DkCvrOptions): Promise<DkCvrData[]>;
+    eeIsikukood(options?: EeIsikukoodOptions): Promise<EeIsikukoodData>;
+    eeIsikukoods(count: number, options?: EeIsikukoodOptions): Promise<EeIsikukoodData[]>;
+    eeRegistrikood(options?: EeRegistrikoodOptions): Promise<EeRegistrikoodData>;
+    eeRegistrikoods(count: number, options?: EeRegistrikoodOptions): Promise<EeRegistrikoodData[]>;
+    eeKmkr(options?: EeKmkrOptions): Promise<EeKmkrData>;
+    eeKmkrs(count: number, options?: EeKmkrOptions): Promise<EeKmkrData[]>;
+    fiHenkilotunnus(options?: FiHenkilotunnusOptions): Promise<FiHenkilotunnusData>;
+    fiHenkilotunnuss(count: number, options?: FiHenkilotunnusOptions): Promise<FiHenkilotunnusData[]>;
+    fiYTunnus(options?: FiYTunnusOptions): Promise<FiYTunnusData>;
+    fiYTunnuss(count: number, options?: FiYTunnusOptions): Promise<FiYTunnusData[]>;
+    deSteuerId(options?: DeSteuerIdOptions): Promise<DeSteuerIdData>;
+    deSteuerIds(count: number, options?: DeSteuerIdOptions): Promise<DeSteuerIdData[]>;
+    deUstIdnr(options?: DeUstIdnrOptions): Promise<DeUstIdnrData>;
+    deUstIdnrs(count: number, options?: DeUstIdnrOptions): Promise<DeUstIdnrData[]>;
+    deHandelsregisternummer(options?: DeHandelsregisternummerOptions): Promise<DeHandelsregisternummerData>;
+    deHandelsregisternummers(count: number, options?: DeHandelsregisternummerOptions): Promise<DeHandelsregisternummerData[]>;
+    deWirtschaftsIdnr(options?: DeWirtschaftsIdnrOptions): Promise<DeWirtschaftsIdnrData>;
+    deWirtschaftsIdnrs(count: number, options?: DeWirtschaftsIdnrOptions): Promise<DeWirtschaftsIdnrData[]>;
+    dePersonalausweis(options?: DePersonalausweisOptions): Promise<DePersonalausweisData>;
+    dePersonalausweiss(count: number, options?: DePersonalausweisOptions): Promise<DePersonalausweisData[]>;
+    grAmka(options?: GrAmkaOptions): Promise<GrAmkaData>;
+    grAmkas(count: number, options?: GrAmkaOptions): Promise<GrAmkaData[]>;
+    grAfm(options?: GrAfmOptions): Promise<GrAfmData>;
+    grAfms(count: number, options?: GrAfmOptions): Promise<GrAfmData[]>;
+    huAdoazonositoJel(options?: HuAdoazonositoJelOptions): Promise<HuAdoazonositoJelData>;
+    huAdoazonositoJels(count: number, options?: HuAdoazonositoJelOptions): Promise<HuAdoazonositoJelData[]>;
+    huTaj(options?: HuTajOptions): Promise<HuTajData>;
+    huTajs(count: number, options?: HuTajOptions): Promise<HuTajData[]>;
+    huSzemelyiAzonosito(options?: HuSzemelyiAzonositoOptions): Promise<HuSzemelyiAzonositoData>;
+    huSzemelyiAzonositos(count: number, options?: HuSzemelyiAzonositoOptions): Promise<HuSzemelyiAzonositoData[]>;
+    huAdoszam(options?: HuAdoszamOptions): Promise<HuAdoszamData>;
+    huAdoszams(count: number, options?: HuAdoszamOptions): Promise<HuAdoszamData[]>;
+    huCegjegyzekszam(options?: HuCegjegyzekszamOptions): Promise<HuCegjegyzekszamData>;
+    huCegjegyzekszams(count: number, options?: HuCegjegyzekszamOptions): Promise<HuCegjegyzekszamData[]>;
+    iePpsn(options?: IePpsnOptions): Promise<IePpsnData>;
+    iePpsns(count: number, options?: IePpsnOptions): Promise<IePpsnData[]>;
+    ieVat(options?: IeVatOptions): Promise<IeVatData>;
+    ieVats(count: number, options?: IeVatOptions): Promise<IeVatData[]>;
+    ieCro(options?: IeCroOptions): Promise<IeCroData>;
+    ieCros(count: number, options?: IeCroOptions): Promise<IeCroData[]>;
+    itCodiceFiscale(options?: ItCodiceFiscaleOptions): Promise<ItCodiceFiscaleData>;
+    itCodiceFiscales(count: number, options?: ItCodiceFiscaleOptions): Promise<ItCodiceFiscaleData[]>;
+    itPartitaIva(options?: ItPartitaIvaOptions): Promise<ItPartitaIvaData>;
+    itPartitaIvas(count: number, options?: ItPartitaIvaOptions): Promise<ItPartitaIvaData[]>;
+    lvPersonasKods(options?: LvPersonasKodsOptions): Promise<LvPersonasKodsData>;
+    lvPersonasKodss(count: number, options?: LvPersonasKodsOptions): Promise<LvPersonasKodsData[]>;
+    lvRegistracijasNumurs(options?: LvRegistracijasNumursOptions): Promise<LvRegistracijasNumursData>;
+    lvRegistracijasNumurss(count: number, options?: LvRegistracijasNumursOptions): Promise<LvRegistracijasNumursData[]>;
+    ltAsmensKodas(options?: LtAsmensKodasOptions): Promise<LtAsmensKodasData>;
+    ltAsmensKodass(count: number, options?: LtAsmensKodasOptions): Promise<LtAsmensKodasData[]>;
+    ltImonesKodas(options?: LtImonesKodasOptions): Promise<LtImonesKodasData>;
+    ltImonesKodass(count: number, options?: LtImonesKodasOptions): Promise<LtImonesKodasData[]>;
+    ltPvm(options?: LtPvmOptions): Promise<LtPvmData>;
+    ltPvms(count: number, options?: LtPvmOptions): Promise<LtPvmData[]>;
+    luMatricule(options?: LuMatriculeOptions): Promise<LuMatriculeData>;
+    luMatricules(count: number, options?: LuMatriculeOptions): Promise<LuMatriculeData[]>;
+    luTva(options?: LuTvaOptions): Promise<LuTvaData>;
+    luTvas(count: number, options?: LuTvaOptions): Promise<LuTvaData[]>;
+    mtIdCard(options?: MtIdCardOptions): Promise<MtIdCardData>;
+    mtIdCards(count: number, options?: MtIdCardOptions): Promise<MtIdCardData[]>;
+    mtVat(options?: MtVatOptions): Promise<MtVatData>;
+    mtVats(count: number, options?: MtVatOptions): Promise<MtVatData[]>;
+    nlBsn(options?: NlBsnOptions): Promise<NlBsnData>;
+    nlBsns(count: number, options?: NlBsnOptions): Promise<NlBsnData[]>;
+    nlRsin(options?: NlRsinOptions): Promise<NlRsinData>;
+    nlRsins(count: number, options?: NlRsinOptions): Promise<NlRsinData[]>;
+    nlBtwId(options?: NlBtwIdOptions): Promise<NlBtwIdData>;
+    nlBtwIds(count: number, options?: NlBtwIdOptions): Promise<NlBtwIdData[]>;
+    nlKvk(options?: NlKvkOptions): Promise<NlKvkData>;
+    nlKvks(count: number, options?: NlKvkOptions): Promise<NlKvkData[]>;
+    ptNif(options?: PtNifOptions): Promise<PtNifData>;
+    ptNifs(count: number, options?: PtNifOptions): Promise<PtNifData[]>;
+    ptCartaoCidadao(options?: PtCartaoCidadaoOptions): Promise<PtCartaoCidadaoData>;
+    ptCartaoCidadaos(count: number, options?: PtCartaoCidadaoOptions): Promise<PtCartaoCidadaoData[]>;
+    roCnp(options?: RoCnpOptions): Promise<RoCnpData>;
+    roCnps(count: number, options?: RoCnpOptions): Promise<RoCnpData[]>;
+    roCui(options?: RoCuiOptions): Promise<RoCuiData>;
+    roCuis(count: number, options?: RoCuiOptions): Promise<RoCuiData[]>;
+    skRodneCislo(options?: SkRodneCisloOptions): Promise<SkRodneCisloData>;
+    skRodneCislos(count: number, options?: SkRodneCisloOptions): Promise<SkRodneCisloData[]>;
+    skIco(options?: SkIcoOptions): Promise<SkIcoData>;
+    skIcos(count: number, options?: SkIcoOptions): Promise<SkIcoData[]>;
+    skIcDph(options?: SkIcDphOptions): Promise<SkIcDphData>;
+    skIcDphs(count: number, options?: SkIcDphOptions): Promise<SkIcDphData[]>;
+    siEmso(options?: SiEmsoOptions): Promise<SiEmsoData>;
+    siEmsos(count: number, options?: SiEmsoOptions): Promise<SiEmsoData[]>;
+    siDavcnaStevilka(options?: SiDavcnaStevilkaOptions): Promise<SiDavcnaStevilkaData>;
+    siDavcnaStevilkas(count: number, options?: SiDavcnaStevilkaOptions): Promise<SiDavcnaStevilkaData[]>;
+    esDni(options?: EsDniOptions): Promise<EsDniData>;
+    esDnis(count: number, options?: EsDniOptions): Promise<EsDniData[]>;
+    esNie(options?: EsNieOptions): Promise<EsNieData>;
+    esNies(count: number, options?: EsNieOptions): Promise<EsNieData[]>;
+    esCif(options?: EsCifOptions): Promise<EsCifData>;
+    esCifs(count: number, options?: EsCifOptions): Promise<EsCifData[]>;
+    sePersonnummer(options?: SePersonnummerOptions): Promise<SePersonnummerData>;
+    sePersonnummers(count: number, options?: SePersonnummerOptions): Promise<SePersonnummerData[]>;
+    seOrganisationsnummer(options?: SeOrganisationsnummerOptions): Promise<SeOrganisationsnummerData>;
+    seOrganisationsnummers(count: number, options?: SeOrganisationsnummerOptions): Promise<SeOrganisationsnummerData[]>;
+};
 export interface CreateFakeDataOptions {
     /**
      * Base seed for this instance. When set, the Nth call uses `seed + N`, so a
@@ -25,4 +221,5 @@ export interface CreateFakeDataOptions {
  * distinct within a run.
  */
 export declare const createFakeData: (provider: FakeDataProvider, options?: CreateFakeDataOptions) => FakeData;
+export {};
 //# sourceMappingURL=fake-data.d.ts.map