@f-o-t/ofx 1.1.0

package/LICENSE.md

@@ -0,0 +1,10 @@
+
+ MIT License
+
+Copyright (c) 2025 FOT 
+
+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

@@ -0,0 +1,276 @@
+# @fot/ofx
+
+Type-safe OFX (Open Financial Exchange) parser with Zod schema validation.
+
+## Installation
+
+```bash
+bun add @fot/ofx
+```
+
+## Quick Start
+
+```typescript
+import { parse, getTransactions, getBalance } from "@fot/ofx";
+
+const ofxContent = fs.readFileSync("statement.ofx", "utf-8");
+const result = parse(ofxContent);
+
+if (result.success) {
+  const transactions = getTransactions(result.data);
+  const balances = getBalance(result.data);
+
+  for (const txn of transactions) {
+    console.log(`${txn.DTPOSTED.toDate()} - ${txn.NAME}: ${txn.TRNAMT}`);
+  }
+}
+```
+
+## API Reference
+
+### Parsing Functions
+
+#### `parse(content: string): ParseResult<OFXDocument>`
+
+Parses an OFX file content and returns a result object.
+
+```typescript
+const result = parse(ofxContent);
+
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.error(result.error);
+}
+```
+
+#### `parseOrThrow(content: string): OFXDocument`
+
+Parses an OFX file content and throws on validation errors.
+
+```typescript
+try {
+  const doc = parseOrThrow(ofxContent);
+} catch (error) {
+  // ZodError
+}
+```
+
+### Extraction Functions
+
+#### `getTransactions(document: OFXDocument): OFXTransaction[]`
+
+Extracts all transactions from bank and credit card statements.
+
+```typescript
+const transactions = getTransactions(doc);
+
+for (const txn of transactions) {
+  console.log({
+    type: txn.TRNTYPE,
+    amount: txn.TRNAMT,
+    date: txn.DTPOSTED.toDate(),
+    name: txn.NAME,
+    memo: txn.MEMO,
+  });
+}
+```
+
+#### `getAccountInfo(document: OFXDocument): (OFXBankAccount | OFXCreditCardAccount)[]`
+
+Extracts account information from the document.
+
+```typescript
+const accounts = getAccountInfo(doc);
+
+for (const account of accounts) {
+  console.log({
+    accountId: account.ACCTID,
+    bankId: "BANKID" in account ? account.BANKID : undefined,
+    type: "ACCTTYPE" in account ? account.ACCTTYPE : "CREDIT_CARD",
+  });
+}
+```
+
+#### `getBalance(document: OFXDocument): BalanceInfo[]`
+
+Extracts balance information (ledger and available).
+
+```typescript
+const balances = getBalance(doc);
+
+for (const balance of balances) {
+  console.log({
+    ledger: balance.ledger?.BALAMT,
+    available: balance.available?.BALAMT,
+    asOf: balance.ledger?.DTASOF.toDate(),
+  });
+}
+```
+
+#### `getSignOnInfo(document: OFXDocument): OFXSignOnResponse`
+
+Extracts sign-on response information.
+
+```typescript
+const signOn = getSignOnInfo(doc);
+
+console.log({
+  status: signOn.STATUS.CODE,
+  serverDate: signOn.DTSERVER.toDate(),
+  language: signOn.LANGUAGE,
+  institution: signOn.FI?.ORG,
+});
+```
+
+## Types
+
+### OFXTransaction
+
+```typescript
+interface OFXTransaction {
+  TRNTYPE: OFXTransactionType;
+  DTPOSTED: OFXDate;
+  TRNAMT: number;
+  FITID: string;
+  NAME?: string;
+  MEMO?: string;
+  CHECKNUM?: string;
+  REFNUM?: string;
+  DTUSER?: OFXDate;
+  DTAVAIL?: OFXDate;
+  CORRECTFITID?: string;
+  CORRECTACTION?: "DELETE" | "REPLACE";
+  SRVRTID?: string;
+  SIC?: string;
+  PAYEEID?: string;
+  CURRENCY?: string;
+}
+```
+
+### OFXTransactionType
+
+```typescript
+type OFXTransactionType =
+  | "CREDIT"
+  | "DEBIT"
+  | "INT"
+  | "DIV"
+  | "FEE"
+  | "SRVCHG"
+  | "DEP"
+  | "ATM"
+  | "POS"
+  | "XFER"
+  | "CHECK"
+  | "PAYMENT"
+  | "CASH"
+  | "DIRECTDEP"
+  | "DIRECTDEBIT"
+  | "REPEATPMT"
+  | "HOLD"
+  | "OTHER";
+```
+
+### OFXDate
+
+```typescript
+interface OFXDate {
+  raw: string;
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  timezone: { offset: number; name: string };
+  toDate(): Date;
+}
+```
+
+### OFXBankAccount
+
+```typescript
+interface OFXBankAccount {
+  ACCTID: string;
+  BANKID: string;
+  ACCTTYPE: "CHECKING" | "SAVINGS" | "MONEYMRKT" | "CREDITLINE" | "CD";
+  BRANCHID?: string;
+  ACCTKEY?: string;
+}
+```
+
+### OFXCreditCardAccount
+
+```typescript
+interface OFXCreditCardAccount {
+  ACCTID: string;
+  ACCTKEY?: string;
+}
+```
+
+### OFXBalance
+
+```typescript
+interface OFXBalance {
+  BALAMT: number;
+  DTASOF: OFXDate;
+}
+```
+
+### BalanceInfo
+
+```typescript
+interface BalanceInfo {
+  ledger?: OFXBalance;
+  available?: OFXBalance;
+}
+```
+
+## Schemas
+
+All Zod schemas are exported for custom validation:
+
+```typescript
+import { schemas } from "@fot/ofx";
+
+const customTransactionSchema = schemas.transaction.extend({
+  customField: z.string(),
+});
+```
+
+Available schemas:
+
+- `schemas.transaction`
+- `schemas.transactionType`
+- `schemas.transactionList`
+- `schemas.bankAccount`
+- `schemas.creditCardAccount`
+- `schemas.accountType`
+- `schemas.balance`
+- `schemas.status`
+- `schemas.financialInstitution`
+- `schemas.signOnResponse`
+- `schemas.bankStatementResponse`
+- `schemas.creditCardStatementResponse`
+- `schemas.ofxDocument`
+- `schemas.ofxHeader`
+- `schemas.ofxResponse`
+- `schemas.ofxDate`
+
+## Performance
+
+Tested on realistic business statement sizes:
+
+| Transactions | File Size | Parse Time |
+| ------------ | --------- | ---------- |
+| ~10,000      | 2.5 MB    | ~800ms     |
+| ~25,000      | 5.4 MB    | ~1.3s      |
+| ~50,000      | 10.4 MB   | ~4.3s      |
+| ~100,000     | 20.5 MB   | ~27s       |
+
+Extraction operations (`getTransactions`, `getBalance`, etc.) are sub-millisecond even on large datasets.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+declare const ofxDateSchema: unknown;
+type OFXDate = z.infer<typeof ofxDateSchema>;
+declare const statusSchema: unknown;
+type OFXStatus = z.infer<typeof statusSchema>;
+declare const financialInstitutionSchema: unknown;
+type OFXFinancialInstitution = z.infer<typeof financialInstitutionSchema>;
+declare const transactionTypeSchema: unknown;
+type OFXTransactionType = z.infer<typeof transactionTypeSchema>;
+declare const transactionSchema: unknown;
+type OFXTransaction = z.infer<typeof transactionSchema>;
+declare const accountTypeSchema: unknown;
+type OFXAccountType = z.infer<typeof accountTypeSchema>;
+declare const bankAccountSchema: unknown;
+type OFXBankAccount = z.infer<typeof bankAccountSchema>;
+declare const creditCardAccountSchema: unknown;
+type OFXCreditCardAccount = z.infer<typeof creditCardAccountSchema>;
+declare const balanceSchema: unknown;
+type OFXBalance = z.infer<typeof balanceSchema>;
+declare const transactionListSchema: unknown;
+type OFXTransactionList = z.infer<typeof transactionListSchema>;
+declare const bankStatementResponseSchema: unknown;
+type OFXBankStatementResponse = z.infer<typeof bankStatementResponseSchema>;
+declare const creditCardStatementResponseSchema: unknown;
+type OFXCreditCardStatementResponse = z.infer<typeof creditCardStatementResponseSchema>;
+declare const signOnResponseSchema: unknown;
+type OFXSignOnResponse = z.infer<typeof signOnResponseSchema>;
+declare const bankStatementTransactionResponseSchema: unknown;
+type OFXBankStatementTransactionResponse = z.infer<typeof bankStatementTransactionResponseSchema>;
+declare const creditCardStatementTransactionResponseSchema: unknown;
+type OFXCreditCardStatementTransactionResponse = z.infer<typeof creditCardStatementTransactionResponseSchema>;
+declare const bankMessageSetResponseSchema: unknown;
+type OFXBankMessageSetResponse = z.infer<typeof bankMessageSetResponseSchema>;
+declare const creditCardMessageSetResponseSchema: unknown;
+type OFXCreditCardMessageSetResponse = z.infer<typeof creditCardMessageSetResponseSchema>;
+declare const signOnMessageSetResponseSchema: unknown;
+type OFXSignOnMessageSetResponse = z.infer<typeof signOnMessageSetResponseSchema>;
+declare const ofxResponseSchema: unknown;
+type OFXResponse = z.infer<typeof ofxResponseSchema>;
+declare const ofxHeaderSchema: unknown;
+type OFXHeader = z.infer<typeof ofxHeaderSchema>;
+declare const ofxDocumentSchema: unknown;
+type OFXDocument = z.infer<typeof ofxDocumentSchema>;
+declare const schemas: {};
+type ParseResult<T> = {
+	success: true;
+	data: T;
+} | {
+	success: false;
+	error: z.ZodError;
+};
+declare function parse(content: string): ParseResult<OFXDocument>;
+declare function parseOrThrow(content: string): OFXDocument;
+declare function getTransactions(document: OFXDocument): OFXTransaction[];
+declare function getAccountInfo(document: OFXDocument): (OFXBankAccount | OFXCreditCardAccount)[];
+interface BalanceInfo {
+	ledger?: OFXBalance;
+	available?: OFXBalance;
+}
+declare function getBalance(document: OFXDocument): BalanceInfo[];
+declare function getSignOnInfo(document: OFXDocument): OFXSignOnResponse;
+export { schemas, parseOrThrow, parse, getTransactions, getSignOnInfo, getBalance, getAccountInfo, ParseResult, OFXTransactionType, OFXTransactionList, OFXTransaction, OFXStatus, OFXSignOnResponse, OFXSignOnMessageSetResponse, OFXResponse, OFXHeader, OFXFinancialInstitution, OFXDocument, OFXDate, OFXCreditCardStatementTransactionResponse, OFXCreditCardStatementResponse, OFXCreditCardMessageSetResponse, OFXCreditCardAccount, OFXBankStatementTransactionResponse, OFXBankStatementResponse, OFXBankMessageSetResponse, OFXBankAccount, OFXBalance, OFXAccountType, BalanceInfo };

