@actual-app/api 6.7.0 → 6.8.0

package/@types/app/bundle.api.d.ts

@@ -0,0 +1,6 @@
+export = __webpack_exports__;
+export = __webpack_exports__;
+/******/
+/************************************************************************/
+/******/
+/******/ /******/ /******/ /******/ declare var __webpack_exports__: any;

package/@types/app/query.d.ts

@@ -0,0 +1,19 @@
+export function q(table: any): Query;
+declare class Query {
+    constructor(state: any);
+    state: any;
+    filter(expr: any): Query;
+    unfilter(exprs: any): Query;
+    select(exprs?: any[]): Query;
+    calculate(expr: any): Query;
+    groupBy(exprs: any): Query;
+    orderBy(exprs: any): Query;
+    limit(num: any): Query;
+    offset(num: any): Query;
+    raw(): Query;
+    withDead(): Query;
+    withoutValidatedRefs(): Query;
+    options(opts: any): Query;
+    serialize(): any;
+}
+export {};

package/@types/index.d.ts

@@ -0,0 +1,7 @@
+import type { InitConfig } from './loot-core/server/main';
+export declare const internal: any;
+export * as methods from './methods';
+export * from './methods';
+export * as utils from './utils';
+export declare function init(config?: InitConfig): Promise<any>;
+export declare function shutdown(): Promise<void>;

package/@types/injected.d.ts

@@ -0,0 +1,2 @@
+export function override(sendImplementation: any): void;
+export let send: any;

package/@types/jest.config.d.ts

@@ -0,0 +1,9 @@
+export const moduleFileExtensions: string[];
+export const testEnvironment: string;
+export const testPathIgnorePatterns: string[];
+export const watchPathIgnorePatterns: string[];
+export const setupFilesAfterEnv: string[];
+export const transformIgnorePatterns: string[];
+export const transform: {
+    '^.+\\.(t|j)sx?$': string;
+};

package/@types/loot-core/client/actions/types.d.ts

@@ -0,0 +1,6 @@
+import type { ThunkDispatch } from 'redux-thunk';
+
+import type { State, Action } from '../state-types';
+
+export type Dispatch = ThunkDispatch<State, never, Action>;
+export type GetState = () => State;

package/@types/loot-core/client/constants.d.ts

@@ -0,0 +1,29 @@
+export declare const SET_NEW_TRANSACTIONS = "SET_NEW_TRANSACTIONS";
+export declare const UPDATE_NEW_TRANSACTIONS = "UPDATE_NEW_TRANSACTIONS";
+export declare const SET_LAST_TRANSACTION = "SET_LAST_TRANSACTION";
+export declare const MARK_ACCOUNT_READ = "MARK_ACCOUNT_READ";
+export declare const LOAD_ACCOUNTS = "LOAD_ACCOUNTS";
+export declare const UPDATE_ACCOUNT = "UPDATE_ACCOUNT";
+export declare const LOAD_CATEGORIES = "LOAD_CATEGORIES";
+export declare const LOAD_PAYEES = "LOAD_PAYEES";
+export declare const SET_PREFS = "SET_PREFS";
+export declare const MERGE_LOCAL_PREFS = "MERGE_LOCAL_PREFS";
+export declare const MERGE_GLOBAL_PREFS = "MERGE_GLOBAL_PREFS";
+export declare const SET_BUDGETS = "SET_BUDGETS";
+export declare const SET_REMOTE_FILES = "SET_REMOTE_FILES";
+export declare const SET_ALL_FILES = "SET_ALL_FILES";
+export declare const CLOSE_BUDGET = "CLOSE_BUDGET";
+export declare const SET_APP_STATE = "SET_APP_STATE";
+export declare const PUSH_MODAL = "PUSH_MODAL";
+export declare const REPLACE_MODAL = "REPLACE_MODAL";
+export declare const CLOSE_MODAL = "CLOSE_MODAL";
+export declare const COLLAPSE_MODALS = "COLLAPSE_MODALS";
+export declare const POP_MODAL = "POP_MODAL";
+export declare const ADD_NOTIFICATION = "ADD_NOTIFICATION";
+export declare const REMOVE_NOTIFICATION = "REMOVE_NOTIFICATION";
+export declare const GET_USER_DATA = "GET_USER_DATA";
+export declare const SET_LAST_UNDO_STATE = "SET_LAST_UNDO_STATE";
+export declare const SET_LAST_SPLIT_STATE = "SET_LAST_SPLIT_STATE";
+export declare const SET_ACCOUNTS_SYNCING = "SET_ACCOUNTS_SYNCING";
+export declare const ACCOUNT_SYNC_STATUS = "ACCOUNT_SYNC_STATUS";
+export declare const SIGN_OUT = "SIGN_OUT";

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

