@actual-app/api 25.2.1 → 25.3.0

package/@types/index.d.ts

@@ -1,6 +1,5 @@
 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>;

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

@@ -42,7 +42,7 @@ type FinanceModals = {
   'select-linked-accounts': {
     accounts: unknown[];
     requisitionId?: string;
-    upgradingAccountId?: string;
+    upgradingAccountId?: string | undefined;
     syncSource?: AccountSyncSource;
   };
 
@@ -74,7 +74,7 @@ type FinanceModals = {
     onMoveExternal: (arg: {
       institutionId: string;
     }) => Promise<{ error: string } | { data: unknown }>;
-    onClose?: () => void;
+    onClose?: (() => void) | undefined;
     onSuccess: (data: GoCardlessToken) => Promise<void>;
   };
 
@@ -186,6 +186,11 @@ type FinanceModals = {
   'schedules-upcoming-length': null;
 
   'schedule-posts-offline-notification': null;
+
+  'synced-account-edit': {
+    account: AccountEntity;
+  };
+
   'account-menu': {
     accountId: string;
     onSave: (account: AccountEntity) => void;
@@ -342,6 +347,7 @@ type FinanceModals = {
   };
   'keyboard-shortcuts': EmptyObject;
   'goal-templates': EmptyObject;
+  'category-automations-edit': EmptyObject;
 };
 
 export type PushModalAction = {

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

@@ -1,21 +1,23 @@
 import type * as constants from '../constants';
 
 export type Notification = {
-  id?: string;
+  id?: string | undefined;
   // 'warning' is unhandled??
   type?: 'message' | 'error' | 'warning';
-  pre?: string;
-  title?: string;
+  pre?: string | undefined;
+  title?: string | undefined;
   message: string;
-  sticky?: boolean;
-  timeout?: number;
-  button?: {
-    title: string;
-    action: () => void | Promise<void>;
-  };
-  messageActions?: Record<string, () => void>;
-  onClose?: () => void;
-  internal?: string;
+  sticky?: boolean | undefined;
+  timeout?: number | undefined;
+  button?:
+    | {
+        title: string;
+        action: () => void | Promise<void>;
+      }
+    | undefined;
+  messageActions?: Record<string, () => void> | undefined;
+  onClose?: (() => void) | undefined;
+  internal?: string | undefined;
 };
 type NotificationWithId = Notification & { id: string };
 

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

@@ -1,8 +1,5 @@
 import type { AccountEntity, CategoryEntity, CategoryGroupEntity, NewCategoryGroupEntity, TransactionEntity } from '../types/models';
-export declare function generateAccount(name: AccountEntity['name'], isConnected?: boolean, offbudget?: boolean): AccountEntity & {
-    bankId: number | null;
-    bankName: string | null;
-};
+export declare function generateAccount(name: AccountEntity['name'], isConnected?: boolean, offbudget?: boolean): AccountEntity;
 export declare function generateCategory(name: string, group: string, isIncome?: boolean): CategoryEntity;
 export declare function generateCategoryGroup(name: string, isIncome?: boolean): CategoryGroupEntity;
 export declare function generateCategoryGroups(definition: Partial<NewCategoryGroupEntity>[]): CategoryGroupEntity[];

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

@@ -7,25 +7,31 @@ export type Init = typeof init;
 
 export function send<K extends keyof Handlers>(
   name: K,
-  args?: Parameters<Handlers[K]>[0],
-  options?: { catchErrors: true },
-): ReturnType<
-  | { data: Handlers[K] }
-  | { error: { type: 'APIError' | 'InternalError'; message: string } }
+  args: Parameters<Handlers[K]>[0],
+  options: { catchErrors: true },
+): Promise<
+  | { data: Awaited<ReturnType<Handlers[K]>>; error: undefined }
+  | {
+      data: undefined;
+      error: { type: 'APIError' | 'InternalError'; message: string };
+    }
 >;
 export function send<K extends keyof Handlers>(
   name: K,
   args?: Parameters<Handlers[K]>[0],
   options?: { catchErrors?: boolean },
-): ReturnType<Handlers[K]>;
+): Promise<Awaited<ReturnType<Handlers[K]>>>;
 export type Send = typeof send;
 
 export function sendCatch<K extends keyof Handlers>(
   name: K,
   args?: Parameters<Handlers[K]>[0],
-): ReturnType<
-  | { data: Handlers[K] }
-  | { error: { type: 'APIError' | 'InternalError'; message: string } }
+): Promise<
+  | { data: Awaited<ReturnType<Handlers[K]>>; error: undefined }
+  | {
+      data: undefined;
+      error: { type: 'APIError' | 'InternalError'; message: string };
+    }
 >;
 export type SendCatch = typeof sendCatch;
 

