@classytic/ledger 0.4.2 → 0.5.1

package/README.md

@@ -1,258 +1,298 @@
 # @classytic/ledger
 
-Embeddable double-entry accounting engine for MongoDB. Integer-cents arithmetic, plugin-based, country-agnostic. Extensible journal types, multi-tenant isolation at every layer.
+Embeddable double-entry accounting engine for MongoDB. Integer-cents arithmetic, plugin-based, country-agnostic, multi-tenant at every layer. Framework-agnostic — works with Express, Fastify, Nest, Arc, or any plain Mongoose app.
 
-Build QuickBooks, Xero, or TaxCycle-grade apps — the engine handles the accounting, you handle the UX.
+> **0.5.1** — Critical plugin-pipeline fixes. `post()`, `unpost()`, `archive()`, and the `reverse()` mark-as-reversed step now route through `repository.update()` so `before:update` / `after:update` hooks fire on every state transition (period locks, audit, observability are no longer silently bypassed). `reverse()` and `duplicate()` propagate every consumer-defined top-level field (`departmentId`, `projectId`, `sourceRef`, `branchTag`, `organizationId`, …). New typed `_ledgerInternal` flag on `RepositoryContext` lets plugin authors observe internal transitions without casts. See [CHANGELOG.md](CHANGELOG.md).
 
 ## Install
 
 ```bash
 npm install @classytic/ledger @classytic/mongokit mongoose
-npm install @classytic/ledger-ca  # Canada (GIFI, GST/HST, CRA)
-npm install @classytic/ledger-bd  # Bangladesh (BFRS, VAT/TDS, Mushak)
+npm install @classytic/ledger-ca   # Canada (GIFI, GST/HST, CRA)
+npm install @classytic/ledger-bd   # Bangladesh (BFRS, VAT/TDS, Mushak)
 ```
 
 ## Quick Start
 
-```typescript
-import mongoose from 'mongoose';
-import { createAccountingEngine } from '@classytic/ledger';
-import { canadaPack } from '@classytic/ledger-ca';
+```ts
+import mongoose from "mongoose";
+import { createAccountingEngine } from "@classytic/ledger";
+import { canadaPack } from "@classytic/ledger-ca";
 
-// The engine owns the models — matches flow/promo pattern
 const engine = createAccountingEngine({
   mongoose: mongoose.connection,
   country: canadaPack,
-  currency: 'CAD',
-  multiTenant: { orgField: 'organizationId', orgRef: 'Organization' },
+  currency: "CAD",
+  multiTenant: { orgField: "organizationId", orgRef: "Organization" },
 });
 
-// Models, repositories, and reports are auto-created
 await engine.repositories.accounts.seedAccounts(orgId);
-const entry = await engine.repositories.journalEntries.post(entryId, orgId);
-const bs = await engine.reports.balanceSheet({ organizationId: orgId, dateOption: 'year', dateValue: 2025 });
-```
 
-### Engine-owned models (recommended)
+await engine.record.sale(orgId, {
+  date: new Date("2025-04-01"),
+  amount: 10000,                 // $100.00 in cents (tax-exclusive)
+  receivableAccount: "1200",     // AR
+  revenueAccount:    "4010",     // Service Revenue
+  tax: { code: "HST", account: "2300" },
+  label: "INV-001",
+});
+
+const bs = await engine.reports.balanceSheet({
+  organizationId: orgId,
+  dateOption: "year",
+  dateValue: 2025,
+});
+```
 
-Pass `mongoose: connection` in config and the engine creates and wires everything:
+The engine owns the models. After `createAccountingEngine` you have:
 
 | Property | What it gives you |
