@actual-app/api 6.7.0 → 6.8.0

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

@@ -0,0 +1,344 @@
+import { ParseFileResult } from '../server/accounts/parse-file';
+import { batchUpdateTransactions } from '../server/accounts/transactions';
+import { Backup } from '../server/backups';
+import { RemoteFile } from '../server/cloud-storage';
+import { Node as SpreadsheetNode } from '../server/spreadsheet/spreadsheet';
+import { Message } from '../server/sync';
+import { QueryState } from '../shared/query';
+
+import { Budget } from './budget';
+import {
+  AccountEntity,
+  CategoryEntity,
+  CategoryGroupEntity,
+  GoCardlessToken,
+  GoCardlessInstitution,
+  SimpleFinAccount,
+  RuleEntity,
+  PayeeEntity,
+} from './models';
+import { GlobalPrefs, LocalPrefs } from './prefs';
+import { EmptyObject } from './util';
+
+export interface ServerHandlers {
+  'transaction-update': (transaction: { id: string }) => Promise<EmptyObject>;
+
+  undo: () => Promise<void>;
+
+  redo: () => Promise<void>;
+
+  'transactions-batch-update': (
+    arg: Omit<
+      Parameters<typeof batchUpdateTransactions>[0],
+      'detectOrphanPayees'
+    >,
+  ) => Promise<Awaited<ReturnType<typeof batchUpdateTransactions>>['updated']>;
+
+  'transaction-add': (transaction) => Promise<EmptyObject>;
+
+  'transaction-delete': (transaction) => Promise<EmptyObject>;
+
+  'transactions-parse-file': (arg: {
+    filepath: string;
+    options;
+  }) => Promise<ParseFileResult>;
+
+  'transactions-export': (arg: {
+    transactions;
+    accounts?;
+    categoryGroups;
+    payees;
+  }) => Promise<unknown>;
+
+  'transactions-export-query': (arg: { query: QueryState }) => Promise<unknown>;
+
+  'get-categories': () => Promise<{
+    grouped: Array<CategoryGroupEntity>;
+    list: Array<CategoryEntity>;
+  }>;
+
+  'get-earliest-transaction': () => Promise<{ date: string }>;
+
+  'get-budget-bounds': () => Promise<{ start: string; end: string }>;
+
+  'rollover-budget-month': (arg: { month }) => Promise<
+    {
+      value: string | number | boolean;
+      name: string;
+    }[]
+  >;
+
+  'report-budget-month': (arg: { month }) => Promise<
+    {
+      value: string | number | boolean;
+      name: string;
+    }[]
+  >;
+
+  'budget-set-type': (arg: { type }) => Promise<unknown>;
+
+  'category-create': (arg: {
+    name;
+    groupId;
+    isIncome?;
+    hidden?: boolean;
+  }) => Promise<string>;
+
+  'category-update': (category) => Promise<unknown>;
+
+  'category-move': (arg: { id; groupId; targetId }) => Promise<unknown>;
+
+  'category-delete': (arg: { id; transferId? }) => Promise<{ error?: string }>;
+
+  'category-group-create': (arg: {
+    name;
+    isIncome?: boolean;
+  }) => Promise<string>;
+
+  'category-group-update': (group) => Promise<unknown>;
+
+  'category-group-move': (arg: { id; targetId }) => Promise<unknown>;
+
+  'category-group-delete': (arg: { id; transferId }) => Promise<unknown>;
+
+  'must-category-transfer': (arg: { id }) => Promise<unknown>;
+
+  'payee-create': (arg: { name }) => Promise<string>;
+
+  'payees-get': () => Promise<PayeeEntity[]>;
+
+  'payees-get-rule-counts': () => Promise<unknown>;
+
+  'payees-merge': (arg: { targetId; mergeIds }) => Promise<unknown>;
+
+  'payees-batch-change': (arg: {
+    added?;
+    deleted?;
+    updated?;
+  }) => Promise<unknown>;
+
+  'payees-check-orphaned': (arg: { ids }) => Promise<unknown>;
+
+  'payees-get-rules': (arg: { id: string }) => Promise<RuleEntity[]>;
+
+  'make-filters-from-conditions': (arg: {
+    conditions;
+  }) => Promise<{ filters: unknown[] }>;
+
+  getCell: (arg: {
+    sheetName;
+    name;
+  }) => Promise<SpreadsheetNode | { value?: SpreadsheetNode['value'] }>;
+
+  getCells: (arg: { names }) => Promise<unknown>;
+
+  getCellNamesInSheet: (arg: { sheetName }) => Promise<unknown>;
+
+  debugCell: (arg: { sheetName; name }) => Promise<unknown>;
+
+  'create-query': (arg: { sheetName; name; query }) => Promise<unknown>;
+
+  query: (query) => Promise<{ data; dependencies }>;
+
+  'account-update': (arg: { id; name }) => Promise<unknown>;
+
+  'accounts-get': () => Promise<AccountEntity[]>;
+
+  'account-properties': (arg: {
+    id;
+  }) => Promise<{ balance: number; numTransactions: number }>;
+
+  'gocardless-accounts-link': (arg: {
+    requisitionId;
+    account;
+    upgradingId;
+    offBudget;
+  }) => Promise<'ok'>;
+
+  'simplefin-accounts-link': (arg: {
+    externalAccount;
+    upgradingId;
+    offBudget;
+  }) => Promise<'ok'>;
+
+  'account-create': (arg: {
+    name: string;
+    balance?: number;
+    offBudget?: boolean;
+    closed?: 0 | 1;
+  }) => Promise<string>;
+
+  'account-close': (arg: {
+    id;
+    transferAccountId?;
+    categoryId?;
+    forced?;
+  }) => Promise<unknown>;
+
+  'account-reopen': (arg: { id }) => Promise<unknown>;
+
+  'account-move': (arg: { id; targetId }) => Promise<unknown>;
+
+  'secret-set': (arg: { name: string; value: string }) => Promise<null>;
+  'secret-check': (arg: string) => Promise<string | { error?: string }>;
+
+  'gocardless-poll-web-token': (arg: {
+    upgradingAccountId?: string;
+    requisitionId: string;
+  }) => Promise<
+    { error: 'unknown' } | { error: 'timeout' } | { data: GoCardlessToken }
+  >;
+
+  'gocardless-status': () => Promise<{ configured: boolean }>;
+
+  'simplefin-status': () => Promise<{ configured: boolean }>;
+
+  'simplefin-accounts': () => Promise<{ accounts: SimpleFinAccount[] }>;
+
+  'gocardless-get-banks': (country: string) => Promise<{
+    data: GoCardlessInstitution[];
+    error?: { reason: string };
+  }>;
+
+  'gocardless-poll-web-token-stop': () => Promise<'ok'>;
+
+  'gocardless-create-web-token': (arg: {
+    upgradingAccountId?: string;
+    institutionId: string;
+    accessValidForDays: number;
+  }) => Promise<
+    | {
+        requisitionId: string;
+        link: string;
+      }
+    | { error: 'unauthorized' }
+    | { error: 'failed' }
+  >;
+
+  'accounts-bank-sync': (arg: { id?: string }) => Promise<{
+    errors;
+    newTransactions;
+    matchedTransactions;
+    updatedAccounts;
+  }>;
+
+  'transactions-import': (arg: { accountId; transactions }) => Promise<{
+    errors?: { message: string }[];
+    added;
+    updated;
+  }>;
+
+  'account-unlink': (arg: { id }) => Promise<'ok'>;
+
+  'save-global-prefs': (prefs) => Promise<'ok'>;
+
+  'load-global-prefs': () => Promise<GlobalPrefs>;
+
+  'save-prefs': (prefsToSet) => Promise<'ok'>;
+
+  'load-prefs': () => Promise<LocalPrefs | null>;
+
+  'sync-reset': () => Promise<{ error?: { reason: string; meta?: unknown } }>;
+
+  'sync-repair': () => Promise<unknown>;
+
+  'key-make': (arg: {
+    password;
+  }) => Promise<{ error?: { reason: string; meta?: unknown } }>;
+
+  'key-test': (arg: {
+    fileId;
+    password;
+  }) => Promise<{ error?: { reason: string } }>;
+
+  'get-did-bootstrap': () => Promise<boolean>;
+
+  'subscribe-needs-bootstrap': (args: {
+    url;
+  }) => Promise<
+    { error: string } | { bootstrapped: unknown; hasServer: boolean }
+  >;
+
+  'subscribe-bootstrap': (arg: { password }) => Promise<{ error?: string }>;
+
+  'subscribe-get-user': () => Promise<{ offline: boolean } | null>;
+
+  'subscribe-change-password': (arg: {
+    password;
+  }) => Promise<{ error?: string }>;
+
+  'subscribe-sign-in': (arg: {
+    password;
+    loginMethod?: string;
+  }) => Promise<{ error?: string }>;
+
+  'subscribe-sign-out': () => Promise<'ok'>;
+
+  'get-server-version': () => Promise<{ error?: string } | { version: string }>;
+
+  'get-server-url': () => Promise<string | null>;
+
+  'set-server-url': (arg: {
+    url: string;
+    validate?: boolean;
+  }) => Promise<{ error?: string }>;
+
+  sync: () => Promise<
+    | { error: { message: string; reason: string; meta: unknown } }
+    | { messages: Message[] }
+  >;
+
+  'get-budgets': () => Promise<Budget[]>;
+
+  'get-remote-files': () => Promise<RemoteFile[]>;
+
+  'reset-budget-cache': () => Promise<unknown>;
+
+  'upload-budget': (arg: { id }) => Promise<{ error?: string }>;
+
+  'download-budget': (arg: { fileId; replace? }) => Promise<{ error; id }>;
+
+  'sync-budget': () => Promise<{
+    error?: { message: string; reason: string; meta: unknown };
+  }>;
+
+  'load-budget': (arg: { id: string }) => Promise<{ error }>;
+
+  'create-demo-budget': () => Promise<unknown>;
+
+  'close-budget': () => Promise<'ok'>;
+
+  'delete-budget': (arg: {
+    id?: string;
+    cloudFileId?: string;
+  }) => Promise<'ok'>;
+
+  'create-budget': (arg: {
+    budgetName?;
+    avoidUpload?;
+    testMode?: boolean;
+    testBudgetId?;
+  }) => Promise<unknown>;
+
+  'import-budget': (arg: {
+    filepath: string;
+    type: 'ynab4' | 'ynab5' | 'actual';
+  }) => Promise<{ error?: string }>;
+
+  'export-budget': () => Promise<{ data: Buffer } | { error: string }>;
+
+  'upload-file-web': (arg: {
+    filename: string;
+    contents: ArrayBuffer;
+  }) => Promise<EmptyObject | null>;
+
+  'backups-get': (arg: { id: string }) => Promise<Backup[]>;
+
+  'backup-load': (arg: { id: string; backupId: string }) => Promise<void>;
+
+  'backup-make': (arg: { id: string }) => Promise<void>;
+
+  'get-last-opened-backup': () => Promise<string | null>;
+
+  'app-focused': () => Promise<void>;
+}

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

