@classytic/ledger 0.5.0 → 0.6.0

package/dist/tax-hooks-BnVenul5.d.mts

@@ -0,0 +1,513 @@
+import { ClientSession, Model } from "mongoose";
+import * as _classytic_mongokit0 from "@classytic/mongokit";
+import { Repository, RepositoryContext, RepositoryInstance } from "@classytic/mongokit";
+
+//#region src/types/repositories.d.ts
+interface PostOptions {
+  session?: ClientSession | null;
+  /** Actor performing this operation (required when strictness.requireActor is enabled) */
+  actorId?: unknown;
+}
+interface ReverseOptions extends PostOptions {
+  /** Date for the reversal entry (defaults to now) */
+  reversalDate?: Date;
+}
+interface SeedOptions {
+  session?: ClientSession | null;
+}
+interface SeedResult {
+  created: number;
+  skipped: number;
+}
+interface BulkCreateInput {
+  accountTypeCode?: string;
+  accountNumber?: string;
+  name?: string;
+  active?: boolean;
+  isCashAccount?: boolean;
+}
+/**
+ * Generic over the account document type so consumers get real
+ * IntelliSense on `created[0].accountNumber` instead of `unknown`.
+ * Defaults to `Record<string, unknown>` for backwards-compatible call sites.
+ */
+interface BulkCreateResult<TAccount = Record<string, unknown>> {
+  summary: {
+    total: number;
+    created: number;
+    skipped: number;
+    errors: number;
+  };
+  created: TAccount[];
+  skipped: TAccount[];
+  errors: TAccount[];
+}
+/**
+ * Generic over the journal-entry document type — `{ original, reversal }`
+ * are the actual persisted shapes, so callers can access `._id`, `.state`,
+ * `.reversed`, etc. without casts.
+ */
+interface ReverseResult<TEntry = Record<string, unknown>> {
+  original: TEntry;
+  reversal: TEntry;
+}
+/**
+ * Journal Entry Repository — extends mongokit Repository with accounting domain methods.
+ *
+ * Inherits ALL Repository<TDoc> methods: create, getById, getAll, update,
+ * delete, count, exists, distinct, aggregate, withTransaction, etc.
+ */
+interface JournalEntryRepository<TDoc = Record<string, unknown>> extends Repository<TDoc> {
+  /** Post an entry (draft → posted). Validates items, balance, and accounts. */
+  post(id: unknown, orgId?: unknown, options?: PostOptions): Promise<TDoc>;
+  /** Unpost an entry (posted → draft). Resets state for re-editing. */
+  unpost(id: unknown, orgId?: unknown, options?: PostOptions): Promise<TDoc>;
+  /** Archive a draft entry (draft → archived). Preserves audit trail. */
+  archive(id: unknown, orgId?: unknown, options?: PostOptions): Promise<TDoc>;
+  /** Duplicate an entry as a new draft. Copies items, type, and label. */
+  duplicate(id: unknown, orgId?: unknown, options?: PostOptions): Promise<TDoc>;
+  /** Reverse a posted entry. Creates mirror entry with flipped debits/credits. */
+  reverse(id: unknown, orgId?: unknown, options?: ReverseOptions): Promise<ReverseResult<TDoc>>;
+}
+/**
+ * Account Repository — extends mongokit Repository with seed and bulk operations.
+ */
+interface AccountRepository<TDoc = Record<string, unknown>> extends Repository<TDoc> {
+  /** Seed standard posting accounts for an org from the country pack. */
+  seedAccounts(orgId: unknown, options?: SeedOptions): Promise<SeedResult>;
+  /** Bulk create accounts with validation and skip-if-exists logic. */
+  bulkCreate(accounts: BulkCreateInput[], orgId: unknown): Promise<BulkCreateResult<TDoc>>;
+}
+/**
+ * Reference to a specific item inside a journal entry. Positional index
+ * because journal items are embedded sub-documents.
+ */
+interface JournalItemRef {
+  /** Journal entry id. */
+  entry: unknown;
+  /** Zero-based index into the entry's `journalItems` array. */
+  itemIndex: number;
+}
+interface MatchInput {
+  /** The account whose items are being matched (sanity checked). */
+  account: unknown;
+  /** Two or more items to match. Must share `account`. */
+  items: JournalItemRef[];
+  /**
+   * Optional caller-provided matching number. When omitted, the repository
+   * generates one via its counter. Must be unique per org.
+   */
+  matchingNumber?: string;
+  note?: string;
+  reconciledBy?: string;
+  organizationId?: unknown;
+  session?: ClientSession | null;
+}
+interface OpenItem {
+  entry: unknown;
+  itemIndex: number;
+  debit: number;
+  credit: number;
+  date?: Date;
+  account: unknown;
+  [key: string]: unknown;
+}
+interface ReconciliationRepository<TDoc = Record<string, unknown>> extends Repository<TDoc> {
+  /**
+   * Match two or more journal items against each other. Stamps a
+   * shared `matchingNumber` onto every referenced item and creates a
+   * reconciliation document. When debit/credit totals balance, the
+   * reconciliation is flagged `isFullReconcile: true`.
+   *
+   * Fires `after:match` hook — the fxRealizationPlugin listens here.
+   */
+  match(input: MatchInput): Promise<TDoc>;
+  /**
+   * Unwind a matching group. Clears `matchingNumber` on every referenced
+   * item and deletes the reconciliation document. The FX realization
+   * entry (if any) is reversed via `journalEntries.reverse`.
+   */
+  unmatch(input: {
+    matchingNumber: string;
+    organizationId?: unknown;
+    session?: ClientSession | null;
+  }): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Find all posted journal items referencing the given account that
+   * do NOT yet have a matching number. Returns lean items with
+   * `{ entry, itemIndex, debit, credit, date }` plus any extra fields
+   * (dimension, maturityDate, currency).
+   *
+   * `filter` lets you narrow further by any journal-item field —
+   * commonly used to scope by `partnerId` for supplier/customer
+   * subsidiary ledger queries:
+   *
+   *   `getOpenItems({ accountId: apControlId, filter: { partnerId: 'sup-1' } })`
+   *
+   * `asOfDate` restricts to items posted on or before that date,
+   * giving historical open-item snapshots — useful for aged-balance
+   * reports run as of a previous month-end.
+   */
+  getOpenItems(params: {
+    accountId: unknown;
+    organizationId?: unknown; /** Extra equality filters on the journal item (e.g. `{ partnerId: 'X' }`). */
+    filter?: Record<string, unknown>; /** Only consider items from entries dated on or before this date. */
+    asOfDate?: Date;
+    limit?: number;
+    skip?: number;
+  }): Promise<OpenItem[]>;
+}
+interface JournalRepository<TDoc = Record<string, unknown>> extends Repository<TDoc> {
+  /**
+   * Seed the organization's default journals from the country pack's
+   * `journalTemplates`. Idempotent — skips journals that already exist.
+   */
+  seedDefaults(orgId: unknown): Promise<SeedResult>;
+  /**
+   * Atomically increment the journal's sequence counter and return a
+   * formatted reference number (e.g. `'INV/2026/03/0042'`). Safe under
+   * concurrent posts — uses `$inc` inside `findOneAndUpdate`.
+   */
+  nextSequenceNumber(journalId: unknown, orgId?: unknown): Promise<string>;
+}
+//#endregion
+//#region src/plugins/credit-limit.plugin.d.ts
+interface CreditLimitPluginOptions {
+  /** The A/R control account that this limit guards. */
+  arControlAccountId: unknown;
+  /**
+   * Resolve the partner's credit limit in cents. Return `null` for
+   * "no limit" (skip the check), `0` for "cash-only customer".
+   */
+  getCreditLimit: (partnerId: unknown, session: ClientSession | null) => Promise<number | null> | number | null;
+  /** Field name for the partner ref on each journal item. Default: `'partnerId'`. */
+  partnerField?: string;
+  /** JournalEntry model — required to sum existing exposure. */
+  JournalEntryModel: Model<unknown>;
+  /** Multi-tenant scope field. */
+  orgField?: string;
+  /**
+   * Optional tolerance in cents — allow up to N cents over the limit.
+   * Defaults to 0 (strict).
+   */
+  toleranceCents?: number;
+}
+declare function creditLimitPlugin(options: CreditLimitPluginOptions): {
+  name: string;
+  apply(repo: RepositoryInstance): void;
+};
+//#endregion
+//#region src/types/mongokit-augmentation.d.ts
+/**
+ * Module augmentation for `@classytic/mongokit`.
+ *
+ * Ledger's state-transition methods (post, unpost, archive, reverseMark) tag
+ * their `repository.update()` call with a `_ledgerInternal` flag so the
+ * double-entry immutability guard can distinguish legitimate transitions from
+ * arbitrary edits. This file types that flag onto both `RepositoryContext`
+ * (what plugins observe) and `SessionOptions` (what callers pass) so consumers
+ * and plugin authors get full IntelliSense without casts.
+ *
+ * This file is side-effect only — importing it anywhere in the package is
+ * enough to activate the augmentation. `src/types/index.ts` re-exports it.
+ */
+type LedgerInternalOp = 'post' | 'unpost' | 'archive' | 'reverseMark' | 'fxRealize' | 'cashBasisRealize';
+declare module '@classytic/mongokit' {
+  interface RepositoryContext {
+    /**
+     * Set by ledger's repository methods (post, unpost, archive, reverseMark)
+     * to signal a legitimate internal state transition. Plugins observing
+     * `before:update` can read this to distinguish from arbitrary edits.
+     *
+     * External `repository.update()` callers cannot spoof this flag because
+     * it is only set by ledger's own repo methods, never surfaced in the
+     * public API.
+     */
+    _ledgerInternal?: LedgerInternalOp;
+  }
+  interface SessionOptions {
+    /**
+     * Ledger-internal flag — see `RepositoryContext._ledgerInternal`.
+     * Typed here so ledger's repo methods can pass it without casts.
+     * Consumers should never set this directly.
+     */
+    _ledgerInternal?: LedgerInternalOp;
+  }
+}
+//#endregion
+//#region src/plugins/double-entry.plugin.d.ts
+interface DoubleEntryPluginOptions {
+  /** Only enforce on posted entries (default: true) */
+  onlyOnPost?: boolean;
+  /** Mongoose model — required to validate partial updates that only set state */
+  JournalEntryModel?: Model<unknown>;
+  /** Account model — when provided, posted creates verify account existence + tenant scoping */
+  AccountModel?: Model<unknown>;
+  /** Multi-tenant org field name (e.g. 'business'). Required for tenant-account integrity checks. */
+  orgField?: string;
+}
+declare function doubleEntryPlugin(options?: DoubleEntryPluginOptions): {
+  name: string;
+  apply(repo: RepositoryInstance): void;
+};
+//#endregion
+//#region src/plugins/fx-realization.plugin.d.ts
+interface FxRealizationPluginOptions {
+  /** Repository used to create the balancing FX entry. */
+  journalEntries: JournalEntryRepository<Record<string, unknown>>;
+  /** Account id for realized FX gains (income). */
+  realizedGainAccount: unknown;
+  /** Account id for realized FX losses (expense). */
+  realizedLossAccount: unknown;
+  /** Base/functional currency — FX is computed relative to this. */
+  baseCurrency: string;
+  /** Multi-tenant org field. */
+  orgField?: string;
+}
+declare function fxRealizationPlugin(options: FxRealizationPluginOptions): {
+  name: string;
+  apply(repo: RepositoryInstance): void;
+};
+//#endregion
+//#region src/plugins/idempotency.plugin.d.ts
+interface IdempotencyPluginOptions {
+  /** Mongoose model for journal entries */
+  JournalEntryModel: Model<unknown>;
+  /** Multi-tenant org field name */
+  orgField?: string;
+}
+declare function idempotencyPlugin(options: IdempotencyPluginOptions): {
+  name: string;
+  apply(repo: RepositoryInstance): void;
+};
+//#endregion
+//#region src/plugins/lock/types.d.ts
+/**
+ * The resolved "who did what, when" for a locked slice of ledger.
+ * Returned by a `LockResolver` to describe why an entry is blocked.
+ */
+interface LockHit {
+  /** Scope that this hit belongs to — e.g. `'fiscal'`, `'tax'`. */
+  readonly scope: string;
+  /** Human-readable label used in error messages (e.g. `'Q1 2025'`). */
+  readonly label: string;
+  /** Optional sub-type inside the scope (e.g. `'VAT'`, `'TDS'`, `'GST'`). */
+  readonly subType?: string;
+  /** Optional external reference (filed return number, statement ID, …). */
+  readonly externalRef?: string;
+}
+/**
+ * Context given to a lock resolver. All fields except `entryDate` are
+ * pass-throughs from the `createLockPlugin` boilerplate — resolvers don't
+ * need to worry about where the date came from (payload vs persisted doc).
+ */
+interface LockResolverContext {
+  /** The effective date the entry will be posted on. */
+  readonly entryDate: Date;
+  /** The resolved multi-tenant scope value, or `undefined` if unscoped. */
+  readonly orgValue: unknown;
+  /** The mongoose session if the operation is running inside a transaction. */
+  readonly session: ClientSession | null;
+  /** The raw entry payload (for resolvers that need extra context). */
+  readonly data: Record<string, unknown>;
+  /** The full upstream repository context (advanced use). */
+  readonly repositoryContext: RepositoryContext;
+}
+/**
+ * Resolver signature. Return `null` if the entry is allowed, or a
+ * `LockHit` to block it with a 409 `PERIOD_LOCKED_{SCOPE}` error.
+ */
+type LockResolver = (ctx: LockResolverContext) => Promise<LockHit | null>;
+/**
+ * Predicate used to narrow a lock to specific accounts. Called per
+ * journal item; if *any* item's account matches, the entry is subject
+ * to the lock. Receives the populated account document (lean).
+ */
+type LockAccountSelector = (account: Record<string, unknown>) => boolean;
+/**
+ * Options accepted by `createLockPlugin`. All fields are type-safe —
+ * the factory handles date/org resolution, session propagation, and
+ * the `_ledgerInternal` skip path automatically.
+ */
+interface CreateLockPluginOptions {
+  /**
+   * Scope identifier — short, lowercase, stable. Used in the plugin name
+   * (`accounting:lock:{scope}`) and the error code
+   * (`PERIOD_LOCKED_{SCOPE}`).
+   */
+  scope: string;
+  /**
+   * Resolver that decides whether a given entry is locked. Call one of
+   * the builtin resolvers (`periodResolver`, `watermarkResolver`) or
+   * implement your own.
+   */
+  resolve: LockResolver;
+  /**
+   * Optional account-level narrowing. When provided, the lock only
+   * fires if at least one of the entry's journal items touches an
+   * account that matches the predicate.
+   *
+   * When this is set, the plugin must be able to load account docs, so
+   * `AccountModel` becomes required.
+   */
+  accountSelector?: LockAccountSelector;
+  /** Required when `accountSelector` is set — used to hydrate accounts. */
+  AccountModel?: Model<unknown>;
+  /**
+   * Journal-entry model — required for partial updates (we need to look
+   * up the persisted `date` and `orgField` when the payload omits them).
+   */
+  JournalEntryModel?: Model<unknown>;
+  /** Multi-tenant scope field name (e.g. `'organizationId'`). */
+  orgField?: string;
+}
+//#endregion
+//#region src/plugins/lock/create-lock-plugin.d.ts
+declare function createLockPlugin(options: CreateLockPluginOptions): {
+  name: string;
+  apply(repo: RepositoryInstance): void;
+};
+//#endregion
+//#region src/plugins/lock/period-resolver.d.ts
+interface PeriodResolverOptions {
+  /** Scope identifier, passed through to the resulting `LockHit`. */
+  scope: string;
+  /** Mongoose model holding closed-period rows. */
+  PeriodModel: Model<unknown>;
+  /** Field name for the start of the window. Default: `'startDate'`. */
+  startField?: string;
+  /** Field name for the end of the window. Default: `'endDate'`. */
+  endField?: string;
+  /**
+   * Field name that indicates "this window is closed". Default:
+   * `'closed'` (matches FiscalPeriod model).
+   */
+  closedField?: string;
+  /** Value of the closed field that counts as closed. Default: `true`. */
+  closedValue?: unknown;
+  /** Field name to use as the display label in errors. Default: `'name'`. */
+  labelField?: string;
+  /** Field name to surface as `LockHit.subType`. Default: undefined. */
+  subTypeField?: string;
+  /** Field name to surface as `LockHit.externalRef`. Default: undefined. */
+  externalRefField?: string;
+  /** Multi-tenant scope field on the period doc. */
+  orgField?: string;
+  /**
+   * Optional additional query fragment merged into the lookup. Receives
+   * the resolver context so callers can derive dynamic filters from the
+   * entry payload (e.g. pick `taxType` from `data`).
+   */
+  extraQuery?: (ctx: LockResolverContext) => Record<string, unknown> | undefined;
+}
+declare function periodResolver(options: PeriodResolverOptions): LockResolver;
+//#endregion
+//#region src/plugins/lock/presets.d.ts
+interface FiscalLockPluginOptions {
+  FiscalPeriodModel: Model<unknown>;
+  JournalEntryModel?: Model<unknown>;
+  orgField?: string;
+}
+declare function fiscalLockPlugin(options: FiscalLockPluginOptions): {
+  name: string;
+  apply(repo: _classytic_mongokit0.RepositoryInstance): void;
+};
+interface TaxLockPluginOptions {
+  /**
+   * Tax-period model. Expected shape (fields are overridable via the
+   * lower-level `createLockPlugin` if your schema differs):
+   *
+   *   {
+   *     periodStart: Date,
+   *     periodEnd: Date,
+   *     status: 'open' | 'filed' | 'amended',
+   *     jurisdiction?: string,
+   *     taxType?: string,
+   *     returnRef?: string,
+   *     [orgField]?: unknown,
+   *   }
+   *
+   * `status !== 'open'` counts as locked.
+   */
+  TaxPeriodModel: Model<unknown>;
+  AccountModel: Model<unknown>;
+  JournalEntryModel?: Model<unknown>;
+  orgField?: string;
+  /**
+   * Predicate deciding which accounts participate in tax returns.
+   * Defaults to `acc => acc.taxMetadata != null` — matches the
+   * convention used by country packs that populate `taxMetadata` on
+   * tax-payable / tax-recoverable account types.
+   */
+  isTaxAffecting?: LockAccountSelector;
+  /**
+   * Derive `{ jurisdiction, taxType }` from the entry payload so each
+   * post can look up the right row. Default: use `data.jurisdiction`
+   * and `data.taxType` directly when present.
+   */
+  deriveFilter?: (data: Record<string, unknown>) => {
+    jurisdiction?: string;
+    taxType?: string;
+  } | undefined;
+}
+declare function taxLockPlugin(options: TaxLockPluginOptions): {
+  name: string;
+  apply(repo: _classytic_mongokit0.RepositoryInstance): void;
+};
+interface DailyLockPluginOptions {
+  /**
+   * Return the `lastClosedDate` for the given org/branch — everything
+   * on or before this date is frozen. Return `null` if the branch
+   * has never been closed.
+   */
+  getLastClosedDate: (orgValue: unknown, session: ClientSession | null) => Promise<Date | null> | Date | null;
+  JournalEntryModel?: Model<unknown>;
+  orgField?: string;
+}
+declare function dailyLockPlugin(options: DailyLockPluginOptions): {
+  name: string;
+  apply(repo: _classytic_mongokit0.RepositoryInstance): void;
+};
+//#endregion
+//#region src/plugins/lock/watermark-resolver.d.ts
+interface WatermarkResolverOptions {
+  /** Scope identifier, passed through to the resulting `LockHit`. */
+  scope: string;
+  /**
+   * Resolve the current watermark for the given org. Return `null` to
+   * mean "no lock in place". The session is forwarded so the lookup
+   * can participate in the caller's transaction.
+   */
+  getWatermark: (orgValue: unknown, session: ClientSession | null) => Promise<Date | null> | Date | null;
+  /**
+   * Optional label override. Defaults to `"through {ISO date}"`.
+   */
+  formatLabel?: (watermark: Date, ctx: LockResolverContext) => string;
+}
+declare function watermarkResolver(options: WatermarkResolverOptions): LockResolver;
+//#endregion
+//#region src/utils/tax-hooks.d.ts
+interface TaxLineInput {
+  account: unknown;
+  amount: number;
+  side: 'debit' | 'credit';
+  taxCode?: string;
+  extraFields?: Record<string, unknown>;
+}
+interface GeneratedTaxLine {
+  account: unknown;
+  debit: number;
+  credit: number;
+  label?: string;
+  taxDetails?: Array<{
+    taxCode: string;
+    taxName?: string;
+  }>;
+}
+interface TaxLineGenerator {
+  generateTaxLines(input: TaxLineInput): GeneratedTaxLine[];
+}
+//#endregion
+export { JournalEntryRepository as A, SeedResult as B, DoubleEntryPluginOptions as C, AccountRepository as D, creditLimitPlugin as E, PostOptions as F, ReconciliationRepository as I, ReverseOptions as L, JournalRepository as M, MatchInput as N, BulkCreateInput as O, OpenItem as P, ReverseResult as R, fxRealizationPlugin as S, CreditLimitPluginOptions as T, LockResolver as _, DailyLockPluginOptions as a, idempotencyPlugin as b, dailyLockPlugin as c, PeriodResolverOptions as d, periodResolver as f, LockHit as g, LockAccountSelector as h, watermarkResolver as i, JournalItemRef as j, BulkCreateResult as k, fiscalLockPlugin as l, CreateLockPluginOptions as m, TaxLineInput as n, FiscalLockPluginOptions as o, createLockPlugin as p, WatermarkResolverOptions as r, TaxLockPluginOptions as s, TaxLineGenerator as t, taxLockPlugin as u, LockResolverContext as v, doubleEntryPlugin as w, FxRealizationPluginOptions as x, IdempotencyPluginOptions as y, SeedOptions as z };

