@actual-app/api 6.7.1 → 6.8.0

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

@@ -0,0 +1,66 @@
+import type { AccountEntity, CategoryEntity, CategoryGroupEntity, PayeeEntity } from '../types/models';
+export type APIAccountEntity = Pick<AccountEntity, 'id' | 'name'> & {
+    offbudget: boolean;
+    closed: boolean;
+};
+export declare const accountModel: {
+    toExternal(account: AccountEntity): APIAccountEntity;
+    fromExternal(account: APIAccountEntity): AccountEntity;
+    validate(account: AccountEntity, { update }?: {
+        update?: boolean;
+    }): AccountEntity;
+};
+export type APICategoryEntity = Pick<CategoryEntity, 'id' | 'name' | 'is_income' | 'hidden'> & {
+    group_id?: string;
+};
+export declare const categoryModel: {
+    toExternal(category: CategoryEntity): APICategoryEntity;
+    fromExternal(category: APICategoryEntity): {
+        id?: string;
+        name: string;
+        is_income?: boolean;
+        cat_group?: string;
+        sort_order?: number;
+        tombstone?: boolean;
+        hidden?: boolean;
+    };
+    validate(category: CategoryEntity, { update }?: {
+        update?: boolean;
+    }): {
+        hidden: number;
+        id?: string;
+        name: string;
+        is_income?: boolean;
+        cat_group?: string;
+        tombstone?: boolean;
+    };
+};
+export type APICategoryGroupEntity = Pick<CategoryGroupEntity, 'id' | 'name' | 'is_income' | 'hidden'> & {
+    categories: APICategoryEntity[];
+};
+export declare const categoryGroupModel: {
+    toExternal(group: CategoryGroupEntity): APICategoryGroupEntity;
+    fromExternal(group: APICategoryGroupEntity): CategoryGroupEntity;
+    validate(categoryGroup: CategoryGroupEntity, { update }?: {
+        update?: boolean;
+    }): {
+        hidden: number;
+        id?: string;
+        name: string;
+        is_income?: boolean;
+        tombstone?: boolean;
+        categories?: CategoryEntity[];
+    };
+};
+export type APIPayeeEntity = Pick<PayeeEntity, 'id' | 'name' | 'transfer_acct'>;
+export declare const payeeModel: {
+    toExternal(payee: PayeeEntity): {
+        id: string;
+        name: string;
+        transfer_acct: string;
+    };
+    fromExternal(payee: APIPayeeEntity): PayeeEntity;
+    validate(payee: PayeeEntity, { update }?: {
+        update?: boolean;
+    }): PayeeEntity;
+};

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

@@ -0,0 +1,3 @@
+import { Handlers } from '../types/handlers';
+import { ServerHandlers } from '../types/server-handlers';
+export declare function installAPI(serverHandlers: ServerHandlers): ServerHandlers & Handlers;

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

@@ -0,0 +1,14 @@
+declare class App<Handlers> {
+    events: any;
+    handlers: Handlers;
+    services: any;
+    unlistenServices: any;
+    constructor();
+    method<Name extends string & keyof Handlers>(name: Name, func: Handlers[Name]): void;
+    service(func: any): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+}
+export declare function createApp<T>(): App<T>;
+export {};

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

