@actual-app/api 6.7.1 → 6.8.0

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

@@ -0,0 +1,7 @@
+export interface ToolsHandlers {
+  'tools/fix-split-transactions': () => Promise<{
+    numBlankPayees: number;
+    numCleared: number;
+    numDeleted: number;
+  }>;
+}

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

@@ -0,0 +1,14 @@
+import { type HandlerFunctions } from '../types/handlers';
+import { Message } from './sync';
+export type UndoState = {
+    messages: Message[];
+    meta?: unknown;
+    tables: string[];
+    undoTag: string;
+};
+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 undo(): Promise<void>;
+export declare function redo(): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function updateVersion(): Promise<void>;

package/@types/loot-core/server/util/budget-name.d.ts

@@ -0,0 +1,2 @@
+export declare function uniqueFileName(existingFiles: any): Promise<string>;
+export declare function idFromFileName(name: any): Promise<string>;

package/@types/loot-core/server/util/rschedule.d.ts

@@ -0,0 +1,5 @@
+import '@rschedule/standard-date-adapter/setup';
+import '@rschedule/json-tools/Schedule';
+export * from '@rschedule/standard-date-adapter';
+export * from '@rschedule/core';
+export * from '@rschedule/core/generators';

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

@@ -0,0 +1,3 @@
+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;

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

@@ -0,0 +1,4 @@
+export declare function isPreviewEnvironment(): boolean;
+export declare function isDevelopmentEnvironment(): boolean;
+export declare function isNonProductionEnvironment(): boolean;
+export declare function isElectron(): boolean;

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

@@ -0,0 +1,22 @@
+export declare function getUploadError({ reason, meta, }: {
+    reason: string;
+    meta?: unknown;
+}): string;
+export declare function getDownloadError({ reason, meta, fileName }: {
+    reason: any;
+    meta: any;
+    fileName: any;
+}): string;
+export declare function getCreateKeyError(error: any): string;
+export declare function getTestKeyError({ reason }: {
+    reason: any;
+}): string;
+export declare function getSyncError(error: any, id: any): string;
+export declare function getBankSyncError(error: {
+    message?: string;
+}): string;
+export declare class LazyLoadFailedError extends Error {
+    type: string;
+    meta: {};
+    constructor(name: string);
+}

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

