@ekwo-ai/coda 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ekwo AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# `@ekwo-ai/coda`
+
+Reads a **CODA** file — the *coded statement of account* Belgian banks deliver,
+records of 128 characters in fixed positions — into plain objects, in
+TypeScript, with no dependencies.
+
+Give it the file and it gives you the statements in it, their lines, and the
+list of what does not add up.
+
+```ts
+import { readCoda } from '@ekwo-ai/coda';
+
+const { statements, violations } = readCoda(bytesOrString);
+
+for (const statement of statements) {
+  statement.account.identifier; // { kind: 'iban', value } or { kind: 'other', value, scheme, issuer }
+  statement.openingBalance;     // { type: 'OPBD', amount: '1000.00', currency: 'EUR', date: '2026-03-04' }
+  statement.closingBalance;
+  statement.balanced;           // true, false, or null when it could not be checked
+  for (const line of statement.lines) {
+    line.amount;                // '-450.50' — signed, a decimal string, never a float
+    line.bookingDate;           // '2026-03-05'
+    line.counterparty;          // { name, account, agentBic, ultimateName }
+    line.remittance;            // { unstructured: [...], structured: [{ reference: '202600010704', type: 'SCOR', issuer: 'BBA' }] }
+    line.bankReference;         // the bank's own reference for the movement
+  }
+}
+```
+
+It knows no database and no ledger. The shape it returns is declared in
+[`src/types.ts`](./src/types.ts), imported from nowhere, and is **field for
+field the shape [`@ekwo-ai/camt053`](../camt053/) declares for itself** — so
+whatever takes a camt.053 that was read takes a CODA that was read, without an
+adapter. What only CODA says comes after those fields, under its own names
+(`sequenceNumber`, `detailNumber`, `transactionCode`, `globalisationCode`,
+`structuredCommunication`, `information`, `freeCommunications`…).
+
+A format is not a country. CODA happens to be Belgian the way Factur-X happens
+to be French and German; nothing here assumes the euro, a Belgian account or a
+language, and the tests read a pound and a dinar account.
+
+## What it does
+
+- Reads **version 2** of the standard — records 0, 1, 2.1/2.2/2.3, 3.1/3.2/3.3,
+  8, 4 and 9 — and refuses version 1 by name: under the same name it is another
+  lay-out.
+- Returns **every statement** of the file. A physical file holds one CODA per
+  account and per day, one after the other, and each violation says which.
+- Identifies the account by **what record 1 says it is**: an IBAN (structures 2
+  and 3) or a domestic number (0 and 1), with its currency. An IBAN is held
+  against ISO 13616 and returned as written when it fails (`invalid_iban`).
+- Signs every amount from the account holder's side and returns it as a
+  **decimal string**. CODA writes twelve digits and **three decimals** whatever
+  the currency; the reader adds on integers of thousandths and returns two
+  decimals, and the third when the file wrote one that is not zero. Nothing is
+  rounded.
+- Checks that **old balance + movements = new balance**, to the last decimal.
+  When it is not, the statement comes back as the bank wrote it, `balanced` is
+  `false`, and `balance_mismatch` says the difference. **Nothing is corrected.**
+- Holds the **trailer record** against the file: the number of records 1, 2, 3
+  and 8, and the debit and credit totals, which the standard defines as the sum
+  of the movement records *with detail number 0000*
+  (`record_count_mismatch`, `debit_total_mismatch`, `credit_total_mismatch`). A
+  file that lost a record on the way fails all three at once.
+- **Never counts a total and its details twice.** A movement is the record with
+  detail number `0000`; the records that follow under the same sequence number
+  are its details (types 5, 6, 7, 8, and 9 beneath a 7). The movement is
+  **split into its details when, and only when, they add up to it exactly** —
+  each line then keeps its own counterparty, communication and references, plus
+  `entry`, `detail`, `detailCount` and `entryAmount` to put it back together.
+  Otherwise it stays one line and `batch_not_split` says why. Either way the
+  lines add up to what moved on the account. It is the rule of the camt.053
+  reader, for the same reason: reconciliation wants the transaction, the
+  balance wants the movement.
+- Returns the **Belgian structured communication** (types 101 and 102) as its
+  twelve digits with `type: 'SCOR'`, `issuer: 'BBA'` — which is how a camt.053
+  carries the same payment — **checks its modulo 97** (where a remainder of
+  zero is written 97) and, when it fails, **reports it and returns it as
+  written** (`invalid_structured_reference`). `formatBelgianReference()` gives
+  the `+++123/4567/89002+++` of the invoice. An ISO 11649 reference (type 100)
+  is treated the same way, with `issuer: 'ISO'`.
+- Puts a **free communication back together** from the three records it is cut
+  across, and keeps it apart from a structured one.
+- Reads the SEPA direct debit out of structured communication **127**: the
+  mandate, the communication, the reason.
+- Keeps **every other structured communication as written**
+  (`structuredCommunication: { type, text }`) rather than half decoding it.
+- Attaches the **information records** (3) to their movement: the free ones
+  make `additionalInformation`; type 001 names the counterparty when record 2.3
+  does not; 008 and 009 name the party behind it.
+
+## A statement is hostile input
+
+It arrives by e-mail, from a download, from a third party's API.
+
+- **Every record is 128 characters or the file is refused**
+  (`invalid_record_length`, with the record's number). Nothing is padded and
+  nothing is trimmed: a format of positions that is off by one is off for every
+  field after it. A file with no line break at all is read as consecutive
+  records, if its length is a whole number of them.
+- **An unknown record is refused by name** (`unknown_record`), and so is a
+  known one out of place (`unexpected_record`): a 2.3 whose 2.1 is another
+  movement, a movement before the old balance, a second header before a
+  trailer. A file that stops before its trailer is `incomplete_statement`.
+- **UTF-8, decoded fatally**, which reads the ASCII the standard writes.
+  `{ encoding: 'iso-8859-1' }` is said by the caller and **never guessed** —
+  every sequence of bytes is valid ISO-8859-1, so a guess could not fail. A
+  control character or a replacement character is `unsupported_encoding`: the
+  file was decoded wrongly by somebody already.
+- **Size** is checked before a record is read (`maxBytes`, 32 MiB by default).
+
+## What is thrown, and what comes back as a violation
+
+**Thrown** (`StatementFileError`, with a `code` and the `record` it stopped on):
+`too_large`, `unsupported_encoding`, `empty_file`, `invalid_record_length`,
+`unknown_record`, `unexpected_record`, `unsupported_version`,
+`inconsistent_record` (the new balance is of another account than the old one),
+`incomplete_statement`.
+
+**Returned** in `violations`, with the statement and the line it is on:
+
+| code | when |
+|---|---|
+| `balance_mismatch` | old balance + movements ≠ new balance; the message says the difference |
+| `record_count_mismatch`, `debit_total_mismatch`, `credit_total_mismatch` | the trailer disagrees with the file |
+| `closing_balance_missing` | no record 8 — which is how the standard writes a day without movement; nothing is invented |
+| `separate_application` | the header says the file is an extract; its balances are zeroed by the standard and prove nothing |
+| `currency_missing` | the account zone carries no currency; none is assumed |
+| `invalid_amount`, `invalid_direction`, `invalid_date`, `booking_date_missing` | the line comes back with `null` there |
+| `invalid_iban` | the account is announced as an IBAN and fails its check digits |
+| `invalid_structured_reference` | a structured communication fails its own modulo 97 — returned as written |
+| `batch_not_split` | see above |
+
+## What it does not do
+
+- **It converts nothing, matches nothing, and does not decide what a duplicate
+  is.**
+- **It does not explain the transaction code.** The eight digits are returned,
+  apart (`transactionCode`) and whole (`bankTransactionCode.proprietary`); the
+  sixty pages of annex II that say what each means are not in this package.
+- **It decodes four structured communications** (100, 101, 102, 127) out of
+  some twenty-five. The others are returned as written.
+- **It does not check the link and next codes** (positions 126 and 128): the
+  records that follow are what is read, not what was announced.
+- **It does not read version 1**, and it does not read a year before the pivot
+  as this century: `YY` is 20YY under `pivotYear` (80 by default) and 19YY from
+  it.
+- **It does not read Windows-1252.** A euro sign at byte 0x80 is a control
+  character of ISO-8859-1 and is refused; decode the file and pass the string.
+
+## The bank reference, and the same month in two formats
+
+`bankReference` is the "reference number of the bank" of record 2.1. The
+standard says of it (§ 7.4): *"purely informative … The bank may change this
+reference without prior notice. Consequently, it is not recommendable to apply
+any kind of programming in this field."* It is returned because it is what the
+file says, blank or all zeros as `null`.
+
+A reader does not decide what a duplicate is, but it should say what it gives
+the one who does: **nothing in the standard promises that this reference is the
+`AcctSvcrRef` the same bank writes in a camt.053 of the same day.** Where it
+is, a core that keys a line on its bank reference will recognise it across the
+two formats; where it is not, it will not.
+
+## Sources
+
+- Febelfin, *Coded statement of account (CODA)*, **version 2.6** (February
+  2018),
+  <https://febelfin.be/media/pages/publicaties/2021/gecodeerde-berichtgeving-coda/c580ddf2b4-1694763197/standard-coda-2.6-en.pdf>,
+  and **version 2.8** (November 2025),
+  <https://febelfin.be/media/pages/publicaties/2023/febelfin-standaarden-voor-online-bankieren/d7168c5c37-1764229602/standard-coda-en_-2025.pdf>
+  — both downloaded on 18 September 2026. The lay-out of the records (annex I)
+  is the same in both; 2.7 and 2.8 add card schemes and a tax category.
+- ISO 13616 (IBAN), ISO 11649 (creditor reference), ISO 7064 (MOD 97-10).
+
+## What is verified, and what is not
+
+**Verified**: every position this reader takes was written from annex I of the
+standard, and the test builder (`test/build.ts`) was written from the same
+annex, separately from the reader — so a fixture is a second reading of the
+lay-out, and the two have to agree. The fixtures under `test/fixtures/` are
+what the builder writes, compared on every run.
+
+**Not verified** — and this is the larger half:
+
+- **No file from a bank has been read.** Every statement here is invented,
+  because a real one is somebody's account. Reader and builder share an author
+  and a reading of the standard: where that reading is wrong, both are, and the
+  tests pass. *The first real file from each bank is a test nobody has run.*
+- **How banks number details.** The standard has the detail number go up for
+  each record 2.1 *and* each record 3.1 of a movement; this reader relies on
+  the sequence number and on `0000` only, and on the type digit of the
+  transaction code for what is a detail of what.
+- **The globalisation code** (position 125) is returned and not used. The
+  hierarchy is read from the transaction type, which the trailer's own
+  definition of its totals supports; a bank that globalises otherwise would
+  show as `batch_not_split`, not as a wrong balance.
+- **Whether details always add up.** Where they do not — a detail given for
+  information, a tax shown and not charged — the movement stays one line and
+  says so. That is safe, and it is not the same as understood.
+- **The counterparty's account** "comes in the structure of the initial
+  payment": it is an IBAN when it passes ISO 13616, else what was written.
+
+## Licence
+
+MIT. See [`LICENSE`](./LICENSE).

package/dist/checks.d.ts

@@ -0,0 +1,12 @@
+/** ISO 13616: move four characters to the end, letters to numbers, mod 97 is 1. */
+export declare function isValidIban(iban: string): boolean;
+/** ISO 11649: `RF`, two check digits, up to twenty-one characters; same arithmetic as an IBAN. */
+export declare function isValidCreditorReference(reference: string): boolean;
+/**
+ * The Belgian structured communication: twelve digits, the last two being the
+ * first ten modulo 97 — and 97 when that is zero, never 00.
+ */
+export declare function isValidBelgianReference(digits: string): boolean;
+/** `123456789002` as it is printed on an invoice: `+++123/4567/89002+++`. Twelve digits or null. */
+export declare function formatBelgianReference(digits: string): string | null;
+//# sourceMappingURL=checks.d.ts.map

package/dist/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../src/checks.ts"],"names":[],"mappings":"AAWA,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGjD;AAED,kGAAkG;AAClG,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAGnE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED,oGAAoG;AACpG,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGpE"}

package/dist/checks.js

@@ -0,0 +1,39 @@
+/** ISO 7064 MOD 97-10 over a string of digits and letters (A = 10 … Z = 35). */
+function mod97(text) {
+    let remainder = 0;
+    for (const character of text) {
+        const code = character.charCodeAt(0);
+        const value = code >= 65 ? code - 55 : code - 48;
+        remainder = (value > 9 ? remainder * 100 + value : remainder * 10 + value) % 97;
+    }
+    return remainder;
+}
+/** ISO 13616: move four characters to the end, letters to numbers, mod 97 is 1. */
+export function isValidIban(iban) {
+    if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(iban))
+        return false;
+    return mod97(iban.slice(4) + iban.slice(0, 4)) === 1;
+}
+/** ISO 11649: `RF`, two check digits, up to twenty-one characters; same arithmetic as an IBAN. */
+export function isValidCreditorReference(reference) {
+    if (!/^RF[0-9]{2}[A-Z0-9]{1,21}$/.test(reference))
+        return false;
+    return mod97(reference.slice(4) + reference.slice(0, 4)) === 1;
+}
+/**
+ * The Belgian structured communication: twelve digits, the last two being the
+ * first ten modulo 97 — and 97 when that is zero, never 00.
+ */
+export function isValidBelgianReference(digits) {
+    if (!/^[0-9]{12}$/.test(digits))
+        return false;
+    const check = Number(BigInt(digits.slice(0, 10)) % 97n) || 97;
+    return check === Number(digits.slice(10));
+}
+/** `123456789002` as it is printed on an invoice: `+++123/4567/89002+++`. Twelve digits or null. */
+export function formatBelgianReference(digits) {
+    if (!/^[0-9]{12}$/.test(digits))
+        return null;
+    return `+++${digits.slice(0, 3)}/${digits.slice(3, 7)}/${digits.slice(7)}+++`;
+}
+//# sourceMappingURL=checks.js.map

