@actual-app/api 25.1.0 → 25.2.1

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

@@ -1,11 +1,16 @@
 import { RulesHandlers } from './types/handlers';
 export declare const app: {
-    events: any;
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
     handlers: RulesHandlers;
-    services: any;
-    unlistenServices: any;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
     method<Name extends "rule-validate" | "rule-add" | "rule-update" | "rule-delete" | "rule-delete-all" | "rule-apply-actions" | "rule-add-payee-rename" | "rules-get" | "rule-get" | "rules-run">(name: Name, func: RulesHandlers[Name]): void;
-    service(func: any): void;
+    service(func: () => () => void): void;
     combine(...apps: any[]): void;
     startServices(): void;
     stopServices(): void;

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

@@ -31,10 +31,10 @@ export interface RulesHandlers {
     }) => Promise<string>;
     'rules-get': () => Promise<RuleEntity[]>;
     'rule-get': (arg: {
-        id: string;
-    }) => Promise<unknown>;
+        id: RuleEntity['id'];
+    }) => Promise<RuleEntity>;
     'rules-run': (arg: {
-        transaction: any;
-    }) => Promise<unknown>;
+        transaction: TransactionEntity;
+    }) => Promise<TransactionEntity>;
 }
 export {};

package/@types/loot-core/server/schedules/app.d.ts

@@ -1,7 +1,6 @@
 import { Rule } from '../accounts/rules';
 import { SchedulesHandlers } from './types/handlers';
 export declare function updateConditions(conditions: any, newConditions: any): any;
-export declare function getNextDate(dateCond: any, start?: Date, noSkipWeekend?: boolean): any;
 export declare function getRuleForSchedule(id: string | null): Promise<Rule>;
 export declare function setNextDate({ id, start, conditions, reset, }: {
     id: string;
@@ -17,19 +16,23 @@ export declare function updateSchedule({ schedule, conditions, resetNextDate, }:
     schedule: any;
     conditions?: any;
     resetNextDate?: boolean;
-}): Promise<void>;
+}): Promise<any>;
 export declare function deleteSchedule({ id }: {
     id: any;
 }): Promise<void>;
 export declare const app: {
-    events: any;
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
     handlers: SchedulesHandlers;
-    services: any;
-    unlistenServices: any;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
     method<Name extends "schedule/create" | "schedule/update" | "schedule/delete" | "schedule/skip-next-date" | "schedule/post-transaction" | "schedule/force-run-service" | "schedule/discover" | "schedule/get-upcoming-dates">(name: Name, func: SchedulesHandlers[Name]): void;
-    service(func: any): void;
+    service(func: () => () => void): void;
     combine(...apps: any[]): void;
     startServices(): void;
     stopServices(): void;
 };
-export declare function getDateWithSkippedWeekend(date: Date, solveMode: 'after' | 'before'): Date;

package/@types/loot-core/server/schedules/types/handlers.d.ts