@@ -0,0 +1,56 @@
+export declare function quoteAlias(alias: any): any;
+export declare function isAggregateQuery(queryState: any): boolean;
+export type SchemaConfig = {
+    tableViews?: Record<string, unknown> | ((name: string, config: {
+        withDead: any;
+        isJoin: any;
+        tableOptions: any;
+    }) => unknown);
+    tableFilters?: (name: string) => unknown[];
+    customizeQuery?: <T extends {
+        table: string;
+        orderExpressions: unknown[];
+    }>(queryString: T) => T;
+    views?: Record<string, {
+        fields?: Record<string, string>;
+        [key: `v_${string}`]: string | ((internalFields: any, publicFields: any) => string);
+    }>;
+};
+export declare function compileQuery(queryState: any, schema: any, schemaConfig?: SchemaConfig): {
+    sqlPieces: {
+        select: string;
+        from: unknown;
+        joins: string;
+        where: string;
+        groupBy: string;
+        orderBy: string;
+        limit: any;
+        offset: any;
+    };
+    state: {
+        schema: any;
+        implicitTableName: any;
+        implicitTableId: unknown;
+        paths: Map<any, any>;
+        dependencies: any[];
+        compileStack: any[];
+        outputTypes: Map<any, any>;
+        validateRefs: any;
+        namedParameters: any[];
+    };
+};
+export declare function defaultConstructQuery(queryState: any, state: any, sqlPieces: any): string;
+export declare function generateSQLWithState(queryState: any, schema?: unknown, schemaConfig?: unknown): {
+    sql: string;
+    state: {
+        schema: any;
+        implicitTableName: any;
+        implicitTableId: unknown;
+        paths: Map<any, any>;
+        dependencies: any[];
+        compileStack: any[];
+        outputTypes: Map<any, any>;
+        validateRefs: any;
+        namedParameters: any[];
+    };
+};

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

@@ -0,0 +1,9 @@
+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?: {};
+}): Promise<any>;
+export declare function runQuery(schema: any, schemaConfig: any, query: any, options: any): Promise<{
+    data: any;
+    dependencies: any[];
+}>;

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

@@ -0,0 +1,5 @@
+export { convertForInsert, convertForUpdate, convertFromSelect, convertInputType, } from './schema-helpers';
+export { compileQuery } from './compiler';
+export { makeViews } from './views';
+export { schema, schemaConfig } from './schema';
+export { runQuery, runCompiledQuery } from './schema/run-query';

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

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

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

@@ -0,0 +1,340 @@
+import { SchemaConfig } from '../compiler';
+export declare const schema: {
+    transactions: {
+        id: {
+            type: string;
+        };
+        is_parent: {
+            type: string;
+        };
+        is_child: {
+            type: string;
+        };
+        parent_id: {
+            type: string;
+        };
+        account: {
+            type: string;
+        };
+        category: {
+            type: string;
+        };
+        amount: {
+            type: string;
+        };
+        payee: {
+            type: string;
+        };
+        notes: {
+            type: string;
+        };
+        date: {
+            type: string;
+        };
+        imported_id: {
+            type: string;
+        };
+        error: {
+            type: string;
+        };
+        imported_payee: {
+            type: string;
+        };
+        starting_balance_flag: {
+            type: string;
+        };
+        transfer_id: {
+            type: string;
+        };
+        sort_order: {
+            type: string;
+        };
+        cleared: {
+            type: string;
+        };
+        reconciled: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+        schedule: {
+            type: string;
+        };
+    };
+    payees: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        transfer_acct: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    accounts: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        offbudget: {
+            type: string;
+        };
+        closed: {
+            type: string;
+        };
+        sort_order: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+        account_sync_source: {
+            type: string;
+        };
+    };
+    categories: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        is_income: {
+            type: string;
+        };
+        hidden: {
+            type: string;
+        };
+        group: {
+            type: string;
+        };
+        sort_order: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    category_groups: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        is_income: {
+            type: string;
+        };
+        hidden: {
+            type: string;
+        };
+        sort_order: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    schedules: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        rule: {
+            type: string;
+        };
+        next_date: {
+            type: string;
+        };
+        completed: {
+            type: string;
+        };
+        posts_transaction: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+        _payee: {
+            type: string;
+        };
+        _account: {
+            type: string;
+        };
+        _amount: {
+            type: string;
+        };
+        _amountOp: {
+            type: string;
+        };
+        _date: {
+            type: string;
+        };
+        _conditions: {
+            type: string;
+        };
+        _actions: {
+            type: string;
+        };
+    };
+    rules: {
+        id: {
+            type: string;
+        };
+        stage: {
+            type: string;
+        };
+        conditions_op: {
+            type: string;
+        };
+        conditions: {
+            type: string;
+        };
+        actions: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    notes: {
+        id: {
+            type: string;
+        };
+        note: {
+            type: string;
+        };
+    };
+    transaction_filters: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        conditions_op: {
+            type: string;
+        };
+        conditions: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    custom_reports: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        start_date: {
+            type: string;
+        };
+        end_date: {
+            type: string;
+        };
+        date_static: {
+            type: string;
+        };
+        date_range: {
+            type: string;
+        };
+        mode: {
+            type: string;
+        };
+        group_by: {
+            type: string;
+        };
+        balance_type: {
+            type: string;
+        };
+        show_empty: {
+            type: string;
+        };
+        show_offbudget: {
+            type: string;
+        };
+        show_hidden: {
+            type: string;
+        };
+        show_uncategorized: {
+            type: string;
+        };
+        selected_categories: {
+            type: string;
+        };
+        graph_type: {
+            type: string;
+        };
+        conditions: {
+            type: string;
+        };
+        conditions_op: {
+            type: string;
+        };
+        metadata: {
+            type: string;
+        };
+        interval: {
+            type: string;
+        };
+        color_scheme: {
+            type: string;
+        };
+        tombstone: {
+            type: string;
+        };
+    };
+    reflect_budgets: {
+        id: {
+            type: string;
+        };
+        month: {
+            type: string;
+        };
+        category: {
+            type: string;
+        };
+        amount: {
+            type: string;
+        };
+        carryover: {
+            type: string;
+        };
+        goal: {
+            type: string;
+        };
+    };
+    zero_budgets: {
+        id: {
+            type: string;
+        };
+        month: {
+            type: string;
+        };
+        category: {
+            type: string;
+        };
+        amount: {
+            type: string;
+        };
+        carryover: {
+            type: string;
+        };
+        goal: {
+            type: string;
+        };
+    };
+};
+export declare const schemaConfig: SchemaConfig;

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