@@ -0,0 +1,62 @@
+import { type LocalPrefs } from '../types/prefs';
+type DateLike = string | Date;
+export declare function _parse(value: DateLike): Date;
+export declare const parseDate: typeof _parse;
+export declare function yearFromDate(date: DateLike): string;
+export declare function monthFromDate(date: DateLike): string;
+export declare function weekFromDate(date: DateLike, firstDayOfWeekIdx: LocalPrefs['firstDayOfWeekIdx']): string;
+export declare function dayFromDate(date: DateLike): string;
+export declare function currentMonth(): string;
+export declare function currentWeek(firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string;
+export declare function currentYear(): string;
+export declare function currentDate(): Date;
+export declare function currentDay(): string;
+export declare function nextMonth(month: DateLike): string;
+export declare function prevYear(month: DateLike): string;
+export declare function prevMonth(month: DateLike): string;
+export declare function addYears(year: DateLike, n: number): string;
+export declare function addMonths(month: DateLike, n: number): string;
+export declare function addWeeks(date: DateLike, n: number): string;
+export declare function differenceInCalendarMonths(month1: DateLike, month2: DateLike): number;
+export declare function differenceInCalendarDays(month1: DateLike, month2: DateLike): number;
+export declare function subMonths(month: string | Date, n: number): string;
+export declare function subWeeks(date: DateLike, n: number): string;
+export declare function subYears(year: string | Date, n: number): string;
+export declare function addDays(day: DateLike, n: number): string;
+export declare function subDays(day: DateLike, n: number): string;
+export declare function isBefore(month1: DateLike, month2: DateLike): boolean;
+export declare function isAfter(month1: DateLike, month2: DateLike): boolean;
+export declare function bounds(month: DateLike): {
+    start: number;
+    end: number;
+};
+export declare function _yearRange(start: DateLike, end: DateLike, inclusive?: boolean): string[];
+export declare function yearRangeInclusive(start: DateLike, end: DateLike): string[];
+export declare function _weekRange(start: DateLike, end: DateLike, inclusive?: boolean, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string[];
+export declare function weekRangeInclusive(start: DateLike, end: DateLike, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string[];
+export declare function _range(start: DateLike, end: DateLike, inclusive?: boolean): string[];
+export declare function range(start: DateLike, end: DateLike): string[];
+export declare function rangeInclusive(start: DateLike, end: DateLike): string[];
+export declare function _dayRange(start: DateLike, end: DateLike, inclusive?: boolean): string[];
+export declare function dayRange(start: DateLike, end: DateLike): string[];
+export declare function dayRangeInclusive(start: DateLike, end: DateLike): string[];
+export declare function getMonthFromIndex(year: string, monthIndex: number): string;
+export declare function getMonthIndex(month: string): number;
+export declare function getYear(month: string): string;
+export declare function getMonth(day: string): string;
+export declare function getDay(day: string): number;
+export declare function getMonthEnd(day: string): string;
+export declare function getWeekEnd(date: DateLike, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string;
+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, str: string): 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>;
+export declare const getMonthYearFormat: import("memoize-one").MemoizedFn<(format: string) => string>;
+export declare const getMonthYearRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;
+export declare const getShortYearFormat: import("memoize-one").MemoizedFn<(format: string) => string>;
+export declare const getShortYearRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;
+export {};

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

@@ -0,0 +1,31 @@
+export type QueryState = {
+    filterExpressions: Array<string>;
+    selectExpressions: Array<unknown>;
+    groupExpressions: Array<unknown>;
+    orderExpressions: Array<unknown>;
+    calculation: boolean;
+    rawMode: boolean;
+    withDead: boolean;
+    validateRefs: boolean;
+    limit: number | null;
+    offset: number | null;
+};
+export declare class Query {
+    state: QueryState;
+    constructor(state: any);
+    filter(expr: any): Query;
+    unfilter(exprs: any): Query;
+    select(exprs?: Array<unknown> | unknown): 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(): QueryState;
+}
+export declare function getPrimaryOrderBy(query: any, defaultOrderBy: any): any;
+export declare function q(table: any): Query;

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

@@ -0,0 +1,62 @@
+export declare const TYPE_INFO: {
+    date: {
+        ops: string[];
+        nullable: boolean;
+    };
+    id: {
+        ops: string[];
+        nullable: boolean;
+    };
+    saved: {
+        ops: any[];
+        nullable: boolean;
+    };
+    string: {
+        ops: string[];
+        nullable: boolean;
+    };
+    number: {
+        ops: string[];
+        nullable: boolean;
+    };
+    boolean: {
+        ops: string[];
+        nullable: boolean;
+    };
+};
+export declare const FIELD_TYPES: Map<string, string>;
+export declare const ALLOCATION_METHODS: {
+    'fixed-amount': string;
+    'fixed-percent': string;
+    remainder: string;
+};
+export declare function mapField(field: any, opts?: any): any;
+export declare function friendlyOp(op: any, type?: any): "" | "is" | "contains" | "one of" | "not one of" | "is not" | "is approx" | "is between" | "does not contain" | "is after" | "is greater than" | "is after or equals" | "is greater than or equals" | "is before" | "is less than" | "is before or equals" | "is less than or equals" | "is true" | "is false" | "set" | "allocate" | "link schedule" | "and" | "or";
+export declare function deserializeField(field: any): {
+    field: string;
+    options: {
+        inflow: boolean;
+        outflow?: undefined;
+    };
+} | {
+    field: string;
+    options: {
+        outflow: boolean;
+        inflow?: undefined;
+    };
+} | {
+    field: any;
+    options?: undefined;
+};
+export declare function getFieldError(type: any): "Invalid date format" | "Value cannot be empty" | "Value must be a number" | "Please choose a valid field for this type of rule" | "Internal error, sorry! Please get in touch https://actualbudget.org/contact/ for support";
+export declare function sortNumbers(num1: any, num2: any): any[];
+export declare function parse(item: any): any;
+export declare function unparse({ error, inputKey, ...item }: {
+    [x: string]: any;
+    error: any;
+    inputKey: any;
+}): {
+    [x: string]: any;
+};
+export declare function makeValue(value: any, cond: any): any;
+export declare function getApproxNumberThreshold(number: any): number;

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

@@ -0,0 +1,43 @@
+import type { IRuleOptions } from '@rschedule/core';
+export declare function getStatus(nextDate: string, completed: boolean, hasTrans: boolean): "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").DateInput;
+    end?: import("@rschedule/core").DateInput;
+    duration?: number;
+    count?: number;
+    frequency: import("@rschedule/core").RuleOption.Frequency;
+    interval?: number;
+    weekStart?: import("@rschedule/core").DateAdapter.Weekday;
+    byDayOfWeek?: import("@rschedule/core").RuleOption.ByDayOfWeek[];
+    byHourOfDay?: import("@rschedule/core").DateAdapter.Hour[];
+    byMillisecondOfSecond?: number[];
+    byMinuteOfHour?: import("@rschedule/core").DateAdapter.Minute[];
+    byMonthOfYear?: import("@rschedule/core").DateAdapter.Month[];
+    bySecondOfMinute?: import("@rschedule/core").DateAdapter.Minute[];
+} | {
+    byDayOfWeek: any;
+    start: import("@rschedule/core").DateInput;
+    end?: import("@rschedule/core").DateInput;
+    duration?: number;
+    count?: number;
+    frequency: import("@rschedule/core").RuleOption.Frequency;
+    interval?: number;
+    weekStart?: import("@rschedule/core").DateAdapter.Weekday;
+    byDayOfMonth?: import("@rschedule/core").RuleOption.ByDayOfMonth[];
+    byHourOfDay?: import("@rschedule/core").DateAdapter.Hour[];
+    byMillisecondOfSecond?: number[];
+    byMinuteOfHour?: import("@rschedule/core").DateAdapter.Minute[];
+    byMonthOfYear?: import("@rschedule/core").DateAdapter.Month[];
+    bySecondOfMinute?: import("@rschedule/core").DateAdapter.Minute[];
+})[];
+export declare function extractScheduleConds(conditions: any): {
+    payee: any;
+    account: any;
+    amount: any;
+    date: any;
+};
+export declare function getScheduledAmount(amount: any): any;
+export declare function describeSchedule(schedule: any, payee: any): string;

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

