@jaskrowo/xtb2sure 0.0.0-stage → 0.2.1

package/LICENSE

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

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# xtb2sure
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Convert XTB `.xlsx` exports into Sure-compatible CSV files.
+
+## What it does
+
+- Reads the `Cash Operations` sheet from an XTB export workbook.
+- Produces two CSV files:
+  - transactions CSV (`date,amount,name,account,notes`)
+  - investments CSV (`date,ticker,currency,qty,price,account,name`)
+
+## Requirements
+
+- Node.js 24
+
+## Install
+
+```bash
+npm install
+```
+
+## Usage
+
+```bash
+node --experimental-transform-types ./src/cli.ts convert <input.xlsx> --currency <CODE> --account "<ACCOUNT_NAME>"
+```
+
+Options:
+
+- `--out-dir <dir>`
+- `--transactions-out <file>`
+- `--investments-out <file>`
+- `--strict`
+- `--dry-run`
+- `--report <file>`
+
+Examples:
+
+```bash
+node --experimental-transform-types ./src/cli.ts convert sample_data/IKE/input.xlsx --currency USD --account "XTB IKE"
+```
+
+```bash
+node --experimental-transform-types ./src/cli.ts convert sample_data/PLN/input.xlsx --currency PLN --account "XTB PLN" --out-dir ./out
+
+Or via npm script:
+
+```bash
+npm run convert -- sample_data/PLN/input.xlsx --currency PLN --account "XTB PLN"
+```
+```
+
+## Exit codes
+
+- `0` success
+- `1` conversion or validation failure
+- `2` usage or config error
+
+## Development
+
+Run tests (Node.js test runner):
+
+```bash
+npm test
+```

package/bin/xtb2sure.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/cli.ts";

package/package.json

@@ -1,6 +1,63 @@
 {
-  "name": "@jaskrowo/xtb2sure",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@jaskrowo/xtb2sure",
+    "version": "0.2.1",
+    "description": "Convert XTB .xlsx exports into Sure-compatible CSV files",
+    "main": "src/index.ts",
+    "engines": {
+        "node": "24"
+    },
+    "type": "module",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/domeq/xtb2sure.git"
+    },
+    "files": [
+        "src",
+        "bin"
+    ],
+    "bin": {
+        "xtb2sure": "./bin/xtb2sure.js"
+    },
+    "scripts": {
+        "dev": "node --experimental-transform-types --watch src/index.ts",
+        "convert": "node --experimental-transform-types ./src/cli.ts convert",
+        "format": "biome format --write .",
+        "knip": "knip",
+        "lint-fix": "biome check --write .",
+        "lint": "biome check .",
+        "prepare": "husky",
+        "release": "release-it",
+        "start": "node --experimental-transform-types src/index.ts",
+        "test": "node --experimental-transform-types --test",
+        "typecheck": "tsc --noEmit"
+    },
+    "lint-staged": {
+        "*": [
+            "biome check --write --no-errors-on-unmatched"
+        ]
+    },
+    "imports": {
+        "#*": "./src/*"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.5.15",
+        "@commitlint/cli": "21.2.3",
+        "@commitlint/config-conventional": "21.2.3",
+        "@release-it/conventional-changelog": "12.0.2",
+        "@types/node": "24.19.1",
+        "husky": "9.1.7",
+        "knip": "6.41.0",
+        "lint-staged": "17.6.0",
+        "release-it": "21.1.1",
+        "typescript": "5.9.3"
+    },
+    "dependencies": {
+        "commander": "15.0.0",
+        "csv-stringify": "6.9.0",
+        "xlsx": "0.18.5"
+    }
+}

