ekwo-os 0.4.1

package/dist/pack/read.d.ts

@@ -0,0 +1,766 @@
+/**
+ * Reading a pack: the files, the CSV, and what the schema says about them.
+ *
+ * A pack is `packs/<cc>/`: a manifest, a chart of accounts as CSV, taxes as
+ * JSON, and — accepted here, compiled later — the declaration boxes, the
+ * financial statements and the translations. Nothing in it executes.
+ */
+import { type VatRegime } from './vat-codes.js';
+/**
+ * The chart a pack has when it declares none, and the name of the framework
+ * pack. Both are mechanism words: `default` is not a country and `generic` is
+ * not a language — a pack says its chart is called PCMN, in its own data.
+ */
+export declare const DEFAULT_CHART = "default";
+export declare const GENERIC_PACK = "generic";
+/**
+ * One text of a pack's source register.
+ *
+ * The register is where a link lives, and the only place: a tax, a box of the
+ * declaration or a sentence of an invoice writes the article it claims in its
+ * own `legal_reference` and names the key of the text that article is in. So a
+ * publisher that reorganises its site is one line of the pack to change, and a
+ * reviewer opening a pack has the reading list before they have read a rule.
+ *
+ * Nothing here is a copy of the text. A pack says where the law is, never what
+ * it says: a quotation ages without anybody noticing, and a country pack that
+ * carried one would be a second, unversioned edition of a statute.
+ */
+export interface PackSource {
+    /** How the rest of the pack names this text. Unique inside one register. */
+    key: string;
+    title: string;
+    /** Who publishes it officially — the half of a source a link cannot carry. */
+    publisher: string;
+    /** Absolute, https, and a permanent identifier wherever the publisher has one. */
+    url: string;
+    /** The day somebody opened it. What says how old the reading is. */
+    consulted_on: string;
+    /** law | regulation | form | standard | portal | guidance. */
+    kind: string;
+    /**
+     * True on the one entry that publishes the list an exemption reason code of
+     * this country comes from — BT-121, outside the common system of VAT, where
+     * the VATEX list of EN 16931 does not reach.
+     *
+     * At most one entry of a register carries it, and it has to be a `standard`,
+     * because a code list is one. It exists because the opposite is not true: a
+     * `standard` is "a technical norm or code list", so FRS 102 and the FASB
+     * Accounting Standards Codification are `standard` entries too, and reading
+     * the first of them as this list authorised a reason code on any tax of the
+     * pack in declaration order.
+     */
+    reason_codes?: boolean;
+}
+/**
+ * What a manifest says about who stands behind a pack.
+ *
+ * `sources` holds the register above and — for a pack written before it —
+ * bare strings, which are titles with nowhere to read them. Both are accepted
+ * so that a community pack goes on compiling; `ekwo pack check` warns on the
+ * string, and a pack that is not `community` has to carry at least one entry
+ * of the register.
+ */
+export interface PackCertification {
+    status: string;
+    by?: string | null;
+    on?: string;
+    sources?: (string | PackSource)[];
+}
+/** The register of a pack: the entries, with the deprecated bare titles dropped. */
+export declare function sourcesOf(certification: PackCertification | null | undefined): PackSource[];
+/**
+ * Which VAT the country of a pack levies, as the three code lists see it.
+ *
+ * Two of those lists are the Union's — EN 16931 is a European standard and the
+ * VATEX list is published by the European Commission — so whether a pack may
+ * carry a code from them is a question about its country. The answer is a row
+ * of `territories`, read from the seed the database reads, and never a country
+ * written into this repository's code.
+ *
+ * **The day is the pack's `released_at`, not today.** A pack is a transcription
+ * of a country's law, and `released_at` is the day it says that transcription
+ * is true; it is in the manifest, it is inside the pack's checksum, and asking
+ * it makes `ekwo pack check` answer the same thing about the same commit for
+ * ever. Today would not: a pack that passes in the morning and fails in the
+ * evening with nothing committed in between is the one thing a check must
+ * never be, and the day a State acceded or left is exactly when it would
+ * happen. A tax's own `valid_from` would be worse still — the taxes of a pack
+ * span decades, so one pack would speak two regimes at once and a British rate
+ * of 1994 would be asked for a VATEX code from a list that did not exist. A
+ * pack whose manifest names no day falls back on today, because a pack that
+ * does not say when it speaks of is speaking of now.
+ *
+ * **A table that says nothing is not a table saying no.** `eu_vat_scope_of()`
+ * answers `none` for a code it does not carry, which is right for its own
+ * question — a supply to a place the Union has never heard of is not an
+ * intra-Community one. It is not right for this one. Every refusal below
+ * *narrows* what a pack may say, and narrowing on the strength of a missing
+ * row would refuse a valid pack for a country somebody has not added to the
+ * reference data yet. So a country the table carries no row for is held to the
+ * table as published — the Union's — and the gap is closed where it belongs:
+ * `tests/territories.test.ts` refuses a pack of this repository whose country
+ * is not in `territories`, and the test beside it says the same of the seed the
+ * CLI reads.
+ *
+ * `full` and nothing else counts as being in the system **for a pack**. The
+ * third value, `goods`, is Northern Ireland, and it is not a fact about a pack
+ * at all: the Union's rules reach goods there and not services, so half the
+ * table applies and which half depends on the tax. A pack whose country is
+ * such a territory is therefore still held to the rules of a country outside
+ * the system, which refuses a code rather than accepting a wrong one — and a
+ * *tax* that names the territory it applies in is judged on that territory
+ * instead, by `regimeOfTerritory` below.
+ *
+ * **Whether BT-151 is read is a second question, and the manifest answers the
+ * other half of it.** The category codes are UNCL5305, a UN/CEFACT list, and
+ * they hold wherever a pack is; being *asked* for one is about whether an
+ * invoice governed by the standard exists. Inside the common system it does.
+ * Outside it, it does where the pack declares an e-invoicing profile —
+ * `peppol-bis-3`, `factur-x-en16931`, `xrechnung`, a PINT — every one of which
+ * is built on the semantic model of EN 16931 and carries the field. Where the
+ * pack declares neither, as the first pack of a country with no value added
+ * tax did, nothing reads BT-151 and nothing demands it.
+ *
+ * **Which list a reason code may come from is named by the entry itself.**
+ * `reasonList` was the title of the first entry of the register whose `kind`
+ * was `standard`, and `standard` covers a code list *and* an accounting
+ * standard, so a pack naming FRS 102 or the FASB Codification was silently
+ * declaring a list of exemption reason codes. An entry now says so with
+ * `reason_codes`, at most one per pack, and `sourceRegister` refuses the rest.
+ */
+export declare function vatRegime(manifest: Manifest, root?: string): Promise<VatRegime>;
+export interface PackAccount {
+    code: string;
+    parent: string | null;
+    type: string;
+    reconcilable: boolean;
+    name: string;
+    sequence: number;
+}
+export interface PackPosting {
+    /**
+     * `base` is the line itself and `tax_on_base` is the share of the tax that
+     * is not recoverable; neither carries an account, because both land on the
+     * account the document line names.
+     */
+    type: 'base' | 'tax' | 'tax_on_base';
+    factor: number;
+    account: string | null;
+    /**
+     * The box the posting is known by: the first of `boxes`, and null when it
+     * reports to none. It is what the natural key of a posting is read on, and
+     * what a reader that knows nothing of several boxes still sees.
+     */
+    box: string | null;
+    /**
+     * Every box this one amount is printed in. One box is the ordinary case;
+     * several is a form that prints the same figure in boxes no total can
+     * derive from one another — box 6.1 inside box 6 inside box 1 on the
+     * Estonian KMD, box 6 beside box 7 on the British VAT Return. `box` is
+     * `boxes[0]`, and an empty list means the posting reports nowhere.
+     */
+    boxes: string[];
+    box_factor: number;
+    /** Declaration form the box belongs to. Defaults to the pack's periodic return. */
+    report: string | null;
+    sequence: number;
+}
+export interface PackTax {
+    code: string;
+    name: string;
+    description: string | null;
+    /** vat | gst | sales_tax | withholding | other. A label for the reports. */
+    kind: string;
+    amount_type: string;
+    rate: number;
+    scope: string;
+    treatment: string;
+    valid_from: string;
+    valid_to: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. Null where the pack names none. */
+    source: string | null;
+    vat_category: string | null;
+    exemption_code: string | null;
+    /** False when the buyer never gets the tax back. */
+    recoverable: boolean;
+    /** The unit price already holds the tax. */
+    price_include: boolean;
+    /**
+     * What this tax turns on that the ledger cannot see, from a closed
+     * vocabulary. What the question is, never how to answer it: no value, no
+     * operator, no expression — the article that sets a threshold or prescribes
+     * a certificate is the one in `legal_reference`.
+     */
+    conditions: string[];
+    /** ISO 3166-2 with the country prefix, for a tax levied by a state. */
+    jurisdiction: string | null;
+    /**
+     * Where the parties have to be for this tax to apply: `applies_when` of the
+     * pack, flattened. Each is a code of `territories`, or null where the tax
+     * says nothing about that party.
+     */
+    applies_seller_territory: string | null;
+    applies_buyer_territory: string | null;
+    applies_supply_territory: string | null;
+    /** Due on collection. Compiled to a column the cash-basis engine reads. */
+    cash_basis: boolean;
+    /** Account the tax waits on until the invoice is paid. */
+    cash_basis_transition_account: string | null;
+    sequence: number;
+    postings: {
+        invoice: PackPosting[];
+        credit_note: PackPosting[];
+    };
+    /** Reserved for phase 1: several taxes on one line. Refused until the core carries it. */
+    group?: string[];
+}
+/** One chart of accounts of a country, and the accounts it holds. */
+export interface PackChart {
+    code: string;
+    name: string;
+    name_i18n: Record<string, string>;
+    /** File the accounts were read from, relative to the pack directory. */
+    file: string;
+    accounts: PackAccount[];
+    is_default: boolean;
+    audience: string | null;
+    /** Codes of the statements this chart reports on. */
+    statements: string[];
+    certification: PackCertification | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+}
+/** One rule bringing accounts of a chart to a line of a statement. */
+export interface PackStatementRule {
+    kind: 'code_range' | 'code_prefix' | 'account_type' | 'account_code';
+    code_from: string | null;
+    code_to: string | null;
+    account_type: string | null;
+    side: 'debit' | 'credit' | 'any';
+    sequence: number;
+}
+/** One line of a financial statement. */
+export interface PackStatementLine {
+    code: string;
+    parent: string | null;
+    name: string;
+    sequence: number;
+    sign: 1 | -1;
+    /**
+     * Whether the line wrote `sign` itself, as opposed to taking the 1 every
+     * line reads with. The checker needs the difference: a total that declares
+     * `"sign": 1` is saying something about a total that a total cannot say,
+     * and it is worth telling its author so while they are writing the pack.
+     */
+    declares_sign: boolean;
+    is_total: boolean;
+    plus: string[];
+    minus: string[];
+    xbrl: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+    rules: PackStatementRule[];
+}
+/** `statements.json`: the financial statements of a pack. */
+export interface PackStatement {
+    code: string;
+    kind: string;
+    framework: string | null;
+    /**
+     * Taxonomy the `xbrl` fact keys of this statement are written against, as
+     * `name:version` — `nbb-cbso:26.0`. The format library that reads the keys
+     * carries the table of one version; against another, a key resolves onto a
+     * different line and nothing says so.
+     */
+    taxonomy: string | null;
+    name: string;
+    valid_from: string;
+    valid_to: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+    /** Chart this statement belongs to, or null for every chart of the country. */
+    chart_code: string | null;
+    lines: PackStatementLine[];
+}
+/** One box of a declaration form. A total carries the lists it is added from. */
+export interface PackReportBox {
+    box: string;
+    kind: 'base' | 'tax' | 'total';
+    name: string;
+    sequence: number;
+    /**
+     * Where the administration prints this box, when that is not where the pack
+     * declares it. Null means the same as `sequence`.
+     *
+     * The two were one field until a third pack paid for it: an eCDF subtotal
+     * prints above the boxes it adds up, and CDTFA-401-A prints line 11 on page
+     * one and computes it from the sections on page three. A pack had to spend
+     * its one ordering field on the evaluator, and the form's own order was
+     * lost. The evaluation order is the dependencies and is neither of these.
+     */
+    print_sequence: number | null;
+    plus: string[];
+    minus: string[];
+    /**
+     * Percentage of `rate_of` this box comes to. The other way a box is
+     * computed, for a form that states a line as a multiplication in words.
+     * Null on every box that is a list, which is most of them.
+     */
+    rate: number | null;
+    /** The box `rate` is applied to, bare or qualified with its kind. */
+    rate_of: string | null;
+    floor_zero: boolean;
+    hidden: boolean;
+    xml_element: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+}
+/** One sentence a country requires on an invoice, and when it applies. */
+export interface PackMention {
+    code: string;
+    /** One of the nine conditions of the closed vocabulary. */
+    applies_when: string;
+    text: string;
+    text_i18n: Record<string, string>;
+    sequence: number;
+    valid_from: string;
+    valid_to: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+}
+/**
+ * Where one rule of a country comes from.
+ *
+ * A tax and a box of a declaration form are rows, and each carries its own
+ * `legal_reference` and `source`. A document rule is a word — `gapless_per_year`,
+ * `30`, `invoice_date` — with nowhere to write either, so the citation lives
+ * beside it under `documents.references` and comes back here in the same shape.
+ */
+export interface PackRuleReference {
+    /** The article that imposes the rule. Null where the pack cites none. */
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+}
+/**
+ * The `documents`, `einvoicing` and `bank` sections of the manifest, read as
+ * one thing because they compile to one row: what a country requires on a
+ * document, how it is exchanged, and the formats its banks speak.
+ *
+ * Every field is null where the pack said nothing, and null is what reaches
+ * the column. There is no fallback here and there is none in the schema: a
+ * legal payment term or an e-invoicing profile invented for a country that
+ * has not spoken would be one country's law printed on another's invoice.
+ */
+export interface PackDocumentRules {
+    /** True where the law forbids a hole in the sequence. Null if unsaid. */
+    numbering_gapless: boolean | null;
+    number_format: string | null;
+    legal_payment_days: number | null;
+    late_payment_reference: string | null;
+    /** invoice_date | delivery_date | payment_date. */
+    tax_point_rule: string | null;
+    /**
+     * Where the three rules above come from, one citation per rule.
+     *
+     * Three and not one, because they are three articles of two or three
+     * different texts in every country the packs cover: Belgium numbers an
+     * invoice under a royal decree and counts a payment term under a law of
+     * 2002, France numbers under an annex to the tax code and counts under the
+     * commercial code. A single reference on the section would have had to name
+     * them all in one string, and then no rule would have had one.
+     */
+    numbering_reference: PackRuleReference;
+    payment_terms_reference: PackRuleReference;
+    tax_point_reference: PackRuleReference;
+    einvoice_profile: string | null;
+    einvoice_mandatory_from: string | null;
+    /** The text that makes the profile obligatory, and where it is read. */
+    einvoice_reference: PackRuleReference;
+    /** ISO 6523 ICD, four digits. */
+    party_scheme: string | null;
+    vat_scheme: string | null;
+    bank_statement_formats: string[];
+    payment_formats: string[];
+    fiscal_year_default: string | null;
+    mentions: PackMention[];
+}
+/**
+ * When a form is due, as a rule rather than a date.
+ *
+ * Two shapes and nothing else. `day_of_month_after_period` is Belgium's
+ * twentieth and Estonia's; `last_day_of_month_after_period` is California's
+ * quarterly return and, with `plus_days`, the United Kingdom's month and seven
+ * days. What is deliberately unsayable is a schedule that depends on *who* is
+ * filing rather than on *what period* — France staggers its dates by the
+ * taxpayer's identification number, and a pack that cannot say that says
+ * nothing at all, which is better than a date that is wrong for most filers.
+ */
+export interface PackDeadline {
+    rule: 'day_of_month_after_period' | 'last_day_of_month_after_period';
+    day: number | null;
+    plus_days: number | null;
+    legal_reference: string;
+    source: string | null;
+}
+/** `tax_report.json`: one declaration form and its boxes. */
+export interface PackReport {
+    code: string;
+    name: string;
+    /**
+     * The cadences this form is filed on, in the order month, quarter, year.
+     *
+     * A list because a country may file one set of boxes on more than one
+     * cadence, and because the single value it replaced had no honest answer
+     * for the country that files three: the word `month_or_quarter` was two
+     * cadences pretending to be one, and there was no `month_or_quarter_or_year`
+     * to invent next. A pack written before the list still says
+     * `"period": "month_or_quarter"`, and that is read as the two it names.
+     */
+    periods: string[];
+    /**
+     * The cadence this form is filed on unless the company has asked for
+     * another, or null where the law gives no single answer.
+     *
+     * It sits on the form and not on the country because the proposal is about a
+     * declaration: a country proposing one cadence can only ever be speaking
+     * about one of the several declarations a company files, and the moment a
+     * company records a cadence per form the proposal has to be per form too. A
+     * pack written before the move says it in `defaults.vat_period`, which is
+     * still read and no longer written.
+     */
+    period_default: string | null;
+    valid_from: string;
+    valid_to: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+    /** When the form is due, or null where the pack says nothing about it. */
+    deadline: PackDeadline | null;
+    /**
+     * The file this form is deposited as, by the name of the brick that writes
+     * it — `vat-consignment` for the Belgian XML Intervat takes. Null where no
+     * brick writes it yet, which is most of them: a form nobody can write is
+     * still a form a company files by hand on a portal.
+     */
+    file_format: string | null;
+    boxes: PackReportBox[];
+}
+/**
+ * `packs/<cc>/golden/scenario.json` — one year of books, declared.
+ *
+ * A country pack says what its taxes are and where they post. Nothing in the
+ * pack says what comes *out* of all that on a real year, so nothing in the
+ * pack could be wrong in a way anyone would notice: a box that sums the wrong
+ * postings and a posting that writes the wrong box agree with each other and
+ * the pack still compiles. The golden scenario is the second opinion — a set
+ * of documents and payments, and beside them, in their own files, the
+ * declaration, the statements and the trial balance the engine makes of them,
+ * to the cent.
+ *
+ * It proves internal coherence and nothing else, which is why every tax and
+ * every box also cites its source and why the manifest carries a
+ * certification status. A golden test is not a reviewer.
+ */
+export interface PackGolden {
+    name: string;
+    /** Chart the scenario installs. Null takes the pack's default. */
+    chart: string | null;
+    /**
+     * Territory the company of the scenario is established in, where its country
+     * is not precise enough. Null everywhere a country is the answer.
+     */
+    territory: string | null;
+    language: string | null;
+    fiscalYear: {
+        name: string;
+        start: string;
+        end: string;
+    };
+    /** The periods the declaration is filed for, in the order they are filed. */
+    periods: {
+        code: string;
+        from: string;
+        to: string;
+    }[];
+    /** Statement codes to evaluate. Empty takes the statements of the chart. */
+    statements: string[];
+    contacts: PackGoldenContact[];
+    documents: PackGoldenDocument[];
+    payments: PackGoldenPayment[];
+}
+export interface PackGoldenContact {
+    ref: string;
+    name: string;
+    type: 'customer' | 'supplier';
+    country: string;
+    /** Territory of the party, where the country is not precise enough. */
+    territory: string | null;
+    vat_number: string | null;
+    auxiliary_code: string | null;
+}
+export interface PackGoldenDocument {
+    ref: string;
+    type: 'sale_invoice' | 'sale_credit_note' | 'purchase_invoice' | 'purchase_credit_note';
+    contact: string;
+    date: string;
+    due_date: string | null;
+    /** Territory the supply takes place in, where the buyer's is not the answer. */
+    supply_territory: string | null;
+    /** What this document is in the scenario for. */
+    why: string;
+    lines: {
+        name: string;
+        quantity: number;
+        unit_price: number;
+        discount_percent: number;
+        tax: string | null;
+        account: string;
+    }[];
+}
+export interface PackGoldenPayment {
+    ref: string;
+    direction: 'inbound' | 'outbound';
+    date: string;
+    amount: number;
+    contact: string;
+    journal: string;
+    /** `ref` of the document this settles, or null for a payment on account. */
+    match: string | null;
+    why: string;
+}
+/** One line of `assets.json`: what a kind of asset is usually depreciated over. */
+export interface PackAssetCategory {
+    code: string;
+    name: string;
+    name_i18n: Record<string, string>;
+    method: string;
+    duration_months: number;
+    coefficient: number | null;
+    prorata: string | null;
+    account_type: string | null;
+    sequence: number;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+}
+/**
+ * `packs/<cc>/assets.json` — the country data of the `assets` module.
+ *
+ * It is read here, with the rest of the pack, rather than by the module: a
+ * pack is one object with one checksum and one `ekwo pack check`, and a module
+ * that read its own section would be a second reader of the same folder with
+ * its own idea of what a valid pack is. What is module-specific is where the
+ * compiler writes it — `supabase/seed/modules/assets/` and not the pack seed.
+ */
+export interface PackAssets {
+    prorata_straight_line: string;
+    prorata_declining: string;
+    day_count: string;
+    declining_cap_percent: number | null;
+    declining_switch_to_linear: boolean;
+    disposal_style: string | null;
+    legal_reference: string | null;
+    /** Key of the register entry where that reference can be read. */
+    source: string | null;
+    categories: PackAssetCategory[];
+}
+export interface Pack {
+    /** Lower-case directory name, e.g. `be`. */
+    slug: string;
+    dir: string;
+    manifest: Manifest;
+    /** Charts of this country, the default one first. Never empty. */
+    charts: PackChart[];
+    /** Accounts of the default chart. The chart a pack has when it declares only one. */
+    accounts: PackAccount[];
+    taxes: PackTax[];
+    /** `statements.json`, with every line and rule normalised. */
+    statements: PackStatement[];
+    /**
+     * Languages this pack publishes, the language of its own files first. A
+     * language the manifest declares covers every label; one that is only a
+     * file under `i18n/` may be partial.
+     */
+    languages: string[];
+    /** Every translated label of the pack, by section, by key, by language. */
+    labels: PackLabels;
+    /** What this country requires on a document, how it is exchanged, and its bank formats. */
+    documents: PackDocumentRules;
+    /** The periodic return of this pack, from `tax_report.json`. */
+    report: PackReport | null;
+    /** Code of the periodic return. The default of every box. */
+    reportCode: string | null;
+    /** `assets.json`, or null where this country says nothing about fixed assets. */
+    assets: PackAssets | null;
+    /** `golden/scenario.json`, or null where the manifest says why there is none. */
+    golden: PackGolden | null;
+    /** The reason the manifest gives for carrying no golden. Null where it carries one. */
+    goldenExemption: string | null;
+    /** sha256 of every file of the pack, so a change is visible without a diff. */
+    checksum: string;
+    /** Sections the schema accepts and this release does not compile. */
+    deferred: string[];
+    /**
+     * The source register: every text this pack was built from, with the
+     * publisher that serves it and the day somebody opened it.
+     *
+     * Only the entries. A bare title the manifest still carries is the
+     * deprecated form and reaches `warnings` instead, because a title nobody can
+     * open is not a source — it is the memory of having read one.
+     */
+    sources: PackSource[];
+    /**
+     * What a reader should know and what nothing refuses over.
+     *
+     * A pack that keeps a bare title in its register, or one this release
+     * compiles less of than the schema accepts, still builds. The difference
+     * between this and an issue is whether a figure could come out wrong.
+     */
+    warnings: string[];
+}
+export interface Manifest {
+    country: string;
+    name: string;
+    version: string;
+    schema_min: string;
+    seed_sequence: number;
+    released_at?: string;
+    certification?: PackCertification;
+    defaults: {
+        currency: string;
+        language?: string;
+        roles: Record<string, string | null | undefined>;
+        journal_roles?: Record<string, string | undefined>;
+        [key: string]: unknown;
+    };
+    languages?: string[];
+    journals: {
+        code: string;
+        type: string;
+        name: string;
+        sequence?: number;
+    }[];
+    charts?: {
+        code: string;
+        name: string;
+        accounts: string;
+        default?: boolean;
+        audience?: string;
+        statements?: string[];
+        certification?: PackCertification;
+        legal_reference?: string | null;
+        source?: string | null;
+    }[];
+    [key: string]: unknown;
+}
+/** `packs/generic/pack.json`: a framework of statements, with no country. */
+export interface FrameworkManifest {
+    code: string;
+    name: string;
+    version: string;
+    schema_min: string;
+    released_at?: string;
+    language?: string;
+    certification?: PackCertification;
+    golden?: {
+        exempt: string;
+    };
+}
+/**
+ * Every label of a pack in every language but its own, read from `i18n/`.
+ *
+ * One shape throughout: section, then the key the label belongs to, then the
+ * language. It is the only place a translation lives — the rest of the pack
+ * is written in `defaults.language` and carries no second wording, so a
+ * contributor adding a language edits one file and a reviewer reads one file.
+ */
+export interface PackLabels {
+    /** The country itself, by language. The one section keyed by language alone. */
+    pack_name: Record<string, string>;
+    /** By chart code. */
+    charts: Record<string, Record<string, string>>;
+    /** By account code, across every chart. */
+    accounts: Record<string, Record<string, string>>;
+    /** By journal code. */
+    journals: Record<string, Record<string, string>>;
+    /** By tax code. */
+    taxes: Record<string, Record<string, string>>;
+    /** By `box|kind`, because a form may carry a base and a tax on one line. */
+    tax_report_boxes: Record<string, Record<string, string>>;
+    /** By `statement:line`, because two statements may both carry a line `20`. */
+    statement_lines: Record<string, Record<string, string>>;
+    /** By legal mention code. */
+    legal_mentions: Record<string, Record<string, string>>;
+    /** By fixed-asset category code. */
+    asset_categories: Record<string, Record<string, string>>;
+}
+/** A pack with no country: statements by account type, and nothing else. */
+export interface FrameworkPack {
+    slug: string;
+    dir: string;
+    manifest: FrameworkManifest;
+    statements: PackStatement[];
+    /** Why this pack carries no golden scenario. Never null: it can carry none. */
+    goldenExemption: string | null;
+    checksum: string;
+}
+export declare class PackError extends Error {
+}
+/** Repository root: the folder that holds both `packs/` and `supabase/seed/`. */
+export declare function repoRootDir(): string;
+export declare function packsDir(root?: string): string;
+export declare function seedOutputDir(root?: string): string;
+/**
+ * The seed number each pack of a checkout declares, by slug.
+ *
+ * Read on its own, one field out of each manifest, rather than through
+ * `readPack`: naming the seed file of a pack must not depend on every other
+ * pack in the checkout being valid, or `ekwo pack build be` would fail because
+ * somebody's work in progress next door does not compile yet.
+ */
+export declare function declaredSeedSequences(dir?: string): Promise<Map<string, number>>;
+/** The packs of this repository, by directory name, alphabetically. */
+export declare function listPacks(dir?: string): Promise<string[]>;
+/** The published schema, read from `packs/schema/pack.1.json`. */
+export declare function readSchema(dir?: string): Promise<Record<string, unknown>>;
+/**
+ * Reads, validates and normalises one pack.
+ *
+ * Validation is the published schema for every document, then the three
+ * things a schema cannot say: a role, a posting and a journal role must name
+ * something the pack itself carries.
+ */
+export declare function readPack(slug: string, dir?: string): Promise<Pack>;
+/**
+ * The framework pack: statements by account type, no country, no chart.
+ *
+ * It is read and compiled beside the country packs because it is the same
+ * kind of thing — declarative lines an accountant can read — and because the
+ * fallback that gives any chart a readable balance sheet should not be the one
+ * object of the system that lives in a migration.
+ */
+export declare function readFrameworkPack(slug?: string, dir?: string): Promise<FrameworkPack>;
+/**
+ * A reference in a plus/minus list, or in an i18n key, to the one box it
+ * names. Bare, it has to match exactly one box of the form; qualified
+ * (`08:tax`), it names the kind itself — the French CA3 carries a base and a
+ * tax on line 08 and the Belgian form never does. Returns the box, or the
+ * sentence that says why it does not resolve.
+ */
+export declare function resolveBoxRef(ref: string, boxes: PackReportBox[]): PackReportBox | string;
+/**
+ * The CSV subset a chart of accounts is written in: a header line, one row
+ * per account, no newline inside a field, a field quoted only when it holds a
+ * comma or a quote, a quote doubled inside a quoted field. Forty lines,
+ * because anything richer is a format nobody can review in a diff.
+ */
+export declare function parseCsv(text: string, file: string): Record<string, string>[];
+//# sourceMappingURL=read.d.ts.map