@actual-app/api 25.5.0 → 25.6.0-edge.23

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

@@ -1,54 +1,56 @@
 import { QueryState } from '../../shared/query';
 export declare function quoteAlias(alias: any): any;
 export declare function isAggregateQuery(queryState: any): boolean;
+type Schema = unknown;
 export type SchemaConfig = {
-    tableViews?: Record<string, unknown> | ((name: string, config: {
+    tableViews?: Record<string, string> | ((name: string, config: {
         withDead: any;
         isJoin: any;
         tableOptions: any;
-    }) => unknown);
+    }) => string);
     tableFilters?: (name: string) => unknown[];
-    customizeQuery?: (queryString: QueryState) => QueryState;
+    customizeQuery?: (queryState: QueryState) => QueryState;
     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: number;
-        offset: number;
-    };
-    state: {
-        schema: any;
-        implicitTableName: any;
-        implicitTableId: unknown;
-        paths: Map<any, any>;
-        dependencies: any[];
-        compileStack: any[];
-        outputTypes: Map<any, any>;
-        validateRefs: any;
-        namedParameters: any[];
-    };
+export type OutputTypes = Map<string, string | number | null>;
+type NamedParameter = {
+    type: string;
+    paramName: string;
+    paramType?: string;
+    value: string;
 };
-export declare function defaultConstructQuery(queryState: any, state: any, sqlPieces: any): string;
-export declare function generateSQLWithState(queryState: any, schema?: unknown, schemaConfig?: unknown): {
+type CompileStack = unknown[];
+export type CompilerState = {
+    schema: Schema;
+    implicitTableName: string;
+    implicitTableId: string;
+    paths: Map<string, unknown>;
+    dependencies: string[];
+    compileStack: CompileStack;
+    outputTypes: OutputTypes;
+    validateRefs: boolean;
+    namedParameters: NamedParameter[];
+};
+export type SqlPieces = {
+    select: string;
+    from: string;
+    joins: string;
+    where: string;
+    groupBy: string;
+    orderBy: string;
+    limit: number | null;
+    offset: number | null;
+};
+export declare function compileQuery(queryState: QueryState, schema: Schema, schemaConfig?: SchemaConfig): {
+    sqlPieces: SqlPieces;
+    state: CompilerState;
+};
+export declare function defaultConstructQuery(queryState: QueryState, compilerState: CompilerState, sqlPieces: SqlPieces): string;
+export declare function generateSQLWithState(queryState: QueryState, schema?: Schema, schemaConfig?: SchemaConfig): {
     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[];
-    };
+    state: CompilerState;
 };
+export {};

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