package/src/cli.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env -S node --experimental-transform-types
+
+import process from "node:process";
+import { Command, CommanderError } from "commander";
+import { convertFile } from "./index.ts";
+
+const EXIT_SUCCESS = 0;
+const EXIT_CONVERSION_FAILURE = 1;
+const EXIT_USAGE_ERROR = 2;
+
+interface ConvertCommandOptions {
+    account: string;
+    currency: string;
+    dryRun: boolean;
+    investmentsOut?: string;
+    outDir?: string;
+    report?: string;
+    strict: boolean;
+    transactionsOut?: string;
+}
+
+async function main(argv: string[]): Promise<number> {
+    let exitCode = EXIT_SUCCESS;
+
+    const program = new Command();
+    program
+        .name("xtb2sure")
+        .description("Convert XTB .xlsx exports into Sure-compatible CSV files")
+        .showHelpAfterError()
+        .exitOverride();
+
+    program
+        .command("convert")
+        .argument("<input.xlsx>", "Path to XTB export workbook")
+        .requiredOption("--currency <code>", "Account currency for all investment rows")
+        .requiredOption("--account <name>", "Account label used in generated CSV files")
+        .option("--out-dir <dir>", "Output directory for default file names")
+        .option("--transactions-out <file>", "Transactions CSV path")
+        .option("--investments-out <file>", "Investments CSV path")
+        .option("--strict", "Fail on first conversion issue", false)
+        .option("--dry-run", "Do not write output files", false)
+        .option("--report <file>", "Write conversion report JSON to file")
+        .action(async (inputPath: string, options: ConvertCommandOptions) => {
+            try {
+                const result = await convertFile({
+                    account: options.account,
+                    currency: options.currency,
+                    dryRun: options.dryRun,
+                    inputPath,
+                    investmentsOut: options.investmentsOut,
+                    outDir: options.outDir,
+                    report: options.report,
+                    strict: options.strict,
+                    transactionsOut: options.transactionsOut,
+                });
+
+                const totals = result.reportData.totals;
+                console.error(
+                    `Converted rows=${totals.sourceRows}, transactions=${totals.transactionRows}, investments=${totals.investmentRows}, ignored=${totals.ignoredRows}, issues=${totals.issues}`,
+                );
+
+                if (options.dryRun) {
+                    console.error("Dry run enabled: files were not written.");
+                } else {
+                    console.error(`Transactions CSV: ${result.transactionsOutPath}`);
+                    console.error(`Investments CSV: ${result.investmentsOutPath}`);
+                }
+
+                if (totals.issues > 0 && options.strict) {
+                    exitCode = EXIT_CONVERSION_FAILURE;
+                }
+            } catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                exitCode = EXIT_CONVERSION_FAILURE;
+            }
+        });
+
+    try {
+        await program.parseAsync(argv, { from: "user" });
+
+        return exitCode;
+    } catch (error) {
+        if (error instanceof CommanderError) {
+            if (error.code === "commander.helpDisplayed") {
+                return EXIT_SUCCESS;
+            }
+
+            return EXIT_USAGE_ERROR;
+        }
+
+        console.error(error instanceof Error ? error.message : String(error));
+        return EXIT_CONVERSION_FAILURE;
+    }
+}
+
+main(process.argv.slice(2))
+    .then((code) => {
+        process.exitCode = code;
+    })
+    .catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = EXIT_CONVERSION_FAILURE;
+    });

package/src/convert.ts

