@actual-app/api 6.9.0 → 6.10.0

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

@@ -1,4 +1,50 @@
+import { type CustomReportData, type CustomReportEntity } from '../../types/models';
 import { ReportsHandlers } from './types/handlers';
+export declare const reportModel: {
+    validate(report: Omit<CustomReportEntity, "tombstone">, { update }?: {
+        update?: boolean;
+    }): Omit<CustomReportEntity, "tombstone">;
+    toJS(row: CustomReportData): {
+        id: string;
+        name: string;
+        startDate: string;
+        endDate: string;
+        isDateStatic: boolean;
+        dateRange: string;
+        mode: string;
+        groupBy: string;
+        interval: string;
+        balanceType: string;
+        showEmpty: boolean;
+        showOffBudget: boolean;
+        showHiddenCategories: boolean;
+        showUncategorized: boolean;
+        includeCurrentInterval: boolean;
+        graphType: string;
+        conditions: import("../../types/models").RuleConditionEntity[];
+        conditionsOp: "and" | "or";
+    };
+    fromJS(report: CustomReportEntity): {
+        id: string;
+        name: string;
+        start_date: string;
+        end_date: string;
+        date_static: number;
+        date_range: string;
+        mode: string;
+        group_by: string;
+        interval: string;
+        balance_type: string;
+        show_empty: number;
+        show_offbudget: number;
+        show_hidden: number;
+        show_uncategorized: number;
+        include_current: number;
+        graph_type: string;
+        conditions: import("../../types/models").RuleConditionEntity[];
+        conditions_op: "and" | "or";
+    };
+};
 export declare const app: {
     events: any;
     handlers: ReportsHandlers;

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

@@ -10,13 +10,11 @@ export interface RulesHandlers {
     }>;
     'rule-add': (rule: Omit<RuleEntity, 'id'>) => Promise<{
         error: ValidationError;
-    } | {
-        id: string;
-    }>;
-    'rule-update': (rule: Partial<RuleEntity>) => Promise<{
+    } | RuleEntity>;
+    'rule-update': <PartialRule extends Partial<Omit<RuleEntity, 'id'>> & Pick<RuleEntity, 'id'>>(rule: PartialRule) => Promise<{
         error: ValidationError;
-    } | object>;
-    'rule-delete': (rule: Required<RuleEntity>) => Promise<false | void>;
+    } | PartialRule>;
+    'rule-delete': (id: string) => Promise<boolean>;
     'rule-delete-all': (ids: string[]) => Promise<{
         someDeletionsFailed: boolean;
     }>;

