@actual-app/api 6.7.1 → 6.8.0

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

@@ -0,0 +1,4 @@
+export declare function goalsSpend(template: any, last_month_balance: any, current_month: any, to_budget: any, errors: any, category: any): Promise<{
+    to_budget: any;
+    errors: any;
+}>;

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

@@ -0,0 +1,7 @@
+export declare function goalsWeek(template: any, limit: any, limitCheck: any, hold: any, current_month: any, to_budget: any, errors: any): Promise<{
+    to_budget: any;
+    errors: any;
+    limit: any;
+    limitCheck: any;
+    hold: any;
+}>;

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

@@ -0,0 +1,12 @@
+import { Notification } from '../../client/state-types/notifications';
+export declare function applyTemplate({ month }: {
+    month: any;
+}): Promise<Notification>;
+export declare function overwriteTemplate({ month }: {
+    month: any;
+}): Promise<Notification>;
+export declare function applySingleCategoryTemplate({ month, category }: {
+    month: any;
+    category: any;
+}): Promise<Notification>;
+export declare function runCheckTemplates(): Promise<Notification>;

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

@@ -0,0 +1,2 @@
+export declare function createCategory(cat: any, sheetName: any, prevSheetName: any): Promise<void>;
+export declare function createSummary(groups: any, categories: any, sheetName: any): void;

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