@@ -0,0 +1,110 @@
+import { excelSerialToYYYYMMDD } from "./date.ts";
+import {
+    buildInvestmentName,
+    buildTransactionNotes,
+    classifyOperation,
+    formatQtyOutput,
+    parseTradeValues,
+} from "./operations.ts";
+import type { CashOperationRow, ConversionResult, InvestmentRecord, TransactionRecord } from "./types.ts";
+
+export interface ConvertOptions {
+    account: string;
+    currency: string;
+    strict: boolean;
+}
+
+export function convertRows(rows: CashOperationRow[], options: ConvertOptions): ConversionResult {
+    const transactions: TransactionRecord[] = [];
+    const investments: InvestmentRecord[] = [];
+    const issues: ConversionResult["issues"] = [];
+    let ignoredRows = 0;
+
+    for (const [index, row] of rows.entries()) {
+        const typeClass = classifyOperation(row.Type);
+
+        if (row.Type === "Total") {
+            ignoredRows += 1;
+            continue;
+        }
+
+        if (typeClass === "ignored") {
+            ignoredRows += 1;
+            continue;
+        }
+
+        try {
+            const date = excelSerialToYYYYMMDD(row.Time);
+
+            if (typeClass === "transaction") {
+                transactions.push({
+                    account: options.account,
+                    amount: normalizeAmount(row.Amount),
+                    date,
+                    name: row.Type,
+                    notes: buildTransactionNotes(row),
+                });
+            } else {
+                const { qty, qtyHadExplicitDecimal } = parseTradeValues(row.Comment);
+                const signedQtyValue = row.Type === "Stock sell" ? forceNegative(qty) : forcePositive(qty);
+                const signedQty = formatQtyOutput(signedQtyValue, row.Instrument, qtyHadExplicitDecimal, row.Product);
+                const price = calculateUnitPriceFromAmount(row.Amount, signedQtyValue);
+
+                investments.push({
+                    account: options.account,
+                    currency: options.currency,
+                    date,
+                    name: buildInvestmentName(row),
+                    price,
+                    qty: signedQty,
+                    ticker: row.Ticker,
+                });
+            }
+        } catch (error) {
+            issues.push({
+                message: error instanceof Error ? error.message : String(error),
+                operationId: row.ID,
+                rowIndex: index + 2,
+            });
+
+            if (options.strict) {
+                break;
+            }
+        }
+    }
+
+    if (rows.some((row) => row.Product.trim() !== "" && row.Product.trim() !== "IKE")) {
+        investments.sort((a, b) => a.date.localeCompare(b.date));
+    }
+
+    return {
+        ignoredRows,
+        investments,
+        issues,
+        transactions,
+    };
+}
+
+function normalizeAmount(amount: number): string {
+    return amount.toFixed(2);
+}
+
+function forceNegative(qty: string): string {
+    const num = Math.abs(Number(qty));
+    return String(-num);
+}
+
+function forcePositive(qty: string): string {
+    const num = Math.abs(Number(qty));
+    return String(num);
+}
+
+function calculateUnitPriceFromAmount(amount: number, qty: string): string {
+    const qtyNumber = Math.abs(Number(qty));
+    if (!Number.isFinite(amount) || !Number.isFinite(qtyNumber) || qtyNumber === 0) {
+        throw new Error(`Cannot calculate price from amount=${amount} and qty=${qty}`);
+    }
+
+    const price = Math.abs(amount) / qtyNumber;
+    return String(Number(price.toFixed(8)));
+}

package/src/csv.ts

@@ -0,0 +1,5 @@
+import { stringify } from "csv-stringify/sync";
+
+export function toCsv(headers: string[], rows: string[][]): string {
+    return stringify([headers, ...rows]);
+}

package/src/date.ts

