@zeniai/client-epic-state 5.0.69-betaAR4 → 5.0.69-betaAR5

package/lib/commonStateTypes/filterPrimitives.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared filter primitives — used by both Transaction Categorization and
+ * Spend Management filter pipelines.
+ *
+ * These types are deliberately decoupled from any specific feature group:
+ *
+ *   - `CategoryCombinationOperator` is how a `categories[]` array combines
+ *     (`AND` ⇒ every category must match; `OR` ⇒ any category matches).
+ *   - `FilterCategoryType` is the input-type tag a filter category uses to
+ *     pick its value-picker UI (text autocomplete, user picker, date range,
+ *     number range, plain dropdown).
+ *
+ * They used to be redeclared locally in both `transactionFilterHelpers.ts`
+ * and `spendManagementFilterHelpers.ts` to keep the feature groups
+ * independent. Centralising them here is consistent with Route B (which
+ * separated the *matching pipelines*, not the *shared primitive types*) and
+ * removes the maintenance trap of two identical type definitions drifting
+ * apart over time.
+ */
+/** How `categories[]` combines: AND requires every category to match, OR requires any. */
+export type CategoryCombinationOperator = 'AND' | 'OR';
+/** Input-type tag a filter category uses to pick its value-picker UI. */
+export type FilterCategoryType = 'searchAutocomplete' | 'user' | 'dateRange' | 'numberRange' | 'dropdown';

package/lib/commonStateTypes/filterPrimitives.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Shared filter primitives — used by both Transaction Categorization and
+ * Spend Management filter pipelines.
+ *
+ * These types are deliberately decoupled from any specific feature group:
+ *
+ *   - `CategoryCombinationOperator` is how a `categories[]` array combines
+ *     (`AND` ⇒ every category must match; `OR` ⇒ any category matches).
+ *   - `FilterCategoryType` is the input-type tag a filter category uses to
+ *     pick its value-picker UI (text autocomplete, user picker, date range,
+ *     number range, plain dropdown).
+ *
+ * They used to be redeclared locally in both `transactionFilterHelpers.ts`
+ * and `spendManagementFilterHelpers.ts` to keep the feature groups
+ * independent. Centralising them here is consistent with Route B (which
+ * separated the *matching pipelines*, not the *shared primitive types*) and
+ * removes the maintenance trap of two identical type definitions drifting
+ * apart over time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/entity/account/accountSelector.d.ts