@@ -0,0 +1,4 @@
+export declare const isPlaywright = false;
+export declare const OS: 'windows' | 'mac' | 'linux' | 'unknown';
+export declare const env: 'web' | 'mobile' | 'unknown';
+export declare const isBrowser = false;

package/@types/loot-core/client/state-types/account.d.ts

@@ -0,0 +1,27 @@
+import type * as constants from '../constants';
+
+export type AccountState = {
+  failedAccounts: Map<string, { type: string; code: string }>;
+  accountsSyncing: string[];
+};
+
+export type SetAccountsSyncingAction = {
+  type: typeof constants.SET_ACCOUNTS_SYNCING;
+  ids: string[];
+};
+
+export type AccountSyncStatusAction = {
+  type: typeof constants.ACCOUNT_SYNC_STATUS;
+  id: string;
+} & (
+  | {
+      failed: false;
+    }
+  | {
+      failed: true;
+      errorType: string;
+      errorCode: string;
+    }
+);
+
+export type AccountActions = SetAccountsSyncingAction | AccountSyncStatusAction;

package/@types/loot-core/client/state-types/app.d.ts

@@ -0,0 +1,37 @@
+import type { UndoState } from '../../server/undo';
+import type * as constants from '../constants';
+
+export type SplitState = { ids: Set<string>; mode: 'collapse' | 'expand' };
+
+export type AppState = {
+  loadingText: string | null;
+  updateInfo: {
+    version: string;
+    releaseDate: string;
+    releaseNotes: string;
+  } | null;
+  showUpdateNotification: boolean;
+  managerHasInitialized: boolean;
+  lastUndoState: { current: UndoState | null };
+  lastSplitState: { current: SplitState | null };
+};
+
+export type SetAppStateAction = {
+  type: typeof constants.SET_APP_STATE;
+  state: Partial<AppState>;
+};
+
+export type SetLastUndoStateAction = {
+  type: typeof constants.SET_LAST_UNDO_STATE;
+  undoState: UndoState | null;
+};
+
+export type SetLastSplitStateAction = {
+  type: typeof constants.SET_LAST_SPLIT_STATE;
+  splitState: SplitState | null;
+};
+
+export type AppActions =
+  | SetAppStateAction
+  | SetLastUndoStateAction
+  | SetLastSplitStateAction;

package/@types/loot-core/client/state-types/budgets.d.ts

@@ -0,0 +1,36 @@
+import type { RemoteFile } from '../../server/cloud-storage';
+import type { Budget } from '../../types/budget';
+import type { File } from '../../types/file';
+import type * as constants from '../constants';
+
+export type BudgetsState = {
+  budgets: Budget[];
+  remoteFiles: RemoteFile[] | null;
+  allFiles: File[] | null;
+};
+
+export type SetBudgetsAction = {
+  type: typeof constants.SET_BUDGETS;
+  budgets: Budget[];
+};
+
+export type SetRemoteFilesAction = {
+  type: typeof constants.SET_REMOTE_FILES;
+  files: RemoteFile[];
+};
+
+export type SetAllFilesAction = {
+  type: typeof constants.SET_ALL_FILES;
+  budgets: Budget[];
+  remoteFiles: RemoteFile[];
+};
+
+export type SignOutAction = {
+  type: typeof constants.SIGN_OUT;
+};
+
+export type BudgetsActions =
+  | SetBudgetsAction
+  | SetRemoteFilesAction
+  | SetAllFilesAction
+  | SignOutAction;

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