@@ -1,4 +1,4 @@
-import { DiscoverScheduleEntity } from '../../../types/models';
+import { DiscoverScheduleEntity, ScheduleEntity } from '../../../types/models';
 export interface SchedulesHandlers {
     'schedule/create': (arg: {
         schedule: {
@@ -12,15 +12,15 @@ export interface SchedulesHandlers {
         schedule: any;
         conditions?: any;
         resetNextDate?: boolean;
-    }) => Promise<void>;
+    }) => Promise<ScheduleEntity['id']>;
     'schedule/delete': (arg: {
-        id: string;
+        id: ScheduleEntity['id'];
     }) => Promise<void>;
     'schedule/skip-next-date': (arg: {
-        id: string;
+        id: ScheduleEntity['id'];
     }) => Promise<void>;
     'schedule/post-transaction': (arg: {
-        id: string;
+        id: ScheduleEntity['id'];
     }) => Promise<void>;
     'schedule/force-run-service': () => Promise<unknown>;
     'schedule/discover': () => Promise<DiscoverScheduleEntity[]>;

package/@types/loot-core/server/tools/app.d.ts

@@ -1,11 +1,16 @@
 import { ToolsHandlers } from './types/handlers';
 export declare const app: {
-    events: any;
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
     handlers: ToolsHandlers;
-    services: any;
-    unlistenServices: any;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
     method<Name extends "tools/fix-split-transactions">(name: Name, func: ToolsHandlers[Name]): void;
-    service(func: any): void;
+    service(func: () => () => void): void;
     combine(...apps: any[]): void;
     startServices(): void;
     stopServices(): void;

package/@types/loot-core/server/tools/types/handlers.d.ts

@@ -1,10 +1,11 @@
-import { TransactionEntity } from './models';
+import { TransactionEntity } from '../../../types/models';
 
 export interface ToolsHandlers {
   'tools/fix-split-transactions': () => Promise<{
     numBlankPayees: number;
     numCleared: number;
     numDeleted: number;
+    numTransfersFixed: number;
     mismatchedSplits: TransactionEntity[];
   }>;
 }

package/@types/loot-core/shared/schedules.d.ts

@@ -2,45 +2,19 @@ import type { IRuleOptions } from '@rschedule/core';
 export declare function getStatus(nextDate: string, completed: boolean, hasTrans: boolean, upcomingLength: string): "completed" | "paid" | "due" | "upcoming" | "missed" | "scheduled";
 export declare function getHasTransactionsQuery(schedules: any): import("./query").Query;
 export declare function getRecurringDescription(config: any, dateFormat: any): string;
-export declare function recurConfigToRSchedule(config: any): IRuleOptions[] | ({
-    byDayOfMonth: any;
-    start: import("@rschedule/core").RuleOption.Start;
-    end?: import("@rschedule/core").RuleOption.End;
-    duration?: import("@rschedule/core").RuleOption.Duration;
-    count?: import("@rschedule/core").RuleOption.Count;
-    frequency: import("@rschedule/core").RuleOption.Frequency;
-    interval?: import("@rschedule/core").RuleOption.Interval;
-    weekStart?: import("@rschedule/core").RuleOption.WeekStart;
-    byDayOfWeek?: import("@rschedule/core").RuleOption.ByDayOfWeek[];
-    byHourOfDay?: import("@rschedule/core").RuleOption.ByHourOfDay[];
-    byMillisecondOfSecond?: import("@rschedule/core").RuleOption.ByMillisecondOfSecond[];
-    byMinuteOfHour?: import("@rschedule/core").RuleOption.ByMinuteOfHour[];
-    byMonthOfYear?: import("@rschedule/core").RuleOption.ByMonthOfYear[];
-    bySecondOfMinute?: import("@rschedule/core").RuleOption.BySecondOfMinute[];
-} | {
-    byDayOfWeek: any;
-    start: import("@rschedule/core").RuleOption.Start;
-    end?: import("@rschedule/core").RuleOption.End;
-    duration?: import("@rschedule/core").RuleOption.Duration;
-    count?: import("@rschedule/core").RuleOption.Count;
-    frequency: import("@rschedule/core").RuleOption.Frequency;
-    interval?: import("@rschedule/core").RuleOption.Interval;
-    weekStart?: import("@rschedule/core").RuleOption.WeekStart;
-    byDayOfMonth?: import("@rschedule/core").RuleOption.ByDayOfMonth[];
-    byHourOfDay?: import("@rschedule/core").RuleOption.ByHourOfDay[];
-    byMillisecondOfSecond?: import("@rschedule/core").RuleOption.ByMillisecondOfSecond[];
-    byMinuteOfHour?: import("@rschedule/core").RuleOption.ByMinuteOfHour[];
-    byMonthOfYear?: import("@rschedule/core").RuleOption.ByMonthOfYear[];
-    bySecondOfMinute?: import("@rschedule/core").RuleOption.BySecondOfMinute[];
-})[];
+export declare function recurConfigToRSchedule(config: any): IRuleOptions[];
 export declare function extractScheduleConds(conditions: any): {
     payee: any;
     account: any;
     amount: any;
     date: any;
 };
+export declare function getNextDate(dateCond: any, start?: Date, noSkipWeekend?: boolean): any;
+export declare function getDateWithSkippedWeekend(date: Date, solveMode: 'after' | 'before'): Date;
 export declare function getScheduledAmount(amount: number | {
     num1: number;
     num2: number;
 }, inverse?: boolean): number;
 export declare function describeSchedule(schedule: any, payee: any): string;
+export declare function getUpcomingDays(upcomingLength?: string): number;
+export declare function scheduleIsRecurring(dateCond: any): boolean;

package/@types/loot-core/shared/transactions.d.ts

@@ -1,41 +1,119 @@
 import { type TransactionEntity } from '../types/models';
 import { diffItems, applyChanges } from './util';
-interface TransactionEntityWithError extends TransactionEntity {
-    error: ReturnType<typeof SplitTransactionError> | null;
-    _deleted?: boolean;
-}
 export declare function isTemporaryId(id: string): boolean;
 export declare function isPreviewId(id: string): boolean;
-declare function SplitTransactionError(total: number, parent: TransactionEntity): {
-    type: string;
-    version: number;
-    difference: number;
-};
-type GenericTransactionEntity = TransactionEntity | TransactionEntityWithError;
+type GenericTransactionEntity = TransactionEntity;
 export declare function makeChild<T extends GenericTransactionEntity>(parent: T, data?: object): T;
-export declare function recalculateSplit(trans: TransactionEntity): TransactionEntityWithError;
+export declare function recalculateSplit(trans: TransactionEntity): {
+    error: {
+        type: "SplitTransactionError";
+        version: 1;
+        difference: number;
+    };
+    id: string;
+    is_parent?: boolean;
+    is_child?: boolean;
+    parent_id?: TransactionEntity["id"];
+    account: import("../types/models").AccountEntity["id"];
+    category?: import("../types/models").CategoryEntity["id"];
+    amount: number;
+    payee?: import("../types/models").PayeeEntity["id"];
+    notes?: string;
+    date: string;
+    imported_id?: string;
+    imported_payee?: string;
+    starting_balance_flag?: boolean;
+    transfer_id?: TransactionEntity["id"];
+    sort_order?: number;
+    cleared?: boolean;
+    reconciled?: boolean;
+    tombstone?: boolean;
+    forceUpcoming?: boolean;
+    schedule?: import("../types/models").ScheduleEntity["id"];
+    subtransactions?: TransactionEntity[];
+    _unmatched?: boolean;
+    _deleted?: boolean;
+};
 export declare function ungroupTransactions(transactions: TransactionEntity[]): TransactionEntity[];
-export declare function groupTransaction(split: TransactionEntity[]): TransactionEntity;
+export declare function groupTransaction(split: TransactionEntity[]): {
+    subtransactions: TransactionEntity[];
+    id: string;
+    is_parent?: boolean;
+    is_child?: boolean;
+    parent_id?: TransactionEntity["id"];
+    account: import("../types/models").AccountEntity["id"];
+    category?: import("../types/models").CategoryEntity["id"];
+    amount: number;
+    payee?: import("../types/models").PayeeEntity["id"];
+    notes?: string;
+    date: string;
+    imported_id?: string;
+    imported_payee?: string;
+    starting_balance_flag?: boolean;
+    transfer_id?: TransactionEntity["id"];
+    sort_order?: number;
+    cleared?: boolean;
+    reconciled?: boolean;
+    tombstone?: boolean;
+    forceUpcoming?: boolean;
+    schedule?: import("../types/models").ScheduleEntity["id"];
+    _unmatched?: boolean;
+    _deleted?: boolean;
+    error?: {
+        type: "SplitTransactionError";
+        version: 1;
+        difference: number;
+    } | null;
+};
 export declare function ungroupTransaction(split: TransactionEntity | null): TransactionEntity[];
-export declare function applyTransactionDiff(groupedTrans: Parameters<typeof ungroupTransaction>[0], diff: Parameters<typeof applyChanges>[0]): TransactionEntity;
+export declare function applyTransactionDiff(groupedTrans: Parameters<typeof ungroupTransaction>[0], diff: Parameters<typeof applyChanges>[0]): {
+    subtransactions: TransactionEntity[];
+    id: string;
+    is_parent?: boolean;
+    is_child?: boolean;
+    parent_id?: TransactionEntity["id"];
+    account: import("../types/models").AccountEntity["id"];
+    category?: import("../types/models").CategoryEntity["id"];
+    amount: number;
+    payee?: import("../types/models").PayeeEntity["id"];
+    notes?: string;
+    date: string;
+    imported_id?: string;
+    imported_payee?: string;
+    starting_balance_flag?: boolean;
+    transfer_id?: TransactionEntity["id"];
+    sort_order?: number;
+    cleared?: boolean;
+    reconciled?: boolean;
+    tombstone?: boolean;
+    forceUpcoming?: boolean;
+    schedule?: import("../types/models").ScheduleEntity["id"];
+    _unmatched?: boolean;
+    _deleted?: boolean;
+    error?: {
+        type: "SplitTransactionError";
+        version: 1;
+        difference: number;
+    } | null;
+};
 export declare function addSplitTransaction(transactions: TransactionEntity[], id: string): {
     data: TransactionEntity[];
-    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function updateTransaction(transactions: TransactionEntity[], transaction: TransactionEntity): {
     data: TransactionEntity[];
-    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function deleteTransaction(transactions: TransactionEntity[], id: string): {
     data: TransactionEntity[];
-    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function splitTransaction(transactions: TransactionEntity[], id: string, createSubtransactions?: (parentTransaction: TransactionEntity) => TransactionEntity[]): {
     data: TransactionEntity[];
-    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function realizeTempTransactions(transactions: TransactionEntity[]): TransactionEntity[];
@@ -60,10 +138,16 @@ export declare function makeAsNonChildTransactions(childTransactionsToUpdate: Tr
         cleared?: boolean;
         reconciled?: boolean;
         tombstone?: boolean;
+        forceUpcoming?: boolean;
         schedule?: import("../types/models").ScheduleEntity["id"];
         subtransactions?: TransactionEntity[];
         _unmatched?: boolean;
         _deleted?: boolean;
+        error?: {
+            type: "SplitTransactionError";
+            version: 1;
+            difference: number;
+        } | null;
     }[];
 };
 export {};

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

@@ -55,16 +55,30 @@ export declare function getNumberFormat({ format, hideFraction, }?: {
     regex: any;
     separatorRegex: any;
 };
+/**
+ * The exact amount.
+ */
+export type Amount = number;
+/**
+ * The exact amount that is formatted based on the configured number format.
+ * For example, 123.45 would be '123.45' or '123,45'.
+ */
+export type CurrencyAmount = string;
+/**
+ * The amount with the decimal point removed.
+ * For example, 123.45 would be 12345.
+ */
+export type IntegerAmount = number;
 export declare function safeNumber(value: number): number;
-export declare function toRelaxedNumber(value: string): number;
-export declare function integerToCurrency(n: number, formatter?: Intl.NumberFormat): string;
-export declare function amountToCurrency(n: any): string;
-export declare function amountToCurrencyNoDecimal(n: any): string;
-export declare function currencyToAmount(str: string): any;
-export declare function currencyToInteger(str: string): number;
-export declare function stringToInteger(str: string): number;
-export declare function amountToInteger(n: number): number;
-export declare function integerToAmount(n: any): number;
+export declare function toRelaxedNumber(currencyAmount: CurrencyAmount): Amount;
+export declare function integerToCurrency(integerAmount: IntegerAmount, formatter?: Intl.NumberFormat): string;
+export declare function amountToCurrency(amount: Amount): CurrencyAmount;
+export declare function amountToCurrencyNoDecimal(amount: Amount): CurrencyAmount;
+export declare function currencyToAmount(currencyAmount: CurrencyAmount): Amount | null;
+export declare function currencyToInteger(currencyAmount: CurrencyAmount): IntegerAmount | null;
+export declare function stringToInteger(str: string): number | null;
+export declare function amountToInteger(amount: Amount): IntegerAmount;
+export declare function integerToAmount(integerAmount: IntegerAmount): Amount;
 export declare function looselyParseAmount(amount: string): number;
 export declare function sortByKey<T>(arr: T[], key: keyof T): T[];
 export {};

package/@types/loot-core/types/api-handlers.d.ts

@@ -1,3 +1,5 @@
+import { ImportTransactionsOpts } from '@actual-app/api';
+
 import { type batchUpdateTransactions } from '../server/accounts/transactions';
 import type {
   APIAccountEntity,
@@ -80,6 +82,7 @@ export interface ApiHandlers {
     accountId;
     transactions;
     isPreview?;
+    opts?: ImportTransactionsOpts;
   }) => Promise<{
     errors?: { message: string }[];
     added;

package/@types/loot-core/types/models/dashboard.d.ts

@@ -4,7 +4,7 @@ import { type RuleConditionEntity } from './rule';
 export type TimeFrame = {
   start: string;
   end: string;
-  mode: 'sliding-window' | 'static' | 'full';
+  mode: 'sliding-window' | 'static' | 'full' | 'lastYear' | 'yearToDate';
 };
 
 type AbstractWidget<

package/@types/loot-core/types/models/payee.d.ts

@@ -5,5 +5,6 @@ export interface PayeeEntity {
   name: string;
   transfer_acct?: AccountEntity['id'];
   favorite?: 1 | 0;
+  learn_categories?: 1 | 0;
   tombstone?: boolean;
 }

package/@types/loot-core/types/models/reports.d.ts

@@ -11,6 +11,7 @@ export interface CustomReportEntity {
   groupBy: string;
   interval: string;
   balanceType: string;
+  sortBy?: sortByOpType;
   showEmpty: boolean;
   showOffBudget: boolean;
   showHiddenCategories: boolean;
@@ -30,6 +31,8 @@ export type balanceTypeOpType =
   | 'netAssets'
   | 'netDebts';
 
+export type sortByOpType = 'asc' | 'desc' | 'name' | 'budget';
+
 export type SpendingMonthEntity = Record<
   string | number,
   {
@@ -122,6 +125,7 @@ export interface CustomReportData {
   date_range: string;
   mode: string;
   group_by: string;
+  sort_by: sortByOpType;
   balance_type: string;
   show_empty: number;
   show_offbudget: number;

package/@types/loot-core/types/models/rule.d.ts

@@ -1,4 +1,4 @@
-import { type ScheduleEntity } from './schedule';
+import { type RecurConfig, type ScheduleEntity } from './schedule';
 
 export interface NewRuleEntity {
   stage: 'pre' | null | 'post';
@@ -31,11 +31,11 @@ export type RuleConditionOp =
   | 'onBudget'
   | 'offBudget';
 
-type FieldValueTypes = {
+export type FieldValueTypes = {
   account: string;
   amount: number;
   category: string;
-  date: string;
+  date: string | RecurConfig;
   notes: string;
   payee: string;
   payee_name: string;
@@ -55,7 +55,9 @@ type BaseConditionEntity<
   op: Op;
   value: Op extends 'oneOf' | 'notOneOf'
     ? Array<FieldValueTypes[Field]>
-    : FieldValueTypes[Field];
+    : Op extends 'isbetween'
+      ? { num1: number; num2: number }
+      : FieldValueTypes[Field];
   options?: {
     inflow?: boolean;
     outflow?: boolean;

package/@types/loot-core/types/models/schedule.d.ts

@@ -1,6 +1,6 @@
 import type { AccountEntity } from './account';
 import type { PayeeEntity } from './payee';
-import type { RuleEntity } from './rule';
+import type { RuleConditionEntity, RuleEntity } from './rule';
 
 export interface RecurPattern {
   value: number;
@@ -9,7 +9,7 @@ export interface RecurPattern {
 
 export interface RecurConfig {
   frequency: 'daily' | 'weekly' | 'monthly' | 'yearly';
-  interval: number;
+  interval?: number;
   patterns?: RecurPattern[];
   skipWeekend?: boolean;
   start: string;
@@ -35,8 +35,8 @@ export interface ScheduleEntity {
   _amount: number | { num1: number; num2: number };
   _amountOp: string;
   _date: RecurConfig;
-  _conditions: unknown;
-  _actions: unknown;
+  _conditions: RuleConditionEntity[];
+  _actions: Array<{ op: unknown }>;
 }
 
 export type DiscoverScheduleEntity = {
@@ -45,18 +45,5 @@ export type DiscoverScheduleEntity = {
   payee: PayeeEntity['id'];
   date: ScheduleEntity['_date'];
   amount: ScheduleEntity['_amount'];
-  _conditions: Array<
-    | { op: 'is'; field: 'account'; value: AccountEntity['id'] }
-    | { op: 'is'; field: 'payee'; value: PayeeEntity['id'] }
-    | {
-        op: 'is' | 'isapprox';
-        field: 'date';
-        value: ScheduleEntity['_date'];
-      }
-    | {
-        op: 'is' | 'isapprox';
-        field: 'amount';
-        value: ScheduleEntity['_amount'];
-      }
-  >;
+  _conditions: ScheduleEntity['_conditions'];
 };

package/@types/loot-core/types/models/simplefin.d.ts

@@ -2,6 +2,7 @@ import { AccountEntity } from './account';
 import { BankSyncResponse } from './bank-sync';
 
 export type SimpleFinOrganization = {
+  id: string;
   name: string;
   domain: string;
 };
@@ -9,6 +10,7 @@ export type SimpleFinOrganization = {
 export type SimpleFinAccount = {
   id: string;
   name: string;
+  balance: number;
   org: SimpleFinOrganization;
 };
 

package/@types/loot-core/types/models/transaction.d.ts

@@ -22,8 +22,14 @@ export interface TransactionEntity {
   cleared?: boolean;
   reconciled?: boolean;
   tombstone?: boolean;
+  forceUpcoming?: boolean;
   schedule?: ScheduleEntity['id'];
   subtransactions?: TransactionEntity[];
   _unmatched?: boolean;
   _deleted?: boolean;
+  error?: {
+    type: 'SplitTransactionError';
+    version: 1;
+    difference: number;
+  } | null;
 }

package/@types/loot-core/types/prefs.d.ts

@@ -1,7 +1,6 @@
 export type FeatureFlag =
   | 'goalTemplatesEnabled'
   | 'actionTemplating'
-  | 'upcomingLengthAdjustment'
   | 'contextMenus'
   | 'openidAuth';
 
@@ -31,7 +30,8 @@ export type SyncedPrefs = Partial<
     | `csv-has-header-${string}`
     | `ofx-fallback-missing-payee-${string}`
     | `flip-amount-${string}-${'csv' | 'qif'}`
-    | `flags.${FeatureFlag}`,
+    | `flags.${FeatureFlag}`
+    | `learn-categories`,
     string
   >
 >;
@@ -77,6 +77,7 @@ export type GlobalPrefs = Partial<{
   floatingSidebar: boolean;
   maxMonths: number;
   keyId?: string;
+  language: string;
   theme: Theme;
   preferredDarkTheme: DarkTheme;
   documentDir: string; // Electron only