@@ -1,9 +1,17 @@
-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?: {};
-}): Promise<any>;
-export declare function runQuery(schema: any, schemaConfig: any, query: any, options: any): Promise<{
+import { QueryState } from '../../shared/query';
+import { CompilerState, OutputTypes, SchemaConfig, SqlPieces } from './compiler';
+export declare function execQuery(queryState: QueryState, compilerState: CompilerState, sqlPieces: SqlPieces, params: (string | number)[], outputTypes: OutputTypes): Promise<Record<string, unknown>[]>;
+export type AqlQueryExecutor = (compilerState: CompilerState, queryState: QueryState, sqlPieces: SqlPieces, params: (string | number)[], outputTypes: OutputTypes) => Promise<Record<string, unknown>[]>;
+type AqlQueryParamName = string;
+type AqlQueryParamValue = unknown;
+export type AqlQueryParams = Record<AqlQueryParamName, AqlQueryParamValue>;
+export type RunCompiledAqlQueryOptions = {
+    params?: AqlQueryParams;
+    executors?: Record<string, AqlQueryExecutor>;
+};
+export declare function runCompiledAqlQuery(queryState: QueryState, sqlPieces: SqlPieces, compilerState: CompilerState, { params, executors }?: RunCompiledAqlQueryOptions): Promise<unknown>;
+export declare function compileAndRunAqlQuery(schema: any, schemaConfig: SchemaConfig, queryState: QueryState, options: RunCompiledAqlQueryOptions): Promise<{
     data: any;
-    dependencies: any[];
+    dependencies: string[];
 }>;
+export {};

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

@@ -1,5 +1,12 @@
+import { Query, type QueryState } from '../../shared/query';
+import { CompilerState, SqlPieces } from './compiler';
+import { AqlQueryParams } from './exec';
 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';
+export declare function aqlCompiledQuery(queryState: QueryState, sqlPieces: SqlPieces, compilerState: CompilerState, params?: AqlQueryParams): Promise<unknown>;
+export declare function aqlQuery(query: Query | QueryState, params?: AqlQueryParams): Promise<{
+    data: any;
+    dependencies: string[];
+}>;

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

@@ -1,8 +1,3 @@
-declare function execTransactions(state: any, query: any, sql: any, params: any, outputTypes: any): Promise<any>;
+import { AqlQueryExecutor } from '../exec';
 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 {};
+export declare const schemaExecutors: Record<string, AqlQueryExecutor>;

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

@@ -1,7 +1,7 @@
 import { CategoryEntity, CategoryGroupEntity } from '../../types/models';
 import * as actions from './actions';
 import * as cleanupActions from './cleanup-template';
-import * as goalActions from './goaltemplates';
+import * as goalActions from './goal-template';
 export interface BudgetHandlers {
     'budget/budget-amount': typeof actions.setBudget;
     'budget/copy-previous-month': typeof actions.copyPreviousMonth;

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

@@ -1,4 +1,4 @@
-export declare function getBudgetType(): "report" | "rollover";
+export declare function getBudgetType(): "tracking" | "envelope";
 export declare function getBudgetRange(start: string, end: string): {
     start: string;
     end: string;

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

@@ -0,0 +1,49 @@
+import { CategoryEntity } from '../../types/models';
+import { AverageTemplate, CopyTemplate, PercentageTemplate, SimpleTemplate, SpendTemplate, Template, WeekTemplate } from './types/templates';
+export declare class CategoryTemplateContext {
+    static init(templates: Template[], category: CategoryEntity, month: string, budgeted: number): Promise<CategoryTemplateContext>;
+    isGoalOnly(): boolean;
+    getPriorities(): number[];
+    getRemainderWeight(): number;
+    getLimitExcess(): number;
+    runAll(available: number): Promise<number>;
+    runTemplatesForPriority(priority: number, budgetAvail: number, availStart: number): Promise<number>;
+    runRemainder(budgetAvail: number, perWeight: number): number;
+    getValues(): {
+        budgeted: number;
+        goal: number;
+        longGoal: boolean;
+    };
+    readonly category: CategoryEntity;
+    private month;
+    private templates;
+    private remainder;
+    private goals;
+    private priorities;
+    private remainderWeight;
+    private toBudgetAmount;
+    private fullAmount;
+    private isLongGoal;
+    private goalAmount;
+    private fromLastMonth;
+    private limitMet;
+    private limitExcess;
+    private limitAmount;
+    private limitCheck;
+    private limitHold;
+    readonly previouslyBudgeted: number;
+    protected constructor(templates: Template[], category: CategoryEntity, month: string, fromLastMonth: number, budgeted: number);
+    private runGoal;
+    static checkByAndScheduleAndSpend(templates: Template[], month: string): Promise<void>;
+    static checkPercentage(templates: Template[]): Promise<void>;
+    private checkLimit;
+    private checkSpend;
+    private checkGoal;
+    static runSimple(template: SimpleTemplate, limit: number): number;
+    static runCopy(template: CopyTemplate, templateContext: CategoryTemplateContext): Promise<number>;
+    static runWeek(template: WeekTemplate, templateContext: CategoryTemplateContext): number;
+    static runSpend(template: SpendTemplate, templateContext: CategoryTemplateContext): Promise<number>;
+    static runPercentage(template: PercentageTemplate, availableFunds: number, templateContext: CategoryTemplateContext): Promise<number>;
+    static runAverage(template: AverageTemplate, templateContext: CategoryTemplateContext): Promise<number>;
+    static runBy(templateContext: CategoryTemplateContext): number;
+}

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

@@ -1,4 +1,11 @@
-import { Notification } from '../../client/notifications/notificationsSlice';
+type Notification = {
+    type?: 'message' | 'error' | 'warning' | undefined;
+    pre?: string | undefined;
+    title?: string | undefined;
+    message: string;
+    sticky?: boolean | undefined;
+};
 export declare function cleanupTemplate({ month }: {
     month: string;
 }): Promise<Notification>;
+export {};

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

@@ -0,0 +1,29 @@
+import { CategoryEntity } from '../../types/models';
+type Notification = {
+    type?: 'message' | 'error' | 'warning' | undefined;
+    pre?: string | undefined;
+    title?: string | undefined;
+    message: string;
+    sticky?: boolean | undefined;
+};
+export declare function applyTemplate({ month, }: {
+    month: string;
+}): Promise<Notification>;
+export declare function overwriteTemplate({ month, }: {
+    month: string;
+}): Promise<Notification>;
+export declare function applyMultipleCategoryTemplates({ month, categoryIds, }: {
+    month: string;
+    categoryIds: Array<CategoryEntity['id']>;
+}): Promise<Notification>;
+export declare function applySingleCategoryTemplate({ month, category, }: {
+    month: string;
+    category: CategoryEntity['id'];
+}): Promise<Notification>;
+export declare function runCheckTemplates(): Promise<{
+    type?: "message" | "error" | "warning" | undefined;
+    pre?: string | undefined;
+    message: string;
+    sticky?: boolean | undefined;
+}>;
+export {};

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

@@ -0,0 +1,7 @@
+import { CategoryEntity } from '../../types/models';
+import { Template } from './types/templates';
+export declare function runSchedule(template_lines: Template[], current_month: string, balance: number, remainder: number, last_month_balance: number, to_budget: number, errors: string[], category: CategoryEntity): Promise<{
+    to_budget: number;
+    errors: string[];
+    remainder: number;
+}>;

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

@@ -1,5 +1,11 @@
-import { Notification } from '../../client/notifications/notificationsSlice';
+type Notification = {
+    type?: 'message' | 'error' | 'warning' | undefined;
+    pre?: string | undefined;
+    message: string;
+    sticky?: boolean | undefined;
+};
 export declare const TEMPLATE_PREFIX = "#template";
 export declare const GOAL_PREFIX = "#goal";
 export declare function storeTemplates(): Promise<void>;
 export declare function checkTemplates(): Promise<Notification>;
+export {};

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

@@ -16,7 +16,12 @@ interface WeekTemplate extends BaseTemplate {
   amount: number;
   weeks: number | null;
   starting: string;
-  limit?: { amount: number; hold: boolean };
+  limit?: {
+    amount: number;
+    hold: boolean;
+    period?: 'daily' | 'weekly' | 'monthly';
+    start?: string;
+  };
 }
 
 interface ByTemplate extends BaseTemplate {
@@ -33,13 +38,19 @@ interface SpendTemplate extends BaseTemplate {
   amount: number;
   month: string;
   from: string;
-  repeat?: { annual: boolean; repeat?: number };
+  annual?: boolean;
+  repeat?: number;
 }
 
 interface SimpleTemplate extends BaseTemplate {
   type: 'simple';
   monthly?: number;
-  limit?: { amount: number; hold: boolean };
+  limit?: {
+    amount: number;
+    hold: boolean;
+    period?: 'daily' | 'weekly' | 'monthly';
+    start?: string;
+  };
 }
 
 interface ScheduleTemplate extends BaseTemplate {
@@ -52,7 +63,12 @@ interface ScheduleTemplate extends BaseTemplate {
 interface RemainderTemplate extends BaseTemplate {
   type: 'remainder';
   weight: number;
-  limit?: { amount: number; hold: boolean };
+  limit?: {
+    amount: number;
+    hold: boolean;
+    period?: 'daily' | 'weekly' | 'monthly';
+    start?: string;
+  };
 }
 
 interface AverageTemplate extends BaseTemplate {

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

@@ -1,5 +1,5 @@
 import type { MetadataPrefs } from '../types/prefs';
-export declare const BUDGET_TYPES: readonly ["report", "rollover"];
+export declare const BUDGET_TYPES: readonly ["tracking", "envelope"];
 export type BudgetType = (typeof BUDGET_TYPES)[number];
 export declare const UPCOMING_SCHEDULED_TRANSACTION_LENGTHS: readonly ["1", "7", "14", "30"];
 export type UpcomingScheduledTransactionLength = (typeof UPCOMING_SCHEDULED_TRANSACTION_LENGTHS)[number];

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

@@ -24,6 +24,7 @@ declare function fixSplitTransactions(): Promise<{
     numDeleted: number;
     numTransfersFixed: number;
     numNonParentErrorsFixed: number;
+    numParentTransactionsWithCategoryFixed: number;
     mismatchedSplits: TransactionEntity[];
 }>;
 export {};

package/@types/loot-core/shared/locale.d.ts

@@ -1 +1,2 @@
-export declare function getLocale(language: string): Locale;
+import * as locales from 'date-fns/locale';
+export declare function getLocale(language: string): locales.Locale;

package/@types/loot-core/shared/months.d.ts

@@ -1,3 +1,4 @@
+import { Locale } from 'date-fns';
 import { type SyncedPrefs } from '../types/prefs';
 type DateLike = string | Date;
 export declare function _parse(value: DateLike): Date;
@@ -29,6 +30,7 @@ export declare function subDays(day: DateLike, n: number): string;
 export declare function isBefore(month1: DateLike, month2: DateLike): boolean;
 export declare function isAfter(month1: DateLike, month2: DateLike): boolean;
 export declare function isCurrentMonth(month: DateLike): boolean;
+export declare function isCurrentDay(day: DateLike): boolean;
 export declare function bounds(month: DateLike): {
     start: number;
     end: number;
@@ -55,6 +57,10 @@ export declare function getYearEnd(month: string): string;
 export declare function sheetForMonth(month: string): string;
 export declare function nameForMonth(month: DateLike, locale?: Locale): string;
 export declare function format(month: DateLike, format: string, locale?: Locale): string;
+export declare function formatDistance(date1: DateLike, date2: DateLike, locale?: Locale, options?: {
+    addSuffix?: boolean;
+    includeSeconds?: boolean;
+}): string;
 export declare const getDateFormatRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;
 export declare const getDayMonthFormat: import("memoize-one").MemoizedFn<(format: string) => string>;
 export declare const getDayMonthRegex: import("memoize-one").MemoizedFn<(format: string) => RegExp>;

package/@types/loot-core/shared/schedules.d.ts

@@ -1,6 +1,7 @@
 import type { IRuleOptions } from '@rschedule/core';
+import { Locale } from 'date-fns';
 import { Condition } from '../server/rules';
-export declare function getStatus(nextDate: string, completed: boolean, hasTrans: boolean, upcomingLength: string): "completed" | "paid" | "due" | "upcoming" | "missed" | "scheduled";
+export declare function getStatus(nextDate: string, completed: boolean, hasTrans: boolean, upcomingLength?: string): "completed" | "paid" | "due" | "upcoming" | "missed" | "scheduled";
 export declare function getStatusLabel(status: string): string;
 export declare function getHasTransactionsQuery(schedules: any): import("./query").Query;
 export declare function getRecurringDescription(config: any, dateFormat: any, locale: Locale): string;

package/@types/loot-core/shared/transactions.d.ts

@@ -16,7 +16,7 @@ export declare function recalculateSplit(trans: TransactionEntity): {
     parent_id?: TransactionEntity["id"];
     account: import("../types/models").AccountEntity["id"];
     category?: import("../types/models").CategoryEntity["id"];
-    amount: number;
+    amount: import("./util").IntegerAmount;
     payee?: import("../types/models").PayeeEntity["id"];
     notes?: string;
     date: string;
@@ -36,75 +36,15 @@ export declare function recalculateSplit(trans: TransactionEntity): {
     raw_synced_data?: string | undefined;
 };
 export declare function ungroupTransactions(transactions: TransactionEntity[]): TransactionEntity[];
-export declare function groupTransaction(split: TransactionEntity[]): {
-    subtransactions: TransactionEntity[];
-    id: string;
-    is_parent?: boolean;
-    is_child?: boolean;
-    parent_id?: TransactionEntity["id"];
-    account: import("../types/models").AccountEntity["id"];
-    category?: import("../types/models").CategoryEntity["id"];
-    amount: number;
-    payee?: import("../types/models").PayeeEntity["id"];
-    notes?: string;
-    date: string;
-    imported_id?: string;
-    imported_payee?: string;
-    starting_balance_flag?: boolean;
-    transfer_id?: TransactionEntity["id"];
-    sort_order?: number;
-    cleared?: boolean;
-    reconciled?: boolean;
-    tombstone?: boolean;
-    forceUpcoming?: boolean;
-    schedule?: import("../types/models").ScheduleEntity["id"];
-    _unmatched?: boolean;
-    _deleted?: boolean;
-    error?: {
-        type: "SplitTransactionError";
-        version: 1;
-        difference: number;
-    } | null;
-    raw_synced_data?: string | undefined;
-};
+export declare function groupTransaction(split: TransactionEntity[]): TransactionEntity;
 export declare function ungroupTransaction(split: TransactionEntity | null): TransactionEntity[];
-export declare function applyTransactionDiff(groupedTrans: Parameters<typeof ungroupTransaction>[0], diff: Parameters<typeof applyChanges>[0]): {
-    subtransactions: TransactionEntity[];
-    id: string;
-    is_parent?: boolean;
-    is_child?: boolean;
-    parent_id?: TransactionEntity["id"];
-    account: import("../types/models").AccountEntity["id"];
-    category?: import("../types/models").CategoryEntity["id"];
-    amount: number;
-    payee?: import("../types/models").PayeeEntity["id"];
-    notes?: string;
-    date: string;
-    imported_id?: string;
-    imported_payee?: string;
-    starting_balance_flag?: boolean;
-    transfer_id?: TransactionEntity["id"];
-    sort_order?: number;
-    cleared?: boolean;
-    reconciled?: boolean;
-    tombstone?: boolean;
-    forceUpcoming?: boolean;
-    schedule?: import("../types/models").ScheduleEntity["id"];
-    _unmatched?: boolean;
-    _deleted?: boolean;
-    error?: {
-        type: "SplitTransactionError";
-        version: 1;
-        difference: number;
-    } | null;
-    raw_synced_data?: string | undefined;
-};
-export declare function addSplitTransaction(transactions: TransactionEntity[], id: string): {
+export declare function applyTransactionDiff(groupedTrans: Parameters<typeof ungroupTransaction>[0], diff: Parameters<typeof applyChanges>[0]): TransactionEntity;
+export declare function addSplitTransaction(transactions: readonly TransactionEntity[], id: string): {
     data: TransactionEntity[];
     newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
-export declare function updateTransaction(transactions: TransactionEntity[], transaction: TransactionEntity): {
+export declare function updateTransaction(transactions: readonly TransactionEntity[], transaction: TransactionEntity): {
     data: TransactionEntity[];
     newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
@@ -114,7 +54,7 @@ export declare function deleteTransaction(transactions: TransactionEntity[], id:
     newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
-export declare function splitTransaction(transactions: TransactionEntity[], id: string, createSubtransactions?: (parentTransaction: TransactionEntity) => TransactionEntity[]): {
+export declare function splitTransaction(transactions: readonly TransactionEntity[], id: string, createSubtransactions?: (parentTransaction: TransactionEntity) => TransactionEntity[]): {
     data: TransactionEntity[];
     newTransaction: TransactionEntity | null;
     diff: ReturnType<typeof diffItems<TransactionEntity>>;
@@ -123,7 +63,7 @@ export declare function realizeTempTransactions(transactions: TransactionEntity[
 export declare function makeAsNonChildTransactions(childTransactionsToUpdate: TransactionEntity[], transactions: TransactionEntity[]): {
     updated: TransactionEntity[];
     deleted: {
-        amount: number;
+        amount: import("./util").IntegerAmount;
         id: string;
         is_parent?: boolean;
         is_child?: boolean;

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

@@ -1,3 +1,4 @@
+import { type Locale } from 'date-fns';
 export declare function last<T>(arr: Array<T>): T;
 export declare function getChangedValues<T extends {
     id?: string;
@@ -20,11 +21,11 @@ export declare function diffItems<T extends {
 }>(items: T[], newItems: T[]): Diff<T>;
 export declare function groupById<T extends {
     id: string;
-}>(data: T[]): Record<string, T>;
+}>(data: T[] | null | undefined): Record<string, T>;
 export declare function setIn(map: Map<string, unknown>, keys: string[], item: unknown): void;
 export declare function getIn(map: any, keys: any): any;
 export declare function fastSetMerge<T>(set1: Set<T>, set2: Set<T>): Set<T>;
-export declare function titleFirst(str: string): string;
+export declare function titleFirst(str: string | null | undefined): string;
 export declare function appendDecimals(amountText: string, hideDecimals?: boolean): string;
 declare const NUMBER_FORMATS: readonly ["comma-dot", "dot-comma", "space-comma", "apostrophe-dot", "comma-dot", "comma-dot-in"];
 type NumberFormats = (typeof NUMBER_FORMATS)[number];

package/@types/loot-core/types/models/category.d.ts

@@ -4,6 +4,7 @@ export interface CategoryEntity {
     name: string;
     is_income?: boolean;
     group: CategoryGroupEntity['id'];
+    goal_def?: string;
     sort_order?: number;
     tombstone?: boolean;
     hidden?: boolean;

package/@types/loot-core/types/models/transaction.d.ts

@@ -1,3 +1,4 @@
+import { IntegerAmount } from '../../shared/util';
 import { AccountEntity } from './account';
 import { CategoryEntity } from './category';
 import { PayeeEntity } from './payee';
@@ -9,7 +10,7 @@ export interface TransactionEntity {
     parent_id?: TransactionEntity['id'];
     account: AccountEntity['id'];
     category?: CategoryEntity['id'];
-    amount: number;
+    amount: IntegerAmount;
     payee?: PayeeEntity['id'];
     notes?: string;
     date: string;

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

@@ -3,7 +3,6 @@ export type FeatureFlag =
   | 'goalTemplatesUIEnabled'
   | 'actionTemplating'
   | 'contextMenus'
-  | 'openidAuth'
   | 'pluggyAiBankSync';
 
 /**

package/@types/methods.d.ts

@@ -10,7 +10,12 @@ export declare function runBankSync(args?: {
     accountId: string;
 }): Promise<void>;
 export declare function batchBudgetUpdates(func: any): Promise<void>;
+/**
+ * @deprecated Please use `aqlQuery` instead.
+ * This function will be removed in a future release.
+ */
 export declare function runQuery(query: any): Promise<unknown>;
+export declare function aqlQuery(query: any): Promise<unknown>;
 export declare function getBudgetMonths(): Promise<string[]>;
 export declare function getBudgetMonth(month: any): Promise<{
     month: string;