@@ -0,0 +1,41 @@
+import type * as constants from '../constants';
+
+import type { AccountActions, AccountState } from './account';
+import type { AppActions, AppState } from './app';
+import type { BudgetsActions, BudgetsState } from './budgets';
+import type { ModalsActions, ModalsState } from './modals';
+import type { NotificationsActions, NotificationsState } from './notifications';
+import type { PrefsActions, PrefsState } from './prefs';
+import type { QueriesActions, QueriesState } from './queries';
+import type { UserActions, UserState } from './user';
+
+export type CloseBudgetAction = {
+  type: typeof constants.CLOSE_BUDGET;
+};
+
+export type Action =
+  | AccountActions
+  | AppActions
+  | BudgetsActions
+  | ModalsActions
+  | NotificationsActions
+  | PrefsActions
+  | QueriesActions
+  | UserActions
+  | CloseBudgetAction;
+
+export type State = {
+  account: AccountState;
+  app: AppState;
+  budgets: BudgetsState;
+  modals: ModalsState;
+  notifications: NotificationsState;
+  prefs: PrefsState;
+  queries: QueriesState;
+  user: UserState;
+};
+
+declare module 'react-redux' {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface
+  export interface DefaultRootState extends State {}
+}

package/@types/loot-core/client/state-types/modals.d.ts