@@ -0,0 +1,22 @@
+const EXCEL_EPOCH_UTC_MS = Date.UTC(1899, 11, 30);
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function excelSerialToDate(serial: number): Date {
+    if (!Number.isFinite(serial)) {
+        throw new Error(`Invalid Excel serial date: ${serial}`);
+    }
+
+    const utcMs = EXCEL_EPOCH_UTC_MS + Math.round(serial * DAY_MS);
+    return new Date(utcMs);
+}
+
+function formatDateYYYYMMDD(date: Date): string {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+
+export function excelSerialToYYYYMMDD(serial: number): string {
+    return formatDateYYYYMMDD(excelSerialToDate(serial));
+}

package/src/excel.ts

@@ -0,0 +1,105 @@
+import xlsx from "xlsx";
+import type { CashOperationRow } from "./types.ts";
+
+const { readFile, utils } = xlsx;
+
+const REQUIRED_COLUMNS = [
+    "Type",
+    "Instrument",
+    "Ticker",
+    "Time",
+    "Amount",
+    "ID",
+    "Comment",
+    "Product",
+    "Position ID",
+] as const;
+
+export function readCashOperationsSheet(inputPath: string): CashOperationRow[] {
+    const workbook = withSuppressedXlsxWarnings(() => readFile(inputPath, { cellDates: false, raw: true }));
+    const worksheet = workbook.Sheets["Cash Operations"];
+
+    if (!worksheet) {
+        throw new Error("Input workbook is missing required sheet: Cash Operations");
+    }
+
+    const matrix = utils.sheet_to_json<unknown[]>(worksheet, {
+        header: 1,
+        defval: "",
+        raw: true,
+    });
+
+    const headerIndex = matrix.findIndex(
+        (row) => Array.isArray(row) && row[0] === "Type" && row.includes("Time") && row.includes("Comment"),
+    );
+
+    if (headerIndex < 0) {
+        throw new Error("Could not locate Cash Operations header row");
+    }
+
+    const headers = matrix[headerIndex] as unknown[];
+    const headerToIndex = new Map<string, number>();
+    headers.forEach((header, index) => {
+        headerToIndex.set(String(header), index);
+    });
+
+    const missingColumns = REQUIRED_COLUMNS.filter((column) => !headerToIndex.has(column));
+    if (missingColumns.length > 0) {
+        throw new Error(`Missing required columns in Cash Operations: ${missingColumns.join(", ")}`);
+    }
+
+    const bodyRows = matrix
+        .slice(headerIndex + 1)
+        .filter((row) => Array.isArray(row) && String(row[0]).trim().length > 0);
+    return bodyRows.map((row) => normalizeRowFromArray(row, headerToIndex));
+}
+
+function withSuppressedXlsxWarnings<T>(fn: () => T): T {
+    const originalConsoleError = console.error;
+    console.error = (...args: unknown[]) => {
+        if (typeof args[0] === "string" && args[0].includes("Bad uncompressed size:")) {
+            return;
+        }
+
+        originalConsoleError(...args);
+    };
+
+    try {
+        return fn();
+    } finally {
+        console.error = originalConsoleError;
+    }
+}
+
+function normalizeRowFromArray(row: unknown[], headerToIndex: Map<string, number>): CashOperationRow {
+    const get = (column: string): unknown => row[headerToIndex.get(column) ?? -1];
+
+    return {
+        Type: stringValue(get("Type")),
+        Instrument: stringValue(get("Instrument")),
+        Ticker: stringValue(get("Ticker")),
+        Time: numberValue(get("Time")),
+        Amount: numberValue(get("Amount")),
+        ID: stringValue(get("ID")),
+        Comment: stringValue(get("Comment")),
+        Product: stringValue(get("Product")),
+        "Position ID": stringValue(get("Position ID")),
+    };
+}
+
+function stringValue(value: unknown): string {
+    if (value === null || value === undefined) {
+        return "";
+    }
+
+    return String(value);
+}
+
+function numberValue(value: unknown): number {
+    const num = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(num)) {
+        return Number.NaN;
+    }
+
+    return num;
+}

package/src/index.ts