package/dist/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.js","sourceRoot":"","sources":["../src/checks.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,SAAS,KAAK,CAAC,IAAY;IACzB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,KAAK,MAAM,SAAS,IAAI,IAAI,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC;QACjD,SAAS,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;IAClF,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC,kCAAkC,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACjE,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED,kGAAkG;AAClG,MAAM,UAAU,wBAAwB,CAAC,SAAiB;IACxD,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IAChE,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACjE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAAc;IACpD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC9D,OAAO,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,oGAAoG;AACpG,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,OAAO,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AAChF,CAAC"}

package/dist/decimal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Amounts as the file wrote them, added without a float.
+ *
+ * A CODA amount is fifteen digits: twelve and **three decimals**, whatever the
+ * currency, unsigned — the sign is another position of the record. Sums are
+ * made on a `bigint` of thousandths, and what leaves is a string.
+ */
+/** Fifteen digits as thousandths, or null when they are not fifteen digits. */
+export declare function parseAmount(field: string): bigint | null;
+/**
+ * Thousandths as a decimal string: signed, no leading zeros, two decimals —
+ * and the third when the file wrote one that is not zero. Dropping a written
+ * zero is not rounding; dropping anything else would be, and is never done.
+ */
+export declare function formatAmount(value: bigint): string;
+//# sourceMappingURL=decimal.d.ts.map