@@ -0,0 +1,292 @@
+import { type File } from '../../types/file';
+import type {
+  AccountEntity,
+  CategoryEntity,
+  CategoryGroupEntity,
+  GoCardlessToken,
+} from '../../types/models';
+import type { NewRuleEntity, RuleEntity } from '../../types/models/rule';
+import type { EmptyObject, StripNever } from '../../types/util';
+import type * as constants from '../constants';
+export type ModalType = keyof FinanceModals;
+
+export type OptionlessModal = {
+  [K in ModalType]: EmptyObject extends FinanceModals[K] ? K : never;
+}[ModalType];
+
+export type ModalWithOptions = StripNever<{
+  [K in ModalType]: keyof FinanceModals[K] extends never
+    ? never
+    : FinanceModals[K];
+}>;
+
+// There is a separate (overlapping!) set of modals for the management app. Fun!
+type FinanceModals = {
+  'import-transactions': {
+    accountId: string;
+    filename: string;
+    onImported: (didChange: boolean) => void;
+  };
+
+  'add-account': EmptyObject;
+  'add-local-account': EmptyObject;
+  'close-account': {
+    account: AccountEntity;
+    balance: number;
+    canDelete: boolean;
+  };
+  'select-linked-accounts': {
+    accounts: unknown[];
+    requisitionId: string;
+    upgradingAccountId?: string;
+    syncSource?: AccountSyncSource;
+  };
+
+  'confirm-category-delete': { onDelete: (categoryId: string) => void } & (
+    | { category: string }
+    | { group: string }
+  );
+
+  'load-backup': EmptyObject;
+
+  'manage-rules': { payeeId?: string };
+  'edit-rule': {
+    rule: RuleEntity | NewRuleEntity;
+    onSave: (rule: RuleEntity) => void;
+  };
+  'merge-unused-payees': {
+    payeeIds: string[];
+    targetPayeeId: string;
+  };
+
+  'gocardless-init': {
+    onSuccess: () => void;
+  };
+  'simplefin-init': {
+    onSuccess: () => void;
+  };
+
+  'gocardless-external-msg': {
+    onMoveExternal: (arg: {
+      institutionId: string;
+    }) => Promise<{ error: string } | { data: unknown }>;
+    onClose?: () => void;
+    onSuccess: (data: GoCardlessToken) => Promise<void>;
+  };
+
+  'delete-budget': { file: File };
+
+  import: null;
+
+  'import-ynab4': null;
+
+  'import-ynab5': null;
+
+  'import-actual': null;
+
+  'create-encryption-key': { recreate?: boolean };
+  'fix-encryption-key': {
+    hasExistingKey?: boolean;
+    cloudFileId?: string;
+    onSuccess?: () => void;
+  };
+
+  'edit-field': {
+    name: string;
+    month: string;
+    onSubmit: (name: string, value: string) => void;
+    onClose: () => void;
+  };
+
+  'category-autocomplete': {
+    categoryGroups: CategoryGroupEntity[];
+    onSelect: (categoryId: string, categoryName: string) => void;
+    month?: string;
+    showHiddenCategories?: boolean;
+    onClose?: () => void;
+  };
+
+  'account-autocomplete': {
+    onSelect: (accountId: string, accountName: string) => void;
+    includeClosedAccounts?: boolean;
+    onClose?: () => void;
+  };
+
+  'payee-autocomplete': {
+    onSelect: (payeeId: string) => void;
+    onClose?: () => void;
+  };
+
+  'budget-summary': {
+    month: string;
+  };
+
+  'schedule-edit': { id: string } | null;
+
+  'schedule-link': { transactionIds: string[] } | null;
+
+  'schedules-discover': null;
+
+  'schedule-posts-offline-notification': null;
+  'switch-budget-type': { onSwitch: () => void };
+  'account-menu': {
+    accountId: string;
+    onSave: (account: AccountEntity) => void;
+    onCloseAccount: (accountId: string) => void;
+    onReopenAccount: (accountId: string) => void;
+    onEditNotes: (id: string) => void;
+    onClose?: () => void;
+  };
+  'category-menu': {
+    categoryId: string;
+    onSave: (category: CategoryEntity) => void;
+    onEditNotes: (id: string) => void;
+    onDelete: (categoryId: string) => void;
+    onBudgetAction: (month: string, action: string, args?: unknown) => void;
+    onClose?: () => void;
+  };
+  'rollover-budget-menu': {
+    categoryId: string;
+    month: string;
+    onUpdateBudget: (amount: number) => void;
+    onCopyLastMonthAverage: () => void;
+    onSetMonthsAverage: (numberOfMonths: number) => void;
+    onApplyBudgetTemplate: () => void;
+  };
+  'report-budget-menu': {
+    categoryId: string;
+    month: string;
+    onUpdateBudget: (amount: number) => void;
+    onCopyLastMonthAverage: () => void;
+    onSetMonthsAverage: (numberOfMonths: number) => void;
+    onApplyBudgetTemplate: () => void;
+  };
+  'category-group-menu': {
+    groupId: string;
+    onSave: (group: CategoryGroupEntity) => void;
+    onAddCategory: (groupId: string, isIncome: boolean) => void;
+    onEditNotes: (id: string) => void;
+    onDelete: (groupId: string) => void;
+    onClose?: () => void;
+  };
+  notes: {
+    id: string;
+    name: string;
+    onSave: (id: string, notes: string) => void;
+  };
+  'report-budget-summary': { month: string };
+  'rollover-budget-summary': {
+    month: string;
+    onBudgetAction: (
+      month: string,
+      type: string,
+      args: unknown,
+    ) => Promise<void>;
+  };
+  'new-category-group': {
+    onValidate?: (value: string) => string;
+    onSubmit: (value: string) => Promise<void>;
+  };
+  'new-category': {
+    onValidate?: (value: string) => string;
+    onSubmit: (value: string) => Promise<void>;
+  };
+  'rollover-balance-menu': {
+    categoryId: string;
+    month: string;
+    onCarryover: (carryover: boolean) => void;
+    onTransfer: () => void;
+    onCover: () => void;
+  };
+  'rollover-summary-to-budget-menu': {
+    month: string;
+    onTransfer: () => void;
+    onHoldBuffer: () => void;
+    onResetHoldBuffer: () => void;
+  };
+  'report-balance-menu': {
+    categoryId: string;
+    month: string;
+    onCarryover: (carryover: boolean) => void;
+  };
+  transfer: {
+    title: string;
+    month: string;
+    amount: number;
+    onSubmit: (amount: number, toCategoryId: string) => void;
+    showToBeBudgeted?: boolean;
+  };
+  cover: {
+    categoryId: string;
+    month: string;
+    onSubmit: (fromCategoryId: string) => void;
+  };
+  'hold-buffer': {
+    month: string;
+    onSubmit: (amount: number) => void;
+  };
+  'scheduled-transaction-menu': {
+    transactionId: string;
+    onPost: (transactionId: string) => void;
+    onSkip: (transactionId: string) => void;
+  };
+  'budget-page-menu': {
+    onAddCategoryGroup: () => void;
+    onToggleHiddenCategories: () => void;
+    onSwitchBudgetFile: () => void;
+    onSwitchBudgetType: () => void;
+  };
+  'rollover-budget-month-menu': {
+    month: string;
+    onBudgetAction: (month: string, action: string, arg?: unknown) => void;
+    onEditNotes: (month: string) => void;
+  };
+  'report-budget-month-menu': {
+    month: string;
+    onBudgetAction: (month: string, action: string, arg?: unknown) => void;
+    onEditNotes: (month: string) => void;
+  };
+  'budget-list';
+  'confirm-transaction-edit': {
+    onConfirm: () => void;
+    confirmReason: string;
+  };
+  'confirm-transaction-delete': {
+    onConfirm: () => void;
+  };
+};
+
+export type PushModalAction = {
+  type: typeof constants.PUSH_MODAL;
+  modal: Modal;
+};
+
+export type ReplaceModalAction = {
+  type: typeof constants.REPLACE_MODAL;
+  modal: Modal;
+};
+
+export type PopModalAction = {
+  type: typeof constants.POP_MODAL;
+};
+
+export type CloseModalAction = {
+  type: typeof constants.CLOSE_MODAL;
+};
+
+export type CollapseModalsAction = {
+  type: typeof constants.COLLAPSE_MODALS;
+  rootModalName: string;
+};
+
+export type ModalsActions =
+  | PushModalAction
+  | ReplaceModalAction
+  | PopModalAction
+  | CloseModalAction
+  | CollapseModalsAction;
+
+export type ModalsState = {
+  modalStack: Modal[];
+  isHidden: boolean;
+};