@@ -0,0 +1,93 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { convertRows } from "./convert.ts";
+import { readCashOperationsSheet } from "./excel.ts";
+import { investmentsToCsv, transactionsToCsv } from "./output.ts";
+
+export interface ConvertFileOptions {
+    inputPath: string;
+    currency: string;
+    account: string;
+    outDir?: string;
+    transactionsOut?: string;
+    investmentsOut?: string;
+    strict?: boolean;
+    dryRun?: boolean;
+    report?: string;
+}
+
+export interface ConvertFileResult {
+    transactionsCsv: string;
+    investmentsCsv: string;
+    transactionsOutPath: string;
+    investmentsOutPath: string;
+    reportData: {
+        inputPath: string;
+        totals: {
+            sourceRows: number;
+            transactionRows: number;
+            investmentRows: number;
+            ignoredRows: number;
+            issues: number;
+        };
+        issues: Array<{ rowIndex: number; operationId?: string; message: string }>;
+    };
+}
+
+export async function convertFile(options: ConvertFileOptions): Promise<ConvertFileResult> {
+    const rows = readCashOperationsSheet(options.inputPath);
+    const result = convertRows(rows, {
+        account: options.account,
+        currency: options.currency,
+        strict: Boolean(options.strict),
+    });
+
+    const transactionsCsv = transactionsToCsv(result.transactions);
+    const investmentsCsv = investmentsToCsv(result.investments);
+
+    const resolvedOutDir = options.outDir
+        ? path.resolve(options.outDir)
+        : path.dirname(path.resolve(options.inputPath));
+    const baseName = path.basename(options.inputPath, path.extname(options.inputPath));
+    const transactionsOutPath = path.resolve(
+        options.transactionsOut ?? path.join(resolvedOutDir, `${baseName}.transactions.csv`),
+    );
+    const investmentsOutPath = path.resolve(
+        options.investmentsOut ?? path.join(resolvedOutDir, `${baseName}.investments.csv`),
+    );
+
+    if (!options.dryRun) {
+        await mkdir(path.dirname(transactionsOutPath), { recursive: true });
+        await mkdir(path.dirname(investmentsOutPath), { recursive: true });
+        await writeFile(transactionsOutPath, transactionsCsv, "utf8");
+        await writeFile(investmentsOutPath, investmentsCsv, "utf8");
+    }
+
+    const reportData = {
+        inputPath: path.resolve(options.inputPath),
+        totals: {
+            sourceRows: rows.length,
+            transactionRows: result.transactions.length,
+            investmentRows: result.investments.length,
+            ignoredRows: result.ignoredRows,
+            issues: result.issues.length,
+        },
+        issues: result.issues,
+    };
+
+    if (options.report) {
+        const reportPath = path.resolve(options.report);
+        if (!options.dryRun) {
+            await mkdir(path.dirname(reportPath), { recursive: true });
+            await writeFile(reportPath, `${JSON.stringify(reportData, null, 2)}\n`, "utf8");
+        }
+    }
+
+    return {
+        transactionsCsv,
+        investmentsCsv,
+        transactionsOutPath,
+        investmentsOutPath,
+        reportData,
+    };
+}

package/src/operations.ts

