@actual-app/api 6.7.1 → 6.8.0

package/@types/loot-core/mocks/index.d.ts

@@ -0,0 +1,26 @@
+export declare function generateAccount(name: any, isConnected: any, offbudget: any): {
+    id: string;
+    name: any;
+    balance_current: number;
+    bank: number;
+    bankId: number;
+    bankName: string;
+    offbudget: number;
+    closed: number;
+};
+export declare function generateCategory(name: any, group: any, isIncome?: boolean): {
+    id: string;
+    name: any;
+    cat_group: any;
+    is_income: number;
+    sort_order: number;
+};
+export declare function generateCategoryGroup(name: any, isIncome?: boolean): {
+    id: string;
+    name: any;
+    is_income: number;
+    sort_order: number;
+};
+export declare function generateCategoryGroups(definition: any): any;
+export declare function generateTransaction(data: any, splitAmount?: any, showError?: boolean): any[];
+export declare function generateTransactions(count: any, accountId: any, groupId: any, splitAtIndexes?: any[], showError?: boolean): any[];

package/@types/loot-core/mocks/random.d.ts

@@ -0,0 +1 @@
+export declare const random: () => number;

package/@types/loot-core/mocks/util.d.ts

@@ -0,0 +1,7 @@
+export declare function expectSnapshotWithDiffer(initialValue: any, { onlyUpdates }?: {
+    onlyUpdates?: any;
+}): {
+    expectToMatchDiff: (value: any) => void;
+};
+export declare function getFixtures(filename: any): void;
+export declare function debugDOM(node: any): string;

package/@types/loot-core/platform/client/fetch/index.d.ts

@@ -0,0 +1,48 @@
+import type { Handlers } from '../../../types/handlers';
+import type { ServerEvents } from '../../../types/server-events';
+
+export function init(socketName: string): Promise<unknown>;
+export type Init = typeof init;
+
+export function send<K extends keyof Handlers>(
+  name: K,
+  args?: Parameters<Handlers[K]>[0],
+  options?: { catchErrors: true },
+): ReturnType<
+  | { data: Handlers[K] }
+  | { error: { type: 'APIError' | 'InternalError'; message: string } }
+>;
+export function send<K extends keyof Handlers>(
+  name: K,
+  args?: Parameters<Handlers[K]>[0],
+  options?: { catchErrors?: boolean },
+): ReturnType<Handlers[K]>;
+export type Send = typeof send;
+
+export function sendCatch<K extends keyof Handlers>(
+  name: K,
+  args?: Parameters<Handlers[K]>[0],
+): ReturnType<
+  | { data: Handlers[K] }
+  | { error: { type: 'APIError' | 'InternalError'; message: string } }
+>;
+export type SendCatch = typeof sendCatch;
+
+export function listen<K extends keyof ServerEvents>(
+  name: K,
+  cb: (arg: ServerEvents[K]) => void,
+): () => void;
+export type Listen = typeof listen;
+
+export function unlisten(name: string): void;
+export type Unlisten = typeof unlisten;
+
+/** Mock functions */
+export function initServer(handlers: unknown): void;
+export type InitServer = typeof initServer;
+
+export function serverPush(name: string, args: unknown): void;
+export type ServerPush = typeof serverPush;
+
+export async function clearServer(): void;
+export type ClearServer = typeof clearServer;

package/@types/loot-core/platform/client/undo/index.d.ts

@@ -0,0 +1,29 @@
+import { type ModalType } from '../../client/state-types/modals';
+
+export type UndoState = {
+  id?: string;
+  url: unknown;
+  openModal: ModalType;
+  selectedItems: {
+    name: string;
+    items: Set<string>;
+  } | null;
+};
+
+export function setUndoState<K extends keyof Omit<UndoState, 'id'>>(
+  name: K,
+  value: UndoState[K],
+): void;
+export type SetUndoState = typeof setUndoState;
+
+export function getUndoState<K extends keyof UndoState>(name: K): UndoState[K];
+export type GetUndoState = typeof getUndoState;
+
+export function getTaggedState(id: string): UndoState | undefined;
+export type GetTaggedState = typeof getTaggedState;
+
+export function snapshot(): string;
+export type Snapshot = typeof snapshot;
+
+export function gc(id: string): void;
+export type Gc = typeof gc;

package/@types/loot-core/platform/exceptions/index.d.ts