package/@types/loot-core/client/state-types/notifications.d.ts

@@ -0,0 +1,38 @@
+import type * as constants from '../constants';
+
+export type Notification = {
+  id?: string;
+  // 'warning' is unhandled??
+  type?: 'message' | 'error' | 'warning';
+  pre?: string;
+  title?: string;
+  message: string;
+  sticky?: boolean;
+  timeout?: number;
+  button?: {
+    title: string;
+    action: () => void | Promise<void>;
+  };
+  messageActions?: Record<string, () => void>;
+  onClose?: () => void;
+  internal?: string;
+};
+type NotificationWithId = Notification & { id: string };
+
+export type NotificationsState = {
+  notifications: NotificationWithId[];
+};
+
+type AddNotificationAction = {
+  type: typeof constants.ADD_NOTIFICATION;
+  notification: NotificationWithId;
+};
+
+type RemoveNotificationAction = {
+  type: typeof constants.REMOVE_NOTIFICATION;
+  id: string;
+};
+
+export type NotificationsActions =
+  | AddNotificationAction
+  | RemoveNotificationAction;

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

@@ -0,0 +1,28 @@
+import type { LocalPrefs, GlobalPrefs } from '../../types/prefs';
+import type * as constants from '../constants';
+
+export type PrefsState = {
+  local: LocalPrefs;
+  global: GlobalPrefs;
+};
+
+export type SetPrefsAction = {
+  type: typeof constants.SET_PREFS;
+  prefs: LocalPrefs;
+  globalPrefs: GlobalPrefs;
+};
+
+export type MergeLocalPrefsAction = {
+  type: typeof constants.MERGE_LOCAL_PREFS;
+  prefs: LocalPrefs;
+};
+
+export type MergeGlobalPrefsAction = {
+  type: typeof constants.MERGE_GLOBAL_PREFS;
+  globalPrefs: GlobalPrefs;
+};
+
+export type PrefsActions =
+  | SetPrefsAction
+  | MergeLocalPrefsAction
+  | MergeGlobalPrefsAction;