package/@types/loot-core/platform/server/asyncStorage/index.d.ts

@@ -1,20 +1,34 @@
+import { GlobalPrefs, GlobalPrefsJson } from '../../../types/prefs';
+
 export function init(opts?: { persist?: boolean }): void;
 export type Init = typeof init;
 
-export function getItem(key: string): Promise<string>;
+type InferType<K extends keyof GlobalPrefsJson> = GlobalPrefs[K];
+
+export function getItem<K extends keyof GlobalPrefsJson>(
+  key: K,
+): Promise<GlobalPrefsJson[K]>;
 export type GetItem = typeof getItem;
 
-export function setItem(key: string, value: unknown): void;
+export function setItem<K extends keyof GlobalPrefsJson>(
+  key: K,
+  value: GlobalPrefsJson[K],
+): void;
 export type SetItem = typeof setItem;
 
-export function removeItem(key: string): void;
+export function removeItem(key: keyof GlobalPrefsJson): void;
 export type RemoveItem = typeof removeItem;
 
-export function multiGet(keys: string[]): Promise<[string, string][]>;
+export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+  keys: K,
+): Promise<{ [P in keyof K]: [K[P], GlobalPrefsJson[K[P]]] }>;
 export type MultiGet = typeof multiGet;
 
-export function multiSet(keyValues: [string, unknown][]): void;
+export function multiSet<K extends keyof GlobalPrefsJson>(
+  keyValues: Array<[K, GlobalPrefsJson[K]]>,
+): void;
+
 export type MultiSet = typeof multiSet;
 
-export function multiRemove(keys: string[]): void;
+export function multiRemove(keys: (keyof GlobalPrefsJson)[]): void;
 export type MultiRemove = typeof multiRemove;

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