@@ -0,0 +1,5 @@
+export function captureException(exc: Error): void;
+export type CaptureException = typeof captureException;
+
+export function captureBreadcrumb(breadcrumb: unknown): void;
+export type CaptureBreadcrumb = typeof captureBreadcrumb;

package/@types/loot-core/platform/server/asyncStorage/index.d.ts

@@ -0,0 +1,20 @@
+export function init(opts?: { persist?: boolean }): void;
+export type Init = typeof init;
+
+export function getItem(key: string): Promise<string>;
+export type GetItem = typeof getItem;
+
+export function setItem(key: string, value: unknown): void;
+export type SetItem = typeof setItem;
+
+export function removeItem(key: string): void;
+export type RemoveItem = typeof removeItem;
+
+export function multiGet(keys: string[]): Promise<[string, string][]>;
+export type MultiGet = typeof multiGet;
+
+export function multiSet(keyValues: [string, unknown][]): void;
+export type MultiSet = typeof multiSet;
+
+export function multiRemove(keys: string[]): void;
+export type MultiRemove = typeof multiRemove;

package/@types/loot-core/platform/server/connection/index.d.ts

@@ -0,0 +1,23 @@
+import type { Handlers } from '../../../types/handlers';
+import type { ServerEvents } from '../../../types/server-events';
+
+export function init(
+  channel: Window | number, // in electron the port number, in web the worker
+  handlers: Handlers,
+): void;
+export type Init = typeof init;
+
+export function send<K extends keyof ServerEvents>(
+  type: K,
+  args?: ServerEvents[k],
+): void;
+export type Send = typeof send;
+
+export function getEvents(): unknown[];
+export type GetEvents = typeof getEvents;
+
+export function getNumClients(): number;
+export type GetNumClients = typeof getNumClients;
+
+export function resetEvents(): void;
+export type ResetEvents = typeof resetEvents;

package/@types/loot-core/platform/server/fetch/index.d.ts

@@ -0,0 +1,4 @@
+export function fetch(
+  input: RequestInfo | URL,
+  options?: unknown,
+): Promise<Response>;

package/@types/loot-core/platform/server/fs/index.d.ts

@@ -0,0 +1,71 @@
+export { join } from './path-join';
+
+export function init(): void;
+export type Init = typeof init;
+
+export function getDataDir(): string;
+export type GetDataDir = typeof getDataDir;
+
+export function _setDocumentDir(dir: string): string;
+export type _setDocumentDir = typeof _setDocumentDir;
+
+export function getDocumentDir(): string;
+export type GetDocumentDir = typeof getDocumentDir;
+
+export function getBudgetDir(id: string): string;
+export type GetBudgetDir = typeof getBudgetDir;
+
+export const bundledDatabasePath: string;
+export type BundledDatabasePath = typeof bundledDatabasePath;
+
+export const migrationsPath: string;
+export type MigrationsPath = typeof migrationsPath;
+
+export const demoBudgetPath: string;
+export type DemoBudgetPath = typeof demoBudgetPath;
+
+export function pathToId(filepath: string): string;
+export type PathToId = typeof pathToId;
+
+export function basename(filepath: string): string;
+export type Basename = typeof basename;
+
+export function listDir(filepath: string): Promise<string[]>;
+export type ListDir = typeof listDir;
+
+export function exists(filepath: string): Promise<boolean>;
+export type Exists = typeof exists;
+
+export function mkdir(filepath: string): Promise<undefined>;
+export type Mkdir = typeof mkdir;
+
+export function size(filepath: string): Promise<undefined>;
+export type Size = typeof size;
+
+export function copyFile(frompath: string, topath: string): Promise<undefined>;
+export type CopyFile = typeof copyFile;
+
+export function readFile(
+  filepath: string,
+  encoding: 'binary' | null,
+): Promise<Buffer>;
+export function readFile(filepath: string, encoding?: 'utf8'): Promise<string>;
+export type ReadFile = typeof readFile;
+
+export function writeFile(
+  filepath: string,
+  contents: string | ArrayBuffer | NodeJS.ArrayBufferView,
+): Promise<undefined>;
+export type WriteFile = typeof writeFile;
+
+export function removeFile(filepath: string): Promise<undefined>;
+export type RemoveFile = typeof removeFile;
+
+export function removeDir(dirpath: string): Promise<undefined>;
+export type RemoveDir = typeof removeDir;
+
+export function removeDirRecursively(dirpath: string): Promise<undefined>;
+export type RemoveDirRecursively = typeof removeDirRecursively;
+
+export function getModifiedTime(filepath: string): Promise<string>;
+export type GetModifiedTime = typeof getModifiedTime;