package/@types/loot-core/client/state-types/queries.d.ts

@@ -0,0 +1,69 @@
+import type { Handlers } from '../../types/handlers';
+import { type AccountEntity } from '../../types/models';
+import type * as constants from '../constants';
+
+export type QueriesState = {
+  newTransactions: unknown[];
+  matchedTransactions: unknown[];
+  lastTransaction: unknown | null;
+  updatedAccounts: string[];
+  accounts: AccountEntity[];
+  accountsLoaded: boolean;
+  categories: Awaited<ReturnType<Handlers['get-categories']>>;
+  categoriesLoaded: boolean;
+  payees: Awaited<ReturnType<Handlers['payees-get']>>;
+  payeesLoaded: boolean;
+  earliestTransaction: unknown | null;
+};
+
+type SetNewTransactionsAction = {
+  type: typeof constants.SET_NEW_TRANSACTIONS;
+  newTransactions?: unknown[];
+  matchedTransactions?: unknown[];
+  updatedAccounts?: string[];
+};
+
+type UpdateNewTransactionsAction = {
+  type: typeof constants.UPDATE_NEW_TRANSACTIONS;
+  changedId: string;
+};
+
+type SetLastTransactionAction = {
+  type: typeof constants.SET_LAST_TRANSACTION;
+  transaction: unknown;
+};
+
+type MarkAccountReadAction = {
+  type: typeof constants.MARK_ACCOUNT_READ;
+  accountId: string;
+};
+
+type LoadAccountsAction = {
+  type: typeof constants.LOAD_ACCOUNTS;
+  accounts: AccountEntity[];
+};
+
+type UpdateAccountAction = {
+  type: typeof constants.UPDATE_ACCOUNT;
+  account: AccountEntity;
+};
+
+type LoadCategoriesAction = {
+  type: typeof constants.LOAD_CATEGORIES;
+  categories: State['categories'];
+};
+
+type LoadPayeesAction = {
+  type: typeof constants.LOAD_PAYEES;
+  payees: State['payees'];
+};
+
+export type QueriesActions =
+  | SetNewTransactionsAction
+  | UpdateNewTransactionsAction
+  | SetLastTransactionAction
+  | MarkAccountReadAction
+  | LoadAccountsAction
+  | UpdateAccountAction
+  | LoadCategoriesAction
+  | LoadPayeesAction;

package/@types/loot-core/client/state-types/user.d.ts

@@ -0,0 +1,13 @@
+import type { Handlers } from '../../types/handlers';
+import type * as constants from '../constants';
+
+export type UserState = {
+  data: Awaited<ReturnType<Handlers['subscribe-get-user']>>;
+};
+
+export type GetUserDataAction = {
+  type: typeof constants.GET_USER_DATA;
+  data: State['data'];
+};
+
+export type UserActions = GetUserDataAction;

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

@@ -0,0 +1,2 @@
+import type { Handlers } from '../types/handlers';
+export declare function createTestBudget(handlers: Handlers): Promise<void>;