package/dist/{trial-balance-BZ7yOOFD.d.mts → trial-balance-s92GEvRR.d.mts}

@@ -1,5 +1,5 @@
 import { c as DateRange } from "./core-BkGjuVZj.mjs";
-import { t as CountryPack } from "./index-GmfEFxVn.mjs";
+import { t as CountryPack } from "./index-BthGypsI.mjs";
 import { ClientSession, Model } from "mongoose";
 
 //#region src/utils/logger.d.ts
@@ -403,6 +403,79 @@ declare function generateIncomeStatement(opts: IncomeStatementOptions, params: {
   filters?: Record<string, unknown>;
 }): Promise<IncomeStatementReport>;
 //#endregion
+//#region src/reports/partner-ledger.d.ts
+interface PartnerLedgerOptions {
+  AccountModel: Model<unknown>;
+  JournalEntryModel: Model<unknown>;
+  orgField?: string;
+}
+interface PartnerLedgerParams {
+  organizationId?: unknown;
+  /**
+   * The control account being ledgered — typically `2111 A/P`
+   * (supplier statement) or `1141 A/R` (customer statement).
+   */
+  controlAccountId: unknown;
+  /**
+   * Field name on each journal item that holds the partner reference.
+   * Default: `'partnerId'`. Whatever you declared in
+   * `schemaOptions.journalEntry.extraItemFields`.
+   */
+  partnerField?: string;
+  /**
+   * The specific partner whose statement we're generating. Required —
+   * to get all partners use `generateAgedBalance` instead.
+   */
+  partnerId: unknown;
+  startDate: Date;
+  endDate: Date;
+  /**
+   * If true, include items already matched (settled) inside the period.
+   * Default: true — statements show settled activity in the period.
+   */
+  includeMatched?: boolean;
+  /** Custom aged buckets for the open-items summary. */
+  buckets?: AgedBucketConfig[];
+}
+interface PartnerLedgerLine {
+  date: Date;
+  entry: unknown;
+  itemIndex: number;
+  referenceNumber?: string;
+  label?: string;
+  debit: number;
+  credit: number;
+  /** Running balance (debit - credit, signed) including this row. */
+  balance: number;
+  matchingNumber: string | null;
+  maturityDate?: Date | null;
+  /** Days past `maturityDate` as of `endDate`; null if no maturity set. */
+  daysPastDue: number | null;
+  isMatched: boolean;
+}
+interface PartnerLedgerReport {
+  metadata: {
+    generatedAt: string;
+    partnerId: unknown;
+    controlAccount: {
+      id: unknown;
+      name?: string;
+      code?: string;
+    };
+    period: {
+      startDate: string;
+      endDate: string;
+    };
+  };
+  openingBalance: number;
+  closingBalance: number;
+  openItemsTotal: number;
+  matchedTotal: number;
+  lines: PartnerLedgerLine[];
+  agedBuckets: Record<string, number>;
+}
+declare function generatePartnerLedger(opts: PartnerLedgerOptions, params: PartnerLedgerParams): Promise<PartnerLedgerReport>;
+//#endregion
 //#region src/utils/revaluation.d.ts
 /**
  * Foreign Exchange Revaluation Utilities
@@ -539,4 +612,4 @@ declare function generateTrialBalance(opts: TrialBalanceOptions, params: {
   filters?: Record<string, unknown>;
 }): Promise<TrialBalanceReport>;
 //#endregion
-export { AgedBucketConfig as $, BudgetVsActualReport as A, IncomeStatementReport as B, DimensionBreakdownReport as C, generateCashFlow as D, CashFlowOptions as E, BalanceSheetReport as F, TaxReport as G, ReportAccount as H, CashFlowReport as I, TrialBalanceRow as J, TaxReturnSummary as K, CashFlowSection as L, generateBudgetVsActual as M, BalanceSheetOptions as N, BudgetVsActualOptions as O, generateBalanceSheet as P, AgedBalanceRow as Q, GeneralLedgerAccount as R, DimensionBreakdownParams as S, generateDimensionBreakdown as T, ReportCategory as U, LedgerEntry as V, ReportGroup as W, AgedBalanceParams as X, AgedBalanceOptions as Y, AgedBalanceReport as Z, FiscalCloseResult as _, RevaluationReport as a, reopenFiscalPeriod as b, RevaluationRate as c, computeRevaluation as d, DEFAULT_BUCKETS as et, IncomeStatementOptions as f, FiscalCloseOptions as g, generateGeneralLedger as h, RevaluationParams as i, BudgetVsActualRow as j, BudgetVsActualParams as k, RevaluationResult as l, GeneralLedgerOptions as m, generateTrialBalance as n, Logger as nt, generateRevaluation as o, generateIncomeStatement as p, TrialBalanceReport as q, RevaluationOptions as r, defaultLogger as rt, AccountForeignBalance as s, TrialBalanceOptions as t, generateAgedBalance as tt, buildRevaluationEntry as u, FiscalReopenResult as v, DimensionBreakdownRow as w, DimensionBreakdownOptions as x, closeFiscalPeriod as y, GeneralLedgerReport as z };
+export { TrialBalanceRow as $, generateDimensionBreakdown as A, BalanceSheetReport as B, FiscalReopenResult as C, DimensionBreakdownParams as D, DimensionBreakdownOptions as E, BudgetVsActualReport as F, IncomeStatementReport as G, CashFlowSection as H, BudgetVsActualRow as I, ReportCategory as J, LedgerEntry as K, generateBudgetVsActual as L, generateCashFlow as M, BudgetVsActualOptions as N, DimensionBreakdownReport as O, BudgetVsActualParams as P, TrialBalanceReport as Q, BalanceSheetOptions as R, FiscalCloseResult as S, reopenFiscalPeriod as T, GeneralLedgerAccount as U, CashFlowReport as V, GeneralLedgerReport as W, TaxReport as X, ReportGroup as Y, TaxReturnSummary as Z, IncomeStatementOptions as _, RevaluationReport as a, DEFAULT_BUCKETS as at, generateGeneralLedger as b, RevaluationRate as c, defaultLogger as ct, computeRevaluation as d, AgedBalanceOptions as et, PartnerLedgerLine as f, generatePartnerLedger as g, PartnerLedgerReport as h, RevaluationParams as i, AgedBucketConfig as it, CashFlowOptions as j, DimensionBreakdownRow as k, RevaluationResult as l, PartnerLedgerParams as m, generateTrialBalance as n, AgedBalanceReport as nt, generateRevaluation as o, generateAgedBalance as ot, PartnerLedgerOptions as p, ReportAccount as q, RevaluationOptions as r, AgedBalanceRow as rt, AccountForeignBalance as s, Logger as st, TrialBalanceOptions as t, AgedBalanceParams as tt, buildRevaluationEntry as u, generateIncomeStatement as v, closeFiscalPeriod as w, FiscalCloseOptions as x, GeneralLedgerOptions as y, generateBalanceSheet as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/ledger",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Production-grade double-entry accounting engine for MongoDB — schemas, reports, tax, multi-tenant",
   "type": "module",
   "sideEffects": false,
@@ -78,7 +78,7 @@
     "url": "git+https://github.com/classytic/accounting.git"
   },
   "peerDependencies": {
-    "@classytic/mongokit": ">=3.5.3",
+    "@classytic/mongokit": ">=3.5.5",
     "mongoose": ">=9.4.1"
   },
   "engines": {
@@ -96,12 +96,13 @@
     "format": "biome format src/ --write",
     "check": "biome ci src/ --diagnostic-level=error",
     "knip": "knip",
-    "prepublishOnly": "npm run check && npm run build && npm run typecheck && npm test",
-    "release": "npm run check && npm run build && npm run typecheck && npm test && npm publish --access public"
+    "smoke": "node scripts/smoke.mjs",
+    "prepublishOnly": "npm run check && npm run build && npm run typecheck && npm test && npm run smoke",
+    "release": "npm run check && npm run build && npm run typecheck && npm test && npm run smoke && npm publish --access public"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.10",
-    "@classytic/mongokit": "^3.5.3",
+    "@classytic/mongokit": "^3.5.5",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^3.2.4",
     "knip": "^6.3.0",