package/@types/loot-core/platform/server/fs/path-join.d.ts

@@ -0,0 +1,2 @@
+export function join(...args: string[]): string;
+export type Join = typeof join;

package/@types/loot-core/platform/server/indexeddb/index.d.ts

@@ -0,0 +1,24 @@
+export function getDatabase();
+export type GetDatabase = typeof getDatabase;
+
+export function openDatabase();
+export type OpenDatabase = typeof openDatabase;
+
+export function closeDatabase();
+export type CloseDatabase = typeof closeDatabase;
+
+export function getStore(db: IDBDatabase, name: string);
+export type GetStore = typeof getStore;
+
+export function get(
+  store: IDBObjectStore,
+  key: IDBValidKey | IDBKeyRange,
+  mapper?: (v: unknown) => unknown,
+);
+export type Get = typeof get;
+
+export function set(store: IDBObjectStore, value: unknown);
+export type Set = typeof set;
+
+export function del(store: IDBObjectStore, key: IDBValidKey);
+export type Del = typeof del;

package/@types/loot-core/platform/server/log/index.d.ts

@@ -0,0 +1,9 @@
+import { type Transports } from 'electron-log';
+
+export interface Logger {
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  transports?: Transports;
+}
+
+export const logger: Logger;

package/@types/loot-core/platform/server/sqlite/index.d.ts

@@ -0,0 +1,35 @@
+import { type Database } from 'better-sqlite3';
+
+export async function init(): unknown;
+
+export function _getModule(): SqlJsStatic;
+
+export function prepare(db, sql): unknown;
+
+export function runQuery(
+  db: Database,
+  sql: string,
+  params?: (string | number)[],
+  fetchAll?: false,
+): { changes: unknown };
+export function runQuery<T>(
+  db: Database,
+  sql: string,
+  params: (string | number)[],
+  fetchAll: true,
+): T[];
+
+export function execQuery(db: Database, sql): void;
+
+export function transaction(db: Database, fn: () => void): void;
+
+export async function asyncTransaction(
+  db: Database,
+  fn: () => Promise<void>,
+): Promise<void>;
+
+export async function openDatabase(pathOrBuffer?: string | Buffer): Database;
+
+export function closeDatabase(db: Database): void;
+
+export async function exportDatabase(db: Database): Promise<Uint8Array>;

package/@types/loot-core/server/accounts/export-to-csv.d.ts

@@ -0,0 +1,2 @@
+export declare function exportToCSV(transactions: any, accounts: any, categoryGroups: any, payees: any): Promise<string>;
+export declare function exportQueryToCSV(query: any): Promise<string>;

package/@types/loot-core/server/accounts/link.d.ts

@@ -0,0 +1 @@
+export declare function findOrCreateBank(institution: any, requisitionId: any): Promise<any>;

package/@types/loot-core/server/accounts/ofx2json.d.ts

@@ -0,0 +1,14 @@
+type OFXTransaction = {
+    amount: string;
+    fitId: string;
+    name: string;
+    date: string;
+    memo: string;
+    type: string;
+};
+type OFXParseResult = {
+    headers: Record<string, unknown>;
+    transactions: OFXTransaction[];
+};
+export declare function ofx2json(ofx: string): Promise<OFXParseResult>;
+export {};

package/@types/loot-core/server/accounts/parse-file.d.ts

@@ -0,0 +1,15 @@
+type ParseError = {
+    message: string;
+    internal: string;
+};
+export type ParseFileResult = {
+    errors?: ParseError[];
+    transactions?: unknown[];
+};
+type ParseFileOptions = {
+    hasHeaderRow?: boolean;
+    delimiter?: string;
+    fallbackMissingPayeeToMemo?: boolean;
+};
+export declare function parseFile(filepath: string, options?: ParseFileOptions): Promise<ParseFileResult>;
+export {};

package/@types/loot-core/server/accounts/payees.d.ts

@@ -0,0 +1,5 @@
+export declare function createPayee(description: any): Promise<any>;
+export declare function getStartingBalancePayee(): Promise<{
+    id: any;
+    category: any;
+}>;

package/@types/loot-core/server/accounts/qif2json.d.ts