@@ -0,0 +1,5 @@
+export type EmptyObject = Record<never, never>;
+
+export type StripNever<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K];
+};

package/@types/methods.d.ts

@@ -0,0 +1,85 @@
+export { q } from './app/query';
+export declare function runImport(name: any, func: any): Promise<void>;
+export declare function loadBudget(budgetId: any): Promise<void>;
+export declare function downloadBudget(syncId: any, { password }?: {
+    password?: any;
+}): Promise<void>;
+export declare function sync(): Promise<void>;
+export declare function runBankSync(args?: {
+    accountId: string;
+}): Promise<void>;
+export declare function batchBudgetUpdates(func: any): Promise<void>;
+export declare function runQuery(query: any): Promise<unknown>;
+export declare function getBudgetMonths(): Promise<string[]>;
+export declare function getBudgetMonth(month: any): 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>[];
+}>;
+export declare function setBudgetAmount(month: any, categoryId: any, value: any): Promise<void>;
+export declare function setBudgetCarryover(month: any, categoryId: any, flag: any): Promise<void>;
+export declare function addTransactions(accountId: any, transactions: any, { learnCategories, runTransfers }?: {
+    learnCategories?: boolean;
+    runTransfers?: boolean;
+}): Promise<"ok">;
+export declare function importTransactions(accountId: any, transactions: any): Promise<{
+    errors?: {
+        message: string;
+    }[];
+    added: any;
+    updated: any;
+}>;
+export declare function getTransactions(accountId: any, startDate: any, endDate: any): Promise<import("./loot-core/types/models").TransactionEntity[]>;
+export declare function updateTransaction(id: any, fields: any): Promise<import("./loot-core/types/models").TransactionEntity[] | ({
+    id: any;
+    transfer_id: any;
+} | {
+    id: any;
+    payee: any;
+} | {
+    id: any;
+    category: any;
+})[]>;
+export declare function deleteTransaction(id: any): Promise<import("./loot-core/types/models").TransactionEntity[] | ({
+    id: any;
+    transfer_id: any;
+} | {
+    id: any;
+    payee: any;
+} | {
+    id: any;
+    category: any;
+})[]>;
+export declare function getAccounts(): Promise<import("./loot-core/server/api-models").APIAccountEntity[]>;
+export declare function createAccount(account: any, initialBalance?: any): Promise<string>;
+export declare function updateAccount(id: any, fields: any): Promise<void>;
+export declare function closeAccount(id: any, transferAccountId?: any, transferCategoryId?: any): Promise<unknown>;
+export declare function reopenAccount(id: any): Promise<unknown>;
+export declare function deleteAccount(id: any): Promise<unknown>;
+export declare function getCategoryGroups(): Promise<import("./loot-core/server/api-models").APICategoryGroupEntity[]>;
+export declare function createCategoryGroup(group: any): Promise<string>;
+export declare function updateCategoryGroup(id: any, fields: any): Promise<unknown>;
+export declare function deleteCategoryGroup(id: any, transferCategoryId?: any): Promise<unknown>;
+export declare function getCategories(): Promise<(import("./loot-core/server/api-models").APICategoryGroupEntity | import("./loot-core/server/api-models").APICategoryEntity)[]>;
+export declare function createCategory(category: any): Promise<string>;
+export declare function updateCategory(id: any, fields: any): Promise<unknown>;
+export declare function deleteCategory(id: any, transferCategoryId?: any): Promise<{
+    error?: string;
+}>;
+export declare function getPayees(): Promise<import("./loot-core/server/api-models").APIPayeeEntity[]>;
+export declare function createPayee(payee: any): Promise<string>;
+export declare function updatePayee(id: any, fields: any): Promise<unknown>;
+export declare function deletePayee(id: any): Promise<unknown>;
+export declare function getRules(): Promise<import("./loot-core/types/models").RuleEntity[]>;
+export declare function getPayeeRules(id: any): Promise<import("./loot-core/types/models").RuleEntity[]>;
+export declare function createRule(rule: any): Promise<import("./loot-core/types/models").RuleEntity>;
+export declare function updateRule(rule: any): Promise<import("./loot-core/types/models").RuleEntity>;
+export declare function deleteRule(id: any): Promise<boolean>;

package/@types/methods.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/migrations/1632571489012_remove_cache.d.ts

@@ -0,0 +1 @@
+export default function runMigration(db: any): Promise<void>;

package/@types/utils.d.ts

@@ -0,0 +1,2 @@
+export function amountToInteger(n: any): number;
+export function integerToAmount(n: any): number;

package/@types/validateNodeVersion.d.ts

@@ -0,0 +1 @@
+export function validateNodeVersion(): void;