@zeniai/client-epic-state 4.17.64 → 4.17.65

package/lib/view/spendManagement/billPay/billDetailView/billDetailViewReducer.d.ts

@@ -9,8 +9,8 @@ export declare const fetchBillDetail: import("@reduxjs/toolkit").ActionCreatorWi
     hasZeniAssistAccess: boolean;
     cacheOverride: any;
 }, "billDetailView/fetchBillDetail", never, never>, updateBillDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    billId: ID;
     billDetail: BillDetailViewPayload;
+    billId: ID;
 }, "billDetailView/updateBillDetail">, updateBillDetailFetchState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[billId: string, fetchState: FetchState, error?: ZeniAPIStatus<Record<string, unknown>> | undefined, vendorId?: string | undefined], {
     billId: string;
     fetchState: FetchState;

package/lib/view/spendManagement/billPay/billDetailView/billDetailViewSelector.d.ts

@@ -21,35 +21,35 @@ import { OutsideZeniPaymentLocalData } from '../editBillView/editBillViewState';
 import { PreviousBillsSelectorView } from '../previousBills/previousBillsSelector';
 import { BillApprovalType, ZeniAssistForBills } from './billDetailViewState';
 export interface BillDetailViewSelector extends SelectorView {
-    previousBills: PreviousBillsSelectorView;
-    deleteStatus: FetchStateAndError;
-    cancelAndDeleteStatus: FetchStateAndError;
-    cancelStatus: FetchStateAndError;
-    billSaveStatus: FetchState;
+    allAccountingClasses: Class[];
+    allApprovers: UserAndRole[];
     approvalUpdateStatus: FetchStateAndError;
+    approverListFetchState: FetchStateAndError;
     billActivities: BillActivity[];
-    filteredAttributes: AttributeType[];
     billHistory: ActivityHistorySelectorView;
-    approverListFetchState: FetchStateAndError;
-    realTimeApproval: ActivityRealTimeApprovalSelectorView;
+    billSaveStatus: FetchState;
+    cancelAndDeleteStatus: FetchStateAndError;
+    cancelStatus: FetchStateAndError;
+    deleteStatus: FetchStateAndError;
     filteredApprovers: UserAndRole[];
-    allApprovers: UserAndRole[];
-    allAccountingClasses: Class[];
+    filteredAttributes: AttributeType[];
     isRecurring: boolean;
-    recurringBillInstances?: RecurringBillData[];
-    recurringBillConfigDetail?: RecurringBillConfig;
-    zeniAssist?: ZeniAssistForBills;
-    outsideZeniPaymentInfo?: OutsideZeniPaymentLocalData;
-    transactionDetails?: BillTransaction;
-    createdBy?: User;
+    previousBills: PreviousBillsSelectorView;
+    realTimeApproval: ActivityRealTimeApprovalSelectorView;
+    approvalType?: BillApprovalType;
     bankAccount?: BankAccount;
+    createdBy?: User;
+    latestApprovedDate?: ZeniDate;
+    outsideZeniPaymentInfo?: OutsideZeniPaymentLocalData;
     paymentInstrument?: PaymentInstrument;
-    withdrawFrom?: FundingAccount;
+    paymentMethodType?: BillPayConfig;
+    recurringBillConfigDetail?: RecurringBillConfig;
+    recurringBillInstances?: RecurringBillData[];
+    transactionDetails?: BillTransaction;
     vendorCurrency?: string;
     vendorOwnerId?: ID;
-    approvalType?: BillApprovalType;
-    paymentMethodType?: BillPayConfig;
-    latestApprovedDate?: ZeniDate;
+    withdrawFrom?: FundingAccount;
+    zeniAssist?: ZeniAssistForBills;
 }
 export interface StepWithStatus extends StepWithUser {
     actorsActivity: ActorActivityWithUser[];
@@ -58,25 +58,25 @@ export interface StepWithStatus extends StepWithUser {
 export interface ActorActivityWithUser {
     activity: ActivityStatus;
     description: string;
-    userId: ID;
-    type: string;
     isRecurringAutoApprove: boolean;
-    lastUpdateTime?: ZeniDate;
+    type: string;
+    userId: ID;
     actor?: User;
+    lastUpdateTime?: ZeniDate;
     subType?: string;
 }
 export interface BillActivity {
-    entityType: EntityType;
     createTime: ZeniDate;
-    updateTime: ZeniDate;
-    stepsWithStatus: StepWithStatus[];
+    entityType: EntityType;
     isRealTimeApprovalEnabled: boolean;
+    stepsWithStatus: StepWithStatus[];
+    updateTime: ZeniDate;
     approvalRuleId?: ID;
-    entityApprovalId?: ID;
-    criteria?: Criteria[];
     areApprovalsSerialized?: boolean;
-    isAdminFallbackApprover?: boolean;
+    criteria?: Criteria[];
     currentPendingStepIndex?: number;
+    entityApprovalId?: ID;
+    isAdminFallbackApprover?: boolean;
 }
 export declare const getBillActivities: (state: RootState, billId: ID, billStageCode?: BillStageCodeType) => BillActivity[];
 export declare const getBillDetailView: (state: RootState, billId: ID) => BillDetailViewSelector;

package/lib/view/spendManagement/billPay/billDetailView/billDetailViewState.d.ts

@@ -4,12 +4,12 @@ export type BillAssistActionType = 'retry' | 'refund';
 export declare const getBillTransactionDetailKey: (billId: ID) => string;
 export type BillTransactionDetailKey = ReturnType<typeof getBillTransactionDetailKey>;
 export interface BillDetailView extends FetchedState {
-    deleteStatus: FetchStateAndError;
+    approvalRuleIds: ID[];
+    approvalUpdateStatus: FetchStateAndError;
     cancelAndDeleteStatus: FetchStateAndError;
     cancelStatus: FetchStateAndError;
-    approvalUpdateStatus: FetchStateAndError;
+    deleteStatus: FetchStateAndError;
     entityApprovalIds: ID[];
-    approvalRuleIds: ID[];
     eventIds: ID[];
     zeniAssist: ZeniAssistForBills;
     billId?: ID;
@@ -17,11 +17,11 @@ export interface BillDetailView extends FetchedState {
 }
 export interface ZeniAssistForBills {
     eligibleActionsFetchStatus: FetchStateAndError;
-    retryStatus: FetchStateAndError;
     refundStatus: FetchStateAndError;
+    retryStatus: FetchStateAndError;
+    isEligibleForRefund?: boolean;
     isEligibleForRetryIBT?: boolean;
     isEligibleForRetryOBP?: boolean;
-    isEligibleForRefund?: boolean;
 }
 export interface BillDetailViewState {
     billDetailById: Record<BillTransactionDetailKey, BillDetailView>;

package/lib/view/spendManagement/billPay/billDetailView/epics/fetchBillDetailEpic.d.ts

@@ -35,8 +35,8 @@ export declare const waitForVendorByNameThenUpdateBillDetailEpic: (actions$: Act
     type: "billDetailView/updateBillDetailFetchState";
 } | {
     payload: {
-        billId: ID;
         billDetail: import("../billDetailViewPayload").BillDetailViewPayload;
+        billId: ID;
     };
     type: "billDetailView/updateBillDetail";
 }>;

package/lib/view/spendManagement/billPay/billList/billListPayload.d.ts

@@ -8,24 +8,24 @@ import { UserPayload } from '../../../../entity/user/userPayload';
 import { VendorPayload } from '../../../../entity/vendor/vendorPayload';
 import { ZeniAPIResponse } from '../../../../responsePayload';
 export interface BillListPayload {
+    accounts: AccountBasePayload[];
     customers: CustomerPayload[];
-    query_definitions: Record<string, unknown>;
-    transactions: BillTransactionPayload[];
     entity_approvals: EntityApprovalStatusPayload[];
     pending_approval_transaction_ids_for_user: ID[];
-    vendors: VendorPayload[];
-    accounts: AccountBasePayload[];
-    users: UserPayload[];
-    recurring_bill_configs: RecurringBillConfigResponsePayload[];
     query: {
-        start_date: string;
-        end_date: string;
-        transaction_type: string;
-        sort_by: string;
-        sort_order: string;
         bill_pay_provider: string;
         bill_stage_code: string;
+        end_date: string;
         is_include_pending_approval_transaction_ids_for_user: boolean;
+        sort_by: string;
+        sort_order: string;
+        start_date: string;
+        transaction_type: string;
     };
+    query_definitions: Record<string, unknown>;
+    recurring_bill_configs: RecurringBillConfigResponsePayload[];
+    transactions: BillTransactionPayload[];
+    users: UserPayload[];
+    vendors: VendorPayload[];
 }
 export type FetchBillsByBillStatusResponse = ZeniAPIResponse<BillListPayload>;

package/lib/view/spendManagement/billPay/billList/billListReducer.d.ts

@@ -22,8 +22,8 @@ export declare const fetchBillList: import("@reduxjs/toolkit").ActionCreatorWith
     tab: "paid" | "pending_approval" | "scheduled" | "draft";
     error: ZeniAPIStatus<Record<string, unknown>>;
 }, "billList/updateBillListFailure", never, never>, updateTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<"paid" | "pending_approval" | "scheduled" | "draft", "billList/updateTab">, updateSubTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<"rejected" | "ach" | "wire" | "failed" | "cancelled" | "deleted" | "all" | "overdue" | "awaiting_approval" | "awaiting_my_approval" | "offline", "billList/updateSubTab">, updateSelectedBillId: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "billList/updateSelectedBillId">, clearBillList: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"billList/clearBillList">, updateBillDetailSaveBillCode: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SaveBillStageCode, "billList/updateBillDetailSaveBillCode">, updateBillListUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    uiState: Partial<BillListUIState>;
     period: TimePeriod;
+    uiState: Partial<BillListUIState>;
 }, "billList/updateBillListUIState">, updateSearchResult: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "billList/updateSearchResult">, updateFilterResult: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     filters: BillPayFilters;
 }, "billList/updateFilterResult">, updateBillListDownloadUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{

package/lib/view/spendManagement/billPay/billList/billListSelector.d.ts

@@ -18,36 +18,36 @@ interface BillBulkSelectInfo {
     bulkSelectExceptionInfo?: BillBulkSelectExceptionInfoType;
 }
 interface BillListBulkActionInfo {
-    isBulkActionAllowed: boolean;
     allowedBulkActions: BulkOperationType[];
-    bulkSubmissionFetchState: FetchState;
     billsSelectedForBulkAction: ID[];
+    bulkSubmissionFetchState: FetchState;
+    isBulkActionAllowed: boolean;
     isRecurringBillInBulkActionList: boolean;
 }
 export interface BillTransactionView extends BillTransaction {
     approvers: Approvers;
     isRecurring: boolean;
-    createdByUser?: User;
     bulkSelectInfo?: BillBulkSelectInfo;
+    createdByUser?: User;
     recurringBillConfig?: RecurringBillConfig;
     withdrawFrom?: FundingAccount;
 }
 export interface BillListReport extends SelectorView {
-    billOrder: EntityOrder;
-    transactions: BillTransactionView[];
-    currentTab: BillTab;
-    currentSubTab: BillsSubTabType;
     allSubTabs: BillsSubTabType[];
     approvalCount: number;
-    uiState: BillListUIState;
-    searchText: string;
-    filters: BillPayFilters;
-    billPayBotEmail: string;
-    isDownloadEnabled: boolean;
     billBulkSubmissionLimit: number;
     billListBulkActionInfo: BillListBulkActionInfo;
-    selectedBillId?: ID;
+    billOrder: EntityOrder;
+    billPayBotEmail: string;
+    currentSubTab: BillsSubTabType;
+    currentTab: BillTab;
+    filters: BillPayFilters;
+    isDownloadEnabled: boolean;
+    searchText: string;
+    transactions: BillTransactionView[];
+    uiState: BillListUIState;
     billDetailSaveBillCode?: SaveBillStageCode;
+    selectedBillId?: ID;
 }
 export declare const getBillList: (state: RootState, currentTimePeriod: TimePeriod, isBulkActionFeatureEnabled: boolean, loggedInUserId?: ID) => BillListReport;
 export declare const getApproversOrRejectors: (billTransaction: BillTransaction, entityApprovalStatusState: EntityApprovalStatusState, userState: UserState) => Approvers;

package/lib/view/spendManagement/billPay/billList/billListState.d.ts

@@ -10,20 +10,20 @@ export interface SpendManagementUIState {
 export declare const getBillListKey: (period: TimePeriod, tab: string) => string;
 export type BillListKey = ReturnType<typeof getBillListKey>;
 export interface BillListStatus extends FetchedState {
-    transactionIDs: ID[];
     pendingApprovalTransactionIDs: ID[];
+    transactionIDs: ID[];
     uiState: BillListUIState;
 }
 export declare const billListInitialState: BillListStatus;
 export interface BillListState {
     byBillListKey: Record<BillListKey, BillListStatus>;
-    currentTab: BillTab;
     currentSubTab: BillsSubTabType;
-    searchText: string;
-    filters: BillPayFilters;
+    currentTab: BillTab;
     downloadUIState: BillListDownloadUIState;
-    selectedBillId?: ID;
+    filters: BillPayFilters;
+    searchText: string;
     billDetailSaveBillCode?: SaveBillStageCode;
+    selectedBillId?: ID;
 }
 export interface BillListUIState extends SpendManagementUIState {
     sortKey: BillPayViewSortKey;
@@ -40,8 +40,8 @@ export type BillsSubTabType = ReturnType<typeof toBillsSubTabType>;
 declare const toBillPaySortKeyType: (v: string) => "status" | "amount" | "dueDate" | "name" | "paymentMethod" | "invoiceDate";
 export declare type BillPayViewSortKey = ReturnType<typeof toBillPaySortKeyType>;
 export interface BillPayFilters {
-    categoryCombinationOperator: CategoryCombinationOperator;
     categories: BillPayFilterCategory[];
+    categoryCombinationOperator: CategoryCombinationOperator;
 }
 export interface BillPayFilterCategory {
     field: BillListViewFilterCategoryField;

package/lib/view/spendManagement/billPay/billPayConfig/billPayConfigPayload.d.ts

@@ -6,39 +6,39 @@ import { ZeniAPIResponse } from '../../../../responsePayload';
 import { AccType, AccountTypeSubConfigCodeKeyType, BillPayConfig, BillPaymentConfigCodeType, BillPaymentOutsideZeniSubConfigCodeType, BillPaymentSubConfigCodeKeyType, BillPaymentSubConfigCodeType, BillPaymentWireSubConfigCodeKeyType, BillPaymentWireSubConfigCodeType, ConfigPeriod, InternationalSubConfigCodeKeyType, InternationalSubConfigCodeType, InternationalWireMethodCodeKeyType, InternationalWireMethodCodeType, PaymentAchSubConfigCodeKeyType, PaymentAchSubConfigCodeType, VendorCurrency } from './billPayConfigState';
 export interface BillPayConfigPayload {
     bill_pay_bot_email: string;
-    is_us_domestic_wire_enabled: boolean;
-    is_same_day_ach_enabled: boolean;
     is_international_wire_enabled: boolean;
     is_international_wires_verified: boolean;
     is_outside_zeni_payment_enabled: boolean;
-    payment_processor: BillPayConfigPaymentProcessorPayload;
+    is_same_day_ach_enabled: boolean;
+    is_us_domestic_wire_enabled: boolean;
+    last_selected_from_account: {
+        account_id: string | null;
+        account_type: string | null;
+    };
     max_bills_allowed_for_bulk_action: number;
+    payment_processor: BillPayConfigPaymentProcessorPayload;
     required_fields: {
         ach: Record<PaymentAchSubConfigCodeType, string[]>;
         wire: Record<BillPaymentWireSubConfigCodeType, string[]>;
     };
     vendor: {
-        supported_currencies: SupportedCurrencyPayload;
-        supported_countries: CountryPayload[];
         local_currency_supported_countries: CountryPayload[];
-    };
-    last_selected_from_account: {
-        account_id: string | null;
-        account_type: string | null;
+        supported_countries: CountryPayload[];
+        supported_currencies: SupportedCurrencyPayload;
     };
 }
 interface SupportedCurrencyPayload {
     ach: Record<PaymentAchSubConfigCodeType, CurrencyPayload[]>;
-    wire: Record<BillPaymentWireSubConfigCodeType, CurrencyPayload[]>;
     by_country: Record<string, CountryWiseCurrencyPayload>;
+    wire: Record<BillPaymentWireSubConfigCodeType, CurrencyPayload[]>;
 }
 export interface CountryWiseCurrencyPayload {
     country_name: string;
     currencies: VendorCurrencyPayload[];
 }
 export interface VendorCurrencyPayload extends CurrencyPayload {
-    currency: string;
     country_code: string;
+    currency: string;
     is_enabled: boolean;
 }
 interface CountryPayload {
@@ -52,19 +52,19 @@ interface PaymentTimeline {
 }
 interface ClassConfig {
     ach: Record<PaymentAchSubConfigCodeType, ClassBasePayload>;
-    wire: Record<BillPaymentWireSubConfigCodeType, ClassBasePayload>;
     'outside-zeni': Record<BillPaymentOutsideZeniSubConfigCodeType, ClassBasePayload>;
+    wire: Record<BillPaymentWireSubConfigCodeType, ClassBasePayload>;
 }
 interface AccountConfig {
     ach: Record<PaymentAchSubConfigCodeType, AccountBasePayload>;
-    wire: Record<BillPaymentWireSubConfigCodeType, AccountBasePayload>;
     'outside-zeni': Record<BillPaymentOutsideZeniSubConfigCodeType, AccountBasePayload>;
+    wire: Record<BillPaymentWireSubConfigCodeType, AccountBasePayload>;
 }
 interface BillPayConfigPaymentProcessorPayload {
-    payment_timeline: PaymentTimeline;
     account: AccountConfig;
     class: ClassConfig;
     fees: FeesConfig;
+    payment_timeline: PaymentTimeline;
 }
 interface InternationalWireConfig {
     'usd-to-local-currency': BillPayConfigFeePayload;
@@ -76,19 +76,19 @@ interface WireConfig {
 }
 interface FeesConfig {
     ach: Record<PaymentAchSubConfigCodeType, BillPayConfigFeeForAccTypePayload>;
-    wire: WireConfig;
     'outside-zeni': Record<BillPaymentOutsideZeniSubConfigCodeType, BillPayConfigFeeForAccTypePayload>;
+    wire: WireConfig;
 }
 type BillPayConfigFeeForAccTypePayload = Record<AccType, BillPayConfigFeePayload>;
 interface BillPayConfigFeePayload {
     amount: number;
-    description: string;
     currency_code: string;
     currency_symbol: string;
-    static_fee?: number | null;
-    static_fee_ceil_amount?: number | null;
+    description: string;
     dynamic_fee?: number | null;
     dynamic_fee_type?: string | null;
+    static_fee?: number | null;
+    static_fee_ceil_amount?: number | null;
 }
 type ConfigTimelineForAccTypePayload = Record<AccType, ConfigTimelinePayload>;
 export interface ConfigTimelinePayload {
@@ -107,8 +107,8 @@ export declare const getInternationalSubConfigCodeKey: (subCode: InternationalSu
 export declare const getInternationalWireMethodCodeKey: (subCode: InternationalWireMethodCodeType) => InternationalWireMethodCodeKeyType;
 export declare const getAccountTypeSubConfigCodeKey: (subCode: AccType) => AccountTypeSubConfigCodeKeyType;
 export interface TimelineDetail {
-    minPeriod: ConfigPeriod;
     maxPeriod: ConfigPeriod;
+    minPeriod: ConfigPeriod;
 }
 export declare const mapBillPayConfigPayloadToBillPayConfig: (paymentProcessor: BillPayConfigPaymentProcessorPayload, isEnabled: boolean, isVerified: boolean, code: BillPaymentConfigCodeType, subCode: BillPaymentSubConfigCodeType, accType?: AccType, internationalMethod?: InternationalWireMethodCodeType, internationalSubMethod?: InternationalSubConfigCodeType) => BillPayConfig;
 export declare const mapBillPayVendorConfigPayloadToBillPayVendorConfig: (payload: BillPayConfigPayload, code: BillPaymentConfigCodeType, subCode: BillPaymentSubConfigCodeType) => Currency[];

package/lib/view/spendManagement/billPay/billPayConfig/billPayConfigState.d.ts

@@ -10,45 +10,45 @@ type VendorCurrencyConfig = Record<BillPayConfigKey, Currency[]>;
 export declare const toDynamicFeeType: (v: string) => "percent" | "fixed";
 type DynamicFeeType = ReturnType<typeof toDynamicFeeType>;
 export interface BillPayConfigState extends FetchedState {
+    billBulkSubmissionLimit: number;
+    billPayBotEmail: string;
     methodById: Record<string, BillPayConfig>;
     vendor: {
-        supportedCountries: Country[];
+        currencyListByCountryId: Record<ID, VendorCurrency[]>;
         localCurrencySupportedCountries: Country[];
+        supportedCountries: Country[];
         supportedCurrencies: VendorCurrencyConfig;
-        currencyListByCountryId: Record<ID, VendorCurrency[]>;
     };
-    billPayBotEmail: string;
-    billBulkSubmissionLimit: number;
     lastSelectedFromAccount?: {
         accountId: ID;
         accountType: AccountTypeSubConfigCodeKeyType;
     };
 }
 export interface VendorCurrency extends Currency {
-    currencyName: string;
     countryCode: string;
+    currencyName: string;
 }
 export interface BillPayConfig {
-    minPeriod: ConfigPeriod;
-    maxPeriod: ConfigPeriod;
-    method: string;
-    fee: Amount;
-    description: string;
     account: AccountBase;
     class: ClassBase;
+    description: string;
+    fee: Amount;
     isEnabled: boolean;
     isVerified: boolean;
+    maxPeriod: ConfigPeriod;
+    method: string;
+    minPeriod: ConfigPeriod;
     internationalFee?: InternationalFee;
 }
 export interface InternationalFee {
-    staticFee: Amount;
-    staticFeeCeilingAmount: Amount;
     dynamicFee: number;
     dynamicFeeType: DynamicFeeType;
+    staticFee: Amount;
+    staticFeeCeilingAmount: Amount;
 }
 export interface ConfigPeriod {
-    value: number;
     units: string;
+    value: number;
 }
 export declare const BILL_PAYMENT_METHOD_CODE: readonly ["ach", "wire", "outside-zeni"];
 export declare const toBillPaymentMethodCodeType: (v: string) => "ach" | "wire" | "outside-zeni";
@@ -92,18 +92,18 @@ export declare const NEW_INTERNATIONAL_METHOD_SUBTEXT = "billPay_wire_internatio
 export declare const SWIFT_OUR_INTERNATIONAL_METHOD_SUBTEXT = "swiftOur";
 export declare const LOCAL_CURRENCY_INTERNATIONAL_METHOD_SUBTEXT = "usdToLocalCurrency";
 export interface BillPaymentMethodConfig {
-    id: ID;
-    name: string;
-    code: BillPaymentConfigCodeType;
-    subCode: string;
-    maxPeriod: ConfigPeriod;
-    method: string;
-    fee: Amount;
-    description: string;
     account: AccountBase;
     class: ClassBase;
+    code: BillPaymentConfigCodeType;
+    description: string;
+    fee: Amount;
+    id: ID;
     isEnabled: boolean;
     isVerified: boolean;
+    maxPeriod: ConfigPeriod;
+    method: string;
+    name: string;
+    subCode: string;
     internationalFee?: InternationalFee;
 }
 export {};

package/lib/view/spendManagement/billPay/billPayReview/billPayReviewPayload.d.ts

@@ -1,18 +1,18 @@
 import { BillTransactionPayload } from '../../../../entity/billPay/billTransaction/billTransactionPayload';
 import { ZeniAPIResponse } from '../../../../responsePayload';
 interface DuplicateBillPayReviewPayload {
-    transactions: BillTransactionPayload[];
     query: DuplicateBillPayQuery;
+    transactions: BillTransactionPayload[];
 }
 interface DuplicateBillPayQuery {
-    sort_by: string;
-    sort_order: string;
-    limit: number;
-    entity_type: string;
+    bill_pay_provider: string;
     entity_id: string;
     entity_name: string;
-    bill_pay_provider: string;
+    entity_type: string;
     is_include_attachment: boolean;
+    limit: number;
+    sort_by: string;
+    sort_order: string;
     transaction_type: string;
 }
 export type DuplicateBillPayResponse = ZeniAPIResponse<DuplicateBillPayReviewPayload>;

package/lib/view/spendManagement/billPay/billPayReview/billPayReviewSelector.d.ts

@@ -10,25 +10,25 @@ import { BillPayConfig } from '../billPayConfig/billPayConfigState';
 import { PaymentDetailsSectionView } from '../editBillView/editBillViewSelector';
 import { OutsideZeniPaymentLocalData, RecurringBillConfigLocalData } from '../editBillView/editBillViewState';
 export interface BillPayReviewSelectorView extends SelectorView {
+    billPayConfigList: BillPayConfig[];
     duplicateBillTransactions: BillTransaction[];
-    vendor: Vendor | undefined;
+    file: Attachment | undefined;
+    isCollectToAccountInfoFromVendorContact: boolean;
+    isInvoiceDateAutoUpdated: boolean;
+    isRecurring: boolean;
     lineDetailSection: Record<ID, Partial<TransactionWithAccountAndClassLine>>;
-    totalAmount: Amount;
-    recipientTotalAmount: Amount;
     paymentDetailsSection: PaymentDetailsSectionView | undefined;
-    file: Attachment | undefined;
+    recipientTotalAmount: Amount;
     saveStatus: FetchStateAndError | undefined;
+    totalAmount: Amount;
+    vendor: Vendor | undefined;
     zeniAssistRetryStatus: FetchStateAndError | undefined;
-    isCollectToAccountInfoFromVendorContact: boolean;
-    billPayConfigList: BillPayConfig[];
-    isRecurring: boolean;
-    isInvoiceDateAutoUpdated: boolean;
     billPayInfo?: BillPayInfo;
-    recurringBillInstance?: number;
-    recurringConfig?: RecurringBillConfigLocalData;
+    invoiceNumber?: string;
     isBillMarkedForRetry?: boolean;
     outsideZeniPaymentInfo?: OutsideZeniPaymentLocalData;
-    invoiceNumber?: string;
+    recurringBillInstance?: number;
+    recurringConfig?: RecurringBillConfigLocalData;
     toAccountVendorEmail?: string;
 }
 export interface DuplicateBillsSelectorView extends SelectorView {

package/lib/view/spendManagement/billPay/billPayReview/billPayReviewState.d.ts

@@ -6,7 +6,7 @@ export interface DuplicateBillCheckState {
     transactionId?: ID;
 }
 export interface BillPayReviewState {
-    newBillReviewState: DuplicateBillCheckState;
     editBillReviewStateById: Record<BillTransactionDetailKey, DuplicateBillCheckState>;
+    newBillReviewState: DuplicateBillCheckState;
 }
 export declare const initialDuplicateBillCheckState: DuplicateBillCheckState;

package/lib/view/spendManagement/billPay/billPaySetupApproverView/billPaySetupApproverViewPayload.d.ts

@@ -5,9 +5,9 @@ import { ZeniAPIResponse } from '../../../../responsePayload';
 import { ApproverViewPayload } from './types/commonPayload';
 export type BillPaySetupApproverViewResponse = ZeniAPIResponse<ApproverViewPayload>;
 interface BillPaySetupApproversListPayload {
-    users: UserPayload[];
     attributes: AttributeType[];
     user_roles: UserRolePayload[];
+    users: UserPayload[];
 }
 export type BillPaySetupApproversListResponse = ZeniAPIResponse<BillPaySetupApproversListPayload>;
 export {};

package/lib/view/spendManagement/billPay/billPaySetupApproverView/billPaySetupApproverViewSelectorTypes.d.ts

@@ -15,16 +15,16 @@ export interface ApprovalRuleWithUser extends Omit<ApprovalRule, 'steps'> {
 }
 export interface BillPaySetupApproverView extends SelectorView {
     allApprovalRules: ApprovalRuleWithUser[];
-    deleteStatus: FetchStateAndError;
     approvalRulesStatus: AllowedValueWithCode;
+    deleteStatus: FetchStateAndError;
 }
 export interface BillPaySetupApproverUpdateDataView extends SelectorView {
+    allAccountingClasses: Class[];
+    allApprovalRules: ApprovalRule[];
     allApprovers: UserAndRole[];
     allAttributes: AttributeType[];
+    approverListFetchStatus: FetchStateAndError;
     filteredApprovers: UserAndRole[];
     filteredAttributes: AttributeType[];
-    approverListFetchStatus: FetchStateAndError;
-    allApprovalRules: ApprovalRule[];
-    allAccountingClasses: Class[];
     billPaySetupApproverViewUpdateData?: ApproverViewUpdateData;
 }

package/lib/view/spendManagement/billPay/billPaySetupApproverView/billPaySetupApproverViewState.d.ts

@@ -2,12 +2,12 @@ import { FetchStateAndError, FetchedState, ID } from '../../../../commonStateTyp
 import { AttributeType } from '../../../../entity/approvalRule/approvalRuleState';
 import { ApproverViewUpdateData } from './types/commonState';
 export interface BillPaySetupApproverViewState extends FetchedState {
+    approvalRuleIds: ID[];
+    approvalRulesDeleteStatusById: Record<ID, FetchStateAndError>;
     approverListState: {
         approverIds: ID[];
         attributes: AttributeType[];
         fetchStatus: FetchStateAndError;
     };
-    approvalRuleIds: ID[];
-    approvalRulesDeleteStatusById: Record<ID, FetchStateAndError>;
     billPaySetupApproverViewUpdateData?: ApproverViewUpdateData;
 }

package/lib/view/spendManagement/billPay/billPaySetupApproverView/types/commonState.d.ts

@@ -2,8 +2,8 @@ import { FetchStateAndError, ID } from '../../../../../commonStateTypes/common';
 import { Criteria, Step } from '../../../../../entity/approvalRule/approvalRuleState';
 export type ApprovalUpdateActionType = 'approval_create' | 'approval_update';
 export interface ApproverViewUpdateData {
-    updateStatus: FetchStateAndError;
     type: ApprovalUpdateActionType;
+    updateStatus: FetchStateAndError;
     data?: ApprovalRuleUpdateData | ApprovalRuleCreateData;
 }
 export interface ApprovalRuleUpdateData {

package/lib/view/spendManagement/billPay/billPaySetupView/types/billPayTerms.d.ts

@@ -4,8 +4,8 @@ import { UserRolePayload } from '../../../../../entity/userRole/userRolePayload'
 import { ZeniAPIResponse } from '../../../../../responsePayload';
 interface AcceptBillPayTermsPayload {
     companies: CompanyPayload[];
-    users: UserPayload[];
     user_roles: UserRolePayload[];
+    users: UserPayload[];
 }
 export type AcceptBillPayTermsResponse = ZeniAPIResponse<AcceptBillPayTermsPayload>;
 export {};

package/lib/view/spendManagement/billPay/billsBulkActionView/billsBulkActionViewPayload.d.ts

@@ -1,22 +1,22 @@
 import { ZeniAPIResponse } from '../../../../responsePayload';
 export interface BulkActionItemResponseBasePayload {
     entity_id: string;
-    status: string;
     error: {
         error_code: string;
         error_message: string;
     } | null;
+    status: string;
 }
 export interface BulkActionItemResponsePayload extends BulkActionItemResponseBasePayload {
     processing_message: string | null;
 }
 export interface BulkActionResponsePayload {
-    total_operations_requested: number;
-    total_operations_processing: number;
     bulk_operation_id: string;
-    operation_type: string;
     hard_refresh_after_sec: number;
+    operation_type: string;
     operations: BulkActionItemResponsePayload[];
+    total_operations_processing: number;
+    total_operations_requested: number;
 }
 export type BillsBulkActionResponse = ZeniAPIResponse<BulkActionResponsePayload>;
 interface BulkActionReviewErrorResponsePayload {