package/dist/decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../src/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAExD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD"}

package/dist/decimal.js

@@ -0,0 +1,25 @@
+/**
+ * Amounts as the file wrote them, added without a float.
+ *
+ * A CODA amount is fifteen digits: twelve and **three decimals**, whatever the
+ * currency, unsigned — the sign is another position of the record. Sums are
+ * made on a `bigint` of thousandths, and what leaves is a string.
+ */
+const DIGITS = /^[0-9]{15}$/;
+/** Fifteen digits as thousandths, or null when they are not fifteen digits. */
+export function parseAmount(field) {
+    return DIGITS.test(field) ? BigInt(field) : null;
+}
+/**
+ * Thousandths as a decimal string: signed, no leading zeros, two decimals —
+ * and the third when the file wrote one that is not zero. Dropping a written
+ * zero is not rounding; dropping anything else would be, and is never done.
+ */
+export function formatAmount(value) {
+    const negative = value < 0n;
+    const digits = (negative ? -value : value).toString().padStart(4, '0');
+    const whole = digits.slice(0, -3);
+    const fraction = digits.slice(-3).replace(/0$/, '');
+    return `${negative ? '-' : ''}${whole}.${fraction}`;
+}
+//# sourceMappingURL=decimal.js.map

package/dist/decimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.js","sourceRoot":"","sources":["../src/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,GAAG,aAAa,CAAC;AAE7B,+EAA+E;AAC/E,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACnD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,MAAM,QAAQ,GAAG,KAAK,GAAG,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACvE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACpD,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,QAAQ,EAAE,CAAC;AACtD,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What makes a file unreadable, as opposed to a statement that reads and does
+ * not add up. The second comes back in `violations`; the first is thrown,
+ * because a format of fixed positions that is off by one character is off for
+ * every field after it, and there is no statement to hang a violation on.
+ */
+export type StatementFileErrorCode = 
+/** Larger than `maxBytes`. Refused before a single character is read. */
+'too_large'
+/** Bytes that are not the encoding announced, a replacement or a control character. */
+ | 'unsupported_encoding'
+/** Nothing in the file. */
+ | 'empty_file'
+/** A record that is not 128 characters long. */
+ | 'invalid_record_length'
+/** A record whose identification is none of 0, 1, 2, 3, 4, 8, 9 — or an article that is none of 1, 2, 3. */
+ | 'unknown_record'
+/** A known record where the format does not allow it: a 2.2 without its 2.1, a line before the old balance. */
+ | 'unexpected_record'
+/** A header whose version code is not 2: version 1 is another lay-out under the same name. */
+ | 'unsupported_version'
+/** Two records of one statement that disagree on the account it is the statement of. */
+ | 'inconsistent_record'
+/** The file stops before the trailer record of a statement it began. */
+ | 'incomplete_statement';
+export declare class StatementFileError extends Error {
+    readonly code: StatementFileErrorCode;
+    /** The record the reader stopped on, from 1, when there is one. */
+    readonly record: number | null;
+    constructor(code: StatementFileErrorCode, message: string, record?: number | null);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB;AAChC,yEAAyE;AACvE,WAAW;AACb,uFAAuF;GACrF,sBAAsB;AACxB,2BAA2B;GACzB,YAAY;AACd,gDAAgD;GAC9C,uBAAuB;AACzB,4GAA4G;GAC1G,gBAAgB;AAClB,+GAA+G;GAC7G,mBAAmB;AACrB,8FAA8F;GAC5F,qBAAqB;AACvB,wFAAwF;GACtF,qBAAqB;AACvB,wEAAwE;GACtE,sBAAsB,CAAC;AAE3B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEnB,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,IAAW;CAMxF"}

package/dist/errors.js

@@ -0,0 +1,12 @@
+export class StatementFileError extends Error {
+    code;
+    /** The record the reader stopped on, from 1, when there is one. */
+    record;
+    constructor(code, message, record = null) {
+        super(record === null ? message : `record ${record}: ${message}`);
+        this.name = 'StatementFileError';
+        this.code = code;
+        this.record = record;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AA0BA,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAClC,IAAI,CAAyB;IACtC,mEAAmE;IAC1D,MAAM,CAAgB;IAE/B,YAAY,IAA4B,EAAE,OAAe,EAAE,SAAwB,IAAI;QACrF,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,MAAM,KAAK,OAAO,EAAE,CAAC,CAAC;QAClE,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { ReadOptions, StatementFile } from './types.js';
+export { formatBelgianReference, isValidBelgianReference, isValidCreditorReference, isValidIban } from './checks.js';
+export { StatementFileError, type StatementFileErrorCode } from './errors.js';
+export type * from './types.js';
+/** Every record of a CODA file is this long, the line break not counted. */
+export declare const RECORD_LENGTH = 128;
+/**
+ * Read a CODA file — a string, or the bytes as they came — into its
+ * statements, their lines, and what does not add up.
+ *
+ * Throws a `StatementFileError` for what is not a readable CODA at all: a
+ * record of the wrong length, an unknown record, a record out of place, an
+ * encoding that is not the one announced. Everything else comes back, with the
+ * trouble named in `violations` and nothing silently repaired: a new balance
+ * that does not follow from the old one is returned as the bank wrote it, and
+ * reported.
+ */
+export declare function readCoda(input: string | Uint8Array, options?: ReadOptions): StatementFile;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAIV,WAAW,EAIX,aAAa,EAId,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACrH,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC9E,mBAAmB,YAAY,CAAC;AAEhC,4EAA4E;AAC5E,eAAO,MAAM,aAAa,MAAM,CAAC;AA8oBjC;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAQ7F"}