package/dist/index.js

@@ -0,0 +1,357 @@
+// src/index.ts
+import { z } from "zod";
+var toInt = (val) => Number.parseInt(val, 10);
+var toFloat = (val) => Number.parseFloat(val);
+var toArray = (value) => Array.isArray(value) ? value : [value];
+function parseDateComponents(val) {
+  return {
+    day: toInt(val.substring(6, 8)),
+    hour: toInt(val.substring(8, 10) || "0"),
+    minute: toInt(val.substring(10, 12) || "0"),
+    month: toInt(val.substring(4, 6)),
+    second: toInt(val.substring(12, 14) || "0"),
+    year: toInt(val.substring(0, 4))
+  };
+}
+function parseTimezone(val) {
+  const match = val.match(/\[([+-]?\d+):(\w+)\]/);
+  return {
+    name: match?.[2] ?? "UTC",
+    offset: match ? toInt(match[1] ?? "0") : 0
+  };
+}
+var ofxDateSchema = z.string().transform((val) => {
+  const components = parseDateComponents(val);
+  const timezone = parseTimezone(val);
+  return {
+    ...components,
+    raw: val,
+    timezone,
+    toDate() {
+      const offsetMs = timezone.offset * 60 * 60 * 1000;
+      return new Date(Date.UTC(components.year, components.month - 1, components.day, components.hour, components.minute, components.second) - offsetMs);
+    }
+  };
+});
+var statusSchema = z.object({
+  CODE: z.string(),
+  MESSAGE: z.string().optional(),
+  SEVERITY: z.enum(["INFO", "WARN", "ERROR"])
+});
+var financialInstitutionSchema = z.object({
+  FID: z.string().optional(),
+  ORG: z.string().optional()
+});
+var transactionTypeSchema = z.enum([
+  "CREDIT",
+  "DEBIT",
+  "INT",
+  "DIV",
+  "FEE",
+  "SRVCHG",
+  "DEP",
+  "ATM",
+  "POS",
+  "XFER",
+  "CHECK",
+  "PAYMENT",
+  "CASH",
+  "DIRECTDEP",
+  "DIRECTDEBIT",
+  "REPEATPMT",
+  "HOLD",
+  "OTHER"
+]);
+var transactionSchema = z.object({
+  CHECKNUM: z.string().optional(),
+  CORRECTACTION: z.enum(["DELETE", "REPLACE"]).optional(),
+  CORRECTFITID: z.string().optional(),
+  CURRENCY: z.string().optional(),
+  DTAVAIL: ofxDateSchema.optional(),
+  DTPOSTED: ofxDateSchema,
+  DTUSER: ofxDateSchema.optional(),
+  FITID: z.string(),
+  MEMO: z.string().optional(),
+  NAME: z.string().optional(),
+  PAYEEID: z.string().optional(),
+  REFNUM: z.string().optional(),
+  SIC: z.string().optional(),
+  SRVRTID: z.string().optional(),
+  TRNAMT: z.string().transform(toFloat),
+  TRNTYPE: transactionTypeSchema
+});
+var accountTypeSchema = z.enum([
+  "CHECKING",
+  "SAVINGS",
+  "MONEYMRKT",
+  "CREDITLINE",
+  "CD"
+]);
+var bankAccountSchema = z.object({
+  ACCTID: z.string(),
+  ACCTKEY: z.string().optional(),
+  ACCTTYPE: accountTypeSchema,
+  BANKID: z.string(),
+  BRANCHID: z.string().optional()
+});
+var creditCardAccountSchema = z.object({
+  ACCTID: z.string(),
+  ACCTKEY: z.string().optional()
+});
+var balanceSchema = z.object({
+  BALAMT: z.string().transform(toFloat),
+  DTASOF: ofxDateSchema
+});
+var transactionListSchema = z.object({
+  DTEND: ofxDateSchema,
+  DTSTART: ofxDateSchema,
+  STMTTRN: z.array(transactionSchema).default([])
+});
+var bankStatementResponseSchema = z.object({
+  AVAILBAL: balanceSchema.optional(),
+  BANKACCTFROM: bankAccountSchema,
+  BANKTRANLIST: transactionListSchema.optional(),
+  CURDEF: z.string().default("USD"),
+  LEDGERBAL: balanceSchema.optional(),
+  MKTGINFO: z.string().optional()
+});
+var creditCardStatementResponseSchema = z.object({
+  AVAILBAL: balanceSchema.optional(),
+  BANKTRANLIST: transactionListSchema.optional(),
+  CCACCTFROM: creditCardAccountSchema,
+  CURDEF: z.string().default("USD"),
+  LEDGERBAL: balanceSchema.optional(),
+  MKTGINFO: z.string().optional()
+});
+var signOnResponseSchema = z.object({
+  ACCESSKEY: z.string().optional(),
+  DTSERVER: ofxDateSchema,
+  FI: financialInstitutionSchema.optional(),
+  LANGUAGE: z.string().default("ENG"),
+  SESSCOOKIE: z.string().optional(),
+  STATUS: statusSchema
+});
+var bankStatementTransactionResponseSchema = z.object({
+  STATUS: statusSchema,
+  STMTRS: bankStatementResponseSchema.optional(),
+  TRNUID: z.string()
+});
+var creditCardStatementTransactionResponseSchema = z.object({
+  CCSTMTRS: creditCardStatementResponseSchema.optional(),
+  STATUS: statusSchema,
+  TRNUID: z.string()
+});
+var singleOrArray = (schema) => z.union([schema, z.array(schema)]).optional();
+var bankMessageSetResponseSchema = z.object({
+  STMTTRNRS: singleOrArray(bankStatementTransactionResponseSchema)
+});
+var creditCardMessageSetResponseSchema = z.object({
+  CCSTMTTRNRS: singleOrArray(creditCardStatementTransactionResponseSchema)
+});
+var signOnMessageSetResponseSchema = z.object({
+  SONRS: signOnResponseSchema
+});
+var ofxResponseSchema = z.object({
+  BANKMSGSRSV1: bankMessageSetResponseSchema.optional(),
+  CREDITCARDMSGSRSV1: creditCardMessageSetResponseSchema.optional(),
+  SIGNONMSGSRSV1: signOnMessageSetResponseSchema
+});
+var ofxHeaderSchema = z.object({
+  CHARSET: z.string().optional(),
+  COMPRESSION: z.string().optional(),
+  DATA: z.string().optional(),
+  ENCODING: z.string().optional(),
+  NEWFILEUID: z.string().optional(),
+  OFXHEADER: z.string().optional(),
+  OLDFILEUID: z.string().optional(),
+  SECURITY: z.string().optional(),
+  VERSION: z.string().optional()
+});
+var ofxDocumentSchema = z.object({
+  header: ofxHeaderSchema,
+  OFX: ofxResponseSchema
+});
+var schemas = {
+  accountType: accountTypeSchema,
+  balance: balanceSchema,
+  bankAccount: bankAccountSchema,
+  bankMessageSetResponse: bankMessageSetResponseSchema,
+  bankStatementResponse: bankStatementResponseSchema,
+  bankStatementTransactionResponse: bankStatementTransactionResponseSchema,
+  creditCardAccount: creditCardAccountSchema,
+  creditCardMessageSetResponse: creditCardMessageSetResponseSchema,
+  creditCardStatementResponse: creditCardStatementResponseSchema,
+  creditCardStatementTransactionResponse: creditCardStatementTransactionResponseSchema,
+  financialInstitution: financialInstitutionSchema,
+  ofxDate: ofxDateSchema,
+  ofxDocument: ofxDocumentSchema,
+  ofxHeader: ofxHeaderSchema,
+  ofxResponse: ofxResponseSchema,
+  signOnMessageSetResponse: signOnMessageSetResponseSchema,
+  signOnResponse: signOnResponseSchema,
+  status: statusSchema,
+  transaction: transactionSchema,
+  transactionList: transactionListSchema,
+  transactionType: transactionTypeSchema
+};
+function parseHeader(content) {
+  const lines = content.split(/\r?\n/);
+  const header = {};
+  let bodyStartIndex = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i]?.trim() ?? "";
+    if (line.startsWith("<?xml") || line.startsWith("<OFX>")) {
+      bodyStartIndex = i;
+      break;
+    }
+    const match = line.match(/^(\w+):(.*)$/);
+    if (match?.[1] && match[2] !== undefined) {
+      header[match[1]] = match[2];
+    }
+    if (line === "" && Object.keys(header).length > 0) {
+      bodyStartIndex = i + 1;
+      break;
+    }
+  }
+  const body = lines.slice(bodyStartIndex).join(`
+`);
+  return { body, header: ofxHeaderSchema.parse(header) };
+}
+function addToContent(content, key, value) {
+  const existing = content[key];
+  if (existing !== undefined) {
+    content[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+  } else {
+    content[key] = value;
+  }
+}
+function sgmlToObject(sgml) {
+  const result = {};
+  const tagStack = [{ content: result, name: "root" }];
+  const cleanSgml = sgml.replace(/<\?.*?\?>/g, "").replace(/<!--.*?-->/gs, "").trim();
+  const tagRegex = /<(\/?)([\w.]+)>([^<]*)/g;
+  let match = tagRegex.exec(cleanSgml);
+  while (match !== null) {
+    const isClosing = match[1];
+    const tagName = match[2];
+    const textContent = match[3]?.trim() ?? "";
+    if (!tagName) {
+      match = tagRegex.exec(cleanSgml);
+      continue;
+    }
+    const current = tagStack[tagStack.length - 1];
+    if (!current) {
+      match = tagRegex.exec(cleanSgml);
+      continue;
+    }
+    if (isClosing) {
+      if (tagStack.length > 1) {
+        tagStack.pop();
+      }
+    } else if (textContent) {
+      addToContent(current.content, tagName, textContent);
+    } else {
+      const newObj = {};
+      addToContent(current.content, tagName, newObj);
+      tagStack.push({ content: newObj, name: tagName });
+    }
+    match = tagRegex.exec(cleanSgml);
+  }
+  return result;
+}
+function processObject(obj) {
+  const processed = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "STMTTRN") {
+      processed[key] = toArray(value).map((v) => typeof v === "object" && v !== null ? processObject(v) : v);
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      processed[key] = processObject(value);
+    } else {
+      processed[key] = value;
+    }
+  }
+  return processed;
+}
+function normalizeTransactions(data) {
+  return processObject(data);
+}
+function parse(content) {
+  try {
+    const { header, body } = parseHeader(content);
+    const rawData = sgmlToObject(body);
+    const normalizedData = normalizeTransactions(rawData);
+    const parseResult = ofxResponseSchema.safeParse(normalizedData.OFX);
+    if (!parseResult.success) {
+      return { error: parseResult.error, success: false };
+    }
+    return {
+      data: { header, OFX: parseResult.data },
+      success: true
+    };
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return { error: err, success: false };
+    }
+    throw err;
+  }
+}
+function parseOrThrow(content) {
+  const result = parse(content);
+  if (!result.success) {
+    throw result.error;
+  }
+  return result.data;
+}
+function extractFromBankResponses(document, extractor) {
+  const bankResponse = document.OFX.BANKMSGSRSV1?.STMTTRNRS;
+  if (!bankResponse)
+    return [];
+  const results = [];
+  for (const response of toArray(bankResponse)) {
+    const result = extractor(response);
+    if (result !== undefined) {
+      results.push(result);
+    }
+  }
+  return results;
+}
+function extractFromCreditCardResponses(document, extractor) {
+  const ccResponse = document.OFX.CREDITCARDMSGSRSV1?.CCSTMTTRNRS;
+  if (!ccResponse)
+    return [];
+  const results = [];
+  for (const response of toArray(ccResponse)) {
+    const result = extractor(response);
+    if (result !== undefined) {
+      results.push(result);
+    }
+  }
+  return results;
+}
+function getTransactions(document) {
+  const bankTransactions = extractFromBankResponses(document, (r) => r.STMTRS?.BANKTRANLIST?.STMTTRN);
+  const ccTransactions = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS?.BANKTRANLIST?.STMTTRN);
+  return [...bankTransactions, ...ccTransactions].flat();
+}
+function getAccountInfo(document) {
+  const bankAccounts = extractFromBankResponses(document, (r) => r.STMTRS?.BANKACCTFROM);
+  const ccAccounts = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS?.CCACCTFROM);
+  return [...bankAccounts, ...ccAccounts];
+}
+function getBalance(document) {
+  const bankBalances = extractFromBankResponses(document, (r) => r.STMTRS ? { available: r.STMTRS.AVAILBAL, ledger: r.STMTRS.LEDGERBAL } : undefined);
+  const ccBalances = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS ? { available: r.CCSTMTRS.AVAILBAL, ledger: r.CCSTMTRS.LEDGERBAL } : undefined);
+  return [...bankBalances, ...ccBalances];
+}
+function getSignOnInfo(document) {
+  return document.OFX.SIGNONMSGSRSV1.SONRS;
+}
+export {
+  schemas,
+  parseOrThrow,
+  parse,
+  getTransactions,
+  getSignOnInfo,
+  getBalance,
+  getAccountInfo
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+   "bugs": {
+      "url": "https://github.com/F-O-T/montte-nx/issues"
+   },
+   "dependencies": {
+      "zod": "4.1.13"
+   },
+   "description": "Typesafe ofx handling",
+   "devDependencies": {
+      "@biomejs/biome": "^2.3.7",
+      "@types/bun": "1.3.3",
+      "bumpp": "10.3.2",
+      "bunup": "0.16.10",
+      "simple-git-hooks": "2.13.1",
+      "typescript": "5.9.3"
+   },
+   "exports": {
+      ".": {
+         "import": {
+            "default": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+         }
+      },
+      "./package.json": "./package.json"
+   },
+   "files": [
+      "dist"
+   ],
+   "homepage": "https://github.com/F-O-T/montte-nx#readme",
+   "license": "MIT",
+   "module": "./dist/index.js",
+   "name": "@f-o-t/ofx",
+   "peerDependencies": {
+      "typescript": ">=4.5.0"
+   },
+   "peerDependenciesMeta": {
+      "typescript": {
+         "optional": true
+      }
+   },
+   "private": false,
+   "publishConfig": {
+      "access": "public"
+   },
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/F-O-T/montte-nx.git"
+   },
+   "scripts": {
+      "build": "bunup",
+      "dev": "bunup --watch",
+      "lint": "biome check .",
+      "lint:fix": "biome check --write .",
+      "postinstall": "bun simple-git-hooks",
+      "release": "bumpp --commit --push --tag",
+      "test": "bun test",
+      "test:coverage": "bun test --coverage",
+      "test:watch": "bun test --watch",
+      "type-check": "tsc --noEmit"
+   },
+   "simple-git-hooks": {
+      "pre-commit": "bun run lint && bun run type-check"
+   },
+   "type": "module",
+   "types": "./dist/index.d.ts",
+   "version": "1.1.0"
+}