@actual-app/api 25.3.1 → 25.4.0

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

@@ -1,5 +1,4 @@
 import { type CustomReportData, type CustomReportEntity } from '../../types/models';
-import { ReportsHandlers } from './types/handlers';
 export declare const reportModel: {
     validate(report: Omit<CustomReportEntity, "tombstone">, { update }?: {
         update?: boolean;
@@ -47,6 +46,14 @@ export declare const reportModel: {
         conditions_op: "and" | "or";
     };
 };
+declare function createReport(report: CustomReportEntity): Promise<string>;
+declare function updateReport(item: CustomReportEntity): Promise<void>;
+declare function deleteReport(id: CustomReportEntity['id']): Promise<void>;
+export type ReportsHandlers = {
+    'report/create': typeof createReport;
+    'report/update': typeof updateReport;
+    'report/delete': typeof deleteReport;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -63,3 +70,4 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+export {};

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

@@ -1,4 +1,21 @@
-import { RulesHandlers } from './types/handlers';
+import { RuleActionEntity, TransactionEntity, type RuleEntity } from '../../types/models';
+import { Action } from '.';
+type ValidationError = {
+    conditionErrors: string[];
+    actionErrors: string[];
+};
+export type RulesHandlers = {
+    'rule-validate': typeof ruleValidate;
+    'rule-add': typeof addRule;
+    'rule-update': typeof updateRule;
+    'rule-delete': typeof deleteRule;
+    'rule-delete-all': typeof deleteAllRules;
+    'rule-apply-actions': typeof applyRuleActions;
+    'rule-add-payee-rename': typeof addRulePayeeRename;
+    'rules-get': typeof getRules;
+    'rule-get': typeof getRule;
+    'rules-run': typeof runRules;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -15,3 +32,35 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+declare function ruleValidate(rule: Partial<RuleEntity>): Promise<{
+    error: ValidationError | null;
+}>;
+declare function addRule(rule: Omit<RuleEntity, 'id'>): Promise<{
+    error: ValidationError;
+} | RuleEntity>;
+declare function updateRule<PartialRule extends Partial<Omit<RuleEntity, 'id'>> & Pick<RuleEntity, 'id'>>(rule: PartialRule): Promise<{
+    error: ValidationError;
+} | PartialRule>;
+declare function deleteRule(id: RuleEntity['id']): Promise<boolean>;
+declare function deleteAllRules(ids: Array<RuleEntity['id']>): Promise<{
+    someDeletionsFailed: boolean;
+}>;
+declare function applyRuleActions({ transactions, actions, }: {
+    transactions: TransactionEntity[];
+    actions: Array<Action | RuleActionEntity>;
+}): Promise<null | {
+    added: TransactionEntity[];
+    updated: unknown[];
+}>;
+declare function addRulePayeeRename({ fromNames, to, }: {
+    fromNames: string[];
+    to: string;
+}): Promise<string>;
+declare function getRule({ id, }: {
+    id: RuleEntity['id'];
+}): Promise<RuleEntity | null>;
+declare function getRules(): Promise<RuleEntity[]>;
+declare function runRules({ transaction, }: {
+    transaction: TransactionEntity;
+}): Promise<TransactionEntity>;
+export {};

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

@@ -1,5 +1,5 @@
+import { ScheduleEntity } from '../../types/models';
 import { Rule } from '../rules';
-import { SchedulesHandlers } from './types/handlers';
 export declare function updateConditions(conditions: any, newConditions: any): any;
 export declare function getRuleForSchedule(id: string | null): Promise<Rule>;
 export declare function setNextDate({ id, start, conditions, reset, }: {
@@ -11,7 +11,7 @@ export declare function setNextDate({ id, start, conditions, reset, }: {
 export declare function createSchedule({ schedule, conditions, }?: {
     schedule?: any;
     conditions?: any[];
-}): Promise<any>;
+}): Promise<ScheduleEntity['id']>;
 export declare function updateSchedule({ schedule, conditions, resetNextDate, }: {
     schedule: any;
     conditions?: any;
@@ -20,6 +20,28 @@ export declare function updateSchedule({ schedule, conditions, resetNextDate, }:
 export declare function deleteSchedule({ id }: {
     id: any;
 }): Promise<void>;
+declare function skipNextDate({ id }: {
+    id: any;
+}): Promise<void>;
+declare function discoverSchedules(): Promise<any>;
+declare function getUpcomingDates({ config, count }: {
+    config: any;
+    count: any;
+}): Promise<string[]>;
+declare function postTransactionForSchedule({ id }: {
+    id: string;
+}): Promise<void>;
+declare function advanceSchedulesService(syncSuccess: any): Promise<void>;
+export type SchedulesHandlers = {
+    'schedule/create': typeof createSchedule;
+    'schedule/update': typeof updateSchedule;
+    'schedule/delete': typeof deleteSchedule;
+    'schedule/skip-next-date': typeof skipNextDate;
+    'schedule/post-transaction': typeof postTransactionForSchedule;
+    'schedule/force-run-service': typeof advanceSchedulesService;
+    'schedule/discover': typeof discoverSchedules;
+    'schedule/get-upcoming-dates': typeof getUpcomingDates;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -36,3 +58,4 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+export {};

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

@@ -1 +1 @@
-export declare function findSchedules(): Promise<import("../../types/models").DiscoverScheduleEntity[]>;
+export declare function findSchedules(): Promise<any>;

package/@types/loot-core/server/server-config.d.ts

@@ -4,6 +4,7 @@ type ServerConfig = {
     SIGNUP_SERVER: string;
     GOCARDLESS_SERVER: string;
     SIMPLEFIN_SERVER: string;
+    PLUGGYAI_SERVER: string;
 };
 export declare function isValidBaseURL(base: string): boolean;
 export declare function setServer(url: string): void;

package/@types/loot-core/server/sheet.d.ts

@@ -3,7 +3,7 @@ export declare function get(): Spreadsheet;
 export declare function loadSpreadsheet(db: any, onSheetChange?: any): Promise<Spreadsheet>;
 export declare function unloadSpreadsheet(): void;
 export declare function reloadSpreadsheet(db: any): Promise<Spreadsheet>;
-export declare function loadUserBudgets(db: any): Promise<void>;
+export declare function loadUserBudgets(db: typeof import('./db')): Promise<void>;
 export declare function getCell(sheet: string, name: string): import("./spreadsheet/spreadsheet").Node;
 export declare function getCellValue(sheet: string, name: string): string | number | boolean;
 export declare function startTransaction(): void;

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

@@ -0,0 +1,38 @@
+import { QueryState } from '../../shared/query';
+export type SpreadsheetHandlers = {
+    'get-cell': typeof getCell;
+    'get-cell-names': typeof getCellNames;
+    'create-query': typeof createQuery;
+};
+export declare const app: {
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
+    handlers: SpreadsheetHandlers;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
+    method<Name extends "get-cell" | "get-cell-names" | "create-query">(name: Name, func: SpreadsheetHandlers[Name]): void;
+    service(func: () => () => void): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};
+declare function getCell({ sheetName, name, }: {
+    sheetName: string;
+    name: string;
+}): Promise<{
+    name: string;
+    value: string | number | boolean;
+}>;
+declare function getCellNames({ sheetName }: {
+    sheetName: string;
+}): Promise<any[]>;
+declare function createQuery({ sheetName, name, query, }: {
+    sheetName: string;
+    name: string;
+    query: QueryState;
+}): Promise<string>;
+export {};

package/@types/loot-core/server/spreadsheet/graph-data-structure.d.ts

@@ -1,10 +1,10 @@
 export declare function Graph(): {
-    addNode: (node: any) => any;
-    removeNode: (node: any) => any;
+    addNode: (node: any) => /*elided*/ any;
+    removeNode: (node: any) => /*elided*/ any;
     adjacent: (node: any) => any;
     adjacentIncoming: (node: any) => any;
-    addEdge: (node1: any, node2: any) => any;
-    removeEdge: (node1: any, node2: any) => any;
+    addEdge: (node1: any, node2: any) => /*elided*/ any;
+    removeEdge: (node1: any, node2: any) => /*elided*/ any;
     removeIncomingEdges: (node: any) => void;
     topologicalSort: (sourceNodes: any) => any[];
     generateDOT: () => string;

package/@types/loot-core/server/spreadsheet/spreadsheet.d.ts

@@ -1,9 +1,10 @@
+import { QueryState } from '../../shared/query';
 export type Node = {
     name: string;
     expr: string | number | boolean;
     value: string | number | boolean;
     sheet: unknown;
-    query?: string;
+    query?: QueryState;
     sql?: {
         sqlPieces: unknown;
         state: {
@@ -61,7 +62,7 @@ export declare class Spreadsheet {
     set(name: string, value: string | number | boolean): void;
     recompute(name: string): void;
     recomputeAll(): void;
-    createQuery(sheetName: string, cellName: string, query: string): void;
+    createQuery(sheetName: string, cellName: string, query: QueryState): void;
     createStatic(sheetName: string, cellName: string, initialValue: number | boolean): void;
     createDynamic(sheetName: string, cellName: string, { dependencies, run, initialValue, refresh, }: {
         dependencies?: string[];

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

@@ -0,0 +1,38 @@
+export type SyncHandlers = {
+    sync: typeof sync;
+    'sync-reset': typeof resetSync;
+    'sync-repair': typeof repairSync;
+};
+export declare const app: {
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
+    handlers: SyncHandlers;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
+    method<Name extends "sync" | "sync-reset" | "sync-repair">(name: Name, func: SyncHandlers[Name]): void;
+    service(func: () => () => void): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};
+declare function sync(): Promise<{
+    messages: import(".").Message[];
+} | {
+    error: {
+        message: string;
+        reason: string;
+        meta: unknown;
+    };
+}>;
+declare function resetSync(): Promise<{
+    error?: {
+        reason: string;
+        meta?: unknown;
+    };
+}>;
+declare function repairSync(): Promise<void>;
+export {};

package/@types/loot-core/server/sync/make-test-message.d.ts

@@ -1,5 +1,5 @@
 export declare function makeTestMessage(keyId: any): Promise<{
-    value: Buffer;
+    value: Buffer<ArrayBufferLike>;
     meta: {
         keyId: any;
         algorithm: "aes-256-gcm";

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

@@ -1,4 +1,7 @@
-import { ToolsHandlers } from './types/handlers';
+import { TransactionEntity } from '../../types/models';
+export type ToolsHandlers = {
+    'tools/fix-split-transactions': typeof fixSplitTransactions;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -15,3 +18,12 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+declare function fixSplitTransactions(): Promise<{
+    numBlankPayees: number;
+    numCleared: number;
+    numDeleted: number;
+    numTransfersFixed: number;
+    numNonParentErrorsFixed: number;
+    mismatchedSplits: TransactionEntity[];
+}>;
+export {};

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

@@ -1,4 +1,5 @@
-import { type TransactionEntity, type RuleActionEntity, type RuleEntity, AccountEntity } from '../../types/models';
+import { type TransactionEntity, type RuleActionEntity, type RuleEntity } from '../../types/models';
+import * as db from '../db';
 import { Action, Rule } from '../rules';
 export { iterateIds } from '../rules';
 export declare function resetState(): void;
@@ -19,7 +20,7 @@ export declare function insertRule(rule: Omit<RuleEntity, 'id'> & {
 }): Promise<any>;
 export declare function updateRule(rule: any): Promise<void>;
 export declare function deleteRule(id: string): Promise<boolean>;
-export declare function runRules(trans: any, accounts?: Map<string, AccountEntity> | null): Promise<TransactionEntity>;
+export declare function runRules(trans: any, accounts?: Map<string, db.DbAccount> | null): Promise<TransactionEntity>;
 export declare function conditionsToAQL(conditions: any, { recurDateBounds, applySpecialCases }?: {
     recurDateBounds?: number;
     applySpecialCases?: boolean;
@@ -43,7 +44,7 @@ export declare function getProbableCategory(transactions: any): any;
 export declare function updateCategoryRules(transactions: any): Promise<void>;
 export type TransactionForRules = TransactionEntity & {
     payee_name?: string;
-    _account?: AccountEntity;
+    _account?: db.DbAccount;
 };
-export declare function prepareTransactionForRules(trans: TransactionEntity, accounts?: Map<string, AccountEntity> | null): Promise<TransactionForRules>;
+export declare function prepareTransactionForRules(trans: TransactionEntity, accounts?: Map<string, db.DbAccount> | null): Promise<TransactionForRules>;
 export declare function finalizeTransactionForRules(trans: TransactionEntity | TransactionForRules): Promise<TransactionEntity>;

package/@types/loot-core/server/undo.d.ts

@@ -9,6 +9,6 @@ export type UndoState = {
 export declare function appendMessages(messages: any, oldData: any): void;
 export declare function clearUndo(): void;
 export declare function withUndo<T>(func: () => Promise<T>, meta?: unknown): Promise<T>;
-export declare function undoable<T extends HandlerFunctions>(func: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+export declare function undoable<T extends HandlerFunctions>(func: T, metaFunc?: (...metaArgs: Parameters<T>) => unknown): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
 export declare function undo(): Promise<void>;
 export declare function redo(): Promise<void>;

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

@@ -1,3 +1,4 @@
-import { type HandlerFunctions } from '../types/handlers';
-export declare function sequential<T extends HandlerFunctions>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
-export declare function once<T extends HandlerFunctions>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>> | null;
+type AnyFunction = (...args: any[]) => any;
+export declare function sequential<T extends AnyFunction>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+export declare function once<T extends AnyFunction>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>> | null;
+export {};

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

@@ -0,0 +1 @@
+export declare function getLocale(language: string): Locale;

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

@@ -53,8 +53,8 @@ export declare function getWeekEnd(date: DateLike, firstDayOfWeekIdx?: SyncedPre
 export declare function getYearStart(month: string): string;
 export declare function getYearEnd(month: string): string;
 export declare function sheetForMonth(month: string): string;
-export declare function nameForMonth(month: DateLike): string;
-export declare function format(month: DateLike, format: string): string;
+export declare function nameForMonth(month: DateLike, locale?: Locale): string;
+export declare function format(month: DateLike, format: string, locale?: Locale): string;
 export declare const getDateFormatRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;
 export declare const getDayMonthFormat: import("memoize-one").MemoizedFn<(format: string) => string>;
 export declare const getDayMonthRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;

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

@@ -1,7 +1,9 @@
 import type { IRuleOptions } from '@rschedule/core';
+import { Condition } from '../server/rules';
 export declare function getStatus(nextDate: string, completed: boolean, hasTrans: boolean, upcomingLength: string): "completed" | "paid" | "due" | "upcoming" | "missed" | "scheduled";
+export declare function getStatusLabel(status: string): string;
 export declare function getHasTransactionsQuery(schedules: any): import("./query").Query;
-export declare function getRecurringDescription(config: any, dateFormat: any): string;
+export declare function getRecurringDescription(config: any, dateFormat: any, locale: Locale): string;
 export declare function recurConfigToRSchedule(config: any): IRuleOptions[];
 export declare function extractScheduleConds(conditions: any): {
     payee: any;
@@ -16,5 +18,5 @@ export declare function getScheduledAmount(amount: 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;
+export declare function getUpcomingDays(upcomingLength?: string, today?: string): number;
+export declare function scheduleIsRecurring(dateCond: Condition | null): boolean;

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

@@ -8,7 +8,7 @@ export type Diff<T extends {
 }> = {
     added: T[];
     updated: Partial<T>[];
-    deleted: Partial<T>[];
+    deleted: Pick<T, 'id'>[];
 };
 export declare function applyChanges<T extends {
     id: string;
@@ -80,4 +80,7 @@ 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 declare function tsToRelativeTime(ts: string | null, locale: Locale, options?: {
+    capitalize: boolean;
+}): string;
 export {};

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

@@ -1,14 +1,17 @@
 import type { AccountHandlers } from '../server/accounts/app';
-import type { AdminHandlers } from '../server/admin/types/handlers';
-import type { BudgetHandlers } from '../server/budget/types/handlers';
-import type { DashboardHandlers } from '../server/dashboard/types/handlers';
-import type { FiltersHandlers } from '../server/filters/types/handlers';
-import type { NotesHandlers } from '../server/notes/types/handlers';
+import type { AdminHandlers } from '../server/admin/app';
+import type { BudgetHandlers } from '../server/budget/app';
+import type { DashboardHandlers } from '../server/dashboard/app';
+import type { FiltersHandlers } from '../server/filters/app';
+import type { NotesHandlers } from '../server/notes/app';
+import type { PayeesHandlers } from '../server/payees/app';
 import type { PreferencesHandlers } from '../server/preferences/app';
-import type { ReportsHandlers } from '../server/reports/types/handlers';
-import type { RulesHandlers } from '../server/rules/types/handlers';
-import type { SchedulesHandlers } from '../server/schedules/types/handlers';
-import type { ToolsHandlers } from '../server/tools/types/handlers';
+import type { ReportsHandlers } from '../server/reports/app';
+import type { RulesHandlers } from '../server/rules/app';
+import type { SchedulesHandlers } from '../server/schedules/app';
+import type { SpreadsheetHandlers } from '../server/spreadsheet/app';
+import type { SyncHandlers } from '../server/sync/app';
+import type { ToolsHandlers } from '../server/tools/app';
 import type { TransactionHandlers } from '../server/transactions/app';
 
 import type { ApiHandlers } from './api-handlers';
@@ -28,6 +31,9 @@ export interface Handlers
     TransactionHandlers,
     AdminHandlers,
     ToolsHandlers,
-    AccountHandlers {}
+    AccountHandlers,
+    PayeesHandlers,
+    SpreadsheetHandlers,
+    SyncHandlers {}
 
 export type HandlerFunctions = Handlers[keyof Handlers];

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

@@ -4,6 +4,7 @@ export type AccountEntity = {
   offbudget: 0 | 1;
   closed: 0 | 1;
   sort_order: number;
+  last_reconciled: string | null;
   tombstone: 0 | 1;
 } & (_SyncFields<true> | _SyncFields<false>);
 
@@ -21,4 +22,4 @@ type _SyncFields<T> = {
   last_sync: T extends true ? string : null;
 };
 
-export type AccountSyncSource = 'simpleFin' | 'goCardless';
+export type AccountSyncSource = 'simpleFin' | 'goCardless' | 'pluggyai';

package/@types/loot-core/types/models/bank-sync.d.ts

@@ -20,4 +20,4 @@ export type BankSyncResponse = {
   error_code: string;
 };
 
-export type BankSyncProviders = 'goCardless' | 'simpleFin';
+export type BankSyncProviders = 'goCardless' | 'simpleFin' | 'pluggyai';

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

@@ -1,15 +1,19 @@
 export type * from './account';
+export type * from './bank';
 export type * from './bank-sync';
 export type * from './category';
 export type * from './category-group';
 export type * from './dashboard';
 export type * from './gocardless';
-export type * from './simplefin';
 export type * from './note';
+export type * from './openid';
 export type * from './payee';
+export type * from './pluggyai';
 export type * from './reports';
 export type * from './rule';
 export type * from './schedule';
+export type * from './simplefin';
 export type * from './transaction';
 export type * from './transaction-filter';
 export type * from './user';
+export type * from './user-access';

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

@@ -1,7 +1,8 @@
 export type OpenIdConfig = {
   selectedProvider: string;
-  issuer: string;
+  issuer?: string;
   client_id: string;
   client_secret: string;
   server_hostname: string;
+  discoveryURL: string;
 };

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

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

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

@@ -0,0 +1,18 @@
+export type PluggyAiOrganization = {
+  name: string;
+  domain: string;
+};
+
+export type PluggyAiAccount = {
+  id: string;
+  name: string;
+  org: PluggyAiOrganization;
+};
+
+export type SyncServerPluggyAiAccount = {
+  account_id: string;
+  institution?: string;
+  orgDomain?: string;
+  orgId?: string;
+  name: string;
+};

package/@types/loot-core/types/models/user-access.d.ts

@@ -0,0 +1,10 @@
+export interface NewUserAccessEntity {
+  fileId: string;
+  userId: string;
+}
+
+export interface UserAccessEntity extends NewUserAccessEntity {
+  displayName: string;
+  userName: string;
+  fileName: string;
+}

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

@@ -1,26 +1,25 @@
 export interface NewUserEntity {
-    userName: string;
-    displayName: string;
-    role: string;
-    enabled: boolean;
+  userName: string;
+  displayName: string;
+  role: string;
+  enabled: boolean;
 }
+
 export interface UserEntity extends NewUserEntity {
-    id: string;
-    owner: boolean;
+  id: string;
+  owner: boolean;
 }
+
 export interface UserEntityDropdown {
-    userId: string;
-    userName: string;
-    displayName?: string;
+  userId: string;
+  userName: string;
+  displayName?: string;
 }
+
 export interface UserAvailable {
-    userId: string;
-    displayName?: string;
-    userName: string;
-    haveAccess?: number;
-    owner?: number;
+  userId: string;
+  displayName?: string;
+  userName: string;
+  haveAccess?: number;
+  owner?: number;
 }
-export declare const PossibleRoles: {
-    ADMIN: string;
-    BASIC: string;
-};

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

@@ -3,7 +3,8 @@ export type FeatureFlag =
   | 'goalTemplatesUIEnabled'
   | 'actionTemplating'
   | 'contextMenus'
-  | 'openidAuth';
+  | 'openidAuth'
+  | 'pluggyAiBankSync';
 
 /**
  * Cross-device preferences. These sync across devices when they are changed.
@@ -31,6 +32,7 @@ export type SyncedPrefs = Partial<
     | `csv-has-header-${string}`
     | `custom-sync-mappings-${string}`
     | `sync-import-pending-${string}`
+    | `sync-reimport-deleted-${string}`
     | `sync-import-notes-${string}`
     | `ofx-fallback-missing-payee-${string}`
     | `flip-amount-${string}-${'csv' | 'qif'}`
@@ -88,6 +90,15 @@ export type GlobalPrefs = Partial<{
   preferredDarkTheme: DarkTheme;
   documentDir: string; // Electron only
   serverSelfSignedCert: string; // Electron only
+  syncServerConfig?: {
+    // Electron only
+    autoStart?: boolean;
+    port?: number;
+    ngrokConfig?: {
+      domain?: string;
+      authToken?: string;
+    };
+  };
 }>;
 
 // GlobalPrefsJson represents what's saved in the global-store.json file
@@ -108,6 +119,7 @@ export type GlobalPrefsJson = Partial<{
   theme?: GlobalPrefs['theme'];
   'preferred-dark-theme'?: GlobalPrefs['preferredDarkTheme'];
   'server-self-signed-cert'?: GlobalPrefs['serverSelfSignedCert'];
+  syncServerConfig?: GlobalPrefs['syncServerConfig'];
 }>;
 
 export type AuthMethods = 'password' | 'openid';