@moatless/bookkeeping 0.1.0

package/dist/services/journal.service.d.ts

@@ -0,0 +1,45 @@
+import type { JournalEntry } from "../types";
+import type { IStorageService } from "../storage/interface";
+export interface JournalEntryRecord {
+    entry: JournalEntry;
+    entryPath: string;
+    entryDir: string;
+}
+export interface UpsertJournalEntryResult {
+    action: "created" | "updated" | "unchanged";
+    entryDir: string;
+}
+/**
+ * Journal entry service - handles journal entries in storage
+ * Works with both GitHub and filesystem storage backends
+ */
+export declare class JournalService {
+    private storage;
+    constructor(storage: IStorageService);
+    private static getEntryKey;
+    /**
+     * List all journal entries from a fiscal year
+     * Returns entries with their externalId for sync matching
+     */
+    listJournalEntries(fiscalYear: number): Promise<Map<string, JournalEntry>>;
+    /**
+     * List all journal entries from a fiscal year with their paths
+     */
+    listJournalEntryRecords(fiscalYear: number): Promise<Map<string, JournalEntryRecord>>;
+    /**
+     * Create a new journal entry
+     */
+    createJournalEntry(fiscalYear: number, entry: JournalEntry): Promise<void>;
+    /**
+     * Update an existing journal entry
+     */
+    updateJournalEntry(fiscalYear: number, existingEntry: JournalEntry, updatedEntry: JournalEntry): Promise<void>;
+    /**
+     * Create or update a journal entry, returning the entry directory path used.
+     */
+    upsertJournalEntry(fiscalYear: number, entry: JournalEntry, existingRecord?: JournalEntryRecord): Promise<UpsertJournalEntryResult>;
+    /**
+     * Check if two entries are equal (for change detection)
+     */
+    static entriesEqual(a: JournalEntry, b: JournalEntry): boolean;
+}

package/dist/services/journal.service.js

