@actual-app/api 25.4.0 → 25.5.0

package/@types/app/bundle.api.d.ts

@@ -1,6 +1,2 @@
 export = __webpack_exports__;
-export = __webpack_exports__;
-/******/
-/************************************************************************/
-/******/
-/******/ /******/ /******/ /******/ declare var __webpack_exports__: any;
+declare var __webpack_exports__: any;

package/@types/loot-core/client/budgets/budgetsSlice.d.ts

@@ -135,7 +135,9 @@ type UploadBudgetPayload = {
     id?: string;
 };
 export declare const uploadBudget: import("@reduxjs/toolkit").AsyncThunk<{
-    error: string;
+    error: {
+        reason: string;
+    };
 } | {
     error?: undefined;
 }, UploadBudgetPayload, {
@@ -330,7 +332,9 @@ export declare const actions: {
         rejectedMeta?: unknown;
     }>;
     uploadBudget: import("@reduxjs/toolkit").AsyncThunk<{
-        error: string;
+        error: {
+            reason: string;
+        };
     } | {
         error?: undefined;
     }, UploadBudgetPayload, {

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

@@ -85,7 +85,10 @@ export type Modal = {
         onMoveExternal: (arg: {
             institutionId: string;
         }) => Promise<{
-            error: 'unknown' | 'timeout';
+            error: 'timeout';
+        } | {
+            error: 'unknown';
+            message?: string;
         } | {
             data: GoCardlessToken;
         }>;
@@ -425,6 +428,7 @@ export type Modal = {
     name: 'confirm-unlink-account';
     options: {
         accountName: string;
+        isViewBankSyncSettings: boolean;
         onUnlink: () => void;
     };
 } | {

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

@@ -41,6 +41,7 @@ export declare const savePrefs: import("@reduxjs/toolkit").AsyncThunk<void, Save
 export declare const loadGlobalPrefs: import("@reduxjs/toolkit").AsyncThunk<Partial<{
     floatingSidebar: boolean;
     maxMonths: number;
+    categoryExpandedState: number;
     keyId?: string;
     language: string;
     theme: import("../../types/prefs").Theme;
@@ -50,10 +51,6 @@ export declare const loadGlobalPrefs: import("@reduxjs/toolkit").AsyncThunk<Part
     syncServerConfig?: {
         autoStart?: boolean;
         port?: number;
-        ngrokConfig?: {
-            domain?: string;
-            authToken?: string;
-        };
     };
 }>, void, {
     state: import("../store").RootState;
@@ -133,6 +130,7 @@ export declare const actions: {
     loadGlobalPrefs: import("@reduxjs/toolkit").AsyncThunk<Partial<{
         floatingSidebar: boolean;
         maxMonths: number;
+        categoryExpandedState: number;
         keyId?: string;
         language: string;
         theme: import("../../types/prefs").Theme;
@@ -142,10 +140,6 @@ export declare const actions: {
         syncServerConfig?: {
             autoStart?: boolean;
             port?: number;
-            ngrokConfig?: {
-                domain?: string;
-                authToken?: string;
-            };
         };
     }>, void, {
         state: import("../store").RootState;

package/@types/loot-core/client/queries/queriesSlice.d.ts

@@ -214,7 +214,7 @@ export declare const moveCategory: import("@reduxjs/toolkit").AsyncThunk<void, M
 }>;
 type MoveCategoryGroupPayload = {
     id: CategoryGroupEntity['id'];
-    targetId: CategoryGroupEntity['id'];
+    targetId: CategoryGroupEntity['id'] | null;
 };
 export declare const moveCategoryGroup: import("@reduxjs/toolkit").AsyncThunk<void, MoveCategoryGroupPayload, {
     state: import("../store").RootState;

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

@@ -1,12 +1,20 @@
 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;
+    userName?: undefined;
+    permission?: undefined;
+    userId?: undefined;
+    displayName?: undefined;
+    loginMethod?: undefined;
+    tokenExpired?: undefined;
+} | {
+    offline: boolean;
+    userName: any;
+    permission: any;
+    userId: any;
+    displayName: any;
+    loginMethod: any;
+    tokenExpired: boolean;
 }, void, {
     state: import("../store").RootState;
     dispatch: import("../store").AppDispatch;
@@ -47,12 +55,20 @@ export declare const name: "user", reducer: import("redux").Reducer<UsersState>,
 export declare const actions: {
     getUserData: import("@reduxjs/toolkit").AsyncThunk<{
         offline: boolean;
-        userName?: string;
-        userId?: string;
-        displayName?: string;
-        permission?: string;
-        loginMethod?: string;
-        tokenExpired?: boolean;
+        userName?: undefined;
+        permission?: undefined;
+        userId?: undefined;
+        displayName?: undefined;
+        loginMethod?: undefined;
+        tokenExpired?: undefined;
+    } | {
+        offline: boolean;
+        userName: any;
+        permission: any;
+        userId: any;
+        displayName: any;
+        loginMethod: any;
+        tokenExpired: boolean;
     }, void, {
         state: import("../store").RootState;
         dispatch: import("../store").AppDispatch;

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

@@ -1,7 +1,10 @@
-import type { AccountEntity, CategoryEntity, CategoryGroupEntity, NewCategoryGroupEntity, TransactionEntity } from '../types/models';
+import type { AccountEntity, CategoryEntity, CategoryGroupEntity, TransactionEntity } from '../types/models';
 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[];
+export type CategoryGroupDefinition = Omit<CategoryGroupEntity, 'id' | 'categories'> & {
+    categories: Omit<CategoryEntity, 'id' | 'group'>[];
+};
+export declare function generateCategoryGroups(definition: Partial<CategoryGroupDefinition>[]): CategoryGroupEntity[];
 export declare function generateTransaction(data: Partial<TransactionEntity> & Pick<TransactionEntity, 'account'>, splitAmount?: number, showError?: boolean): TransactionEntity[];
 export declare function generateTransactions(count: number, accountId: string, groupId: string, splitAtIndexes?: number[], showError?: boolean): TransactionEntity[];

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

@@ -5,3 +5,4 @@ export declare function expectSnapshotWithDiffer(initialValue: any, { onlyUpdate
 };
 export declare function getFixtures(filename: any): void;
 export declare function debugDOM(node: any): string;
+export declare function patchFetchForSqlJS(baseURL: string): void;

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

@@ -13,22 +13,23 @@ export type GetItem = typeof getItem;
 export function setItem<K extends keyof GlobalPrefsJson>(
   key: K,
   value: GlobalPrefsJson[K],
-): void;
+): Promise<void>;
 export type SetItem = typeof setItem;
 
-export function removeItem(key: keyof GlobalPrefsJson): void;
+export function removeItem(key: keyof GlobalPrefsJson): Promise<void>;
 export type RemoveItem = typeof removeItem;
 
-export async function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
+export function multiGet<K extends readonly (keyof GlobalPrefsJson)[]>(
   keys: K,
-): Promise<{ [P in keyof K]: [K[P], GlobalPrefsJson[K[P]]] }>;
+): Promise<{ [P in K[number]]: GlobalPrefsJson[P] }>;
+
 export type MultiGet = typeof multiGet;
 
 export function multiSet<K extends keyof GlobalPrefsJson>(
   keyValues: Array<[K, GlobalPrefsJson[K]]>,
-): void;
+): Promise<void>;
 
 export type MultiSet = typeof multiSet;
 
-export function multiRemove(keys: (keyof GlobalPrefsJson)[]): void;
+export function multiRemove(keys: (keyof GlobalPrefsJson)[]): Promise<void>;
 export type MultiRemove = typeof multiRemove;

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

@@ -1,24 +1,15 @@
-export function getDatabase();
-export type GetDatabase = typeof getDatabase;
-
-export function openDatabase();
-export type OpenDatabase = typeof openDatabase;
-
-export function closeDatabase();
-export type CloseDatabase = typeof closeDatabase;
-
-export function getStore(db: IDBDatabase, name: string);
-export type GetStore = typeof getStore;
-
-export function get(
-  store: IDBObjectStore,
-  key: IDBValidKey | IDBKeyRange,
-  mapper?: (v: unknown) => unknown,
-);
-export type Get = typeof get;
-
-export function set(store: IDBObjectStore, value: unknown);
-export type Set = typeof set;
-
-export function del(store: IDBObjectStore, key: IDBValidKey);
-export type Del = typeof del;
+type Data = {
+    filepath: string;
+    contents: string;
+};
+export declare const getStore: (db: IDBDatabase, name: string) => {
+    trans: IDBTransaction;
+    store: IDBObjectStore;
+};
+export declare const get: (store: IDBObjectStore, key: IDBValidKey | IDBKeyRange) => Promise<Data>;
+export declare const set: (store: IDBObjectStore, item: Data) => Promise<unknown>;
+export declare const del: (store: IDBObjectStore, key: string) => Promise<unknown>;
+export declare const getDatabase: () => Promise<IDBDatabase>;
+export declare const openDatabase: () => Promise<IDBDatabase>;
+export declare const closeDatabase: () => void;
+export {};

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

@@ -20,15 +20,7 @@ export declare function addTransactions(acctId: any, transactions: any, { runTra
     runTransfers?: boolean;
     learnCategories?: boolean;
 }): Promise<any>;
-export declare function syncAccount(userId: string | undefined, userKey: string | undefined, id: string, acctId: string, bankId: string): Promise<{
-    added: any[];
-    updated: string[];
-    updatedPreview: Array<{
-        transaction: TransactionEntity;
-        existing?: TransactionEntity;
-        ignored?: boolean;
-    }>;
-} | {
+export declare function syncAccount(userId: string | undefined, userKey: string | undefined, id: string, acctId: string, bankId: string): Promise<ReconcileTransactionsResult | {
     added: any[];
     updated: any[];
 }>;

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

@@ -13,19 +13,11 @@ export declare const accountModel: {
     }): import("./db").DbAccount;
 };
 export type APICategoryEntity = Pick<CategoryEntity, 'id' | 'name' | 'is_income' | 'hidden'> & {
-    group_id?: string;
+    group_id: string;
 };
 export declare const categoryModel: {
     toExternal(category: CategoryEntity): APICategoryEntity;
-    fromExternal(category: APICategoryEntity): {
-        id: string;
-        name: string;
-        is_income?: boolean;
-        cat_group?: CategoryGroupEntity["id"];
-        sort_order?: number;
-        tombstone?: boolean;
-        hidden?: boolean;
-    };
+    fromExternal(category: APICategoryEntity): CategoryEntity;
     validate(category: Partial<import("./db").DbCategory>, { update }?: {
         update?: boolean;
     }): import("./db").DbCategory;

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

@@ -1,6 +1,8 @@
 declare function execTransactions(state: any, query: any, sql: any, params: any, outputTypes: any): Promise<any>;
 export declare function isHappyPathQuery(queryState: any): boolean;
+declare function execCategoryGroups(state: any, query: any, sql: any, params: any, outputTypes: any): Promise<unknown[]>;
 export declare const schemaExecutors: {
     transactions: typeof execTransactions;
+    category_groups: typeof execCategoryGroups;
 };
 export {};

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

@@ -0,0 +1,142 @@
+import { OpenIdConfig } from '../../types/models';
+export type AuthHandlers = {
+    'get-did-bootstrap': typeof didBootstrap;
+    'subscribe-needs-bootstrap': typeof needsBootstrap;
+    'subscribe-bootstrap': typeof bootstrap;
+    'subscribe-get-login-methods': typeof getLoginMethods;
+    'subscribe-get-user': typeof getUser;
+    'subscribe-change-password': typeof changePassword;
+    'subscribe-sign-in': typeof signIn;
+    'subscribe-sign-out': typeof signOut;
+    'subscribe-set-token': typeof setToken;
+    'enable-openid': typeof enableOpenId;
+    'get-openid-config': typeof getOpenIdConfig;
+    'enable-password': typeof enablePassword;
+};
+export declare const app: {
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
+    handlers: AuthHandlers;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
+    method<Name extends "get-did-bootstrap" | "subscribe-needs-bootstrap" | "subscribe-bootstrap" | "subscribe-get-login-methods" | "subscribe-get-user" | "subscribe-change-password" | "subscribe-sign-in" | "subscribe-sign-out" | "subscribe-set-token" | "enable-openid" | "get-openid-config" | "enable-password">(name: Name, func: AuthHandlers[Name]): void;
+    service(func: () => () => void): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};
+declare function didBootstrap(): Promise<boolean>;
+declare function needsBootstrap({ url }?: {
+    url?: string;
+}): Promise<{
+    error: string;
+    bootstrapped?: undefined;
+    hasServer?: undefined;
+    availableLoginMethods?: undefined;
+    multiuser?: undefined;
+} | {
+    bootstrapped: boolean;
+    hasServer: boolean;
+    error?: undefined;
+    availableLoginMethods?: undefined;
+    multiuser?: undefined;
+} | {
+    bootstrapped: boolean;
+    availableLoginMethods: {
+        method: string;
+        displayName: string;
+        active: boolean;
+    }[];
+    multiuser: boolean;
+    hasServer: boolean;
+    error?: undefined;
+}>;
+declare function bootstrap(loginConfig: {
+    password?: string;
+    openId?: OpenIdConfig;
+}): Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+declare function getLoginMethods(): Promise<{
+    error: string;
+    methods?: undefined;
+} | {
+    methods: {
+        method: string;
+        displayName: string;
+        active: boolean;
+    }[];
+    error?: undefined;
+}>;
+declare function getUser(): Promise<{
+    offline: boolean;
+    userName?: undefined;
+    permission?: undefined;
+    userId?: undefined;
+    displayName?: undefined;
+    loginMethod?: undefined;
+    tokenExpired?: undefined;
+} | {
+    offline: boolean;
+    userName: any;
+    permission: any;
+    userId: any;
+    displayName: any;
+    loginMethod: any;
+    tokenExpired: boolean;
+}>;
+declare function changePassword({ password }: {
+    password: string;
+}): Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+declare function signIn(loginInfo: {
+    password: string;
+    loginMethod?: string;
+} | {
+    returnUrl: string;
+    loginMethod?: 'openid';
+}): Promise<{
+    error: string;
+    redirectUrl?: undefined;
+} | {
+    redirectUrl: string;
+    error?: undefined;
+} | {
+    error?: undefined;
+    redirectUrl?: undefined;
+}>;
+declare function signOut(): Promise<string>;
+declare function setToken({ token }: {
+    token: string;
+}): Promise<void>;
+declare function enableOpenId(openIdConfig: {
+    openId: OpenIdConfig;
+}): Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+declare function getOpenIdConfig({ password }: {
+    password: string;
+}): Promise<{
+    openId: OpenIdConfig;
+} | {
+    error: string;
+}>;
+declare function enablePassword(passwordConfig: {
+    password: string;
+}): Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+export {};

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

@@ -1,9 +1,10 @@
-export declare function getBudgetType(): any;
+export declare function getBudgetType(): "report" | "rollover";
 export declare function getBudgetRange(start: string, end: string): {
     start: string;
     end: string;
     range: string[];
 };
+export declare function createCategory(cat: any, sheetName: any, prevSheetName: any, start: any, end: any): void;
 export declare function triggerBudgetChanges(oldValues: any, newValues: any): void;
 export declare function doTransfer(categoryIds: any, transferId: any): Promise<void>;
 export declare function createBudget(months: any): Promise<void>;

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

@@ -1,4 +1,7 @@
 export declare function createBlankCategory(cat: any, months: any): void;
 export declare function createCategory(cat: any, sheetName: any, prevSheetName: any): void;
+export declare function createCategoryGroup(group: any, sheetName: any): void;
 export declare function createSummary(groups: any, categories: any, prevSheetName: any, sheetName: any): void;
 export declare function createBudget(meta: any, categories: any, months: any): void;
+export declare function handleCategoryChange(months: any, oldValue: any, newValue: any): void;
+export declare function handleCategoryGroupChange(months: any, oldValue: any, newValue: any): void;

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

@@ -1,2 +1,5 @@
 export declare function createCategory(cat: any, sheetName: any, prevSheetName: any): Promise<void>;
-export declare function createSummary(groups: any, categories: any, sheetName: any): void;
+export declare function createCategoryGroup(group: any, sheetName: any): void;
+export declare function createSummary(groups: any, sheetName: any): void;
+export declare function handleCategoryChange(months: any, oldValue: any, newValue: any): void;
+export declare function handleCategoryGroupChange(months: any, oldValue: any, newValue: any): void;

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

@@ -0,0 +1,139 @@
+import { Budget } from '../../types/budget';
+import * as cloudStorage from '../cloud-storage';
+import { ImportableBudgetType } from '../importers';
+export type BudgetFileHandlers = {
+    'validate-budget-name': typeof handleValidateBudgetName;
+    'unique-budget-name': typeof handleUniqueBudgetName;
+    'get-budgets': typeof getBudgets;
+    'get-remote-files': typeof getRemoteFiles;
+    'get-user-file-info': typeof getUserFileInfo;
+    'reset-budget-cache': typeof resetBudgetCache;
+    'upload-budget': typeof uploadBudget;
+    'download-budget': typeof downloadBudget;
+    'sync-budget': typeof syncBudget;
+    'load-budget': typeof loadBudget;
+    'create-demo-budget': typeof createDemoBudget;
+    'close-budget': typeof closeBudget;
+    'delete-budget': typeof deleteBudget;
+    'duplicate-budget': typeof duplicateBudget;
+    'create-budget': typeof createBudget;
+    'import-budget': typeof importBudget;
+    'export-budget': typeof exportBudget;
+    'upload-file-web': typeof uploadFileWeb;
+    'backups-get': typeof getBackups;
+    'backup-load': typeof loadBackup;
+    'backup-make': typeof makeBackup;
+    'get-last-opened-backup': typeof getLastOpenedBackup;
+};
+export declare const app: {
+    events: import("mitt").Emitter<{
+        sync: import("../../types/server-events").ServerEvents["sync-event"];
+        'load-budget': {
+            id: string;
+        };
+    }>;
+    handlers: BudgetFileHandlers;
+    services: (() => () => void)[];
+    unlistenServices: (() => void)[];
+    method<Name extends "load-budget" | "validate-budget-name" | "unique-budget-name" | "get-budgets" | "get-remote-files" | "get-user-file-info" | "reset-budget-cache" | "upload-budget" | "download-budget" | "sync-budget" | "create-demo-budget" | "close-budget" | "delete-budget" | "duplicate-budget" | "create-budget" | "import-budget" | "export-budget" | "upload-file-web" | "backups-get" | "backup-load" | "backup-make" | "get-last-opened-backup">(name: Name, func: BudgetFileHandlers[Name]): void;
+    service(func: () => () => void): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};
+declare function handleValidateBudgetName({ name }: {
+    name: string;
+}): Promise<{
+    valid: boolean;
+    message?: string;
+}>;
+declare function handleUniqueBudgetName({ name }: {
+    name: string;
+}): Promise<string>;
+declare function getBudgets(): Promise<Budget[]>;
+declare function getRemoteFiles(): Promise<cloudStorage.RemoteFile[]>;
+declare function getUserFileInfo(fileId: string): Promise<cloudStorage.RemoteFile>;
+declare function resetBudgetCache(): Promise<void>;
+declare function uploadBudget({ id }?: {
+    id?: Budget['id'];
+}): Promise<{
+    error?: {
+        reason: string;
+    };
+}>;
+declare function downloadBudget({ cloudFileId, }: {
+    cloudFileId: Budget['cloudFileId'];
+}): Promise<{
+    id?: Budget['id'];
+    error?: {
+        reason: string;
+        meta?: unknown;
+    };
+}>;
+declare function syncBudget(): Promise<{
+    error?: {
+        message: string;
+        reason: string;
+        meta: unknown;
+    };
+}>;
+declare function loadBudget({ id }: {
+    id: Budget['id'];
+}): Promise<{
+    error?: "budget-not-found" | "loading-budget" | "out-of-sync-migrations" | "out-of-sync-data" | "opening-budget";
+}>;
+declare function createDemoBudget(): Promise<{
+    error: "budget-not-found" | "loading-budget" | "out-of-sync-migrations" | "out-of-sync-data" | "opening-budget";
+} | {
+    error?: undefined;
+}>;
+declare function closeBudget(): Promise<string>;
+declare function deleteBudget({ id, cloudFileId, }: {
+    id?: Budget['id'];
+    cloudFileId?: Budget['cloudFileId'];
+}): Promise<"ok" | "fail">;
+declare function duplicateBudget({ id, newName, cloudSync, open, }: {
+    id: Budget['id'];
+    newName: Budget['name'];
+    cloudSync: boolean;
+    open: 'none' | 'original' | 'copy';
+}): Promise<Budget['id']>;
+declare function createBudget({ budgetName, avoidUpload, testMode, testBudgetId, }?: {
+    budgetName?: Budget['name'];
+    avoidUpload?: boolean;
+    testMode?: boolean;
+    testBudgetId?: Budget['name'];
+}): Promise<{
+    error: "budget-not-found" | "loading-budget" | "out-of-sync-migrations" | "out-of-sync-data" | "opening-budget";
+} | {
+    error?: undefined;
+}>;
+declare function importBudget({ filepath, type, }: {
+    filepath: string;
+    type: ImportableBudgetType;
+}): Promise<{
+    error?: string;
+}>;
+declare function exportBudget(): Promise<{
+    data: Buffer<ArrayBuffer>;
+    error?: undefined;
+} | {
+    error: string;
+    data?: undefined;
+}>;
+declare function uploadFileWeb({ filename, contents, }: {
+    filename: string;
+    contents: ArrayBuffer;
+}): Promise<{}>;
+declare function getBackups({ id }: {
+    id: any;
+}): Promise<import("./backups").Backup[]>;
+declare function loadBackup({ id, backupId }: {
+    id: any;
+    backupId: any;
+}): Promise<void>;
+declare function makeBackup({ id }: {
+    id: any;
+}): Promise<void>;
+declare function getLastOpenedBackup(): Promise<string>;
+export {};

package/@types/loot-core/server/cloud-storage.d.ts

@@ -34,8 +34,8 @@ export declare function importBuffer(fileData: any, buffer: any): Promise<{
 export declare function upload(): Promise<void>;
 export declare function possiblyUpload(): Promise<void>;
 export declare function removeFile(fileId: any): Promise<void>;
-export declare function listRemoteFiles(): Promise<RemoteFile[] | null>;
+export declare function listRemoteFiles(): Promise<RemoteFile[]>;
 export declare function getRemoteFile(fileId: string): Promise<RemoteFile | null>;
-export declare function download(fileId: any): Promise<{
+export declare function download(cloudFileId: any): Promise<{
     id: any;
 }>;

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

@@ -1,4 +1,5 @@
 import { Database } from '@jlongster/sql.js';
+import { TransactionEntity } from '../../types/models';
 import { WithRequired } from '../../types/util';
 import { DbAccount, DbBank, DbCategory, DbCategoryGroup, DbPayee, DbTransaction, DbViewTransaction } from './types';
 export * from './types';
@@ -80,7 +81,7 @@ export declare function getCategoriesGrouped(ids?: Array<DbCategoryGroup['id']>)
 export declare function insertCategoryGroup(group: WithRequired<Partial<DbCategoryGroup>, 'name'>): Promise<DbCategoryGroup['id']>;
 export declare function updateCategoryGroup(group: WithRequired<Partial<DbCategoryGroup>, 'name' | 'is_income'>): Promise<void>;
 export declare function moveCategoryGroup(id: DbCategoryGroup['id'], targetId: DbCategoryGroup['id']): Promise<void>;
-export declare function deleteCategoryGroup(group: Pick<DbCategoryGroup, 'id'>, transferId?: string): Promise<void>;
+export declare function deleteCategoryGroup(group: Pick<DbCategoryGroup, 'id'>, transferId?: DbCategory['id']): Promise<void>;
 export declare function insertCategory(category: WithRequired<Partial<DbCategory>, 'name' | 'cat_group'>, { atEnd }?: {
     atEnd?: boolean | undefined;
 }): Promise<DbCategory['id']>;
@@ -111,6 +112,6 @@ export declare function deleteAccount(account: any): Promise<void>;
 export declare function moveAccount(id: DbAccount['id'], targetId: DbAccount['id'] | null): 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 insertTransaction(transaction: any): Promise<TransactionEntity['id']>;
 export declare function updateTransaction(transaction: any): Promise<void>;
 export declare function deleteTransaction(transaction: any): Promise<void>;