@@ -0,0 +1,4 @@
+export declare function createBlankCategory(cat: any, months: any): void;
+export declare function createCategory(cat: any, sheetName: any, prevSheetName: 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;

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

@@ -0,0 +1,77 @@
+import type { Notification } from '../../../client/state-types/notifications';
+
+export interface BudgetHandlers {
+  'budget/budget-amount': (arg: {
+    category: string /* category id */;
+    month: string;
+    amount: number;
+  }) => Promise<void>;
+
+  'budget/copy-previous-month': (arg: { month: string }) => Promise<void>;
+
+  'budget/set-zero': (arg: { month: string }) => Promise<void>;
+
+  'budget/set-3month-avg': (arg: { month: string }) => Promise<void>;
+
+  'budget/check-templates': () => Promise<Notification>;
+
+  'budget/apply-goal-template': (arg: {
+    month: string;
+  }) => Promise<Notification>;
+
+  'budget/overwrite-goal-template': (arg: {
+    month: string;
+  }) => Promise<Notification>;
+
+  'budget/cleanup-goal-template': (arg: {
+    month: string;
+  }) => Promise<Notification>;
+
+  'budget/hold-for-next-month': (arg: {
+    month: string;
+    amount: number;
+  }) => Promise<boolean>;
+
+  'budget/reset-hold': (arg: { month: string }) => Promise<void>;
+
+  'budget/cover-overspending': (arg: {
+    month: string;
+    to: string;
+    from: string;
+  }) => Promise<void>;
+
+  'budget/transfer-available': (arg: {
+    month: string;
+    amount: number;
+    category: string;
+  }) => Promise<void>;
+
+  'budget/transfer-category': (arg: {
+    month: string;
+    amount: number;
+    to: string;
+    from: string;
+  }) => Promise<void>;
+
+  'budget/set-carryover': (arg: {
+    startMonth: string;
+    category: string;
+    flag: boolean;
+  }) => Promise<void>;
+
+  'budget/apply-single-template': (arg: {
+    month: string;
+    category: string; //category id
+  }) => Promise<Notification>;
+
+  'budget/set-n-month-avg': (arg: {
+    month: string;
+    N: number;
+    category: string; //category id
+  }) => Promise<void>;
+
+  'budget/copy-single-month': (arg: {
+    month: string;
+    category: string; //category id
+  }) => Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export { number } from '../spreadsheet/globals';
+export declare function sumAmounts(...amounts: any[]): number;
+export declare function flatten2(arr: any): any;
+export declare function unflatten2(arr: any): any[];

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

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+export interface RemoteFile {
+    deleted: boolean;
+    fileId: string;
+    groupId: string;
+    name: string;
+    encryptKeyId: string;
+    hasKey: boolean;
+}
+export declare function checkKey(): Promise<{
+    valid: boolean;
+    error?: {
+        reason: string;
+    };
+}>;
+export declare function resetSyncState(newKeyState: any): Promise<{
+    error: {
+        reason: string;
+    };
+} | {
+    error?: undefined;
+}>;
+export declare function exportBuffer(): Promise<Buffer>;
+export declare function importBuffer(fileData: any, buffer: any): Promise<{
+    id: any;
+}>;
+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 download(fileId: any): Promise<{
+    id: any;
+}>;

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

@@ -0,0 +1,60 @@
+import { CategoryEntity, CategoryGroupEntity } from '../../types/models';
+export { toDateRepr, fromDateRepr } from '../models';
+export declare function getDatabasePath(): any;
+export declare function openDatabase(id?: any): Promise<void>;
+export declare function reopenDatabase(): Promise<void>;
+export declare function closeDatabase(): Promise<void>;
+export declare function setDatabase(db_: any): void;
+export declare function getDatabase(): 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 execQuery(sql: any): void;
+export declare function cache(sql: any): any;
+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 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 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 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(): Promise<CategoryEntity[]>;
+export declare function getCategoriesGrouped(): 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>;
+export declare function deleteCategoryGroup(group: any, transferId?: string): Promise<void>;
+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 insertPayee(payee: any): Promise<any>;
+export declare function deletePayee(payee: any): Promise<void>;
+export declare function deleteTransferPayee(payee: any): 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 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 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 insertTransaction(transaction: any): Promise<any>;
+export declare function updateTransaction(transaction: any): Promise<void>;
+export declare function deleteTransaction(transaction: any): Promise<void>;

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

@@ -0,0 +1,3 @@
+export declare function loadMappings(): Promise<void>;
+export declare function getMappings(): any;
+export declare function getMapping(id: any): any;

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

@@ -0,0 +1,11 @@
+export declare const SORT_INCREMENT = 16384;
+export declare function shoveSortOrders<T extends {
+    id: string;
+    sort_order: number;
+}>(items: T[], targetId?: string): {
+    updates: {
+        id: string;
+        sort_order: number;
+    }[];
+    sort_order: any;
+};

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

@@ -0,0 +1,2 @@
+export declare function incrFetch(runQuery: any, terms: any, compare: any, makeQuery: any, params?: any[]): Promise<any[]>;
+export declare function whereIn(ids: string[], field: string): string;

package/@types/loot-core/server/encryption-internals.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+export declare function sha256String(str: any): Promise<string>;
+export declare function randomBytes(n: any): Buffer;
+export declare function encrypt(masterKey: any, value: any): {
+    value: Buffer;
+    meta: {
+        keyId: any;
+        algorithm: "aes-256-gcm";
+        iv: string;
+        authTag: string;
+    };
+};
+export declare function decrypt(masterKey: any, encrypted: any, meta: any): Buffer;
+export declare function createKey({ secret, salt }: {
+    secret: any;
+    salt: any;
+}): {
+    raw: Buffer;
+    base64: string;
+};
+export declare function importKey(str: any): {
+    raw: Buffer;
+    base64: any;
+};

package/@types/loot-core/server/encryption-internals.web.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+export declare function sha256String(str: any): Promise<string>;
+export declare function randomBytes(n: any): Buffer;
+export declare function encrypt(masterKey: any, value: any): Promise<{
+    value: ArrayBuffer;
+    meta: {
+        keyId: any;
+        algorithm: string;
+        iv: string;
+        authTag: string;
+    };
+}>;
+export declare function decrypt(masterKey: any, encrypted: any, meta: any): Promise<Buffer>;
+export declare function createKey({ secret, salt }: {
+    secret: any;
+    salt: any;
+}): Promise<{
+    raw: CryptoKey;
+    base64: string;
+}>;
+export declare function importKey(str: any): Promise<{
+    raw: CryptoKey;
+    base64: any;
+}>;

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

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+declare class Key {
+    id: any;
+    value: any;
+    constructor({ id }: {
+        id: any;
+    });
+    createFromPassword({ password, salt }: {
+        password: any;
+        salt: any;
+    }): Promise<void>;
+    createFromBase64(str: any): Promise<void>;
+    getId(): any;
+    getValue(): any;
+    serialize(): {
+        id: any;
+        base64: any;
+    };
+}
+export declare function getKey(keyId: any): any;
+export declare function hasKey(keyId: any): boolean;
+export declare function encrypt(value: any, keyId: any): {
+    value: Buffer;
+    meta: {
+        keyId: any;
+        algorithm: "aes-256-gcm";
+        iv: string;
+        authTag: string;
+    };
+};
+export declare function decrypt(encrypted: any, meta: any): Buffer;
+export declare function randomBytes(n: any): Buffer;
+export declare function loadKey(key: any): Promise<void>;
+export declare function unloadKey(key: any): void;
+export declare function unloadAllKeys(): void;
+export declare function createKey({ id, password, salt }: {
+    id: any;
+    password: any;
+    salt: any;
+}): Promise<Key>;
+export {};

package/@types/loot-core/server/encryption.test.d.ts

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

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

@@ -0,0 +1,73 @@
+export declare class PostError extends Error {
+    meta?: {
+        meta: string;
+    };
+    reason: string;
+    type: 'PostError';
+    constructor(reason: string, meta?: {
+        meta: string;
+    });
+}
+export declare class HTTPError extends Error {
+    statusCode: number;
+    responseBody: string;
+    constructor(code: number, body: string);
+}
+export declare class SyncError extends Error {
+    meta?: {
+        isMissingKey: boolean;
+    } | {
+        error: {
+            message: string;
+            stack: string;
+        };
+        query: {
+            sql: string;
+            params: Array<string | number>;
+        };
+    };
+    reason: string;
+    constructor(reason: string, meta?: {
+        isMissingKey: boolean;
+    } | {
+        error: {
+            message: string;
+            stack: string;
+        };
+        query: {
+            sql: string;
+            params: Array<string | number>;
+        };
+    });
+}
+export declare class TransactionError extends Error {
+}
+export declare class RuleError extends Error {
+    type: string;
+    constructor(name: string, message: string);
+}
+export declare function APIError(msg: string, meta?: Record<string, any>): {
+    type: string;
+    message: string;
+    meta: Record<string, any>;
+};
+export declare function FileDownloadError(reason: string, meta?: {
+    fileId?: string;
+    isMissingKey?: boolean;
+}): {
+    type: string;
+    reason: string;
+    meta: {
+        fileId?: string;
+        isMissingKey?: boolean;
+    };
+};
+export declare function FileUploadError(reason: string, meta?: {
+    isMissingKey: boolean;
+}): {
+    type: string;
+    reason: string;
+    meta: {
+        isMissingKey: boolean;
+    };
+};

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

@@ -0,0 +1,12 @@
+import { FiltersHandlers } from './types/handlers';
+export declare const app: {
+    events: any;
+    handlers: FiltersHandlers;
+    services: any;
+    unlistenServices: any;
+    method<Name extends "filter-create" | "filter-update" | "filter-delete">(name: Name, func: FiltersHandlers[Name]): void;
+    service(func: any): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};

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

@@ -0,0 +1,7 @@
+export interface FiltersHandlers {
+  'filter-create': (filter: object) => Promise<string>;
+
+  'filter-update': (filter: object) => Promise<void>;
+
+  'filter-delete': (id: string) => Promise<void>;
+}

package/@types/loot-core/server/importers/actual.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function importActual(_filepath: string, buffer: Buffer): Promise<{
+    error: any;
+}>;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+type ImportableBudgetType = 'ynab4' | 'ynab5' | 'actual';
+export declare function handleBudgetImport(type: ImportableBudgetType, filepath: string, buffer: Buffer): Promise<{
+    error: any;
+}>;
+export {};

package/@types/loot-core/server/importers/ynab4-types.d.ts

@@ -0,0 +1,167 @@
+/* eslint-disable import/no-unused-modules */
+
+export namespace YNAB4 {
+  export interface YFull {
+    masterCategories: MasterCategory[];
+    payees: Payee[];
+    monthlyBudgets: MonthlyBudget[];
+    fileMetaData: FileMetaData;
+    transactions: Transaction[];
+    scheduledTransactions: ScheduledTransaction[];
+    // accountMappings: [];
+    budgetMetaData: BudgetMetaData;
+    accounts: Account[];
+  }
+
+  export interface MasterCategory {
+    entityType: string;
+    expanded: boolean;
+    note?: string;
+    name: string;
+    type: string;
+    deleteable: boolean;
+    subCategories?: SubCategory[];
+    entityVersion: string;
+    entityId: string;
+    sortableIndex: number;
+
+    // speculative
+    isTombstone?: boolean;
+  }
+
+  export interface SubCategory {
+    entityType: string;
+    name: string;
+    note?: string;
+    type: string;
+    // cachedBalance: null;
+    masterCategoryId: string;
+    entityVersion: string;
+    entityId: string;
+    sortableIndex: number;
+
+    // speculative
+    isTombstone?: boolean;
+  }
+
+  export interface Payee {
+    entityType: string;
+    autoFillCategoryId?: string;
+    autoFillAmount: number;
+    name: string;
+    renameConditions?: RenameCondition[];
+    autoFillMemo?: string;
+    targetAccountId?: string;
+    // locations: null;
+    enabled: boolean;
+    entityVersion: string;
+    entityId: string;
+
+    // speculative
+    isTombstone?: boolean;
+  }
+
+  export interface RenameCondition {
+    entityType: string;
+    parentPayeeId: string;
+    operator: string;
+    operand: string;
+    entityVersion: string;
+    entityId: string;
+  }
+
+  export interface MonthlyBudget {
+    entityType: string;
+    monthlySubCategoryBudgets: MonthlySubCategoryBudget[];
+    month: string;
+    entityVersion: string;
+    entityId: string;
+  }
+
+  export interface MonthlySubCategoryBudget {
+    entityType: string;
+    categoryId: string;
+    budgeted: number;
+    // overspendingHandling: null;
+    entityVersion: string;
+    entityId: string;
+    parentMonthlyBudgetId: string;
+
+    // speculative
+    isTombstone?: boolean;
+  }
+
+  export interface FileMetaData {
+    entityType: string;
+    budgetDataVersion: string;
+    currentKnowledge: string;
+  }
+
+  export interface Transaction {
+    entityType: string;
+    entityId: string;
+    categoryId: string;
+    payeeId: string;
+    amount: number;
+    date: string;
+    accountId: string;
+    entityVersion: string;
+    cleared: string;
+    accepted: boolean;
+    isTombstone?: boolean;
+    memo?: string;
+    dateEnteredFromSchedule?: string;
+    // speculative:
+    subTransactions?: SubTransaction[];
+    transferTransactionId?: string;
+    targetAccountId?: string;
+  }
+
+  // speculative, not in the test data
+  export type SubTransaction = Exclude<Transaction, 'subTransactions'>;
+
+  export interface ScheduledTransaction {
+    entityType: string;
+    entityId: string;
+    categoryId: string;
+    payeeId: string;
+    amount: number;
+    date: string;
+    isTombstone?: boolean;
+    accountId: string;
+    entityVersion: string;
+    memo: string;
+    twiceAMonthStartDay: number;
+    cleared: string;
+    frequency: string;
+    accepted: boolean;
+  }
+
+  export interface BudgetMetaData {
+    entityType: string;
+    strictBudget: string;
+    currencyISOSymbol?: string;
+    entityVersion: string;
+    currencyLocale: string;
+    budgetType: string;
+    dateLocale: string;
+    entityId: string;
+  }
+
+  export interface Account {
+    entityType: string;
+    // lastReconciledDate: null;
+    lastEnteredCheckNumber: number;
+    lastReconciledBalance: number;
+    accountType: string;
+    hidden: boolean;
+    sortableIndex: number;
+    onBudget: boolean;
+    accountName: string;
+    entityVersion: string;
+    entityId: string;
+
+    // speculative
+    isTombstone?: boolean;
+  }
+}

package/@types/loot-core/server/importers/ynab4.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { YNAB4 } from './ynab4-types';
+export declare function doImport(data: YNAB4.YFull): Promise<void>;
+export declare function getBudgetName(filepath: any): string;
+export declare function parseFile(buffer: Buffer): YNAB4.YFull;