@@ -123,3 +123,29 @@ export declare const getAccountsOrdered: (filter: COABalancesFilter, accountStat
 export declare const getAccountsByType: (accountState: AccountState, accountTypes: AccountType[]) => Partial<Record<AccountType, Account[]>>;
 export declare const getAccountIdsForTypes: (accountState: AccountState, accountTypes: AccountType[]) => ID[];
 export declare const getAccountIdsForLabels: (accountState: AccountState, labels: string[]) => ID[];
+/**
+ * Returns all accounts currently in state (single pass over accountsByKey).
+ * Use for dropdowns that need account names and types; map to
+ * { accountId, accountName, accountType } as needed.
+ */
+export declare const getAllAccounts: (accountState: AccountState) => Account[];
+export interface AccountFilterOption {
+    accountId: ID;
+    accountName: string;
+    accountType: AccountType;
+}
+/**
+ * Partitions accounts for transaction filter dropdowns: bank/credit_card → paymentAccountNames,
+ * all other account types → categoryOptions. Use for payment_account_name and category filter options.
+ *
+ * Memoised via `createSelector` so the composite `{categoryOptions,
+ * paymentAccountNames}` keeps a stable identity across Redux dispatches that
+ * don't change account data. Without this, every consumer using
+ * `useSelector(state => getTransactionFilterAccountOptions(state.accountState))`
+ * would re-render on every dispatch (the inline call returns a fresh outer
+ * object each time, defeating reference equality).
+ */
+export declare const getTransactionFilterAccountOptions: (accountState: AccountState) => {
+    categoryOptions: AccountFilterOption[];
+    paymentAccountNames: AccountFilterOption[];
+};

package/lib/entity/account/accountSelector.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAccountIdsForLabels = exports.getAccountIdsForTypes = exports.getAccountsByType = exports.getAccountsOrdered = exports.getAccountBase = void 0;
+exports.getTransactionFilterAccountOptions = exports.getAllAccounts = exports.getAccountIdsForLabels = exports.getAccountIdsForTypes = exports.getAccountsByType = exports.getAccountsOrdered = exports.getAccountBase = void 0;
 exports.getAccount = getAccount;
 exports.getAccountWithBalance = getAccountWithBalance;
+const toolkit_1 = require("@reduxjs/toolkit");
 const flatMap_1 = __importDefault(require("lodash/flatMap"));
 const coaBalance_1 = require("../../commonStateTypes/coaBalance/coaBalance");
 const sortBalancesByFreeRangeTotal_1 = require("../../commonStateTypes/coaBalance/sortBalancesByFreeRangeTotal");
@@ -192,3 +193,48 @@ const getAccountIdsForLabels = (accountState, labels) => {
     return allAccountIdsForLabels;
 };
 exports.getAccountIdsForLabels = getAccountIdsForLabels;
+/**
+ * Returns all accounts currently in state (single pass over accountsByKey).
+ * Use for dropdowns that need account names and types; map to
+ * { accountId, accountName, accountType } as needed.
+ */
+const getAllAccounts = (accountState) => Object.values(accountState.accountsByKey);
+exports.getAllAccounts = getAllAccounts;
+/**
+ * Partitions accounts for transaction filter dropdowns: bank/credit_card → paymentAccountNames,
+ * all other account types → categoryOptions. Use for payment_account_name and category filter options.
+ *
+ * Memoised via `createSelector` so the composite `{categoryOptions,
+ * paymentAccountNames}` keeps a stable identity across Redux dispatches that
+ * don't change account data. Without this, every consumer using
+ * `useSelector(state => getTransactionFilterAccountOptions(state.accountState))`
+ * would re-render on every dispatch (the inline call returns a fresh outer
+ * object each time, defeating reference equality).
+ */
+exports.getTransactionFilterAccountOptions = (0, toolkit_1.createSelector)(
+// Key the memo on the underlying `accountsByKey` record rather than on
+// `getAllAccounts` output: the latter returns a fresh `Object.values(...)`
+// array on every call, which would defeat reselect's reference-equality
+// check and re-run the projection on every dispatch.
+[(accountState) => accountState.accountsByKey], (accountsByKey) => {
+    const accounts = Object.values(accountsByKey);
+    const paymentAccountNames = [];
+    const categoryOptions = [];
+    for (const account of accounts) {
+        if (account.accountType == null) {
+            continue;
+        }
+        const option = {
+            accountId: account.accountId,
+            accountName: account.accountName,
+            accountType: account.accountType,
+        };
+        if ((0, accountState_1.isPaymentAccountType)(account.accountType)) {
+            paymentAccountNames.push(option);
+        }
+        else {
+            categoryOptions.push(option);
+        }
+    }
+    return { categoryOptions, paymentAccountNames };
+});

package/lib/entity/account/accountState.d.ts

@@ -8,9 +8,14 @@ import { RecommendationBase } from '../../commonStateTypes/recommendationBase';
 import { Status } from '../../commonStateTypes/status';
 import { ReportIDPlusForecastID } from '../../commonStateTypes/viewAndReport/viewAndReport';
 import { ZeniUrl } from '../../zeniUrl';
+export declare const ALL_ACCOUNT_TYPES: readonly ["bank", "credit_card", "expenses", "cogs", "income", "cash_in", "cash_out", "cash_position", "other_income", "other_expense", "accounts_receivable", "other_current_assets", "fixed_assets", "other_assets", "accounts_payable", "other_current_liabilities", "long_term_liabilities", "equity", "current_liabilities", "current_assets"];
 export declare const toAccountType: (v: string) => "cash_position" | "fixed_assets" | "bank" | "credit_card" | "expenses" | "cogs" | "income" | "cash_in" | "cash_out" | "other_income" | "other_expense" | "accounts_receivable" | "other_current_assets" | "other_assets" | "accounts_payable" | "other_current_liabilities" | "long_term_liabilities" | "equity" | "current_liabilities" | "current_assets";
 export type AccountType = ReturnType<typeof toAccountType>;
 export declare const toAccountTypeStrict: (v: string | null | undefined) => AccountType | undefined;
+/** Account types used for payment-account filters (e.g. transaction filter "payment account name"). */
+export declare const PAYMENT_ACCOUNT_TYPES: readonly ["bank", "credit_card"];
+export type PaymentAccountType = (typeof PAYMENT_ACCOUNT_TYPES)[number];
+export declare function isPaymentAccountType(accountType: AccountType | undefined): accountType is PaymentAccountType;
 export type UncategorizedAccountTypes = 'expense' | 'income';
 declare const toAccountLabel: (v: string) => "prepaid_expenses" | "fixed_assets" | "uncategorized_income" | "uncategorized_expense" | "bank_charges_and_fees" | "travel_transportation" | "accrued_expenses";
 export type AccountLabel = ReturnType<typeof toAccountLabel>;

package/lib/entity/account/accountState.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toReconciliationAccountSourceStrict = exports.toReconciliationAccountSource = exports.toAccountLabelStrict = exports.toAccountTypeStrict = exports.toAccountType = void 0;
+exports.toReconciliationAccountSourceStrict = exports.toReconciliationAccountSource = exports.toAccountLabelStrict = exports.PAYMENT_ACCOUNT_TYPES = exports.toAccountTypeStrict = exports.toAccountType = exports.ALL_ACCOUNT_TYPES = void 0;
+exports.isPaymentAccountType = isPaymentAccountType;
 exports.getAccountKey = getAccountKey;
 const nestedAccountID_1 = require("../../commonStateTypes/accountView/nestedAccountID");
 const nestedClassID_1 = require("../../commonStateTypes/classesView/nestedClassID");
 const stringToUnion_1 = require("../../commonStateTypes/stringToUnion");
-const ALL_ACCOUNT_TYPES = [
+exports.ALL_ACCOUNT_TYPES = [
     'bank',
     'credit_card',
     'expenses',
@@ -27,10 +28,16 @@ const ALL_ACCOUNT_TYPES = [
     'current_liabilities',
     'current_assets',
 ];
-const toAccountType = (v) => (0, stringToUnion_1.stringToUnion)(v, ALL_ACCOUNT_TYPES);
+const toAccountType = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.ALL_ACCOUNT_TYPES);
 exports.toAccountType = toAccountType;
-const toAccountTypeStrict = (v) => (0, stringToUnion_1.stringToUnionStrict)(v ?? '', ALL_ACCOUNT_TYPES);
+const toAccountTypeStrict = (v) => (0, stringToUnion_1.stringToUnionStrict)(v ?? '', exports.ALL_ACCOUNT_TYPES);
 exports.toAccountTypeStrict = toAccountTypeStrict;
+/** Account types used for payment-account filters (e.g. transaction filter "payment account name"). */
+exports.PAYMENT_ACCOUNT_TYPES = ['bank', 'credit_card'];
+function isPaymentAccountType(accountType) {
+    return (accountType != null &&
+        exports.PAYMENT_ACCOUNT_TYPES.includes(accountType));
+}
 const ALL_ACCOUNT_LABELS = [
     'uncategorized_income',
     'uncategorized_expense',

package/lib/entity/approvalRule/approvalRulePayload.d.ts

@@ -1,27 +1,11 @@
 import { ApprovalRule } from './approvalRuleState';
-/**
- * Condition Payload — one entry inside criteria.conditions[].
- *
- * field examples: 'amount' | 'vendor_id' | 'department_id'
- * type examples:  'gte' | 'lte' | 'eq' | 'in' | 'not_in'
- * value: number for amount comparisons; string[] for in / not_in lookups.
- */
-export interface ConditionPayload {
-    field: string;
-    type: string;
-    value: number | string[];
-}
-/**
- * Criteria Payload — list of conditions joined by `criteria_operator`.
- *
- * `currency_code` / `currency_symbol` apply to amount conditions inside
- * `conditions[]`. Kept here pending confirmation that they should remain.
- */
 export interface CriteriaPayload {
-    conditions: ConditionPayload[];
-    criteria_operator: string;
     currency_code: string;
     currency_symbol: string;
+    min: number;
+    range_entity: string;
+    type: string;
+    max?: number | null;
 }
 export interface ActorPayload {
     type: string;
@@ -41,17 +25,11 @@ export interface StepPayload {
 export interface ApprovalRulePayload {
     approval_rule_id: string;
     create_time: string;
-    criteria: CriteriaPayload;
+    criteria: CriteriaPayload[];
     entity_type: string;
     name: string | null;
     steps: StepPayload[];
     update_time: string;
-    are_approvals_serialized?: boolean;
-    description?: string | null;
-    is_fallback?: boolean;
-    pending_approvals_count?: number;
-    pending_entity_approval_update_status?: string;
-    priority?: number;
     version?: number | string;
 }
 /**

package/lib/entity/approvalRule/approvalRulePayload.js

@@ -17,140 +17,19 @@ const toApprovalRule = (payload) => ({
     version: payload.version,
     criteria: toApprovalCriteria(payload.criteria),
     steps: toApprovalSteps(payload.steps),
-    description: payload.description ?? undefined,
-    priority: payload.priority,
-    isFallback: payload.is_fallback ?? false,
-    // separationOfDuties: backend doesn't ship this field yet; left undefined
-    // until the spec is finalized.
-    areApprovalsSerialized: payload.are_approvals_serialized,
-    pendingApprovalsCount: payload.pending_approvals_count,
-    pendingEntityApprovalUpdateStatus: payload.pending_entity_approval_update_status,
 });
 exports.toApprovalRule = toApprovalRule;
-/**
- * Maps the wire-level criteria block into the state-side discriminated
- * `Criteria[]` union.
- *
- * The wire keeps each condition as a flat row inside `conditions[]`.
- * Amount comparisons can show up as a `gte` only, a `lte` only, or a
- * `gte` + `lte` pair — those collapse into a single AmountCriteria whose
- * `comparator` is `greater_than`, `less_than`, or `range` respectively.
- *
- * Vendor and department conditions map one-to-one: `in` becomes `is`,
- * `not_in` becomes `is_not`.
- *
- * Resilient to two forms of upstream drift:
- *  - Missing / null criteria → returns [].
- *  - Legacy criteria shape (array of amount-range objects, the pre-3.0
- *    wire) → converted to an AmountCriteria so existing rules in production
- *    still render while the backend rolls out.
- */
 const toApprovalCriteria = (payload) => {
-    if (payload == null) {
-        return [];
-    }
-    if (Array.isArray(payload)) {
-        // Legacy pre-3.0 wire: an array of amount-range entries.
-        return legacyAmountRangeToCriteria(payload);
-    }
-    if (!Array.isArray(payload.conditions)) {
-        return [];
-    }
-    const results = [];
-    const amountCriteria = toAmountCriteria(payload);
-    if (amountCriteria != null) {
-        results.push(amountCriteria);
-    }
-    payload.conditions
-        .filter((condition) => condition.field === 'vendor_id')
-        .forEach((condition) => {
-        const vendor = toVendorCriteria(condition);
-        if (vendor != null) {
-            results.push(vendor);
-        }
-    });
-    payload.conditions
-        .filter((condition) => condition.field === 'department_id')
-        .forEach((condition) => {
-        const department = toDepartmentCriteria(condition);
-        if (department != null) {
-            results.push(department);
-        }
-    });
-    return results;
-};
-const legacyAmountRangeToCriteria = (legacy) => {
-    if (legacy.length === 0) {
-        return [];
-    }
-    const first = legacy[0] ?? {};
-    const currency = first.currency_code ?? 'USD';
-    const symbol = first.currency_symbol ?? '$';
-    const min = typeof first.min === 'number'
-        ? (0, amount_1.toAmount)(first.min, currency, symbol)
-        : undefined;
-    const max = typeof first.max === 'number'
-        ? (0, amount_1.toAmount)(first.max, currency, symbol)
-        : undefined;
-    if (min == null && max == null) {
-        return [];
-    }
-    const comparator = min != null && max != null
-        ? 'range'
-        : min != null
-            ? 'greater_than'
-            : 'less_than';
-    return [{ type: 'amount', comparator, min, max }];
-};
-const toAmountCriteria = (payload) => {
-    if (!Array.isArray(payload.conditions)) {
-        return undefined;
-    }
-    const amountConditions = payload.conditions.filter((condition) => condition.field === 'amount');
-    const gteCondition = amountConditions.find((condition) => condition.type === 'gte' || condition.type === 'eq');
-    const lteCondition = amountConditions.find((condition) => condition.type === 'lte');
-    if (gteCondition == null && lteCondition == null) {
-        return undefined;
-    }
-    const currencyCode = payload.currency_code ?? 'USD';
-    const currencySymbol = payload.currency_symbol ?? '$';
-    const min = typeof gteCondition?.value === 'number'
-        ? (0, amount_1.toAmount)(gteCondition.value, currencyCode, currencySymbol)
-        : undefined;
-    const max = typeof lteCondition?.value === 'number'
-        ? (0, amount_1.toAmount)(lteCondition.value, currencyCode, currencySymbol)
-        : undefined;
-    let comparator;
-    if (min != null && max != null) {
-        comparator = 'range';
-    }
-    else if (min != null) {
-        comparator = 'greater_than';
-    }
-    else {
-        comparator = 'less_than';
-    }
-    return { type: 'amount', comparator, min, max };
-};
-const toVendorCriteria = (condition) => {
-    if (!Array.isArray(condition.value)) {
-        return undefined;
-    }
-    return {
-        type: 'vendor',
-        operator: condition.type === 'not_in' ? 'is_not' : 'is',
-        vendorIds: condition.value,
-    };
-};
-const toDepartmentCriteria = (condition) => {
-    if (!Array.isArray(condition.value)) {
-        return undefined;
-    }
-    return {
-        type: 'department',
-        operator: condition.type === 'not_in' ? 'is_not' : 'is',
-        departmentIds: condition.value,
-    };
+    return payload.map((criteria) => ({
+        rangeType: criteria.type,
+        rangeEntity: criteria.range_entity,
+        range: {
+            min: (0, amount_1.toAmount)(criteria.min, criteria.currency_code, criteria.currency_symbol),
+            max: criteria.max != null
+                ? (0, amount_1.toAmount)(criteria.max, criteria.currency_code, criteria.currency_symbol)
+                : undefined,
+        },
+    }));
 };
 const toApprovalSteps = (payload) => {
     return payload.map((step) => ({

package/lib/entity/approvalRule/approvalRuleSelector.d.ts

@@ -1,28 +1,4 @@
 import { ID } from '../../commonStateTypes/common';
-import { EntityType } from '../entityApprovalStatus/entityApprovalStatusState';
-import { AmountCriteria, ApprovalRule, ApprovalRuleState, Criteria, DepartmentCriteria, VendorCriteria } from './approvalRuleState';
+import { ApprovalRule, ApprovalRuleState } from './approvalRuleState';
 export declare function getApprovalRuleById(approvalRuleState: ApprovalRuleState, approvalRuleId: ID): ApprovalRule | undefined;
 export declare function getApprovalRulesByIds(approvalRuleState: ApprovalRuleState, approvalRuleIds: ID[]): ApprovalRule[];
-/**
- * Returns the amount-range portion of a rule's criteria, if any.
- *
- * Use this whenever a caller needs to read amount min/max from the new
- * discriminated `Criteria` union without inlining a type guard.
- */
-export declare function getAmountCriteria(criteria: Criteria[]): AmountCriteria | undefined;
-export declare function getVendorCriteria(criteria: Criteria[]): VendorCriteria | undefined;
-export declare function getDepartmentCriteria(criteria: Criteria[]): DepartmentCriteria | undefined;
-/**
- * Returns all rules of the given entityType, sorted by `priority` ascending.
- *
- * Rules without a `priority` value sort to the end (treated as Infinity).
- * Use this for the list page where rules render in evaluation order.
- */
-export declare function getApprovalRulesByEntityType(approvalRuleState: ApprovalRuleState, entityType: EntityType): ApprovalRule[];
-/**
- * Returns the tenant's fallback rule for the given entityType, if one exists.
- *
- * The fallback rule is shown by the "fallback engine active" banner on the
- * list page and is used to handle bills/reimbursements that match no other rule.
- */
-export declare function getFallbackApprovalRule(approvalRuleState: ApprovalRuleState, entityType: EntityType): ApprovalRule | undefined;

package/lib/entity/approvalRule/approvalRuleSelector.js

@@ -2,11 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getApprovalRuleById = getApprovalRuleById;
 exports.getApprovalRulesByIds = getApprovalRulesByIds;
-exports.getAmountCriteria = getAmountCriteria;
-exports.getVendorCriteria = getVendorCriteria;
-exports.getDepartmentCriteria = getDepartmentCriteria;
-exports.getApprovalRulesByEntityType = getApprovalRulesByEntityType;
-exports.getFallbackApprovalRule = getFallbackApprovalRule;
 function getApprovalRuleById(approvalRuleState, approvalRuleId) {
     return approvalRuleState.approvalRuleById[approvalRuleId] ?? undefined;
 }
@@ -16,38 +11,3 @@ function getApprovalRulesByIds(approvalRuleState, approvalRuleIds) {
         .filter((value) => value != null);
     return approvalRulesByIds;
 }
-/**
- * Returns the amount-range portion of a rule's criteria, if any.
- *
- * Use this whenever a caller needs to read amount min/max from the new
- * discriminated `Criteria` union without inlining a type guard.
- */
-function getAmountCriteria(criteria) {
-    return criteria.find((c) => c.type === 'amount');
-}
-function getVendorCriteria(criteria) {
-    return criteria.find((c) => c.type === 'vendor');
-}
-function getDepartmentCriteria(criteria) {
-    return criteria.find((c) => c.type === 'department');
-}
-/**
- * Returns all rules of the given entityType, sorted by `priority` ascending.
- *
- * Rules without a `priority` value sort to the end (treated as Infinity).
- * Use this for the list page where rules render in evaluation order.
- */
-function getApprovalRulesByEntityType(approvalRuleState, entityType) {
-    return Object.values(approvalRuleState.approvalRuleById)
-        .filter((rule) => rule.entityType === entityType)
-        .sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
-}
-/**
- * Returns the tenant's fallback rule for the given entityType, if one exists.
- *
- * The fallback rule is shown by the "fallback engine active" banner on the
- * list page and is used to handle bills/reimbursements that match no other rule.
- */
-function getFallbackApprovalRule(approvalRuleState, entityType) {
-    return Object.values(approvalRuleState.approvalRuleById).find((rule) => rule.entityType === entityType && rule.isFallback === true);
-}

package/lib/entity/approvalRule/approvalRuleState.d.ts

@@ -25,37 +25,14 @@ export interface Actor {
     subType?: AttributeType | RoleType;
     userId?: ID;
 }
-/**
- * Approval rule criteria — discriminated union over the three condition
- * types the wire format supports: amount, vendor, and department.
- *
- * State-side, each rule carries a `Criteria[]` with at most one variant of
- * each kind (e.g. one AmountCriteria + one VendorCriteria + one DepartmentCriteria).
- *
- * Form-side, the rule create/edit form uses `ApprovalRuleFormCriteria`
- * (defined in commonState) — a structured object with named slots for
- * amount/vendor/department. Epics translate between the two.
- */
-export type AmountComparator = 'greater_than' | 'less_than' | 'range';
-export interface AmountCriteria {
-    comparator: AmountComparator;
-    type: 'amount';
-    /** Upper bound. Present for `less_than` and `range`. */
-    max?: Amount;
-    /** Lower bound. Present for `greater_than` and `range`. */
-    min?: Amount;
-}
-export interface VendorCriteria {
-    operator: 'is' | 'is_not';
-    type: 'vendor';
-    vendorIds: ID[];
-}
-export interface DepartmentCriteria {
-    departmentIds: ID[];
-    operator: 'is' | 'is_not';
-    type: 'department';
+export interface Criteria {
+    range: {
+        min: Amount;
+        max?: Amount;
+    };
+    rangeEntity: string;
+    rangeType: string;
 }
-export type Criteria = AmountCriteria | VendorCriteria | DepartmentCriteria;
 export interface Step {
     actors: Actor[];
     operator: StepOperatorType;
@@ -74,25 +51,7 @@ export interface ApprovalRule {
     entityType: EntityType;
     steps: Step[];
     updateTime: ZeniDate;
-    /** Backend bookkeeping: whether approval steps must run serialized. */
-    areApprovalsSerialized?: boolean;
-    /** Free-text description shown beneath the rule name on the list page. */
-    description?: string;
-    /** True when this rule is the tenant's default fallback rule. */
-    isFallback?: boolean;
     name?: string;
-    /** Backend bookkeeping: number of entities currently pending against this rule. */
-    pendingApprovalsCount?: number;
-    /** Backend bookkeeping: status of background updates against this rule. */
-    pendingEntityApprovalUpdateStatus?: string;
-    /** Rule's position in the evaluation order; lower number = higher priority. */
-    priority?: number;
-    /**
-     * When on, the creator of a bill/reimbursement cannot auto-approve
-     * their own request even if they are also an approver. Backend spec
-     * is still pending — kept optional for now.
-     */
-    separationOfDuties?: boolean;
     version?: number | string;
 }
 export interface Approvers {

package/lib/entity/class/classSelector.d.ts

@@ -5,6 +5,16 @@ import { ReportID } from '../../commonStateTypes/viewAndReport/viewAndReport';
 import { AccountState } from '../account/accountState';
 import { ClassReport } from './classSelectorTypes';
 import { Class, ClassState } from './classState';
+/**
+ * Minimal class shape consumed by filter dropdowns. Only the identity and
+ * the display label are needed — payload size and prop-type breadth are
+ * kept small so consumers can't accidentally rely on `Class` fields that
+ * the projection does not carry.
+ */
+export interface ClassFilterOption {
+    classId: ID;
+    className: string;
+}
 export declare function getClassesByIds(classState: ClassState, id: {
     classIds: ID[];
     reportId: ReportID;
@@ -20,3 +30,28 @@ export declare function getClassReport(classState: ClassState, accountState: Acc
     reportId: ReportID;
     classesViewParentId?: ClassesViewParentID;
 }, filter: COABalancesFilter): ClassReport | undefined;
+/**
+ * Returns all classes currently in state (single pass over classesByKey).
+ * Use for dropdowns that need class names; map to { classId, className } as needed.
+ */
+export declare function getAllClasses(classState: ClassState): Class[];
+/**
+ * Memoised projection of `getAllClasses` to the `{classId, className}` shape
+ * expected by filter dropdowns. Consumers should prefer this over inlining a
+ * `getAllClasses(...).map(...)` inside `useSelector`: the inline map allocates
+ * a fresh array on every Redux dispatch, breaking `useSelector`'s
+ * reference-equality optimisation and triggering re-renders on every state
+ * change unrelated to class data.
+ *
+ * Two cleanups happen here, intentionally inside the selector so every
+ * consumer benefits uniformly:
+ *   1. **Drop entries with a blank `className`.** Soft-deleted classes can
+ *      retain their classId in state while the human name is blanked, which
+ *      would otherwise render as an empty row in the filter dropdown.
+ *   2. **Dedupe by `classId`.** `classesByKey` is keyed by
+ *      `${classId}-${reportId}` (see `getClassKey`), so a class loaded under
+ *      multiple report contexts appears as multiple entries from
+ *      `Object.values(classesByKey)`. The first non-blank entry per
+ *      `classId` wins.
+ */
+export declare const getClassFilterOptions: (classState: ClassState) => ClassFilterOption[];

package/lib/entity/class/classSelector.js

@@ -3,9 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassFilterOptions = void 0;
 exports.getClassesByIds = getClassesByIds;
 exports.getClassById = getClassById;
 exports.getClassReport = getClassReport;
+exports.getAllClasses = getAllClasses;
+const toolkit_1 = require("@reduxjs/toolkit");
 const get_1 = __importDefault(require("lodash/get"));
 const coaBalance_1 = require("../../commonStateTypes/coaBalance/coaBalance");
 const accountSelector_1 = require("../account/accountSelector");
@@ -58,3 +61,50 @@ function getClassReport(classState, accountState, id, filter) {
         accounts: accountReport,
     };
 }
+/**
+ * Returns all classes currently in state (single pass over classesByKey).
+ * Use for dropdowns that need class names; map to { classId, className } as needed.
+ */
+function getAllClasses(classState) {
+    return Object.values(classState.classesByKey);
+}
+/**
+ * Memoised projection of `getAllClasses` to the `{classId, className}` shape
+ * expected by filter dropdowns. Consumers should prefer this over inlining a
+ * `getAllClasses(...).map(...)` inside `useSelector`: the inline map allocates
+ * a fresh array on every Redux dispatch, breaking `useSelector`'s
+ * reference-equality optimisation and triggering re-renders on every state
+ * change unrelated to class data.
+ *
+ * Two cleanups happen here, intentionally inside the selector so every
+ * consumer benefits uniformly:
+ *   1. **Drop entries with a blank `className`.** Soft-deleted classes can
+ *      retain their classId in state while the human name is blanked, which
+ *      would otherwise render as an empty row in the filter dropdown.
+ *   2. **Dedupe by `classId`.** `classesByKey` is keyed by
+ *      `${classId}-${reportId}` (see `getClassKey`), so a class loaded under
+ *      multiple report contexts appears as multiple entries from
+ *      `Object.values(classesByKey)`. The first non-blank entry per
+ *      `classId` wins.
+ */
+exports.getClassFilterOptions = (0, toolkit_1.createSelector)(
+// Key the memo on the underlying `classesByKey` record rather than on
+// `getAllClasses` output: the latter returns a fresh `Object.values(...)`
+// array on every call, which would defeat reselect's reference-equality
+// check and re-run the projection on every dispatch.
+[(classState) => classState.classesByKey], (classesByKey) => {
+    const classes = Object.values(classesByKey);
+    const seenClassIds = new Set();
+    const options = [];
+    for (const c of classes) {
+        if (c.classId == null || seenClassIds.has(c.classId)) {
+            continue;
+        }
+        if (c.className == null || c.className.trim() === '') {
+            continue;
+        }
+        seenClassIds.add(c.classId);
+        options.push({ classId: c.classId, className: c.className });
+    }
+    return options;
+});