@@ -0,0 +1,204 @@
+import { journalEntryDirFromPath, journalEntryPath } from "../utils/file-namer";
+import { parseYaml, toYaml } from "../utils/yaml";
+/**
+ * Journal entry service - handles journal entries in storage
+ * Works with both GitHub and filesystem storage backends
+ */
+export class JournalService {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    static getEntryKey(entry) {
+        return (entry.externalId ??
+            `${entry.series ?? ""}-${entry.entryNumber}`);
+    }
+    /**
+     * List all journal entries from a fiscal year
+     * Returns entries with their externalId for sync matching
+     */
+    async listJournalEntries(fiscalYear) {
+        const records = await this.listJournalEntryRecords(fiscalYear);
+        const entriesMap = new Map();
+        for (const [key, record] of records) {
+            entriesMap.set(key, record.entry);
+        }
+        return entriesMap;
+    }
+    /**
+     * List all journal entries from a fiscal year with their paths
+     */
+    async listJournalEntryRecords(fiscalYear) {
+        const fiscalYearDir = `journal-entries/FY-${fiscalYear}`;
+        const entriesMap = new Map();
+        try {
+            const directories = await this.storage.listDirectory(fiscalYearDir);
+            for (const dir of directories) {
+                if (dir.type !== "dir" || dir.name.startsWith("_")) {
+                    continue;
+                }
+                const entryPath = `${dir.path}/entry.yaml`;
+                try {
+                    const { content } = await this.storage.readFile(entryPath);
+                    const journalEntry = parseYaml(content);
+                    const key = JournalService.getEntryKey(journalEntry);
+                    entriesMap.set(key, {
+                        entry: journalEntry,
+                        entryPath,
+                        entryDir: journalEntryDirFromPath(entryPath),
+                    });
+                }
+                catch (error) {
+                    console.error(`Failed to read ${entryPath}:`, error);
+                }
+            }
+        }
+        catch (_error) {
+            // Directory might not exist yet
+            console.warn(`Fiscal year directory not found: ${fiscalYearDir}`);
+        }
+        return entriesMap;
+    }
+    /**
+     * Create a new journal entry
+     */
+    async createJournalEntry(fiscalYear, entry) {
+        const yaml = toYaml(entry);
+        const filePath = journalEntryPath(fiscalYear, entry.series ?? null, entry.entryNumber, entry.entryDate, entry.description);
+        const message = `Create journal entry: ${entry.series ?? ""}${entry.entryNumber} - ${entry.description}`;
+        await this.storage.writeFile(filePath, yaml, { message });
+    }
+    /**
+     * Update an existing journal entry
+     */
+    async updateJournalEntry(fiscalYear, existingEntry, updatedEntry) {
+        const yaml = toYaml(updatedEntry);
+        // Use existing entry's path info (series, number, date, description)
+        const existingPath = journalEntryPath(fiscalYear, existingEntry.series ?? null, existingEntry.entryNumber, existingEntry.entryDate, existingEntry.description);
+        const updatedPath = journalEntryPath(fiscalYear, updatedEntry.series ?? null, updatedEntry.entryNumber, updatedEntry.entryDate, updatedEntry.description);
+        let filePath = existingPath;
+        if (updatedPath !== existingPath) {
+            const renameDirectory = this.storage.renameDirectory;
+            if (renameDirectory) {
+                const existingDir = journalEntryDirFromPath(existingPath);
+                const updatedDir = journalEntryDirFromPath(updatedPath);
+                if (existingDir !== updatedDir) {
+                    try {
+                        await renameDirectory(existingDir, updatedDir);
+                        filePath = updatedPath;
+                    }
+                    catch {
+                        filePath = existingPath;
+                    }
+                }
+            }
+        }
+        try {
+            const { sha } = await this.storage.readFile(filePath);
+            const message = `Update journal entry: ${updatedEntry.series ?? ""}${updatedEntry.entryNumber} - ${updatedEntry.description}`;
+            await this.storage.writeFile(filePath, yaml, { message, sha });
+        }
+        catch (_error) {
+            // If file doesn't exist at expected path, create it
+            const message = `Update journal entry: ${updatedEntry.series ?? ""}${updatedEntry.entryNumber} - ${updatedEntry.description}`;
+            await this.storage.writeFile(filePath, yaml, { message });
+        }
+    }
+    /**
+     * Create or update a journal entry, returning the entry directory path used.
+     */
+    async upsertJournalEntry(fiscalYear, entry, existingRecord) {
+        const entryPath = journalEntryPath(fiscalYear, entry.series ?? null, entry.entryNumber, entry.entryDate, entry.description);
+        const entryDir = journalEntryDirFromPath(entryPath);
+        if (!existingRecord) {
+            const message = `Create journal entry: ${entry.series ?? ""}${entry.entryNumber} - ${entry.description}`;
+            await this.storage.writeFile(entryPath, toYaml(entry), { message });
+            return { action: "created", entryDir };
+        }
+        if (JournalService.entriesEqual(existingRecord.entry, entry)) {
+            return { action: "unchanged", entryDir: existingRecord.entryDir };
+        }
+        let targetPath = existingRecord.entryPath;
+        let targetDir = existingRecord.entryDir;
+        if (existingRecord.entryPath !== entryPath) {
+            const renameDirectory = this.storage.renameDirectory;
+            if (renameDirectory) {
+                if (existingRecord.entryDir !== entryDir) {
+                    try {
+                        await renameDirectory(existingRecord.entryDir, entryDir);
+                        targetPath = entryPath;
+                        targetDir = entryDir;
+                    }
+                    catch {
+                        targetPath = existingRecord.entryPath;
+                        targetDir = existingRecord.entryDir;
+                    }
+                }
+            }
+        }
+        const yaml = toYaml(entry);
+        const message = `Update journal entry: ${entry.series ?? ""}${entry.entryNumber} - ${entry.description}`;
+        try {
+            const { sha } = await this.storage.readFile(targetPath);
+            await this.storage.writeFile(targetPath, yaml, { message, sha });
+        }
+        catch {
+            await this.storage.writeFile(targetPath, yaml, { message });
+        }
+        return { action: "updated", entryDir: targetDir };
+    }
+    /**
+     * Check if two entries are equal (for change detection)
+     */
+    static entriesEqual(a, b) {
+        // Compare key fields
+        if ((a.series ?? null) !== (b.series ?? null) ||
+            a.entryNumber !== b.entryNumber ||
+            a.description !== b.description ||
+            a.entryDate !== b.entryDate ||
+            a.status !== b.status ||
+            a.currency !== b.currency ||
+            a.totalDebit.amount !== b.totalDebit.amount ||
+            a.totalDebit.currency !== b.totalDebit.currency ||
+            (a.totalDebit.originalAmount ?? null) !== (b.totalDebit.originalAmount ?? null) ||
+            (a.totalDebit.originalCurrency ?? null) !== (b.totalDebit.originalCurrency ?? null) ||
+            a.totalCredit.amount !== b.totalCredit.amount ||
+            a.totalCredit.currency !== b.totalCredit.currency ||
+            (a.totalCredit.originalAmount ?? null) !== (b.totalCredit.originalAmount ?? null) ||
+            (a.totalCredit.originalCurrency ?? null) !== (b.totalCredit.originalCurrency ?? null) ||
+            (a.voucherNumber ?? null) !== (b.voucherNumber ?? null) ||
+            (a.voucherSeriesCode ?? null) !== (b.voucherSeriesCode ?? null) ||
+            (a.reversingEntryExternalId ?? null) !== (b.reversingEntryExternalId ?? null) ||
+            (a.reversedByEntryExternalId ?? null) !== (b.reversedByEntryExternalId ?? null)) {
+            return false;
+        }
+        // Compare lines count
+        if (a.lines.length !== b.lines.length) {
+            return false;
+        }
+        // Compare each line
+        for (let i = 0; i < a.lines.length; i++) {
+            const lineA = a.lines[i];
+            const lineB = b.lines[i];
+            if (!lineA || !lineB)
+                return false;
+            if (lineA.lineNumber !== lineB.lineNumber ||
+                lineA.account !== lineB.account ||
+                lineA.debit.amount !== lineB.debit.amount ||
+                lineA.debit.currency !== lineB.debit.currency ||
+                (lineA.debit.originalAmount ?? null) !== (lineB.debit.originalAmount ?? null) ||
+                (lineA.debit.originalCurrency ?? null) !== (lineB.debit.originalCurrency ?? null) ||
+                lineA.credit.amount !== lineB.credit.amount ||
+                lineA.credit.currency !== lineB.credit.currency ||
+                (lineA.credit.originalAmount ?? null) !== (lineB.credit.originalAmount ?? null) ||
+                (lineA.credit.originalCurrency ?? null) !== (lineB.credit.originalCurrency ?? null) ||
+                (lineA.memo ?? null) !== (lineB.memo ?? null) ||
+                (lineA.taxCode ?? null) !== (lineB.taxCode ?? null) ||
+                (lineA.costCenter ?? null) !== (lineB.costCenter ?? null) ||
+                (lineA.ledgerAccountName ?? null) !== (lineB.ledgerAccountName ?? null)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/storage/filesystem.d.ts

@@ -0,0 +1,49 @@
+import type { IStorageService, FileContent, StorageEntry, WriteOptions } from "./interface";
+/**
+ * Filesystem implementation of storage service.
+ * Uses local filesystem for file operations (for CLI tools like gitops).
+ */
+export declare class FilesystemStorageService implements IStorageService {
+    private basePath;
+    constructor(basePath: string);
+    /**
+     * Resolve a relative path to an absolute path
+     */
+    private resolvePath;
+    /**
+     * Generate a SHA-like hash from file content for version tracking
+     */
+    private contentHash;
+    /**
+     * Read a file from the filesystem
+     */
+    readFile(filePath: string): Promise<FileContent>;
+    /**
+     * Write a file to the filesystem
+     */
+    writeFile(filePath: string, content: string, _options?: WriteOptions): Promise<void>;
+    /**
+     * Write a binary file to the filesystem
+     */
+    writeBinaryFile(filePath: string, content: Uint8Array): Promise<void>;
+    /**
+     * List contents of a directory
+     */
+    listDirectory(dirPath: string): Promise<StorageEntry[]>;
+    /**
+     * Delete a file from the filesystem
+     */
+    deleteFile(filePath: string, _sha: string, _message?: string): Promise<void>;
+    /**
+     * Filesystem doesn't support public URLs
+     */
+    getPublicUrl(_path: string): string | null;
+    /**
+     * Check if a file exists
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * Rename a directory
+     */
+    renameDirectory(oldPath: string, newPath: string): Promise<void>;
+}

package/dist/storage/filesystem.js

@@ -0,0 +1,122 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+/**
+ * Filesystem implementation of storage service.
+ * Uses local filesystem for file operations (for CLI tools like gitops).
+ */
+export class FilesystemStorageService {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    /**
+     * Resolve a relative path to an absolute path
+     */
+    resolvePath(relativePath) {
+        return path.join(this.basePath, relativePath);
+    }
+    /**
+     * Generate a SHA-like hash from file content for version tracking
+     */
+    contentHash(content) {
+        return crypto.createHash("sha1").update(content).digest("hex");
+    }
+    /**
+     * Read a file from the filesystem
+     */
+    async readFile(filePath) {
+        const absolutePath = this.resolvePath(filePath);
+        const content = await fs.readFile(absolutePath, "utf-8");
+        return {
+            content,
+            sha: this.contentHash(content),
+        };
+    }
+    /**
+     * Write a file to the filesystem
+     */
+    async writeFile(filePath, content, _options) {
+        const absolutePath = this.resolvePath(filePath);
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fs.writeFile(absolutePath, content, "utf-8");
+    }
+    /**
+     * Write a binary file to the filesystem
+     */
+    async writeBinaryFile(filePath, content) {
+        const absolutePath = this.resolvePath(filePath);
+        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fs.writeFile(absolutePath, content);
+    }
+    /**
+     * List contents of a directory
+     */
+    async listDirectory(dirPath) {
+        const absolutePath = this.resolvePath(dirPath);
+        const entries = [];
+        try {
+            const items = await fs.readdir(absolutePath, { withFileTypes: true });
+            for (const item of items) {
+                if (item.isFile()) {
+                    entries.push({
+                        name: item.name,
+                        type: "file",
+                        path: path.join(dirPath, item.name),
+                    });
+                }
+                else if (item.isDirectory()) {
+                    entries.push({
+                        name: item.name,
+                        type: "dir",
+                        path: path.join(dirPath, item.name),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist - return empty array
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        return entries;
+    }
+    /**
+     * Delete a file from the filesystem
+     */
+    async deleteFile(filePath, _sha, _message) {
+        const absolutePath = this.resolvePath(filePath);
+        await fs.unlink(absolutePath);
+    }
+    /**
+     * Filesystem doesn't support public URLs
+     */
+    getPublicUrl(_path) {
+        return null;
+    }
+    /**
+     * Check if a file exists
+     */
+    async exists(filePath) {
+        try {
+            await fs.access(this.resolvePath(filePath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Rename a directory
+     */
+    async renameDirectory(oldPath, newPath) {
+        const absoluteOldPath = this.resolvePath(oldPath);
+        const absoluteNewPath = this.resolvePath(newPath);
+        // Ensure parent directory of new path exists
+        await fs.mkdir(path.dirname(absoluteNewPath), { recursive: true });
+        await fs.rename(absoluteOldPath, absoluteNewPath);
+    }
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,2 @@
+export type { IStorageService, StorageEntry, FileContent, WriteOptions, } from "./interface";
+export { FilesystemStorageService } from "./filesystem";

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { FilesystemStorageService } from "./filesystem";

package/dist/storage/interface.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Storage abstraction interface.
+ * Allows swapping between different storage backends (GitHub, Filesystem, Azure Blob, etc.)
+ */
+export interface StorageEntry {
+    name: string;
+    type: "file" | "dir";
+    path: string;
+}
+export interface FileContent {
+    /** Text content (binary files should be Base64-encoded by caller) */
+    content: string;
+    /** Version identifier for optimistic locking (e.g., Git SHA, ETag, mtime) */
+    sha: string;
+}
+export interface WriteOptions {
+    /** Commit message (GitHub) or audit log entry (other backends) */
+    message?: string;
+    /** Required for updates - ensures no concurrent modifications */
+    sha?: string;
+}
+export interface IStorageService {
+    /**
+     * Read a file's content and version identifier.
+     * @throws Error if file does not exist
+     */
+    readFile(path: string): Promise<FileContent>;
+    /**
+     * Write a file (create or update).
+     * For updates, provide sha in options for optimistic locking.
+     */
+    writeFile(path: string, content: string, options?: WriteOptions): Promise<void>;
+    /**
+     * List contents of a directory.
+     * Returns only files and directories (no symlinks or submodules).
+     */
+    listDirectory(path: string): Promise<StorageEntry[]>;
+    /**
+     * Delete a file.
+     * Requires sha for optimistic locking.
+     */
+    deleteFile(path: string, sha: string, message?: string): Promise<void>;
+    /**
+     * Get a public URL for a file, if supported.
+     * Returns null if the storage backend doesn't support public URLs.
+     */
+    getPublicUrl(path: string): string | null;
+}

package/dist/storage/interface.js

@@ -0,0 +1,5 @@
+/**
+ * Storage abstraction interface.
+ * Allows swapping between different storage backends (GitHub, Filesystem, Azure Blob, etc.)
+ */
+export {};

package/dist/sync-types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Result stats for sync operations
+ */
+export interface SyncStats {
+    fetched: number;
+    written: number;
+    skipped: number;
+    errors: number;
+}
+/**
+ * Stats per fiscal year (more detailed)
+ */
+export interface FiscalYearStats {
+    year: number;
+    fetched: number;
+    created: number;
+    updated: number;
+    unchanged: number;
+    failed: number;
+}
+/**
+ * Error entry for tracking issues
+ */
+export interface SyncError {
+    year: number;
+    externalId: string;
+    message: string;
+}
+/**
+ * Complete sync result
+ */
+export interface SyncJournalResult {
+    success: boolean;
+    fiscalYears: FiscalYearStats[];
+    totals: {
+        fetched: number;
+        created: number;
+        updated: number;
+        unchanged: number;
+        failed: number;
+    };
+    errors: SyncError[];
+    durationMs: number;
+}
+/**
+ * Fiscal year info for sync operations
+ */
+export interface FiscalYearInfo {
+    /** External ID from provider (used for API calls) */
+    externalId: number;
+    /** Calendar year (used for file paths) */
+    year: number;
+}
+/**
+ * Fiscal year with dates (from database)
+ */
+export interface FiscalYearWithDates {
+    name: string | null;
+    start_date: string;
+    end_date: string;
+}

package/dist/sync-types.js

@@ -0,0 +1 @@
+export {};

package/dist/transformers/bokio.d.ts

@@ -0,0 +1,10 @@
+import type { CreateJournalEntryRequest, JournalEntry as BokioJournalEntry } from "@moatless/bokio-client";
+import type { JournalEntry } from "../types";
+/**
+ * Transform a Bokio journal entry to a JournalEntry
+ */
+export declare function mapBokioEntryToJournalEntry(entry: BokioJournalEntry): JournalEntry;
+/**
+ * Transform a local JournalEntry to a Bokio CreateJournalEntryRequest
+ */
+export declare function mapJournalEntryToBokioRequest(entry: JournalEntry): CreateJournalEntryRequest;

package/dist/transformers/bokio.js

@@ -0,0 +1,56 @@
+/**
+ * Transform a Bokio journal entry to a JournalEntry
+ */
+export function mapBokioEntryToJournalEntry(entry) {
+    // Parse voucher number and series from journalEntryNumber (e.g., "A123" -> series: "A", number: 123)
+    const voucherNumberMatch = entry.journalEntryNumber.match(/\d+/);
+    const voucherNumber = voucherNumberMatch
+        ? parseInt(voucherNumberMatch[0], 10)
+        : 0;
+    const seriesCode = entry.journalEntryNumber.replace(/\d+/g, "") || undefined;
+    const lines = entry.items.map((item, idx) => ({
+        lineNumber: idx + 1,
+        account: String(item.account),
+        debit: { amount: item.debit, currency: "SEK" },
+        credit: { amount: item.credit, currency: "SEK" },
+    }));
+    const totalDebit = entry.items.reduce((sum, item) => sum + item.debit, 0);
+    const totalCredit = entry.items.reduce((sum, item) => sum + item.credit, 0);
+    return {
+        series: seriesCode,
+        entryNumber: voucherNumber,
+        entryDate: entry.date,
+        description: entry.title,
+        status: "POSTED",
+        currency: "SEK",
+        externalId: entry.id,
+        totalDebit: { amount: totalDebit, currency: "SEK" },
+        totalCredit: { amount: totalCredit, currency: "SEK" },
+        lines,
+        sourceIntegration: "bokio",
+        sourceSyncedAt: new Date().toISOString(),
+        reversingEntryExternalId: entry.reversingJournalEntryId ?? undefined,
+        reversedByEntryExternalId: entry.reversedByJournalEntryId ?? undefined,
+    };
+}
+/**
+ * Helper to handle both plain number and MoneyAmount object formats.
+ * This provides backwards compatibility with YAML files that have plain numbers.
+ */
+function getAmount(value) {
+    return typeof value === "number" ? value : value.amount;
+}
+/**
+ * Transform a local JournalEntry to a Bokio CreateJournalEntryRequest
+ */
+export function mapJournalEntryToBokioRequest(entry) {
+    return {
+        title: entry.description,
+        date: entry.entryDate,
+        items: entry.lines.map((line) => ({
+            debit: getAmount(line.debit),
+            credit: getAmount(line.credit),
+            account: parseInt(line.account, 10),
+        })),
+    };
+}

package/dist/transformers/fortnox.d.ts

@@ -0,0 +1,6 @@
+import type { Voucher } from "@moatless/fortnox-client";
+import type { JournalEntry } from "../types";
+/**
+ * Transform a Fortnox voucher to a JournalEntry
+ */
+export declare function mapFortnoxVoucherToJournalEntry(voucher: Voucher, _fiscalYear?: number): JournalEntry;

package/dist/transformers/fortnox.js

@@ -0,0 +1,39 @@
+/**
+ * Transform a Fortnox voucher to a JournalEntry
+ */
+export function mapFortnoxVoucherToJournalEntry(voucher, _fiscalYear) {
+    const series = voucher.VoucherSeries;
+    const externalId = `${voucher.VoucherSeries}-${voucher.VoucherNumber}`;
+    // Calculate totals from voucher rows
+    let totalDebit = 0;
+    let totalCredit = 0;
+    const lines = (voucher.VoucherRows ?? []).map((row, idx) => {
+        totalDebit += row.Debit ?? 0;
+        totalCredit += row.Credit ?? 0;
+        const memo = row.TransactionInformation || row.Description || undefined;
+        return {
+            lineNumber: idx + 1,
+            account: String(row.Account),
+            debit: { amount: row.Debit ?? 0, currency: "SEK" },
+            credit: { amount: row.Credit ?? 0, currency: "SEK" },
+            memo: memo ? String(memo) : undefined,
+            costCenter: row.CostCenter ?? undefined,
+        };
+    });
+    return {
+        series,
+        entryNumber: voucher.VoucherNumber ?? 0,
+        entryDate: voucher.TransactionDate ?? voucher.VoucherDate ?? "",
+        description: voucher.Description ?? "",
+        status: "POSTED",
+        currency: "SEK",
+        externalId,
+        totalDebit: { amount: totalDebit, currency: "SEK" },
+        totalCredit: { amount: totalCredit, currency: "SEK" },
+        lines,
+        sourceIntegration: "fortnox",
+        sourceSyncedAt: new Date().toISOString(),
+        voucherNumber: voucher.VoucherNumber,
+        voucherSeriesCode: voucher.VoucherSeries,
+    };
+}

package/dist/transformers/index.d.ts

@@ -0,0 +1,3 @@
+export { mapFortnoxVoucherToJournalEntry } from "./fortnox";
+export { mapBokioEntryToJournalEntry, mapJournalEntryToBokioRequest } from "./bokio";
+export type { JournalEntry as BokioJournalEntry } from "@moatless/bokio-client";

package/dist/transformers/index.js

@@ -0,0 +1,2 @@
+export { mapFortnoxVoucherToJournalEntry } from "./fortnox";
+export { mapBokioEntryToJournalEntry, mapJournalEntryToBokioRequest } from "./bokio";