@@ -0,0 +1,26 @@
+type Division = {
+    category?: string;
+    subcategory?: string;
+    description?: string;
+    amount?: number;
+};
+type QIFTransaction = {
+    date?: string;
+    amount?: string;
+    number?: string;
+    memo?: string;
+    address?: string[];
+    clearedStatus?: string;
+    category?: string;
+    subcategory?: string;
+    payee?: string;
+    division?: Division[];
+};
+export declare function qif2json(qif: any, options?: {
+    dateFormat?: string;
+}): {
+    dateFormat: string | undefined;
+    type?: any;
+    transactions: QIFTransaction[];
+};
+export {};

package/@types/loot-core/server/accounts/rules.d.ts

@@ -0,0 +1,90 @@
+export declare function parseDateString(str: any): {
+    type: string;
+    date: string;
+};
+export declare class Condition {
+    field: any;
+    op: any;
+    options: any;
+    rawValue: any;
+    type: any;
+    unparsedValue: any;
+    value: any;
+    constructor(op: any, field: any, value: any, options: any, fieldTypes: any);
+    eval(object: any): any;
+    getValue(): any;
+    serialize(): {
+        options: any;
+        op: any;
+        field: any;
+        value: any;
+        type: any;
+    };
+}
+declare const ACTION_OPS: readonly ["set", "set-split-amount", "link-schedule"];
+type ActionOperator = (typeof ACTION_OPS)[number];
+export declare class Action {
+    field: any;
+    op: ActionOperator;
+    options: any;
+    rawValue: any;
+    type: any;
+    value: any;
+    constructor(op: ActionOperator, field: any, value: any, options: any, fieldTypes: any);
+    exec(object: any): void;
+    serialize(): {
+        options: any;
+        op: "set" | "set-split-amount" | "link-schedule";
+        field: any;
+        value: any;
+        type: any;
+    };
+}
+export declare function execActions(actions: Action[], transaction: any): any;
+export declare class Rule {
+    actions: any;
+    conditions: any;
+    conditionsOp: any;
+    id: any;
+    stage: any;
+    constructor({ id, stage, conditionsOp, conditions, actions, fieldTypes, }: {
+        id?: string;
+        stage?: any;
+        conditionsOp: any;
+        conditions: any;
+        actions: any;
+        fieldTypes: any;
+    });
+    evalConditions(object: any): any;
+    execActions<T>(object: T): Partial<T>;
+    exec(object: any): Partial<any>;
+    apply(object: any): any;
+    getId(): any;
+    serialize(): {
+        id: any;
+        stage: any;
+        conditionsOp: any;
+        conditions: any;
+        actions: any;
+    };
+}
+export declare class RuleIndexer {
+    field: any;
+    method: any;
+    rules: any;
+    constructor({ field, method }: {
+        field: string;
+        method?: string;
+    });
+    getIndex(key: any): any;
+    getIndexForValue(value: any): any;
+    getKey(value: any): string;
+    getIndexes(rule: any): any[];
+    index(rule: any): void;
+    remove(rule: any): void;
+    getApplicableRules(object: any): Set<unknown>;
+}
+export declare function rankRules(rules: any): any[];
+export declare function migrateIds(rule: any, mappings: any): void;
+export declare function iterateIds(rules: any, fieldName: any, func: any): void;
+export {};

package/@types/loot-core/server/accounts/sync.d.ts

@@ -0,0 +1,13 @@
+export declare function getGoCardlessAccounts(userId: any, userKey: any, id: any): Promise<any>;
+export declare function reconcileTransactions(acctId: any, transactions: any, isBankSyncAccount?: boolean): Promise<{
+    added: any[];
+    updated: any[];
+}>;
+export declare function addTransactions(acctId: any, transactions: any, { runTransfers, learnCategories }?: {
+    runTransfers?: boolean;
+    learnCategories?: boolean;
+}): Promise<any>;
+export declare function syncAccount(userId: string, userKey: string, id: string, acctId: string, bankId: string): Promise<{
+    added: any[];
+    updated: any[];
+}>;

package/@types/loot-core/server/accounts/title/index.d.ts

@@ -0,0 +1,3 @@
+export declare function title(str: any, options?: {
+    special: any;
+}): any;

package/@types/loot-core/server/accounts/title/lower-case.d.ts

@@ -0,0 +1 @@
+export declare const lowerCaseSet: Set<string>;

package/@types/loot-core/server/accounts/title/specials.d.ts

@@ -0,0 +1 @@
+export declare const specials: string[];