@@ -0,0 +1,6 @@
+import { Query, type QueryState } from '../../../shared/query';
+export declare function runCompiledQuery(query: any, sqlPieces: any, state: any, params?: unknown): Promise<any>;
+export declare function runQuery(query: Query | QueryState, params?: unknown): Promise<{
+    data: any;
+    dependencies: any[];
+}>;

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

@@ -0,0 +1,8 @@
+export declare function convertInputType(value: any, type: any): any;
+export declare function convertOutputType(value: any, type: any): any;
+export declare function conform(schema: any, schemaConfig: any, table: any, obj: any, { skipNull }?: {
+    skipNull?: boolean;
+}): any;
+export declare function convertForInsert(schema: any, schemaConfig: any, table: any, rawObj: any): any;
+export declare function convertForUpdate(schema: any, schemaConfig: any, table: any, rawObj: any): any;
+export declare function convertFromSelect(schema: any, schemaConfig: any, table: any, obj: any): {};

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

@@ -0,0 +1 @@
+export declare function makeViews(schema: any, schemaConfig: any): string;

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

@@ -0,0 +1,16 @@
+export type Backup = {
+    id: string;
+    date: string;
+} | LatestBackup;
+type LatestBackup = {
+    id: string;
+    date: null;
+    isLatest: true;
+};
+export declare function getAvailableBackups(id: string): Promise<Backup[]>;
+export declare function updateBackups(backups: any): Promise<any[]>;
+export declare function makeBackup(id: string): Promise<void>;
+export declare function loadBackup(id: string, backupId: string): Promise<void>;
+export declare function startBackupService(id: string): void;
+export declare function stopBackupService(): void;
+export {};

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

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

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

