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

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/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/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,6 +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;
-export declare const schemaExecutors: {
-    transactions: typeof execTransactions;
-};
-export {};
+export declare const schemaExecutors: Record<string, AqlQueryExecutor>;

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/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,9 +1,10 @@
-export declare function getBudgetType(): any;
+export declare function getBudgetType(): "tracking" | "envelope";
 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/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/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/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/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/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 {