package/@types/loot-core/server/accounts/transaction-rules.d.ts

@@ -0,0 +1,47 @@
+import { type TransactionEntity, type RuleActionEntity, type RuleEntity } from '../../types/models';
+import { Action } from './rules';
+export { iterateIds } from './rules';
+export declare function resetState(): void;
+export declare function parseConditionsOrActions(str: any): any[];
+export declare function serializeConditionsOrActions(arr: any): string;
+export declare const ruleModel: {
+    validate(rule: any, { update }?: {
+        update?: boolean;
+    }): any;
+    toJS(row: any): any;
+    fromJS(rule: any): any;
+};
+export declare function makeRule(data: any): any;
+export declare function loadRules(): Promise<void>;
+export declare function getRules(): any[];
+export declare function insertRule(rule: Omit<RuleEntity, 'id'> & {
+    id?: string;
+}): Promise<any>;
+export declare function updateRule(rule: any): Promise<void>;
+export declare function deleteRule<T extends {
+    id: string;
+}>(rule: T): Promise<false | void>;
+export declare function runRules(trans: any): any;
+export declare function conditionsToAQL(conditions: any, { recurDateBounds }?: {
+    recurDateBounds?: number;
+}): {
+    filters: any;
+    errors: any[];
+};
+export declare function applyActions(transactions: TransactionEntity[], actions: Array<Action | RuleActionEntity>): Promise<{
+    added: TransactionEntity[];
+    updated: TransactionEntity[] | ({
+        id: any;
+        transfer_id: any;
+    } | {
+        id: any;
+        payee: any;
+    } | {
+        id: any;
+        category: any;
+    })[];
+}>;
+export declare function getRulesForPayee(payeeId: any): any[];
+export declare function updatePayeeRenameRule(fromNames: string[], to: string): Promise<any>;
+export declare function getProbableCategory(transactions: any): any;
+export declare function updateCategoryRules(transactions: any): Promise<void>;

package/@types/loot-core/server/accounts/transactions.d.ts

@@ -0,0 +1,33 @@
+import { TransactionEntity } from '../../types/models';
+export declare function batchUpdateTransactions({ added, deleted, updated, learnCategories, detectOrphanPayees, runTransfers, }: {
+    added?: Array<{
+        id: string;
+        payee: unknown;
+        category: unknown;
+    }>;
+    deleted?: Array<{
+        id: string;
+        payee: unknown;
+    }>;
+    updated?: Array<{
+        id: string;
+        payee?: unknown;
+        account?: unknown;
+        category?: unknown;
+    }>;
+    learnCategories?: boolean;
+    detectOrphanPayees?: boolean;
+    runTransfers?: boolean;
+}): Promise<{
+    added: TransactionEntity[];
+    updated: TransactionEntity[] | ({
+        id: any;
+        transfer_id: any;
+    } | {
+        id: any;
+        payee: any;
+    } | {
+        id: any;
+        category: any;
+    })[];
+}>;

package/@types/loot-core/server/accounts/transfer.d.ts

@@ -0,0 +1,37 @@
+export declare function addTransfer(transaction: any, transferredAccount: any): Promise<{
+    id: any;
+    payee: any;
+} | {
+    category?: any;
+    id: any;
+    transfer_id: any;
+    payee?: undefined;
+}>;
+export declare function removeTransfer(transaction: any): Promise<{
+    id: any;
+    transfer_id: any;
+}>;
+export declare function updateTransfer(transaction: any, transferredAccount: any): Promise<{
+    id: any;
+    category: any;
+}>;
+export declare function onInsert(transaction: any): Promise<{
+    id: any;
+    payee: any;
+} | {
+    category?: any;
+    id: any;
+    transfer_id: any;
+    payee?: undefined;
+}>;
+export declare function onDelete(transaction: any): Promise<void>;
+export declare function onUpdate(transaction: any): Promise<{
+    id: any;
+    transfer_id: any;
+} | {
+    id: any;
+    payee: any;
+} | {
+    id: any;
+    category: any;
+}>;

package/@types/loot-core/server/accounts/xmlcamt2json.d.ts

@@ -0,0 +1,10 @@
+interface TransactionCAMT {
+    amount: number;
+    date: string;
+    payee_name: string | null;
+    imported_payee: string | null;
+    notes: string | null;
+    imported_id?: string;
+}
+export declare function xmlCAMT2json(content: string): Promise<TransactionCAMT[]>;
+export {};