-|----------|-------------------|
-| `engine.models.Account` / `JournalEntry` / `FiscalPeriod` / `Budget` / `Reconciliation` | Mongoose models, ready to query |
-| `engine.repositories.accounts.seedAccounts()` / `bulkCreate()` | Account repo with domain methods |
-| `engine.repositories.journalEntries.post()` / `reverse()` / `unpost()` / `duplicate()` | JE repo with plugins pre-wired (double-entry, fiscal-lock, idempotency) |
-| `engine.repositories.fiscalPeriods` / `budgets` | Plain CRUD repos |
-| `engine.repositories.reconciliations.reconcile()` / `unreconcile()` / `getUnreconciled()` | Reconciliation repo with domain methods |
-| `engine.reports.trialBalance()` / `balanceSheet()` / etc. | All 10 reports, bound to the owned models |
-
-This pattern unblocks framework auto-discovery (Arc `loadResources`, Fastify plugins, etc.) because resources can be defined at module top-level without factory wrappers.
-
-### Low-level (manual schema/model setup)
-
-If you need custom naming or don't want the engine to own models, omit `mongoose` from config:
-
-```typescript
-const engine = createAccountingEngine({ country: canadaPack, currency: 'CAD' });
-const Account = mongoose.model('GLAccount', engine.createAccountSchema());
-const JournalEntry = mongoose.model('GLEntry', engine.createJournalEntrySchema('GLAccount'));
-const accountRepo = engine.wireAccountRepository(new Repository(Account), Account);
-const reports = engine.createReports({ Account, JournalEntry });
-```
+| --- | --- |
+| `engine.models.{Account,JournalEntry,FiscalPeriod,Budget,Reconciliation}` | Mongoose models |
+| `engine.repositories.accounts` | `seedAccounts()`, `bulkCreate()` + plugins |
+| `engine.repositories.journalEntries` | `post()`, `unpost()`, `reverse()`, `duplicate()` + double-entry, fiscal-lock, idempotency |
+| `engine.repositories.{fiscalPeriods,budgets}` | Plain CRUD |
+| `engine.repositories.reconciliations` | `reconcile()`, `unreconcile()`, `getUnreconciled()` |
+| `engine.record.*` | Domain verbs (`sale`, `expense`, `transfer`, `payment`, `adjustment`) |
+| `engine.introspect.*` | Runtime catalog of accounts, tax codes, reports |
+| `engine.reports.*` | All 10 reports, bound to owned models |
+
+## Semantic Record API
+
+Record business operations as domain verbs. The engine resolves account codes, splits tax, and produces a balanced journal entry — you never touch debits/credits.
+
+```ts
+// Cash sale with 13% HST
+await engine.record.sale(orgId, {
+  date, amount: 10000,
+  receivableAccount: "1001", revenueAccount: "4010",
+  tax: { code: "HST", account: "2300" },
+});
 
-## Core Features
-
-**Accounting Engine**
-- Double-entry validation with balance enforcement
-- Integer-cents storage — zero floating-point drift
-- Draft → Posted → Reversed state machine
-- Configurable immutability (corrections only via reversal)
-- Multi-tenant isolation at every layer (reports, schemas, repositories)
-- Country packs for localized charts of accounts and tax codes
-- Extensible journal type registry — add domain-specific types (POS, E-Commerce, Payroll) at startup
-
-**10 Reports**
-- Trial Balance (3-column: initial + period + ending)
-- Balance Sheet (with computed retained earnings)
-- Income Statement (revenue, COGS, gross profit, operating expenses, net income)
-- General Ledger (per-account with running balances)
-- Cash Flow (Operating / Investing / Financing)
-- Aged Receivable / Payable (configurable buckets: current, 30, 60, 90+)
-- Budget vs Actual (variance analysis)
-- Dimension Breakdown (by department, project, cost center)
-- Foreign Exchange Revaluation (unrealized gain/loss computation)
-- Fiscal Year Close / Reopen (automatic closing entries)
-
-**Plugins**
-- `doubleEntryPlugin` — validates debits = credits, account existence, tenant integrity
-- `fiscalLockPlugin` — prevents posting to closed fiscal periods
-- `dateLockPlugin` — blocks entries before a configurable lock date
-- `taxHookPlugin` — auto-generates tax lines via user-defined `TaxLineGenerator`
-- `idempotencyPlugin` — prevents duplicate entries by key
-
-**Utilities**
-- `Money` — cents arithmetic, tax splitting, allocation with zero-sum guarantee
-- `buildDimensionFields` — schema helpers for analytic dimensions
-- `suggestMatches` — reconciliation matching suggestions
-- `computeRevaluation` — FX gain/loss computation
+// Expense with recoverable input tax credit
+await engine.record.expense(orgId, {
+  date, amount: 3000,
+  expenseAccount: "6010", paidFromAccount: "2001",
+  tax: { code: "HST_ITC", account: "2400" },
+});
 
-## Engine Configuration
+await engine.record.transfer(orgId, { date, amount: 5000, fromAccount: "1001", toAccount: "1002" });
 
-```typescript
-createAccountingEngine({
-  country: canadaPack,                    // required
-  currency: 'CAD',                        // required — base/functional currency
-  multiTenant: { orgField, orgRef },      // optional — multi-tenant scoping
-  multiCurrency: { enabled: true, currencies: ['USD', 'EUR'] },
-  fiscalYearStartMonth: 1,               // 1=Jan (default), 4=Apr, 7=Jul
-  retainedEarningsAccountCode: '3600',   // overrides country pack
-  audit: { trackActor: true },
-  idempotency: true,
-  strictness: {
-    immutable: true,      // disable unpost, corrections via reverse only
-    requireActor: true,   // actorId required on post/reverse
-    requireApproval: true // entries must be approved before posting
-  },
+await engine.record.payment(orgId, {
+  date, amount: 11300,
+  fromReceivableAccount: "1200", toCashAccount: "1001",
+});
+
+// Multi-line adjustment (depreciation, accruals, corrections)
+await engine.record.adjustment(orgId, {
+  date, label: "Monthly depreciation",
+  lines: [
+    { account: "6030", debit:  1000 },
+    { account: "1500", credit: 1000 },
+  ],
 });
 ```
 
-## Reports API
-
-```typescript
-const reports = accounting.createReports({ Account, JournalEntry, Budget });
-
-// All reports accept: { organizationId, dateOption, dateValue, filters? }
-await reports.trialBalance({ ... });
-await reports.balanceSheet({ ... });
-await reports.incomeStatement({ ... });
-await reports.generalLedger({ ... });
-await reports.cashFlow({ ... });
-await reports.agedBalance({ type: 'receivable', asOfDate: new Date() });
-await reports.budgetVsActual({ ... });        // requires Budget model
-await reports.dimensionBreakdown({ dimension: 'departmentId', ... });
-await reports.revaluation({ rates: [{ currency: 'USD', rate: 1.40 }], ... });
+All verbs accept `options.user`, `options.session`, `options.idempotencyKey`, plus any custom field — they all flow into mongokit's `RepositoryContext` so audit/observability plugins (and your hooks) pick them up automatically.
+
+## Introspection
+
+```ts
+const catalog = await engine.introspect.catalog(orgId);
+// { accounts, journalTypes, reports, taxCodes, fiscalPeriods }
+
+engine.introspect.accounts(orgId);
+engine.introspect.taxCodes("ON");
+engine.introspect.reports();   // sync — static catalog
 ```
 
-All report data is sorted by account code. All monetary values are integer cents — use `Money.toDecimal()` at your API boundary.
+## Structured Validation Errors
+
+```ts
+try {
+  await engine.record.sale(orgId, { ... });
+} catch (err) {
+  if (err instanceof AccountingError) {
+    err.status   // 400 | 403 | 404 | 409
+    err.code     // 'VALIDATION_ERROR' | 'NOT_FOUND' | ...
+    err.fields   // [{ path, issue, value }, ...]
+    err.toJSON();
+  }
+}
+```
 
-## Schemas
+Field errors come straight from plugins (double-entry, fiscal-lock) and the semantic layer.
+
+## Audit, Observability & Framework Integration
+
+The ledger is **framework-agnostic** and operates at the model layer — Express, Fastify, Nest, Hono, and Arc all work the same way. Three places you can hook in, composable:
+
+1. **Any mongokit plugin** via `config.plugins` — see the `@classytic/mongokit` docs for `auditTrailPlugin`, `observabilityPlugin`, and others.
+   ```ts
+   const engine = createAccountingEngine({
+     mongoose: mongoose.connection, country: canadaPack, currency: "CAD",
+     plugins: {
+       journalEntry: [/* your mongokit plugins */],
+       account:      [/* your mongokit plugins */],
+     },
+   });
+   ```
+2. **Runtime listeners** — no plugin needed:
+   ```ts
+   engine.repositories.journalEntries.on("after:create", ({ context, result }) => {
+     auditLog.write({ userId: context.user?._id, orgId: context.organizationId, entryId: result._id });
+   });
+   ```
+3. **Your framework's own audit (HTTP-level)** — e.g. `@classytic/arc`'s `auditPlugin` records resource CRUD with request context. Use it alone, or combine with a model-layer plugin.
+
+| Layer | What it sees | What it misses |
+| --- | --- | --- |
+| HTTP middleware (Arc / Express / Nest) | Request → user, IP, route, payload | Background jobs, CLI scripts, anything bypassing HTTP |
+| Model-layer mongokit plugin | Every collection write, regardless of caller | HTTP context unless the caller forwards it |
+
+For accounting compliance most teams want **both** — HTTP audit for traffic, model audit on `journalEntry` for an immutable trail. Forward request context on the call so both layers see it:
+
+```ts
+// Express
+app.post("/sales", async (req, res) => {
+  await engine.record.sale(req.body.orgId, req.body, {
+    user: req.user, ip: req.ip, userAgent: req.headers["user-agent"],
+  });
+});
+```
 
-```typescript
-accounting.createAccountSchema(options?)
-accounting.createJournalEntrySchema(accountModelName, {
-  extraItemFields: { departmentId: { type: ObjectId, ref: 'Department' } },
-})
-accounting.createFiscalPeriodSchema(options?)
-accounting.createBudgetSchema(options?)
-accounting.createReconciliationSchema(accountModelName, journalEntryModelName, options?)
+## Reports
+
+```ts
+await engine.reports.trialBalance({ organizationId, dateOption: "year",  dateValue: 2025 });
+await engine.reports.balanceSheet({ organizationId, dateOption: "year",  dateValue: 2025 });
+await engine.reports.incomeStatement({ organizationId, dateOption: "quarter", dateValue: { year: 2025, quarter: 2 } });
+await engine.reports.generalLedger({ organizationId, dateOption: "month", dateValue: { year: 2025, month: 4 } });
+await engine.reports.cashFlow({ organizationId, dateOption: "year", dateValue: 2025 });
+await engine.reports.agedBalance({ organizationId, type: "receivable", asOfDate: new Date() });
+await engine.reports.budgetVsActual({ organizationId, dateOption: "year", dateValue: 2025 });
+await engine.reports.dimensionBreakdown({ organizationId, dimension: "departmentId", dateOption: "year", dateValue: 2025 });
+await engine.reports.revaluation({ organizationId, asOfDate: new Date(), rates: [{ currency: "USD", rate: 1.40 }], unrealizedGainLossAccountId });
 ```
 
-## Plugins
+All values are integer cents. Use `Money.toDecimal()` at your API boundary.
 
-```typescript
-import { dateLockPlugin, taxHookPlugin } from '@classytic/ledger';
+The 10 reports:
 
-// Date lock — block posting before a date
-dateLockPlugin({
-  getLockDate: async (orgId) => db.getOrgLockDate(orgId),
-  JournalEntryModel,
-});
+- **Trial Balance** (3-column: opening + period + ending)
+- **Balance Sheet** (with computed retained earnings, multi-year aware)
+- **Income Statement** (revenue, COGS, gross profit, operating expenses, net income)
+- **General Ledger** (per-account with running balances)
+- **Cash Flow** (operating / investing / financing)
+- **Aged Receivable / Payable** (configurable buckets)
+- **Budget vs Actual** (variance analysis)
+- **Dimension Breakdown** (by department, project, cost center)
+- **FX Revaluation** (unrealized gain/loss)
+- **Fiscal Year Close / Reopen** (automatic closing entries)
+
+## Engine Configuration
 
-// Tax hook — auto-generate tax lines
-taxHookPlugin({
-  generator: {
-    generateTaxLines(input) {
-      if (!input.taxCode) return [];
-      const tax = Money.percentage(input.amount, 1300); // 13%
-      return [{ account: hstAccountId, debit: 0, credit: tax, taxDetails: [{ taxCode: 'HST' }] }];
+```ts
+createAccountingEngine({
+  mongoose: mongoose.connection,             // required
+  country:  canadaPack,                      // required
+  currency: "CAD",                           // required — base/functional currency
+  multiTenant: { orgField, orgRef },         // optional
+  multiCurrency: { enabled: true, currencies: ["USD", "EUR"] },
+  fiscalYearStartMonth: 1,                   // 1=Jan (default), 4=Apr, 7=Jul
+  retainedEarningsAccountCode: "3600",       // overrides country pack
+  modelNames: { account: "GLAccount", ... }, // custom collection names
+  schemaOptions: {                           // extra fields/indexes per model
+    journalEntry: {
+      extraFields: { aiJob: { status: String, generatedAt: Date } },
+      extraIndexes: [{ fields: { "aiJob.status": 1 }, options: { sparse: true } }],
     },
   },
+  strictness: {
+    immutable:        true,   // disable unpost — corrections only via reverse
+    requireActor:     true,   // actorId required on post/reverse
+    requireApproval:  true,   // entries must be approved before posting
+  },
+  plugins:    { journalEntry: [...], account: [...] },  // any mongokit plugins
+  pagination: { account: { maxLimit: 5000 } },          // optional caps; no default cap
 });
 ```
 
-## Subpath Exports
+`pagination` has **no default cap** — large enterprise charts of accounts can be tens of thousands of rows. Pass `{ maxLimit: N }` per repository if you want to bound list queries.
 
-| Path | Contents |
-|------|----------|
-| `@classytic/ledger` | Engine, Money, all schemas, plugins, reports, types |
-| `@classytic/ledger/money` | `Money` class |
-| `@classytic/ledger/schemas` | Schema factories |
-| `@classytic/ledger/reports` | Report generators |
-| `@classytic/ledger/plugins` | All plugins |
-| `@classytic/ledger/repositories` | Repository wiring |
-| `@classytic/ledger/exports` | CSV export + QuickBooks field maps |
-| `@classytic/ledger/country` | `defineCountryPack`, `CountryPack` interface |
-| `@classytic/ledger/constants` | Categories, journal types (+ registry), currencies |
-
-## Extensible Journal Types
-
-The 15 built-in journal types (SALES, PURCHASES, GENERAL, PAYROLL, etc.) cover standard accounting. For domain-specific needs, register custom types **before** schema creation:
-
-```typescript
-import { registerJournalType, getJournalTypeCodes, isValidJournalType } from '@classytic/ledger';
-
-// Register at startup, before createJournalEntrySchema()
-registerJournalType('POS_SALES', {
-  code: 'POS_SALES',
-  name: 'POS Sales Journal',
-  description: 'Daily aggregated point-of-sale transactions',
-});
+## Built-in Plugins
 
-registerJournalType('ECOM_SALES', {
-  code: 'ECOM_SALES',
-  name: 'E-Commerce Sales Journal',
-  description: 'Per-order online transactions',
-});
+| Plugin | Purpose |
+| --- | --- |
+| `doubleEntryPlugin` | Validates debits = credits, account existence, tenant integrity |
+| `fiscalLockPlugin` | Prevents posting to closed fiscal periods |
+| `dateLockPlugin` | Blocks entries before a configurable lock date |
+| `taxHookPlugin` | Auto-generates tax lines via a `TaxLineGenerator` |
+| `idempotencyPlugin` | Prevents duplicate entries by key |
 
-// Custom types pass Mongoose enum validation, appear in all lookups
-isValidJournalType('POS_SALES');  // true
-getJournalTypeCodes();            // [...15 built-in, 'POS_SALES', 'ECOM_SALES']
+`doubleEntryPlugin`, `fiscalLockPlugin` and `idempotencyPlugin` are wired automatically by the engine. The others are opt-in via the second `createAccountingEngine` argument.
 
-// Reference numbers use the custom type prefix: POS_SALES/2025/03/0001
+## Custom Journal Types
+
+The 15 built-in journal types (SALES, PURCHASES, GENERAL, PAYROLL, …) cover standard accounting. Register custom types **before** the first engine call:
+
+```ts
+import { registerJournalType } from "@classytic/ledger";
+
+registerJournalType("POS_SALES",  { code: "POS_SALES",  name: "POS Sales Journal" });
+registerJournalType("ECOM_SALES", { code: "ECOM_SALES", name: "E-Commerce Sales" });
 ```
 
-The registry freezes when `createJournalEntrySchema()` is called. Late registration throws. Built-in types cannot be overridden.
+Reference numbers use the type prefix (`POS_SALES/2025/03/0001`). The registry freezes after the first schema is created.
 
 ## Country Packs
 
-Build your own or use an existing one:
-
-```typescript
-import { defineCountryPack } from '@classytic/ledger';
+```ts
+import { defineCountryPack } from "@classytic/ledger";
 
 export const myPack = defineCountryPack({
-  code: 'US',
-  name: 'United States',
-  defaultCurrency: 'USD',
-  retainedEarningsAccountCode: '3200',
-  accountTypes: [ /* your chart of accounts */ ],
-  taxCodes: { /* your tax codes */ },
-  taxCodesByRegion: {},
-  regions: [],
+  code: "US", name: "United States", defaultCurrency: "USD",
+  retainedEarningsAccountCode: "3200",
+  accountTypes: [/* chart of accounts */],
+  taxCodes:     {/* tax codes */},
+  taxCodesByRegion: {}, regions: [],
 });
 ```
 
-Available packs: `@classytic/ledger-ca` (Canada), `@classytic/ledger-bd` (Bangladesh).
+Available: `@classytic/ledger-ca` (Canada), `@classytic/ledger-bd` (Bangladesh).
+
+## Subpath Exports
+
+| Path | Contents |
+| --- | --- |
+| `@classytic/ledger`           | Engine, Money, plugins, reports, types |
+| `@classytic/ledger/money`     | `Money` class |
+| `@classytic/ledger/reports`   | Standalone report generators |
+| `@classytic/ledger/plugins`   | All plugins |
+| `@classytic/ledger/exports`   | CSV export + QuickBooks field maps |
+| `@classytic/ledger/country`   | `defineCountryPack`, `CountryPack` |
+| `@classytic/ledger/constants` | Categories, journal types, currencies |
 
 ## Testing
 
 ```bash
-npm test                           # run all
-npx vitest run tests/e2e/          # e2e scenarios only
-npx vitest run tests/scenarios/    # integration scenarios
-npx vitest run tests/hardening/    # edge cases & invariants
+npm test                            # 1273 tests, 67 files
+npx vitest run tests/e2e/           # full-year scenarios
+npx vitest run tests/scenarios/     # integration scenarios
+npx vitest run tests/hardening/     # edge cases & invariants
 ```
 
-Test suites cover:
-- Canadian small business full-year lifecycle
+Coverage includes:
+
+- Canadian small-business full-year lifecycle (open → post → close → reopen)
+- Multi-year fiscal cycles with retained-earnings rollover
 - Multi-currency trading with FX revaluation
 - Multi-tenant report isolation (org A cannot see org B)
-- Posting pipeline → Trial Balance → Income Statement → Balance Sheet
-- Reversal & correction workflows with audit trail
+- All 10 reports with month / quarter / year / custom date ranges
+- Reversal and correction workflows
 - Custom journal type registry → schema → posting pipeline
-- Double-entry conservation law (debit = credit across all entries)
+- Double-entry conservation across all entries
 - Money arithmetic hardening (overflow, penny-leak, float traps)
-- Public API surface & subpath export verification
 - O-Level / A-Level / university textbook accounting problems
 
 ## Requirements

package/dist/constants/index.d.mts

@@ -1,2 +1,2 @@
-import { S as isValidCategory, _ as getCategoryMainType, a as getJournalTypeCodes, b as isBalanceSheet, c as CURRENCIES, d as isValidCurrency, f as CATEGORIES, g as extractStatementType, h as extractMainType, i as getJournalType, l as getCurrency, m as categoryKey, n as JOURNAL_TYPES, o as isValidJournalType, p as CATEGORY_KEYS, r as getCustomJournalTypes, s as registerJournalType, t as JOURNAL_CODES, u as getMinorUnit, v as getCategoryStatementType, x as isIncomeStatement, y as getNormalBalance } from "../journals-DTipb_rz.mjs";
+import { S as isValidCategory, _ as getCategoryMainType, a as getJournalTypeCodes, b as isBalanceSheet, c as CURRENCIES, d as isValidCurrency, f as CATEGORIES, g as extractStatementType, h as extractMainType, i as getJournalType, l as getCurrency, m as categoryKey, n as JOURNAL_TYPES, o as isValidJournalType, p as CATEGORY_KEYS, r as getCustomJournalTypes, s as registerJournalType, t as JOURNAL_CODES, u as getMinorUnit, v as getCategoryStatementType, x as isIncomeStatement, y as getNormalBalance } from "../journals-C50E9mpo.mjs";
 export { CATEGORIES, CATEGORY_KEYS, CURRENCIES, JOURNAL_CODES, JOURNAL_TYPES, categoryKey, extractMainType, extractStatementType, getCategoryMainType, getCategoryStatementType, getCurrency, getCustomJournalTypes, getJournalType, getJournalTypeCodes, getMinorUnit, getNormalBalance, isBalanceSheet, isIncomeStatement, isValidCategory, isValidCurrency, isValidJournalType, registerJournalType };

package/dist/constants/index.mjs

@@ -1,4 +1,3 @@
-import { a as getJournalType, c as registerJournalType, i as getCustomJournalTypes, n as JOURNAL_TYPES, o as getJournalTypeCodes, s as isValidJournalType, t as JOURNAL_CODES } from "../journals-BfwnCFam.mjs";
-import { a as extractStatementType, c as getNormalBalance, d as isValidCategory, i as extractMainType, l as isBalanceSheet, n as CATEGORY_KEYS, o as getCategoryMainType, r as categoryKey, s as getCategoryStatementType, t as CATEGORIES, u as isIncomeStatement } from "../categories-DWogBUgQ.mjs";
-import { i as isValidCurrency, n as getCurrency, r as getMinorUnit, t as CURRENCIES } from "../currencies-W8kQAkm0.mjs";
+import { a as JOURNAL_CODES, c as getCustomJournalTypes, d as isValidJournalType, f as registerJournalType, i as isValidCurrency, l as getJournalType, n as getCurrency, o as JOURNAL_TYPES, r as getMinorUnit, t as CURRENCIES, u as getJournalTypeCodes } from "../currencies-CsuBGfgs.mjs";
+import { a as extractStatementType, c as getNormalBalance, d as isValidCategory, i as extractMainType, l as isBalanceSheet, n as CATEGORY_KEYS, o as getCategoryMainType, r as categoryKey, s as getCategoryStatementType, t as CATEGORIES, u as isIncomeStatement } from "../categories-BkKdv16V.mjs";
 export { CATEGORIES, CATEGORY_KEYS, CURRENCIES, JOURNAL_CODES, JOURNAL_TYPES, categoryKey, extractMainType, extractStatementType, getCategoryMainType, getCategoryStatementType, getCurrency, getCustomJournalTypes, getJournalType, getJournalTypeCodes, getMinorUnit, getNormalBalance, isBalanceSheet, isIncomeStatement, isValidCategory, isValidCurrency, isValidJournalType, registerJournalType };

package/dist/country/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TaxReportLine, i as TaxCodesByRegion, n as CountryPackInput, o as TaxReportTemplate, r as TaxCode, s as defineCountryPack, t as CountryPack } from "../index-CxZqRaOU.mjs";
+import { a as TaxReportLine, i as TaxCodesByRegion, n as CountryPackInput, o as TaxReportTemplate, r as TaxCode, s as defineCountryPack, t as CountryPack } from "../index-GmfEFxVn.mjs";
 export { CountryPack, CountryPackInput, TaxCode, TaxCodesByRegion, TaxReportLine, TaxReportTemplate, defineCountryPack };

package/dist/{journals-BfwnCFam.mjs → currencies-CsuBGfgs.mjs}

@@ -110,4 +110,83 @@ function getJournalType(code) {
 	return JOURNAL_TYPES[code] ?? _customTypes[code] ?? null;
 }
 //#endregion
-export { getJournalType as a, registerJournalType as c, getCustomJournalTypes as i, JOURNAL_TYPES as n, getJournalTypeCodes as o, _freezeJournalTypes as r, isValidJournalType as s, JOURNAL_CODES as t };
+//#region src/constants/currencies.ts
+const CURRENCIES = Object.freeze({
+	CAD: {
+		code: "CAD",
+		name: "Canadian Dollar",
+		symbol: "$",
+		minorUnit: 2
+	},
+	USD: {
+		code: "USD",
+		name: "US Dollar",
+		symbol: "$",
+		minorUnit: 2
+	},
+	GBP: {
+		code: "GBP",
+		name: "British Pound",
+		symbol: "£",
+		minorUnit: 2
+	},
+	EUR: {
+		code: "EUR",
+		name: "Euro",
+		symbol: "€",
+		minorUnit: 2
+	},
+	JPY: {
+		code: "JPY",
+		name: "Japanese Yen",
+		symbol: "¥",
+		minorUnit: 0
+	},
+	AUD: {
+		code: "AUD",
+		name: "Australian Dollar",
+		symbol: "$",
+		minorUnit: 2
+	},
+	CHF: {
+		code: "CHF",
+		name: "Swiss Franc",
+		symbol: "CHF",
+		minorUnit: 2
+	},
+	INR: {
+		code: "INR",
+		name: "Indian Rupee",
+		symbol: "₹",
+		minorUnit: 2
+	},
+	BDT: {
+		code: "BDT",
+		name: "Bangladeshi Taka",
+		symbol: "৳",
+		minorUnit: 2
+	},
+	AED: {
+		code: "AED",
+		name: "UAE Dirham",
+		symbol: "د.إ",
+		minorUnit: 2
+	},
+	SAR: {
+		code: "SAR",
+		name: "Saudi Riyal",
+		symbol: "﷼",
+		minorUnit: 2
+	}
+});
+function getCurrency(code) {
+	return CURRENCIES[code] ?? null;
+}
+function isValidCurrency(code) {
+	return code in CURRENCIES;
+}
+function getMinorUnit(code) {
+	return CURRENCIES[code]?.minorUnit ?? 2;
+}
+//#endregion
+export { JOURNAL_CODES as a, getCustomJournalTypes as c, isValidJournalType as d, registerJournalType as f, isValidCurrency as i, getJournalType as l, getCurrency as n, JOURNAL_TYPES as o, getMinorUnit as r, _freezeJournalTypes as s, CURRENCIES as t, getJournalTypeCodes as u };