@@ -0,0 +1,113 @@
+import type { CashOperationRow } from "./types.ts";
+
+const TRANSACTION_TYPES = new Set([
+    "Deposit",
+    "Free funds interest",
+    "Free funds interest tax",
+    "IKE deposit",
+    "IKZE deposit",
+    "Withholding tax",
+]);
+
+const INVESTMENT_TYPES = new Set(["Stock purchase", "Stock sell"]);
+
+export function classifyOperation(type: string): "transaction" | "investment" | "ignored" {
+    if (TRANSACTION_TYPES.has(type)) {
+        return "transaction";
+    }
+
+    if (INVESTMENT_TYPES.has(type)) {
+        return "investment";
+    }
+
+    return "ignored";
+}
+
+export interface ParsedTradeValues {
+    price: string;
+    qty: string;
+    qtyHadExplicitDecimal: boolean;
+}
+
+export function parseTradeValues(comment: string): ParsedTradeValues {
+    const normalized = comment.replace(/,/g, ".");
+    const buySellMatch = normalized.match(
+        /(?:\bBUY\b|\bSELL\b)\s+([+-]?\d+(?:\.\d+)?)(?:\/[+-]?\d+(?:\.\d+)?)?\s*@\s*([+-]?\d+(?:\.\d+)?)/i,
+    );
+
+    const qtyMatch = buySellMatch
+        ? [buySellMatch[0], buySellMatch[1]]
+        : normalized.match(/\b([+-]?\d+(?:\.\d+)?)\b\s*@/);
+    const priceMatch = buySellMatch ? [buySellMatch[0], buySellMatch[2]] : normalized.match(/@\s*([+-]?\d+(?:\.\d+)?)/);
+
+    if (!qtyMatch || !priceMatch) {
+        throw new Error(`Could not parse qty/price from comment: ${comment}`);
+    }
+
+    const rawQty = qtyMatch[1];
+    const rawPrice = priceMatch[1];
+    if (!rawQty || !rawPrice) {
+        throw new Error(`Could not parse qty/price from comment: ${comment}`);
+    }
+
+    return {
+        price: normalizeNumberString(rawPrice),
+        qty: normalizeNumberString(rawQty),
+        qtyHadExplicitDecimal: rawQty.includes("."),
+    };
+}
+
+function normalizeNumberString(value: string): string {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid numeric value: ${value}`);
+    }
+
+    if (value.includes(".") && Number.isInteger(parsed)) {
+        return parsed.toFixed(1);
+    }
+
+    return String(parsed);
+}
+
+export function buildTransactionNotes(row: CashOperationRow): string {
+    const comment = row.Comment?.trim();
+    const base = comment ? `XTB ${row.ID}: ${comment}` : `XTB ${row.ID}`;
+    const product = row.Product?.trim();
+
+    if (!product || product === "IKE" || product === "IKZE") {
+        return base;
+    }
+
+    return `${base} [subaccount: ${product}]`;
+}
+
+export function buildInvestmentName(row: CashOperationRow): string {
+    if (row.Product?.trim() === "IKE") {
+        return `XTB ${row.ID}: ${row.Type}`;
+    }
+
+    const instrument = row.Instrument?.trim();
+    if (instrument) {
+        return `${instrument} - ${row.Type} (XTB ${row.ID})`;
+    }
+
+    return `XTB ${row.ID}: ${row.Type}`;
+}
+
+export function formatQtyOutput(
+    qty: string,
+    instrument: string,
+    qtyHadExplicitDecimal: boolean,
+    product: string,
+): string {
+    if (product.trim() === "IKE") {
+        return qtyHadExplicitDecimal ? qty : String(Number(qty));
+    }
+
+    if (qtyHadExplicitDecimal) {
+        return qty;
+    }
+
+    return instrument.trim() ? `${qty}.0` : qty;
+}

package/src/output.ts

@@ -0,0 +1,24 @@
+import { toCsv } from "./csv.ts";
+import type { InvestmentRecord, TransactionRecord } from "./types.ts";
+
+export function transactionsToCsv(records: TransactionRecord[]): string {
+    return toCsv(
+        ["date", "amount", "name", "account", "notes"],
+        records.map((record) => [record.date, record.amount, record.name, record.account, record.notes]),
+    );
+}
+
+export function investmentsToCsv(records: InvestmentRecord[]): string {
+    return toCsv(
+        ["date", "ticker", "currency", "qty", "price", "account", "name"],
+        records.map((record) => [
+            record.date,
+            record.ticker,
+            record.currency,
+            record.qty,
+            record.price,
+            record.account,
+            record.name,
+        ]),
+    );
+}

package/src/types.ts

@@ -0,0 +1,42 @@
+export interface CashOperationRow {
+    Type: string;
+    Instrument: string;
+    Ticker: string;
+    Time: number;
+    Amount: number;
+    ID: string;
+    Comment: string;
+    Product: string;
+    "Position ID": string;
+}
+
+export interface TransactionRecord {
+    date: string;
+    amount: string;
+    name: string;
+    account: string;
+    notes: string;
+}
+
+export interface InvestmentRecord {
+    date: string;
+    ticker: string;
+    currency: string;
+    qty: string;
+    price: string;
+    account: string;
+    name: string;
+}
+
+interface ConversionIssue {
+    rowIndex: number;
+    operationId?: string;
+    message: string;
+}
+
+export interface ConversionResult {
+    transactions: TransactionRecord[];
+    investments: InvestmentRecord[];
+    ignoredRows: number;
+    issues: ConversionIssue[];
+}