@actual-app/api 25.3.0 → 25.4.0

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

@@ -0,0 +1,133 @@
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    account: {
+        failedAccounts: {
+            [key: import("../../types/models").AccountEntity["id"]]: {
+                type: string;
+                code: string;
+            };
+        };
+        accountsSyncing: Array<import("../../types/models").AccountEntity["id"]>;
+    };
+    app: {
+        loadingText: string | null;
+        updateInfo: {
+            version: string;
+            releaseDate: string;
+            releaseNotes: string;
+        } | null;
+        showUpdateNotification: boolean;
+        managerHasInitialized: boolean;
+    };
+    budgets: {
+        budgets: import("../../types/budget").Budget[];
+        remoteFiles: import("../../server/cloud-storage").RemoteFile[] | null;
+        allFiles: import("../../types/file").File[] | null;
+    };
+    modals: {
+        modalStack: import("../modals/modalsSlice").Modal[];
+        isHidden: boolean;
+    };
+    notifications: {
+        notifications: import("../notifications/notificationsSlice").NotificationWithId[];
+        inset?: {
+            bottom?: number;
+            top?: number;
+            right?: number;
+            left?: number;
+        };
+    };
+    prefs: {
+        local: import("../../types/prefs").MetadataPrefs;
+        global: import("../../types/prefs").GlobalPrefs;
+        synced: import("../../types/prefs").SyncedPrefs;
+    };
+    queries: {
+        newTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+        matchedTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+        lastTransaction: import("../../types/models").TransactionEntity | null;
+        updatedAccounts: Array<import("../../types/models").AccountEntity["id"]>;
+        accounts: import("../../types/models").AccountEntity[];
+        accountsLoaded: boolean;
+        categories: {
+            grouped: import("../../types/models").CategoryGroupEntity[];
+            list: import("../../types/models").CategoryEntity[];
+        };
+        categoriesLoaded: boolean;
+        commonPayeesLoaded: boolean;
+        commonPayees: import("../../types/models").PayeeEntity[];
+        payees: import("../../types/models").PayeeEntity[];
+        payeesLoaded: boolean;
+    };
+    user: {
+        data: Awaited<ReturnType<import("../../types/handlers").Handlers["subscribe-get-user"]>>;
+    };
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: ((action: import("redux").Action<"listenerMiddleware/add">) => import("@reduxjs/toolkit").UnsubscribeListener) & import("redux-thunk").ThunkDispatch<{
+        account: {
+            failedAccounts: {
+                [key: import("../../types/models").AccountEntity["id"]]: {
+                    type: string;
+                    code: string;
+                };
+            };
+            accountsSyncing: Array<import("../../types/models").AccountEntity["id"]>;
+        };
+        app: {
+            loadingText: string | null;
+            updateInfo: {
+                version: string;
+                releaseDate: string;
+                releaseNotes: string;
+            } | null;
+            showUpdateNotification: boolean;
+            managerHasInitialized: boolean;
+        };
+        budgets: {
+            budgets: import("../../types/budget").Budget[];
+            remoteFiles: import("../../server/cloud-storage").RemoteFile[] | null;
+            allFiles: import("../../types/file").File[] | null;
+        };
+        modals: {
+            modalStack: import("../modals/modalsSlice").Modal[];
+            isHidden: boolean;
+        };
+        notifications: {
+            notifications: import("../notifications/notificationsSlice").NotificationWithId[];
+            inset?: {
+                bottom?: number;
+                top?: number;
+                right?: number;
+                left?: number;
+            };
+        };
+        prefs: {
+            local: import("../../types/prefs").MetadataPrefs;
+            global: import("../../types/prefs").GlobalPrefs;
+            synced: import("../../types/prefs").SyncedPrefs;
+        };
+        queries: {
+            newTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+            matchedTransactions: Array<import("../../types/models").TransactionEntity["id"]>;
+            lastTransaction: import("../../types/models").TransactionEntity | null;
+            updatedAccounts: Array<import("../../types/models").AccountEntity["id"]>;
+            accounts: import("../../types/models").AccountEntity[];
+            accountsLoaded: boolean;
+            categories: {
+                grouped: import("../../types/models").CategoryGroupEntity[];
+                list: import("../../types/models").CategoryEntity[];
+            };
+            categoriesLoaded: boolean;
+            commonPayeesLoaded: boolean;
+            commonPayees: import("../../types/models").PayeeEntity[];
+            payees: import("../../types/models").PayeeEntity[];
+            payeesLoaded: boolean;
+        };
+        user: {
+            data: Awaited<ReturnType<import("../../types/handlers").Handlers["subscribe-get-user"]>>;
+        };
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type AppStore = typeof store;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export type GetRootState = typeof store.getState;

package/@types/loot-core/client/users/usersSlice.d.ts

@@ -0,0 +1,89 @@
+import { type Handlers } from '../../types/handlers';
+export declare const getUserData: import("@reduxjs/toolkit").AsyncThunk<{
+    offline: boolean;
+    userName?: string;
+    userId?: string;
+    displayName?: string;
+    permission?: string;
+    loginMethod?: string;
+    tokenExpired?: boolean;
+}, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const loggedIn: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const signOut: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: import("../store").RootState;
+    dispatch: import("../store").AppDispatch;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+type UsersState = {
+    data: Awaited<ReturnType<Handlers['subscribe-get-user']>>;
+};
+type GetUserDataPayload = {
+    data: UsersState['data'];
+};
+export declare const name: "user", reducer: import("redux").Reducer<UsersState>, getInitialState: () => UsersState;
+export declare const actions: {
+    getUserData: import("@reduxjs/toolkit").AsyncThunk<{
+        offline: boolean;
+        userName?: string;
+        userId?: string;
+        displayName?: string;
+        permission?: string;
+        loginMethod?: string;
+        tokenExpired?: boolean;
+    }, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    loggedIn: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    signOut: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+        state: import("../store").RootState;
+        dispatch: import("../store").AppDispatch;
+        extra?: unknown;
+        rejectValue?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    loadUserData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<GetUserDataPayload, "user/loadUserData">;
+};
+export declare const loadUserData: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<GetUserDataPayload, "user/loadUserData">;
+export {};

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

@@ -1,5 +1,4 @@
 import type { Handlers } from '../../../types/handlers';
-import type { CategoryGroupEntity } from '../../../types/models';
 import type { ServerEvents } from '../../../types/server-events';
 
 export function init(socketName: string): Promise<unknown>;
@@ -45,15 +44,7 @@ export function unlisten(name: string): void;
 export type Unlisten = typeof unlisten;
 
 /** Mock functions */
-export function initServer(handlers: {
-  query: (query: { table: string; selectExpressions: unknown }) => Promise<{
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    data: any;
-    dependencies: string[];
-  }>;
-  getCell?: () => { value: number };
-  'get-categories'?: () => { grouped: CategoryGroupEntity[] };
-}): void;
+export function initServer(handlers: Partial<Handlers>): void;
 export type InitServer = typeof initServer;
 
 export function serverPush(name: string, args: unknown): void;

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

@@ -1,33 +1,21 @@
-import { OptionlessModal } from '../../../client/state-types/modals';
+import { v4 as uuidv4 } from 'uuid';
+import { Modal } from '../../../client/modals/modalsSlice';
 import { UndoState as ServerUndoState } from '../../../server/undo';
-
-export type UndoState = {
-  url: string | null;
-  // Right now, only the payees page uses this. It's only being set to
-  // `manage-rules` which is an optionless modal. Do we want to also
-  // support modals with options?
-  openModal: OptionlessModal | null;
-  selectedItems: {
-    name: string;
-    items: Set<string>;
-  } | null;
-  undoEvent: ServerUndoState | null;
+type UndoState = {
+    url: string | null;
+    openModal: Modal | null;
+    selectedItems: {
+        name: string;
+        items: Set<string>;
+    } | null;
+    undoEvent: ServerUndoState | null;
 };
-
-export function setUndoState<K extends keyof Omit<UndoState, 'id'>>(
-  name: K,
-  value: UndoState[K],
-): void;
-export type SetUndoState = typeof setUndoState;
-
-export function getUndoState<K extends keyof UndoState>(name: K): UndoState[K];
-export type GetUndoState = typeof getUndoState;
-
-export function getTaggedState(id: string): UndoState | undefined;
-export type GetTaggedState = typeof getTaggedState;
-
-export function snapshot(): string;
-export type Snapshot = typeof snapshot;
-
-export function gc(id: string): void;
-export type Gc = typeof gc;
+type UndoStateWithId = UndoState & {
+    id?: ReturnType<typeof uuidv4>;
+};
+export declare const setUndoState: <K extends keyof Omit<UndoState, "id">>(name: K, value: UndoState[K]) => void;
+export declare const getUndoState: <K extends keyof UndoState>(name: K) => UndoStateWithId[K];
+export declare const getTaggedState: (id: string) => UndoStateWithId;
+export declare const snapshot: () => string;
+export declare const gc: (id: string) => void;
+export {};

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

@@ -1,5 +1,2 @@
-export function captureException(exc: Error): void;
-export type CaptureException = typeof captureException;
-
-export function captureBreadcrumb(breadcrumb: unknown): void;
-export type CaptureBreadcrumb = typeof captureBreadcrumb;
+export declare const captureException: (exc: Error) => void;
+export declare const captureBreadcrumb: (crumb: unknown) => void;

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

@@ -13,9 +13,6 @@ export function send<K extends keyof ServerEvents>(
 ): void;
 export type Send = typeof send;
 
-export function getEvents(): unknown[];
-export type GetEvents = typeof getEvents;
-
 export function getNumClients(): number;
 export type GetNumClients = typeof getNumClients;
 

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

@@ -1,4 +1 @@
-export function fetch(
-  input: RequestInfo | URL,
-  options?: unknown,
-): Promise<Response>;
+export declare const fetch: (input: RequestInfo | URL, options?: RequestInit) => Promise<Response>;

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

@@ -1,6 +1,4 @@
-export interface Logger {
-  info(...args: unknown[]): void;
-  warn(...args: unknown[]): void;
-}
-
-export const logger: Logger;
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};

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

@@ -1,4 +1,5 @@
-import { AccountEntity, CategoryEntity, SyncServerGoCardlessAccount, TransactionEntity, SyncServerSimpleFinAccount } from '../../types/models';
+import { AccountEntity, CategoryEntity, SyncServerGoCardlessAccount, TransactionEntity, SyncServerSimpleFinAccount, SyncServerPluggyAiAccount } from '../../types/models';
+import * as db from '../db';
 import * as bankSync from './sync';
 export type AccountHandlers = {
     'account-update': typeof updateAccount;
@@ -7,6 +8,7 @@ export type AccountHandlers = {
     'account-properties': typeof getAccountProperties;
     'gocardless-accounts-link': typeof linkGoCardlessAccount;
     'simplefin-accounts-link': typeof linkSimpleFinAccount;
+    'pluggyai-accounts-link': typeof linkPluggyAiAccount;
     'account-create': typeof createAccount;
     'account-close': typeof closeAccount;
     'account-reopen': typeof reopenAccount;
@@ -17,7 +19,9 @@ export type AccountHandlers = {
     'gocardless-poll-web-token-stop': typeof stopGoCardlessWebTokenPolling;
     'gocardless-status': typeof goCardlessStatus;
     'simplefin-status': typeof simpleFinStatus;
+    'pluggyai-status': typeof pluggyAiStatus;
     'simplefin-accounts': typeof simpleFinAccounts;
+    'pluggyai-accounts': typeof pluggyAiAccounts;
     'gocardless-get-banks': typeof getGoCardlessBanks;
     'gocardless-create-web-token': typeof createGoCardlessWebToken;
     'accounts-bank-sync': typeof accountsBankSync;
@@ -25,8 +29,11 @@ export type AccountHandlers = {
     '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 updateAccount({ id, name, last_reconciled, }: Pick<AccountEntity, 'id' | 'name'> & Partial<Pick<AccountEntity, 'last_reconciled'>>): Promise<{}>;
+declare function getAccounts(): Promise<(db.DbAccount & {
+    bankName: db.DbBank["name"];
+    bankId: db.DbBank["id"];
+})[]>;
 declare function getAccountBalance({ id, cutoff, }: {
     id: string;
     cutoff: string | Date;
@@ -48,6 +55,11 @@ declare function linkSimpleFinAccount({ externalAccount, upgradingId, offBudget,
     upgradingId?: AccountEntity['id'] | undefined;
     offBudget?: boolean | undefined;
 }): Promise<string>;
+declare function linkPluggyAiAccount({ externalAccount, upgradingId, offBudget, }: {
+    externalAccount: SyncServerPluggyAiAccount;
+    upgradingId?: AccountEntity['id'] | undefined;
+    offBudget?: boolean | undefined;
+}): Promise<string>;
 declare function createAccount({ name, balance, offBudget, closed, }: {
     name: string;
     balance?: number | undefined;
@@ -65,7 +77,7 @@ declare function reopenAccount({ id }: {
 }): Promise<void>;
 declare function moveAccount({ id, targetId, }: {
     id: AccountEntity['id'];
-    targetId: AccountEntity['id'];
+    targetId: AccountEntity['id'] | null;
 }): Promise<void>;
 declare function setSecret({ name, value, }: {
     name: string;
@@ -80,7 +92,9 @@ declare function pollGoCardlessWebToken({ requisitionId, }: {
 declare function stopGoCardlessWebTokenPolling(): Promise<string>;
 declare function goCardlessStatus(): Promise<any>;
 declare function simpleFinStatus(): Promise<any>;
+declare function pluggyAiStatus(): Promise<any>;
 declare function simpleFinAccounts(): Promise<any>;
+declare function pluggyAiAccounts(): Promise<any>;
 declare function getGoCardlessBanks(country: string): Promise<any>;
 declare function createGoCardlessWebToken({ institutionId, accessValidForDays, }: {
     institutionId: string;
@@ -140,7 +154,7 @@ export declare const app: {
     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;
+    method<Name extends "account-update" | "accounts-get" | "account-balance" | "account-properties" | "gocardless-accounts-link" | "simplefin-accounts-link" | "pluggyai-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" | "pluggyai-status" | "simplefin-accounts" | "pluggyai-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;

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

@@ -1 +1,6 @@
-export declare function findOrCreateBank(institution: any, requisitionId: any): Promise<any>;
+import * as db from '../db';
+export declare function findOrCreateBank(institution: any, requisitionId: any): Promise<Pick<db.DbBank, "id" | "bank_id"> | {
+    id: string;
+    bank_id: any;
+    name: any;
+}>;

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

@@ -1,4 +1,15 @@
-import { AdminHandlers } from './types/handlers';
+import { UserAvailable, UserEntity, NewUserAccessEntity } from '../../types/models';
+export type AdminHandlers = {
+    'users-get': typeof getUsers;
+    'user-delete-all': typeof deleteAllUsers;
+    'user-add': typeof addUser;
+    'user-update': typeof updateUser;
+    'access-add': typeof addAccess;
+    'access-delete-all': typeof deleteAllAccess;
+    'access-get-available-users': typeof accessGetAvailableUsers;
+    'transfer-ownership': typeof transferOwnership;
+    'owner-created': typeof ownerCreated;
+};
 export declare const app: {
     events: import("mitt").Emitter<{
         sync: import("../../types/server-events").ServerEvents["sync-event"];
@@ -15,3 +26,45 @@ export declare const app: {
     startServices(): void;
     stopServices(): void;
 };
+declare function getUsers(): Promise<UserEntity[] | {
+    error: string;
+}>;
+declare function deleteAllUsers(ids: Array<UserEntity['id']>): Promise<{
+    someDeletionsFailed: boolean;
+    ids?: number[];
+} | {
+    error: string;
+}>;
+declare function addUser(user: Omit<UserEntity, 'id'>): Promise<{
+    error: string;
+} | {
+    id: string;
+}>;
+declare function updateUser(user: Omit<UserEntity, 'id'>): Promise<{
+    error: string;
+} | {
+    id: string;
+}>;
+declare function addAccess(access: NewUserAccessEntity): Promise<{
+    error?: string;
+} | Record<string, never>>;
+declare function deleteAllAccess({ fileId, ids, }: {
+    fileId: string;
+    ids: string[];
+}): Promise<{
+    someDeletionsFailed: boolean;
+    ids?: number[];
+} | {
+    error: unknown;
+}>;
+declare function accessGetAvailableUsers(fileId: string): Promise<UserAvailable[] | {
+    error: string;
+}>;
+declare function transferOwnership({ fileId, newUserId, }: {
+    fileId: string;
+    newUserId: string;
+}): Promise<{
+    error?: string;
+} | Record<string, never>>;
+declare function ownerCreated(): Promise<boolean>;
+export {};

package/@types/loot-core/server/api-models.d.ts

@@ -8,9 +8,9 @@ export type APIAccountEntity = Pick<AccountEntity, 'id' | 'name'> & {
 export declare const accountModel: {
     toExternal(account: AccountEntity): APIAccountEntity;
     fromExternal(account: APIAccountEntity): AccountEntity;
-    validate(account: AccountEntity, { update }?: {
+    validate(account: Partial<import("./db").DbAccount>, { update }?: {
         update?: boolean;
-    }): AccountEntity;
+    }): import("./db").DbAccount;
 };
 export type APICategoryEntity = Pick<CategoryEntity, 'id' | 'name' | 'is_income' | 'hidden'> & {
     group_id?: string;
@@ -26,16 +26,13 @@ export declare const categoryModel: {
         tombstone?: boolean;
         hidden?: boolean;
     };
-    validate(category: CategoryEntity, { update }?: {
+    validate(category: Partial<import("./db").DbCategory>, { update }?: {
         update?: boolean;
-    }): {
-        hidden: number;
-        id: string;
-        name: string;
-        is_income?: boolean;
-        cat_group?: CategoryGroupEntity["id"];
-        tombstone?: boolean;
-    };
+    }): import("./db").DbCategory;
+    toDb(category: CategoryEntity, { update }?: {
+        update?: boolean;
+    }): import("./db").DbCategory;
+    fromDb(category: import("./db").DbCategory): CategoryEntity;
 };
 export type APICategoryGroupEntity = Pick<CategoryGroupEntity, 'id' | 'name' | 'is_income' | 'hidden'> & {
     categories: APICategoryEntity[];
@@ -43,16 +40,15 @@ export type APICategoryGroupEntity = Pick<CategoryGroupEntity, 'id' | 'name' | '
 export declare const categoryGroupModel: {
     toExternal(group: CategoryGroupEntity): APICategoryGroupEntity;
     fromExternal(group: APICategoryGroupEntity): CategoryGroupEntity;
-    validate(categoryGroup: CategoryGroupEntity, { update }?: {
+    validate(categoryGroup: Partial<import("./db").DbCategoryGroup>, { update }?: {
         update?: boolean;
-    }): {
-        hidden: number;
-        id: string;
-        categories?: CategoryEntity[];
-        name: string;
-        is_income?: boolean;
-        tombstone?: boolean;
-    };
+    }): import("./db").DbCategoryGroup;
+    toDb(categoryGroup: CategoryGroupEntity, { update }?: {
+        update?: boolean;
+    }): import("./db").DbCategoryGroup;
+    fromDb(categoryGroup: import("./db").DbCategoryGroup & {
+        categories: import("./db").DbCategory[];
+    }): CategoryGroupEntity;
 };
 export type APIPayeeEntity = Pick<PayeeEntity, 'id' | 'name' | 'transfer_acct'>;
 export declare const payeeModel: {
@@ -62,9 +58,13 @@ export declare const payeeModel: {
         transfer_acct: string;
     };
     fromExternal(payee: APIPayeeEntity): PayeeEntity;
-    validate(payee: PayeeEntity, { update }?: {
+    validate(payee: Partial<import("./db").DbPayee>, { update }?: {
+        update?: boolean;
+    }): import("./db").DbPayee;
+    toDb(payee: PayeeEntity, { update }?: {
         update?: boolean;
-    }): PayeeEntity;
+    }): import("./db").DbPayee;
+    fromDb(payee: import("./db").DbPayee): PayeeEntity;
 };
 export type APIFileEntity = Omit<RemoteFile, 'deleted' | 'fileId'> & {
     id?: string;

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<unknown[]>;
 export declare function runCompiledQuery(query: any, pieces: any, state: any, { params, executors }?: {
     params?: {};
     executors?: {};

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

@@ -81,6 +81,9 @@ export declare const schema: {
         favorite: {
             type: string;
         };
+        learn_categories: {
+            type: string;
+        };
     };
     accounts: {
         id: {
@@ -110,6 +113,9 @@ export declare const schema: {
         account_sync_source: {
             type: string;
         };
+        last_reconciled: {
+            type: string;
+        };
         last_sync: {
             type: string;
         };
@@ -130,6 +136,9 @@ export declare const schema: {
         group: {
             type: string;
         };
+        goal_def: {
+            type: string;
+        };
         sort_order: {
             type: string;
         };

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

@@ -1,3 +1,4 @@
+import { CategoryEntity } from '../../types/models';
 export declare function getSheetValue(sheetName: string, cell: string): Promise<number>;
 export declare function getSheetBoolean(sheetName: string, cell: string): Promise<boolean>;
 export declare function isReflectBudget(): boolean;
@@ -6,7 +7,7 @@ export declare function getBudget({ category, month, }: {
     month: string;
 }): number;
 export declare function setBudget({ category, month, amount, }: {
-    category: string;
+    category: CategoryEntity['id'];
     month: string;
     amount: unknown;
 }): Promise<void>;
@@ -50,8 +51,8 @@ export declare function resetHold({ month }: {
 }): Promise<void>;
 export declare function coverOverspending({ month, to, from, }: {
     month: string;
-    to: string;
-    from: string;
+    to: CategoryEntity['id'] | 'to-budget';
+    from: CategoryEntity['id'] | 'to-budget' | 'overbudgeted';
 }): Promise<void>;
 export declare function transferAvailable({ month, amount, category, }: {
     month: string;
@@ -65,8 +66,8 @@ export declare function coverOverbudgeted({ month, category, }: {
 export declare function transferCategory({ month, amount, from, to, }: {
     month: string;
     amount: number;
-    to: string;
-    from: string;
+    to: CategoryEntity['id'] | 'to-budget';
+    from: CategoryEntity['id'] | 'to-budget';
 }): Promise<void>;
 export declare function setCategoryCarryover({ startMonth, category, flag, }: {
     startMonth: string;