@@ -0,0 +1,91 @@
+import { type TransactionEntity, type NewTransactionEntity } from '../types/models';
+import { 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 = NewTransactionEntity | TransactionEntity | TransactionEntityWithError;
+export declare function makeChild<T extends GenericTransactionEntity>(parent: T, data: object): T;
+export declare function recalculateSplit(trans: TransactionEntity): TransactionEntityWithError;
+export declare function ungroupTransactions(transactions: TransactionEntity[]): TransactionEntity[];
+export declare function groupTransaction(split: TransactionEntity[]): TransactionEntity;
+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 addSplitTransaction(transactions: TransactionEntity[], id: string): {
+    data: any[];
+    diff: {
+        deleted: any[];
+        updated: any[];
+    };
+    newTransaction?: undefined;
+} | {
+    data: TransactionEntity[];
+    newTransaction: TransactionEntityWithError | TransactionEntity;
+    diff: any;
+};
+export declare function updateTransaction(transactions: TransactionEntity[], transaction: TransactionEntity): {
+    data: any[];
+    diff: {
+        deleted: any[];
+        updated: any[];
+    };
+    newTransaction?: undefined;
+} | {
+    data: TransactionEntity[];
+    newTransaction: TransactionEntityWithError | TransactionEntity;
+    diff: any;
+};
+export declare function deleteTransaction(transactions: TransactionEntity[], id: string): {
+    data: any[];
+    diff: {
+        deleted: any[];
+        updated: any[];
+    };
+    newTransaction?: undefined;
+} | {
+    data: TransactionEntity[];
+    newTransaction: TransactionEntityWithError | TransactionEntity;
+    diff: any;
+};
+export declare function splitTransaction(transactions: TransactionEntity[], id: string): {
+    data: any[];
+    diff: {
+        deleted: any[];
+        updated: any[];
+    };
+    newTransaction?: undefined;
+} | {
+    data: TransactionEntity[];
+    newTransaction: TransactionEntityWithError | TransactionEntity;
+    diff: any;
+};
+export declare function realizeTempTransactions(transactions: TransactionEntity[]): {
+    id: string;
+    account: import("../types/models").AccountEntity;
+    category?: import("../types/models").CategoryEntity;
+    payee?: import("../types/models").PayeeEntity;
+    schedule?: import("../types/models").ScheduleEntity;
+    subtransactions?: TransactionEntity[];
+    sort_order?: number;
+    tombstone?: boolean;
+    imported_payee?: string;
+    date: string;
+    notes?: string;
+    amount: number;
+    cleared?: boolean;
+    reconciled?: boolean;
+    is_parent?: boolean;
+    is_child?: boolean;
+    parent_id?: string;
+    imported_id?: string;
+    starting_balance_flag?: boolean;
+    transfer_id?: string;
+}[];
+export {};

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

@@ -0,0 +1,67 @@
+export declare function last<T>(arr: Array<T>): T;
+export declare function getChangedValues<T extends {
+    id?: string;
+}>(obj1: T, obj2: T): Partial<T>;
+export declare function hasFieldsChanged<T extends object>(obj1: T, obj2: T, fields: Array<keyof T>): boolean;
+export declare function applyChanges<T extends {
+    id: string;
+}>(changes: {
+    added?: T[];
+    updated?: T[];
+    deleted?: T[];
+}, items: T[]): T[];
+export declare function partitionByField<T, K extends keyof T>(data: T[], field: K): Map<any, any>;
+export declare function groupBy<T, K extends keyof T>(data: T[], field: K): Map<T[K], T[]>;
+export declare function diffItems<T extends {
+    id: string;
+}>(items: T[], newItems: T[]): {
+    added: T[];
+    updated: Partial<T>[];
+    deleted: {
+        id: string;
+    }[];
+};
+export declare function groupById<T extends {
+    id: string;
+}>(data: T[]): {
+    [key: string]: T;
+};
+export declare function setIn(map: Map<string, unknown>, keys: string[], item: unknown): void;
+export declare function getIn(map: any, keys: any): any;
+export declare function fastSetMerge<T>(set1: Set<T>, set2: Set<T>): Set<T>;
+export declare function titleFirst(str: string): string;
+export declare function appendDecimals(amountText: string, hideDecimals?: boolean): string;
+type NumberFormats = 'comma-dot' | 'dot-comma' | 'space-comma' | 'space-dot' | 'comma-dot-in';
+export declare const numberFormats: Array<{
+    value: NumberFormats;
+    label: string;
+    labelNoFraction: string;
+}>;
+declare let numberFormatConfig: {
+    format: NumberFormats;
+    hideFraction: boolean;
+};
+export declare function setNumberFormat(config: typeof numberFormatConfig): void;
+export declare function getNumberFormat({ format, hideFraction, }?: {
+    format?: NumberFormats;
+    hideFraction: boolean;
+}): {
+    value: NumberFormats;
+    separator: any;
+    formatter: Intl.NumberFormat;
+    regex: any;
+    separatorRegex: any;
+};
+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 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

@@ -0,0 +1,158 @@
+import { type batchUpdateTransactions } from '../server/accounts/transactions';
+import type {
+  APIAccountEntity,
+  APICategoryEntity,
+  APICategoryGroupEntity,
+  APIPayeeEntity,
+} from '../server/api-models';
+
+import type { NewRuleEntity, RuleEntity, TransactionEntity } from './models';
+import { type ServerHandlers } from './server-handlers';
+
+export interface ApiHandlers {
+  'api/batch-budget-start': () => Promise<unknown>;
+
+  'api/batch-budget-end': () => Promise<unknown>;
+
+  'api/load-budget': (
+    ...args: Parameters<ServerHandlers['load-budget']>
+  ) => Promise<void>;
+
+  'api/download-budget': (arg: {
+    syncId: string;
+    password?: string;
+  }) => Promise<void>;
+
+  'api/start-import': (arg: { budgetName: string }) => Promise<void>;
+
+  'api/finish-import': () => Promise<void>;
+
+  'api/abort-import': () => Promise<void>;
+
+  'api/query': (arg: { query }) => Promise<unknown>;
+
+  'api/budget-months': () => Promise<string[]>;
+
+  'api/budget-month': (arg: { month }) => Promise<{
+    month: string;
+    incomeAvailable: number;
+    lastMonthOverspent: number;
+    forNextMonth: number;
+    totalBudgeted: number;
+    toBudget: number;
+
+    fromLastMonth: number;
+    totalIncome: number;
+    totalSpent: number;
+    totalBalance: number;
+    categoryGroups: Record<string, unknown>[];
+  }>;
+
+  'api/budget-set-amount': (arg: {
+    month: string;
+    categoryId: string;
+    amount: number;
+  }) => Promise<void>;
+
+  'api/budget-set-carryover': (arg: {
+    month: string;
+    categoryId: string;
+    flag: boolean;
+  }) => Promise<void>;
+
+  'api/transactions-export': (arg: {
+    transactions;
+    categoryGroups;
+    payees;
+  }) => Promise<unknown>;
+
+  'api/transactions-import': (arg: { accountId; transactions }) => Promise<{
+    errors?: { message: string }[];
+    added;
+    updated;
+  }>;
+
+  'api/transactions-add': (arg: {
+    accountId;
+    transactions;
+    runTransfers?: boolean;
+    learnCategories?: boolean;
+  }) => Promise<'ok'>;
+
+  'api/transactions-get': (arg: {
+    accountId?: string;
+    startDate?: string;
+    endDate?: string;
+  }) => Promise<TransactionEntity[]>;
+
+  'api/transaction-update': (arg: {
+    id;
+    fields;
+  }) => Promise<Awaited<ReturnType<typeof batchUpdateTransactions>>['updated']>;
+
+  'api/transaction-delete': (arg: {
+    id;
+  }) => Promise<Awaited<ReturnType<typeof batchUpdateTransactions>>['updated']>;
+
+  'api/sync': () => Promise<void>;
+
+  'api/bank-sync': (arg?: { accountId: string }) => Promise<void>;
+
+  'api/accounts-get': () => Promise<APIAccountEntity[]>;
+
+  'api/account-create': (arg: { account; initialBalance? }) => Promise<string>;
+
+  'api/account-update': (arg: { id; fields }) => Promise<void>;
+
+  'api/account-close': (arg: {
+    id;
+    transferAccountId;
+    transferCategoryId;
+  }) => Promise<unknown>;
+
+  'api/account-reopen': (arg: { id }) => Promise<unknown>;
+
+  'api/account-delete': (arg: { id }) => Promise<unknown>;
+
+  'api/categories-get': (arg: {
+    grouped;
+  }) => Promise<Array<APICategoryGroupEntity | APICategoryEntity>>;
+
+  'api/category-groups-get': () => Promise<APICategoryGroupEntity[]>;
+
+  'api/category-group-create': (arg: { group }) => Promise<string>;
+
+  'api/category-group-update': (arg: { id; fields }) => Promise<unknown>;
+
+  'api/category-group-delete': (arg: {
+    id;
+    transferCategoryId;
+  }) => Promise<unknown>;
+
+  'api/category-create': (arg: { category }) => Promise<string>;
+
+  'api/category-update': (arg: { id; fields }) => Promise<unknown>;
+
+  'api/category-delete': (arg: {
+    id;
+    transferCategoryId?;
+  }) => Promise<{ error?: string }>;
+
+  'api/payees-get': () => Promise<APIPayeeEntity[]>;
+
+  'api/payee-create': (arg: { payee }) => Promise<string>;
+
+  'api/payee-update': (arg: { id; fields }) => Promise<unknown>;
+
+  'api/payee-delete': (arg: { id }) => Promise<unknown>;
+
+  'api/rules-get': () => Promise<RuleEntity[]>;
+
+  'api/payee-rules-get': (arg: { id: string }) => Promise<RuleEntity[]>;
+
+  'api/rule-create': (arg: { rule: NewRuleEntity }) => Promise<RuleEntity>;
+
+  'api/rule-update': (arg: { rule: RuleEntity }) => Promise<RuleEntity>;
+
+  'api/rule-delete': (arg: { id: string }) => Promise<boolean>;
+}

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

@@ -0,0 +1,7 @@
+export type Budget = {
+  id: string;
+  cloudFileId?: string;
+  encryptKeyId?: string;
+  groupId?: string;
+  name: string;
+};

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

@@ -0,0 +1,38 @@
+import { Budget } from './budget';
+
+export type FileState =
+  | 'local'
+  | 'remote'
+  | 'synced'
+  | 'detached'
+  | 'broken'
+  | 'unknown';
+
+export type LocalFile = Omit<Budget, 'cloudFileId' | 'groupId'> & {
+  state: 'local';
+};
+
+export type SyncableLocalFile = Budget & {
+  cloudFileId: string;
+  groupId: string;
+  state: 'broken' | 'unknown';
+};
+
+export type SyncedLocalFile = Budget & {
+  cloudFileId: string;
+  groupId: string;
+  encryptKeyId?: string;
+  hasKey: boolean;
+  state: 'synced' | 'detached';
+};
+
+export type RemoteFile = {
+  cloudFileId: string;
+  groupId: string;
+  name: string;
+  encryptKeyId?: string;
+  hasKey: boolean;
+  state: 'remote';
+};
+
+export type File = LocalFile | SyncableLocalFile | SyncedLocalFile | RemoteFile;

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

@@ -0,0 +1,23 @@
+import type { BudgetHandlers } from '../server/budget/types/handlers';
+import type { FiltersHandlers } from '../server/filters/types/handlers';
+import type { NotesHandlers } from '../server/notes/types/handlers';
+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 { ApiHandlers } from './api-handlers';
+import type { ServerHandlers } from './server-handlers';
+
+export interface Handlers
+  extends ServerHandlers,
+    ApiHandlers,
+    BudgetHandlers,
+    FiltersHandlers,
+    NotesHandlers,
+    ReportsHandlers,
+    RulesHandlers,
+    SchedulesHandlers,
+    ToolsHandlers {}
+
+export type HandlerFunctions = Handlers[keyof Handlers];