@@ -0,0 +1,63 @@
+export declare function getSheetValue(sheetName: string, cell: string): Promise<number>;
+export declare function isReflectBudget(): boolean;
+export declare function getBudget({ category, month, }: {
+    category: string;
+    month: string;
+}): number;
+export declare function setBudget({ category, month, amount, }: {
+    category: string;
+    month: string;
+    amount: unknown;
+}): Promise<void>;
+export declare function setGoal({ month, category, goal }: {
+    month: any;
+    category: any;
+    goal: any;
+}): Promise<void>;
+export declare function setBuffer(month: string, amount: unknown): Promise<void>;
+export declare function copyPreviousMonth({ month, }: {
+    month: string;
+}): Promise<void>;
+export declare function copySinglePreviousMonth({ month, category, }: {
+    month: string;
+    category: string;
+}): Promise<void>;
+export declare function setZero({ month }: {
+    month: string;
+}): Promise<void>;
+export declare function set3MonthAvg({ month, }: {
+    month: string;
+}): Promise<void>;
+export declare function setNMonthAvg({ month, N, category, }: {
+    month: string;
+    N: number;
+    category: string;
+}): Promise<void>;
+export declare function holdForNextMonth({ month, amount, }: {
+    month: string;
+    amount: number;
+}): Promise<boolean>;
+export declare function resetHold({ month }: {
+    month: string;
+}): Promise<void>;
+export declare function coverOverspending({ month, to, from, }: {
+    month: string;
+    to: string;
+    from: string;
+}): Promise<void>;
+export declare function transferAvailable({ month, amount, category, }: {
+    month: string;
+    amount: number;
+    category: string;
+}): Promise<void>;
+export declare function transferCategory({ month, amount, from, to, }: {
+    month: string;
+    amount: number;
+    to: string;
+    from: string;
+}): Promise<void>;
+export declare function setCategoryCarryover({ startMonth, category, flag, }: {
+    startMonth: string;
+    category: string;
+    flag: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,12 @@
+import { BudgetHandlers } from './types/handlers';
+export declare const app: {
+    events: any;
+    handlers: BudgetHandlers;
+    services: any;
+    unlistenServices: any;
+    method<Name extends "budget/budget-amount" | "budget/copy-previous-month" | "budget/set-zero" | "budget/set-3month-avg" | "budget/check-templates" | "budget/apply-goal-template" | "budget/overwrite-goal-template" | "budget/cleanup-goal-template" | "budget/hold-for-next-month" | "budget/reset-hold" | "budget/cover-overspending" | "budget/transfer-available" | "budget/transfer-category" | "budget/set-carryover" | "budget/apply-single-template" | "budget/set-n-month-avg" | "budget/copy-single-month">(name: Name, func: BudgetHandlers[Name]): void;
+    service(func: any): void;
+    combine(...apps: any[]): void;
+    startServices(): void;
+    stopServices(): void;
+};

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

@@ -0,0 +1,17 @@
+export declare function getBudgetType(): any;
+export declare function getBudgetRange(start: string, end: string): {
+    start: string;
+    end: string;
+    range: string[];
+};
+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>;
+export declare function createAllBudgets(): Promise<{
+    start: string;
+    end: string;
+}>;
+export declare function setType(type: any): Promise<{
+    start: string;
+    end: string;
+}>;

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

@@ -0,0 +1,4 @@
+import { Notification } from '../../client/state-types/notifications';
+export declare function cleanupTemplate({ month }: {
+    month: string;
+}): Promise<Notification>;

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

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

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

@@ -0,0 +1,5 @@
+export declare function goalsBy(template_lines: any, current_month: any, template: any, l: any, remainder: any, last_month_balance: any, to_budget: any, errors: any): Promise<{
+    to_budget: any;
+    errors: any;
+    remainder: any;
+}>;

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

@@ -0,0 +1,4 @@
+export declare function goalsPercentage(template: any, month: any, available_start: any, sheetName: any, to_budget: any, errors: any): Promise<{
+    to_budget: any;
+    errors: any;
+}>;

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

@@ -0,0 +1,8 @@
+export declare function goalsRemainder(template: any, budgetAvailable: any, remainder_scale: any, to_budget: any): Promise<{
+    to_budget: any;
+}>;
+export declare function findRemainder(priority_list: any, categories: any, category_templates: any): {
+    remainder_found: any;
+    remainder_priority: any;
+    remainder_weight_total: number;
+};

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

@@ -0,0 +1,6 @@
+export declare function goalsSchedule(scheduleFlag: any, template_lines: any, current_month: any, balance: any, remainder: any, last_month_balance: any, to_budget: any, errors: any, category: any): Promise<{
+    to_budget: any;
+    errors: any;
+    remainder: any;
+    scheduleFlag: any;
+}>;

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

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