@@ -0,0 +1,149 @@
+import { AccountEntity, CategoryEntity, SyncServerGoCardlessAccount, TransactionEntity, SyncServerSimpleFinAccount } from '../../types/models';
+import * as bankSync from './sync';
+export type AccountHandlers = {
+    'account-update': typeof updateAccount;
+    'accounts-get': typeof getAccounts;
+    'account-balance': typeof getAccountBalance;
+    'account-properties': typeof getAccountProperties;
+    'gocardless-accounts-link': typeof linkGoCardlessAccount;
+    'simplefin-accounts-link': typeof linkSimpleFinAccount;
+    'account-create': typeof createAccount;
+    'account-close': typeof closeAccount;
+    'account-reopen': typeof reopenAccount;
+    'account-move': typeof moveAccount;
+    'secret-set': typeof setSecret;
+    'secret-check': typeof checkSecret;
+    'gocardless-poll-web-token': typeof pollGoCardlessWebToken;
+    'gocardless-poll-web-token-stop': typeof stopGoCardlessWebTokenPolling;
+    'gocardless-status': typeof goCardlessStatus;
+    'simplefin-status': typeof simpleFinStatus;
+    'simplefin-accounts': typeof simpleFinAccounts;
+    'gocardless-get-banks': typeof getGoCardlessBanks;
+    'gocardless-create-web-token': typeof createGoCardlessWebToken;
+    'accounts-bank-sync': typeof accountsBankSync;
+    'simplefin-batch-sync': typeof simpleFinBatchSync;
+    'transactions-import': typeof importTransactions;
+    'account-unlink': typeof unlinkAccount;
+};
+declare function updateAccount({ id, name }: Pick<AccountEntity, 'id' | 'name'>): Promise<{}>;
+declare function getAccounts(): Promise<any[]>;
+declare function getAccountBalance({ id, cutoff, }: {
+    id: string;
+    cutoff: string | Date;
+}): Promise<number>;
+declare function getAccountProperties({ id }: {
+    id: AccountEntity['id'];
+}): Promise<{
+    balance: number;
+    numTransactions: number;
+}>;
+declare function linkGoCardlessAccount({ requisitionId, account, upgradingId, offBudget, }: {
+    requisitionId: string;
+    account: SyncServerGoCardlessAccount;
+    upgradingId?: AccountEntity['id'] | undefined;
+    offBudget?: boolean | undefined;
+}): Promise<string>;
+declare function linkSimpleFinAccount({ externalAccount, upgradingId, offBudget, }: {
+    externalAccount: SyncServerSimpleFinAccount;
+    upgradingId?: AccountEntity['id'] | undefined;
+    offBudget?: boolean | undefined;
+}): Promise<string>;
+declare function createAccount({ name, balance, offBudget, closed, }: {
+    name: string;
+    balance?: number | undefined;
+    offBudget?: boolean | undefined;
+    closed?: boolean | undefined;
+}): Promise<string>;
+declare function closeAccount({ id, transferAccountId, categoryId, forced, }: {
+    id: AccountEntity['id'];
+    transferAccountId?: AccountEntity['id'] | undefined;
+    categoryId?: CategoryEntity['id'] | undefined;
+    forced?: boolean | undefined;
+}): Promise<void>;
+declare function reopenAccount({ id }: {
+    id: AccountEntity['id'];
+}): Promise<void>;
+declare function moveAccount({ id, targetId, }: {
+    id: AccountEntity['id'];
+    targetId: AccountEntity['id'];
+}): Promise<void>;
+declare function setSecret({ name, value, }: {
+    name: string;
+    value: string | null;
+}): Promise<any>;
+declare function checkSecret(name: string): Promise<string | {
+    error: string;
+}>;
+declare function pollGoCardlessWebToken({ requisitionId, }: {
+    requisitionId: string;
+}): Promise<unknown>;
+declare function stopGoCardlessWebTokenPolling(): Promise<string>;
+declare function goCardlessStatus(): Promise<any>;
+declare function simpleFinStatus(): Promise<any>;
+declare function simpleFinAccounts(): Promise<any>;
+declare function getGoCardlessBanks(country: string): Promise<any>;
+declare function createGoCardlessWebToken({ institutionId, accessValidForDays, }: {
+    institutionId: string;
+    accessValidForDays: number;
+}): Promise<any>;
+type SyncResponse = {
+    newTransactions: Array<TransactionEntity['id']>;
+    matchedTransactions: Array<TransactionEntity['id']>;
+    updatedAccounts: Array<AccountEntity['id']>;
+};
+type SyncError = {
+    type: 'SyncError';
+    accountId: AccountEntity['id'];
+    message: string;
+    category: string;
+    code: string;
+} | {
+    accountId: AccountEntity['id'];
+    message: string;
+    internal?: string;
+};
+export type SyncResponseWithErrors = SyncResponse & {
+    errors: SyncError[];
+};
+declare function accountsBankSync({ ids, }: {
+    ids: Array<AccountEntity['id']>;
+}): Promise<SyncResponseWithErrors>;
+declare function simpleFinBatchSync({ ids, }: {
+    ids: Array<AccountEntity['id']>;
+}): Promise<Array<{
+    accountId: AccountEntity['id'];
+    res: SyncResponseWithErrors;
+}>>;
+type ImportTransactionsResult = bankSync.ReconcileTransactionsResult & {
+    errors: Array<{
+        message: string;
+    }>;
+};
+declare function importTransactions({ accountId, transactions, isPreview, opts, }: {
+    accountId: AccountEntity['id'];
+    transactions: TransactionEntity[];
+    isPreview: boolean;
+    opts?: {
+        defaultCleared: boolean;
+    };
+}): Promise<ImportTransactionsResult>;
+declare function unlinkAccount({ id }: {
+    id: AccountEntity['id'];
+}): Promise<string>;
+export declare const app: {
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
+    handlers: AccountHandlers;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
+    method<Name extends "account-update" | "accounts-get" | "account-balance" | "account-properties" | "gocardless-accounts-link" | "simplefin-accounts-link" | "account-create" | "account-close" | "account-reopen" | "account-move" | "secret-set" | "secret-check" | "gocardless-poll-web-token" | "gocardless-poll-web-token-stop" | "gocardless-status" | "simplefin-status" | "simplefin-accounts" | "gocardless-get-banks" | "gocardless-create-web-token" | "accounts-bank-sync" | "simplefin-batch-sync" | "transactions-import" | "account-unlink">(name: Name, func: AccountHandlers[Name]): void;
+    service(func: () => () => void): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};
+export {};