package/@types/loot-core/server/sync/make-test-message.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export declare function makeTestMessage(keyId: any): Promise<{
     value: Buffer;
     meta: {

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

@@ -0,0 +1,2 @@
+import { type NewWidget } from '../types/models';
+export declare const DEFAULT_DASHBOARD_STATE: NewWidget[];

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

@@ -1,13 +1,13 @@
-import { type LocalPrefs } from '../types/prefs';
+import { type SyncedPrefs } from '../types/prefs';
 type DateLike = string | Date;
 export declare function _parse(value: DateLike): Date;
 export declare const parseDate: typeof _parse;
 export declare function yearFromDate(date: DateLike): string;
 export declare function monthFromDate(date: DateLike): string;
-export declare function weekFromDate(date: DateLike, firstDayOfWeekIdx: LocalPrefs['firstDayOfWeekIdx']): string;
+export declare function weekFromDate(date: DateLike, firstDayOfWeekIdx: SyncedPrefs['firstDayOfWeekIdx']): string;
 export declare function dayFromDate(date: DateLike): string;
 export declare function currentMonth(): string;
-export declare function currentWeek(firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string;
+export declare function currentWeek(firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx']): string;
 export declare function currentYear(): string;
 export declare function currentDate(): Date;
 export declare function currentDay(): string;
@@ -26,14 +26,15 @@ export declare function addDays(day: DateLike, n: number): string;
 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 bounds(month: DateLike): {
     start: number;
     end: number;
 };
 export declare function _yearRange(start: DateLike, end: DateLike, inclusive?: boolean): string[];
 export declare function yearRangeInclusive(start: DateLike, end: DateLike): string[];
-export declare function _weekRange(start: DateLike, end: DateLike, inclusive?: boolean, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string[];
-export declare function weekRangeInclusive(start: DateLike, end: DateLike, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string[];
+export declare function _weekRange(start: DateLike, end: DateLike, inclusive?: boolean, firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx']): string[];
+export declare function weekRangeInclusive(start: DateLike, end: DateLike, firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx']): string[];
 export declare function _range(start: DateLike, end: DateLike, inclusive?: boolean): string[];
 export declare function range(start: DateLike, end: DateLike): string[];
 export declare function rangeInclusive(start: DateLike, end: DateLike): string[];
@@ -46,7 +47,7 @@ export declare function getYear(month: string): string;
 export declare function getMonth(day: string): string;
 export declare function getDay(day: string): number;
 export declare function getMonthEnd(day: string): string;
-export declare function getWeekEnd(date: DateLike, firstDayOfWeekIdx?: LocalPrefs['firstDayOfWeekIdx']): string;
+export declare function getWeekEnd(date: DateLike, firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx']): string;
 export declare function getYearStart(month: string): string;
 export declare function getYearEnd(month: string): string;
 export declare function sheetForMonth(month: string): string;

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

@@ -15,6 +15,10 @@ export declare const TYPE_INFO: {
         ops: string[];
         nullable: boolean;
     };
+    imported_payee: {
+        ops: string[];
+        nullable: boolean;
+    };
     number: {
         ops: string[];
         nullable: boolean;
@@ -31,7 +35,7 @@ export declare const ALLOCATION_METHODS: {
     remainder: string;
 };
 export declare function mapField(field: any, opts?: any): any;
-export declare function friendlyOp(op: any, type?: any): "" | "is" | "contains" | "matches" | "one of" | "not one of" | "is not" | "is approx" | "is between" | "does not contain" | "is after" | "is greater than" | "is after or equals" | "is greater than or equals" | "is before" | "is less than" | "is before or equals" | "is less than or equals" | "is true" | "is false" | "set" | "allocate" | "link schedule" | "and" | "or";
+export declare function friendlyOp(op: any, type?: any): "" | "is" | "contains" | "matches" | "one of" | "not one of" | "is not" | "is approx" | "is between" | "has tag(s)" | "does not contain" | "is after" | "is greater than" | "is after or equals" | "is greater than or equals" | "is before" | "is less than" | "is before or equals" | "is less than or equals" | "is true" | "is false" | "set" | "allocate" | "link schedule" | "prepend to notes" | "append to notes" | "and" | "or";
 export declare function deserializeField(field: any): {
     field: string;
     options: {

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

@@ -4,34 +4,34 @@ export declare function getHasTransactionsQuery(schedules: any): import("./query
 export declare function getRecurringDescription(config: any, dateFormat: any): string;
 export declare function recurConfigToRSchedule(config: any): IRuleOptions[] | ({
     byDayOfMonth: any;
-    start: import("@rschedule/core").DateInput;
-    end?: import("@rschedule/core").DateInput;
-    duration?: number;
-    count?: number;
+    start: import("@rschedule/core").RuleOption.Start;
+    end?: import("@rschedule/core").RuleOption.End;
+    duration?: import("@rschedule/core").RuleOption.Duration;
+    count?: import("@rschedule/core").RuleOption.Count;
     frequency: import("@rschedule/core").RuleOption.Frequency;
-    interval?: number;
-    weekStart?: import("@rschedule/core").DateAdapter.Weekday;
+    interval?: import("@rschedule/core").RuleOption.Interval;
+    weekStart?: import("@rschedule/core").RuleOption.WeekStart;
     byDayOfWeek?: import("@rschedule/core").RuleOption.ByDayOfWeek[];
-    byHourOfDay?: import("@rschedule/core").DateAdapter.Hour[];
-    byMillisecondOfSecond?: number[];
-    byMinuteOfHour?: import("@rschedule/core").DateAdapter.Minute[];
-    byMonthOfYear?: import("@rschedule/core").DateAdapter.Month[];
-    bySecondOfMinute?: import("@rschedule/core").DateAdapter.Minute[];
+    byHourOfDay?: import("@rschedule/core").RuleOption.ByHourOfDay[];
+    byMillisecondOfSecond?: import("@rschedule/core").RuleOption.ByMillisecondOfSecond[];
+    byMinuteOfHour?: import("@rschedule/core").RuleOption.ByMinuteOfHour[];
+    byMonthOfYear?: import("@rschedule/core").RuleOption.ByMonthOfYear[];
+    bySecondOfMinute?: import("@rschedule/core").RuleOption.BySecondOfMinute[];
 } | {
     byDayOfWeek: any;
-    start: import("@rschedule/core").DateInput;
-    end?: import("@rschedule/core").DateInput;
-    duration?: number;
-    count?: number;
+    start: import("@rschedule/core").RuleOption.Start;
+    end?: import("@rschedule/core").RuleOption.End;
+    duration?: import("@rschedule/core").RuleOption.Duration;
+    count?: import("@rschedule/core").RuleOption.Count;
     frequency: import("@rschedule/core").RuleOption.Frequency;
-    interval?: number;
-    weekStart?: import("@rschedule/core").DateAdapter.Weekday;
+    interval?: import("@rschedule/core").RuleOption.Interval;
+    weekStart?: import("@rschedule/core").RuleOption.WeekStart;
     byDayOfMonth?: import("@rschedule/core").RuleOption.ByDayOfMonth[];
-    byHourOfDay?: import("@rschedule/core").DateAdapter.Hour[];
-    byMillisecondOfSecond?: number[];
-    byMinuteOfHour?: import("@rschedule/core").DateAdapter.Minute[];
-    byMonthOfYear?: import("@rschedule/core").DateAdapter.Month[];
-    bySecondOfMinute?: import("@rschedule/core").DateAdapter.Minute[];
+    byHourOfDay?: import("@rschedule/core").RuleOption.ByHourOfDay[];
+    byMillisecondOfSecond?: import("@rschedule/core").RuleOption.ByMillisecondOfSecond[];
+    byMinuteOfHour?: import("@rschedule/core").RuleOption.ByMinuteOfHour[];
+    byMonthOfYear?: import("@rschedule/core").RuleOption.ByMonthOfYear[];
+    bySecondOfMinute?: import("@rschedule/core").RuleOption.BySecondOfMinute[];
 })[];
 export declare function extractScheduleConds(conditions: any): {
     payee: any;

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

@@ -1,5 +1,5 @@
-import { type TransactionEntity, type NewTransactionEntity } from '../types/models';
-import { applyChanges } from './util';
+import { type TransactionEntity } from '../types/models';
+import { diffItems, applyChanges } from './util';
 interface TransactionEntityWithError extends TransactionEntity {
     error: ReturnType<typeof SplitTransactionError> | null;
     _deleted?: boolean;
@@ -11,7 +11,7 @@ declare function SplitTransactionError(total: number, parent: TransactionEntity)
     version: number;
     difference: number;
 };
-type GenericTransactionEntity = NewTransactionEntity | TransactionEntity | TransactionEntityWithError;
+type GenericTransactionEntity = TransactionEntity | TransactionEntityWithError;
 export declare function makeChild<T extends GenericTransactionEntity>(parent: T, data?: object): T;
 export declare function recalculateSplit(trans: TransactionEntity): TransactionEntityWithError;
 export declare function ungroupTransactions(transactions: TransactionEntity[]): TransactionEntity[];
@@ -19,98 +19,49 @@ export declare function groupTransaction(split: TransactionEntity[]): Transactio
 export declare function ungroupTransaction(split: TransactionEntity | null): TransactionEntity[];
 export declare function applyTransactionDiff(groupedTrans: Parameters<typeof ungroupTransaction>[0], diff: Parameters<typeof applyChanges>[0]): TransactionEntity;
 export declare function addSplitTransaction(transactions: TransactionEntity[], id: string): {
-    data: any[];
-    diff: {
-        deleted: any[];
-        updated: any[];
-    };
-    newTransaction?: undefined;
-} | {
     data: TransactionEntity[];
-    newTransaction: TransactionEntityWithError | TransactionEntity;
-    diff: any;
+    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function updateTransaction(transactions: TransactionEntity[], transaction: TransactionEntity): {
-    data: any[];
-    diff: {
-        deleted: any[];
-        updated: any[];
-    };
-    newTransaction?: undefined;
-} | {
     data: TransactionEntity[];
-    newTransaction: TransactionEntityWithError | TransactionEntity;
-    diff: any;
+    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function deleteTransaction(transactions: TransactionEntity[], id: string): {
-    data: any[];
-    diff: {
-        deleted: any[];
-        updated: any[];
-    };
-    newTransaction?: undefined;
-} | {
     data: TransactionEntity[];
-    newTransaction: TransactionEntityWithError | TransactionEntity;
-    diff: any;
+    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
 export declare function splitTransaction(transactions: TransactionEntity[], id: string, createSubtransactions?: (parentTransaction: TransactionEntity) => TransactionEntity[]): {
-    data: any[];
-    diff: {
-        deleted: any[];
-        updated: any[];
-    };
-    newTransaction?: undefined;
-} | {
     data: TransactionEntity[];
-    newTransaction: TransactionEntityWithError | TransactionEntity;
-    diff: any;
+    newTransaction: TransactionEntity | TransactionEntityWithError | null;
+    diff: ReturnType<typeof diffItems<TransactionEntity>>;
 };
-export declare function realizeTempTransactions(transactions: TransactionEntity[]): {
-    id: string;
-    account: import("../types/models").AccountEntity;
-    category?: import("../types/models").CategoryEntity;
-    payee?: import("../types/models").PayeeEntity;
-    schedule?: import("../types/models").ScheduleEntity;
-    subtransactions?: TransactionEntity[];
-    imported_payee?: string;
-    date: string;
-    notes?: string;
-    amount: number;
-    cleared?: boolean;
-    reconciled?: boolean;
-    is_parent?: boolean;
-    is_child?: boolean;
-    parent_id?: string;
-    imported_id?: string;
-    starting_balance_flag?: boolean;
-    transfer_id?: string;
-    sort_order?: number;
-    tombstone?: boolean;
-}[];
+export declare function realizeTempTransactions(transactions: TransactionEntity[]): TransactionEntity[];
 export declare function makeAsNonChildTransactions(childTransactionsToUpdate: TransactionEntity[], transactions: TransactionEntity[]): {
     updated: TransactionEntity[];
     deleted: {
         amount: number;
         id: string;
-        account: import("../types/models").AccountEntity;
-        category?: import("../types/models").CategoryEntity;
-        payee?: import("../types/models").PayeeEntity;
-        schedule?: import("../types/models").ScheduleEntity;
-        subtransactions?: TransactionEntity[];
-        imported_payee?: string;
-        date: string;
-        notes?: string;
-        cleared?: boolean;
-        reconciled?: boolean;
         is_parent?: boolean;
         is_child?: boolean;
-        parent_id?: string;
+        parent_id?: TransactionEntity["id"];
+        account: import("../types/models").AccountEntity["id"];
+        category?: import("../types/models").CategoryEntity["id"];
+        payee?: import("../types/models").PayeeEntity["id"];
+        notes?: string;
+        date: string;
         imported_id?: string;
+        imported_payee?: string;
         starting_balance_flag?: boolean;
-        transfer_id?: string;
+        transfer_id?: TransactionEntity["id"];
         sort_order?: number;
+        cleared?: boolean;
+        reconciled?: boolean;
         tombstone?: boolean;
+        schedule?: import("../types/models").ScheduleEntity["id"];
+        subtransactions?: TransactionEntity[];
     }[];
 };
 export {};

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

@@ -3,24 +3,21 @@ export declare function getChangedValues<T extends {
     id?: string;
 }>(obj1: T, obj2: T): Partial<T>;
 export declare function hasFieldsChanged<T extends object>(obj1: T, obj2: T, fields: Array<keyof T>): boolean;
+export type Diff<T extends {
+    id: string;
+}> = {
+    added: T[];
+    updated: Partial<T>[];
+    deleted: Partial<T>[];
+};
 export declare function applyChanges<T extends {
     id: string;
-}>(changes: {
-    added?: T[];
-    updated?: T[];
-    deleted?: T[];
-}, items: T[]): T[];
+}>(changes: Diff<T>, items: T[]): T[];
 export declare function partitionByField<T, K extends keyof T>(data: T[], field: K): Map<any, any>;
 export declare function groupBy<T, K extends keyof T>(data: T[], field: K): Map<T[K], T[]>;
 export declare function diffItems<T extends {
     id: string;
-}>(items: T[], newItems: T[]): {
-    added: T[];
-    updated: Partial<T>[];
-    deleted: {
-        id: string;
-    }[];
-};
+}>(items: T[], newItems: T[]): Diff<T>;
 export declare function groupById<T extends {
     id: string;
 }>(data: T[]): {

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

@@ -63,13 +63,24 @@ export interface ApiHandlers {
     flag: boolean;
   }) => Promise<void>;
 
+  'api/budget-hold-for-next-month': (arg: {
+    month: string;
+    amount: number;
+  }) => Promise<boolean>;
+
+  'api/budget-reset-hold': (arg: { month: string }) => Promise<void>;
+
   'api/transactions-export': (arg: {
     transactions;
     categoryGroups;
     payees;
   }) => Promise<unknown>;
 
-  'api/transactions-import': (arg: { accountId; transactions }) => Promise<{
+  'api/transactions-import': (arg: {
+    accountId;
+    transactions;
+    isPreview?;
+  }) => Promise<{
     errors?: { message: string }[];
     added;
     updated;
@@ -95,7 +106,7 @@ export interface ApiHandlers {
 
   'api/transaction-delete': (arg: {
     id;
-  }) => Promise<Awaited<ReturnType<typeof batchUpdateTransactions>>['updated']>;
+  }) => Promise<Awaited<ReturnType<typeof batchUpdateTransactions>>['deleted']>;
 
   'api/sync': () => Promise<void>;
 
@@ -169,5 +180,5 @@ export interface ApiHandlers {
 
   'api/rule-update': (arg: { rule: RuleEntity }) => Promise<RuleEntity>;
 
-  'api/rule-delete': (arg: { id: string }) => Promise<boolean>;
+  'api/rule-delete': (id: string) => Promise<boolean>;
 }

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

@@ -1,4 +1,5 @@
 import type { BudgetHandlers } from '../server/budget/types/handlers';
+import type { DashboardHandlers } from '../server/dashboard/types/handlers';
 import type { FiltersHandlers } from '../server/filters/types/handlers';
 import type { NotesHandlers } from '../server/notes/types/handlers';
 import type { ReportsHandlers } from '../server/reports/types/handlers';
@@ -13,6 +14,7 @@ export interface Handlers
   extends ServerHandlers,
     ApiHandlers,
     BudgetHandlers,
+    DashboardHandlers,
     FiltersHandlers,
     NotesHandlers,
     ReportsHandlers,

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

@@ -1,11 +1,15 @@
 import { CategoryEntity } from './category';
 
-export interface CategoryGroupEntity {
-  id?: string;
+export interface NewCategoryGroupEntity {
   name: string;
   is_income?: boolean;
   sort_order?: number;
   tombstone?: boolean;
   hidden?: boolean;
+  categories?: Omit<CategoryEntity, 'id'>[];
+}
+
+export interface CategoryGroupEntity extends NewCategoryGroupEntity {
+  id: string;
   categories?: CategoryEntity[];
 }

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

@@ -1,8 +1,10 @@
+import { CategoryGroupEntity } from './category-group';
+
 export interface CategoryEntity {
-  id?: string;
+  id: string;
   name: string;
   is_income?: boolean;
-  cat_group?: string;
+  cat_group?: CategoryGroupEntity['id'];
   sort_order?: number;
   tombstone?: boolean;
   hidden?: boolean;

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

@@ -0,0 +1,56 @@
+import { type CustomReportEntity } from './reports';
+
+type AbstractWidget<
+  T extends string,
+  Meta extends Record<string, unknown> = null,
+> = {
+  id: string;
+  type: T;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  meta: Meta;
+  tombstone: boolean;
+};
+
+export type NetWorthWidget = AbstractWidget<
+  'net-worth-card',
+  { name?: string } | null
+>;
+export type CashFlowWidget = AbstractWidget<
+  'cash-flow-card',
+  { name?: string } | null
+>;
+export type SpendingWidget = AbstractWidget<
+  'spending-card',
+  { name?: string } | null
+>;
+export type CustomReportWidget = AbstractWidget<
+  'custom-report',
+  { id: string }
+>;
+
+type SpecializedWidget = NetWorthWidget | CashFlowWidget | SpendingWidget;
+export type Widget = SpecializedWidget | CustomReportWidget;
+export type NewWidget = Omit<Widget, 'id' | 'tombstone'>;
+
+// Exported/imported (json) widget definition
+export type ExportImportCustomReportWidget = Omit<
+  CustomReportWidget,
+  'id' | 'meta' | 'tombstone'
+> & {
+  meta: Omit<CustomReportEntity, 'tombstone'>;
+};
+export type ExportImportDashboardWidget = Omit<
+  ExportImportCustomReportWidget | SpecializedWidget,
+  'tombstone'
+>;
+
+export type ExportImportDashboard = {
+  // Dashboard exports can be versioned; currently we support
+  // only a single version, but lets account for multiple
+  // future versions
+  version: 1;
+  widgets: ExportImportDashboardWidget[];
+};

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

@@ -1,6 +1,7 @@
 export type * from './account';
 export type * from './category';
 export type * from './category-group';
+export type * from './dashboard';
 export type * from './gocardless';
 export type * from './simplefin';
 export type * from './note';

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

@@ -1,11 +1,9 @@
-export interface NewPayeeEntity {
-  id?: string;
+import { AccountEntity } from './account';
+
+export interface PayeeEntity {
+  id: string;
   name: string;
-  transfer_acct?: string;
+  transfer_acct?: AccountEntity['id'];
   favorite?: boolean;
   tombstone?: boolean;
 }
-
-export interface PayeeEntity extends NewPayeeEntity {
-  id: string;
-}

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

@@ -1,4 +1,3 @@
-import { CategoryEntity } from './category';
 import { type RuleConditionEntity } from './rule';
 
 export interface CustomReportEntity {
@@ -17,10 +16,9 @@ export interface CustomReportEntity {
   showHiddenCategories: boolean;
   includeCurrentInterval: boolean;
   showUncategorized: boolean;
-  selectedCategories?: CategoryEntity[];
   graphType: string;
   conditions?: RuleConditionEntity[];
-  conditionsOp: string;
+  conditionsOp: 'and' | 'or';
   data?: GroupedEntity;
   tombstone?: boolean;
 }
@@ -140,10 +138,9 @@ export interface CustomReportData {
   show_hidden: number;
   include_current: number;
   show_uncategorized: number;
-  selected_categories?: CategoryEntity[];
   graph_type: string;
   conditions?: RuleConditionEntity[];
-  conditions_op: string;
+  conditions_op: 'and' | 'or';
   metadata?: GroupedEntity;
   interval: string;
   color_scheme?: string;