package/@types/loot-core/server/accounts/payees.d.ts

@@ -1,5 +1,5 @@
-export declare function createPayee(description: any): Promise<any>;
+export declare function createPayee(description: any): Promise<string>;
 export declare function getStartingBalancePayee(): Promise<{
-    id: any;
-    category: any;
+    id: string;
+    category: string;
 }>;

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

@@ -1,10 +1,15 @@
-import { AccountEntity } from '../../types/models';
+import { AccountEntity, TransactionEntity } from '../../types/models';
 export declare function getGoCardlessAccounts(userId: any, userKey: any, id: any): Promise<any>;
-export declare function reconcileTransactions(acctId: any, transactions: any, isBankSyncAccount?: boolean, strictIdChecking?: boolean, isPreview?: boolean, defaultCleared?: boolean): Promise<{
-    added: any[];
-    updated: any[];
-    updatedPreview: any[];
-}>;
+export type ReconcileTransactionsResult = {
+    added: string[];
+    updated: string[];
+    updatedPreview: Array<{
+        transaction: TransactionEntity;
+        existing?: TransactionEntity;
+        ignored?: boolean;
+    }>;
+};
+export declare function reconcileTransactions(acctId: any, transactions: any, isBankSyncAccount?: boolean, strictIdChecking?: boolean, isPreview?: boolean, defaultCleared?: boolean): Promise<ReconcileTransactionsResult>;
 export declare function matchTransactions(acctId: any, transactions: any, isBankSyncAccount?: boolean, strictIdChecking?: boolean): Promise<{
     payeesToCreate: Map<any, any>;
     transactionsStep1: any[];
@@ -15,15 +20,16 @@ export declare function addTransactions(acctId: any, transactions: any, { runTra
     runTransfers?: boolean;
     learnCategories?: boolean;
 }): Promise<any>;
-export declare function syncAccount(userId: string, userKey: string, id: string, acctId: string, bankId: string): Promise<{
+export declare function syncAccount(userId: string | undefined, userKey: string | undefined, id: string, acctId: string, bankId: string): Promise<{
     added: any[];
-    updated: any[];
-    updatedPreview: any[];
+    updated: string[];
+    updatedPreview: Array<{
+        transaction: TransactionEntity;
+        existing?: TransactionEntity;
+        ignored?: boolean;
+    }>;
 } | {
     added: any[];
     updated: any[];
 }>;
-export declare function SimpleFinBatchSync(accounts: {
-    id: AccountEntity['id'];
-    accountId: AccountEntity['account_id'];
-}[]): Promise<any[]>;
+export declare function simpleFinBatchSync(accounts: Array<Pick<AccountEntity, 'id' | 'account_id'>>): Promise<any[]>;

package/@types/loot-core/server/aql/exec.d.ts

@@ -1,4 +1,4 @@
-export declare function execQuery(queryState: any, state: any, sqlPieces: any, params: any, outputTypes: any): Promise<any>;
+export declare function execQuery(queryState: any, state: any, sqlPieces: any, params: any, outputTypes: any): Promise<any[]>;
 export declare function runCompiledQuery(query: any, pieces: any, state: any, { params, executors }?: {
     params?: {};
     executors?: {};

package/@types/loot-core/server/aql/schema/index.d.ts

@@ -61,6 +61,9 @@ export declare const schema: {
         schedule: {
             type: string;
         };
+        raw_synced_data: {
+            type: string;
+        };
     };
     payees: {
         id: {
@@ -107,6 +110,9 @@ export declare const schema: {
         account_sync_source: {
             type: string;
         };
+        last_sync: {
+            type: string;
+        };
     };
     categories: {
         id: {

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

@@ -1,7 +1,8 @@
 import { CategoryEntity } from '../../types/models';
 import { Template } from './types/templates';
 export declare class CategoryTemplate {
-    static init(templates: Template[], category: CategoryEntity, month: any): Promise<CategoryTemplate>;
+    static init(templates: Template[], category: CategoryEntity, month: any, budgeted: number): Promise<CategoryTemplate>;
+    getGoalOnly(): boolean;
     getPriorities(): number[];
     getRemainderWeight(): number;
     getLimitExcess(): number;
@@ -30,6 +31,7 @@ export declare class CategoryTemplate {
     private limitAmount;
     private limitCheck;
     private limitHold;
+    readonly previouslyBudgeted: number;
     private constructor();
     private runGoal;
     static checkByAndScheduleAndSpend(templates: any, month: any): Promise<void>;

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

@@ -1,4 +1,4 @@
-import { Schedule } from '../db/types';
+import { DbSchedule } from '../db';
 export declare function resetCategoryGoalDefsWithNoTemplates(): Promise<void>;
 export type CategoryWithTemplateNote = {
     id: string;
@@ -6,4 +6,4 @@ export type CategoryWithTemplateNote = {
     note: string;
 };
 export declare function getCategoriesWithTemplateNotes(): Promise<CategoryWithTemplateNote[]>;
-export declare function getActiveSchedules(): Promise<Schedule[]>;
+export declare function getActiveSchedules(): Promise<DbSchedule[]>;

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

@@ -45,6 +45,7 @@ interface ScheduleTemplate extends BaseTemplate {
   type: 'schedule';
   name: string;
   full?: boolean;
+  adjustment?: number;
 }
 
 interface RemainderTemplate extends BaseTemplate {
@@ -59,7 +60,7 @@ interface AverageTemplate extends BaseTemplate {
 }
 
 interface GoalTemplate extends BaseTemplate {
-  type: 'simple';
+  type: 'goal';
   amount: number;
 }
 

package/@types/loot-core/server/db/index.d.ts

@@ -1,5 +1,7 @@
 import { Database } from '@jlongster/sql.js';
 import { CategoryEntity, CategoryGroupEntity } from '../../types/models';
+import { DbAccount, DbCategory, DbCategoryGroup, DbPayee, DbTransaction, DbViewTransaction } from './types';
+export * from './types';
 export { toDateRepr, fromDateRepr } from '../models';
 export declare function getDatabasePath(): string;
 export declare function openDatabase(id?: string): Promise<void>;
@@ -47,28 +49,32 @@ export declare function getDatabase(): {
     run(sql: string, params?: import("@jlongster/sql.js").BindParams): any;
 };
 export declare function loadClock(): Promise<void>;
-export declare function runQuery(sql: string, params?: Array<string | number>, fetchAll?: false): any;
-export declare function runQuery(sql: string, params: Array<string | number> | undefined, fetchAll: true): any;
+export declare function runQuery(sql: string, params?: Array<string | number>, fetchAll?: false): {
+    changes: unknown;
+};
+export declare function runQuery<T>(sql: string, params: Array<string | number> | undefined, fetchAll: true): T[];
 export declare function execQuery(sql: string): void;
-export declare function cache(sql: string): any;
+export declare function cache(sql: string): string;
 export declare function transaction(fn: () => void): void;
 export declare function asyncTransaction(fn: () => Promise<void>): Promise<void>;
-export declare function all(sql: any, params?: (string | number)[]): Promise<any>;
+export declare function all(sql: any, params?: (string | number)[]): Promise<any[]>;
 export declare function first(sql: any, params?: (string | number)[]): Promise<any>;
 export declare function firstSync(sql: any, params?: (string | number)[]): any;
-export declare function run(sql: any, params?: (string | number)[]): Promise<any>;
+export declare function run(sql: any, params?: (string | number)[]): Promise<{
+    changes: unknown;
+}>;
 export declare function select(table: any, id: any): Promise<any>;
 export declare function update(table: any, params: any): Promise<void>;
 export declare function insertWithUUID(table: any, row: any): Promise<any>;
 export declare function insert(table: any, row: any): Promise<void>;
 export declare function delete_(table: any, id: any): Promise<void>;
 export declare function deleteAll(table: string): Promise<void>;
-export declare function selectWithSchema(table: any, sql: any, params: any): Promise<any>;
+export declare function selectWithSchema(table: any, sql: any, params: any): Promise<any[]>;
 export declare function selectFirstWithSchema(table: any, sql: any, params: any): Promise<any>;
 export declare function insertWithSchema(table: any, row: any): Promise<any>;
 export declare function updateWithSchema(table: any, fields: any): Promise<void>;
-export declare function getCategories(ids?: Array<CategoryEntity['id']>): Promise<CategoryEntity[]>;
-export declare function getCategoriesGrouped(ids?: Array<CategoryGroupEntity['id']>): Promise<Array<CategoryGroupEntity>>;
+export declare function getCategories(ids?: Array<DbCategory['id']>): Promise<CategoryEntity[]>;
+export declare function getCategoriesGrouped(ids?: Array<DbCategoryGroup['id']>): Promise<Array<CategoryGroupEntity>>;
 export declare function insertCategoryGroup(group: any): Promise<any>;
 export declare function updateCategoryGroup(group: any): Promise<void>;
 export declare function moveCategoryGroup(id: any, targetId: any): Promise<void>;
@@ -77,27 +83,27 @@ export declare function insertCategory(category: any, { atEnd }?: {
     atEnd: any;
 }): Promise<any>;
 export declare function updateCategory(category: any): Promise<void>;
-export declare function moveCategory(id: any, groupId: any, targetId?: string): Promise<void>;
-export declare function deleteCategory(category: any, transferId?: string): Promise<void>;
-export declare function getPayee(id: any): Promise<any>;
-export declare function getAccount(id: any): Promise<any>;
+export declare function moveCategory(id: DbCategory['id'], groupId: DbCategoryGroup['id'], targetId?: DbCategory['id']): Promise<void>;
+export declare function deleteCategory(category: Pick<DbCategory, 'id'>, transferId?: DbCategory['id']): Promise<void>;
+export declare function getPayee(id: DbPayee['id']): Promise<any>;
+export declare function getAccount(id: DbAccount['id']): Promise<any>;
 export declare function insertPayee(payee: any): Promise<any>;
-export declare function deletePayee(payee: any): Promise<void>;
-export declare function deleteTransferPayee(payee: any): Promise<void>;
+export declare function deletePayee(payee: Pick<DbPayee, 'id'>): Promise<void>;
+export declare function deleteTransferPayee(payee: Pick<DbPayee, 'id'>): Promise<void>;
 export declare function updatePayee(payee: any): Promise<void>;
-export declare function mergePayees(target: string, ids: string[]): Promise<void>;
-export declare function getPayees(): Promise<any>;
-export declare function getCommonPayees(): Promise<any>;
-export declare function syncGetOrphanedPayees(): Promise<any>;
-export declare function getOrphanedPayees(): Promise<any>;
-export declare function getPayeeByName(name: any): Promise<any>;
-export declare function getAccounts(): Promise<any>;
+export declare function mergePayees(target: DbPayee['id'], ids: Array<DbPayee['id']>): Promise<void>;
+export declare function getPayees(): Promise<any[]>;
+export declare function getCommonPayees(): Promise<any[]>;
+export declare function syncGetOrphanedPayees(): Promise<any[]>;
+export declare function getOrphanedPayees(): Promise<any[]>;
+export declare function getPayeeByName(name: DbPayee['name']): Promise<any>;
+export declare function getAccounts(): Promise<any[]>;
 export declare function insertAccount(account: any): Promise<any>;
 export declare function updateAccount(account: any): Promise<void>;
 export declare function deleteAccount(account: any): Promise<void>;
-export declare function moveAccount(id: any, targetId: any): Promise<void>;
-export declare function getTransaction(id: any): Promise<any>;
-export declare function getTransactions(accountId: any): Promise<any>;
+export declare function moveAccount(id: DbAccount['id'], targetId: DbAccount['id']): Promise<void>;
+export declare function getTransaction(id: DbViewTransaction['id']): Promise<any>;
+export declare function getTransactions(accountId: DbTransaction['acct']): Promise<any[]>;
 export declare function insertTransaction(transaction: any): Promise<any>;
 export declare function updateTransaction(transaction: any): Promise<void>;
 export declare function deleteTransaction(transaction: any): Promise<void>;