@zeniai/client-epic-state 5.1.0-betaSS2 → 5.1.0

package/lib/entity/cardPolicy/cardPolicySelector.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCardPolicyMccCategories = getCardPolicyMccCategories;
+exports.getCardPolicyMccCategoriesFetchState = getCardPolicyMccCategoriesFetchState;
+exports.getCardPolicyMccCategoriesError = getCardPolicyMccCategoriesError;
+exports.getCardPolicyTemplateById = getCardPolicyTemplateById;
+exports.getAllCardPolicyTemplates = getAllCardPolicyTemplates;
+exports.getCardPolicyTemplatesByIds = getCardPolicyTemplatesByIds;
+exports.getCardPolicyStats = getCardPolicyStats;
+exports.getPolicyDocumentExtractionFetchState = getPolicyDocumentExtractionFetchState;
+exports.getPolicyDocumentExtractionError = getPolicyDocumentExtractionError;
+exports.getExtractedCardPolicyRules = getExtractedCardPolicyRules;
+exports.getUploadedPolicyDocumentFileName = getUploadedPolicyDocumentFileName;
+exports.getPolicyRecommendationFromUploadFetchState = getPolicyRecommendationFromUploadFetchState;
+exports.getPolicyRecommendationFromUploadError = getPolicyRecommendationFromUploadError;
+exports.getPolicyRecommendationFromUploadAnswerId = getPolicyRecommendationFromUploadAnswerId;
+exports.getPolicyRecommendationFromUploadChatSessionId = getPolicyRecommendationFromUploadChatSessionId;
+exports.getCardPolicySuggestedAllowMerchants = getCardPolicySuggestedAllowMerchants;
+exports.getCardPolicySuggestedBlockMerchants = getCardPolicySuggestedBlockMerchants;
+exports.getCardPolicySuggestedAllowCategories = getCardPolicySuggestedAllowCategories;
+exports.getCardPolicySuggestedBlockCategories = getCardPolicySuggestedBlockCategories;
+exports.getCardPolicyVendorSearchOptions = getCardPolicyVendorSearchOptions;
+exports.getCardPolicyVendorSearchFetchState = getCardPolicyVendorSearchFetchState;
+exports.getCardPolicyVendorSearchString = getCardPolicyVendorSearchString;
+function getCardPolicyMccCategories(state) {
+    return state.mccCategories;
+}
+function getCardPolicyMccCategoriesFetchState(state) {
+    return state.mccCategoriesFetchState;
+}
+function getCardPolicyMccCategoriesError(state) {
+    return state.mccCategoriesError;
+}
+function getCardPolicyTemplateById(state, templateId) {
+    return state.cardPolicyTemplateById[templateId];
+}
+function getAllCardPolicyTemplates(state) {
+    return Object.values(state.cardPolicyTemplateById);
+}
+/**
+ * Resolve an ordered list of `templateId`s against the entity store and
+ * return the corresponding `CardPolicyTemplate[]` in the same order.
+ * Missing IDs (e.g. stale local state during a refetch) are silently
+ * dropped. Pair with `getCardPolicyTemplateIds` from the view slice to
+ * render the Policy List page in server order.
+ */
+function getCardPolicyTemplatesByIds(state, templateIds) {
+    return templateIds
+        .map((id) => state.cardPolicyTemplateById[id])
+        .filter((template) => template != null);
+}
+function getCardPolicyStats(state) {
+    return state.cardPolicyStats;
+}
+function getPolicyDocumentExtractionFetchState(state) {
+    return state.policyDocumentExtraction.fetchState;
+}
+function getPolicyDocumentExtractionError(state) {
+    return state.policyDocumentExtraction.error;
+}
+function getExtractedCardPolicyRules(state) {
+    return state.policyDocumentExtraction.extractedRules;
+}
+function getUploadedPolicyDocumentFileName(state) {
+    return state.policyDocumentExtraction.uploadedFileName;
+}
+function getPolicyRecommendationFromUploadFetchState(state) {
+    return state.policyRecommendationFromUpload.fetchState;
+}
+function getPolicyRecommendationFromUploadError(state) {
+    return state.policyRecommendationFromUpload.error;
+}
+function getPolicyRecommendationFromUploadAnswerId(state) {
+    return state.policyRecommendationFromUpload.answerId;
+}
+function getPolicyRecommendationFromUploadChatSessionId(state) {
+    return state.policyRecommendationFromUpload.chatSessionId;
+}
+function getCardPolicySuggestedAllowMerchants(state) {
+    return state.suggestedAllowMerchants;
+}
+function getCardPolicySuggestedBlockMerchants(state) {
+    return state.suggestedBlockMerchants;
+}
+function getCardPolicySuggestedAllowCategories(state) {
+    return state.suggestedAllowCategories;
+}
+function getCardPolicySuggestedBlockCategories(state) {
+    return state.suggestedBlockCategories;
+}
+function getCardPolicyVendorSearchOptions(state) {
+    return state.vendorSearch.vendors;
+}
+function getCardPolicyVendorSearchFetchState(state) {
+    return state.vendorSearch.fetchState;
+}
+function getCardPolicyVendorSearchString(state) {
+    return state.vendorSearch.searchString;
+}

package/lib/entity/cardPolicy/cardPolicyState.d.ts

@@ -0,0 +1,205 @@
+import { FetchState, ID } from '../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { ZeniDate } from '../../zeniDayJS';
+/**
+ * A category grouping merchant category codes (MCCs) used while configuring
+ * card policies (e.g. "Apparel", "AC Refrigeration Repair"). The same data
+ * is consumed by both the manual policy-creation flow and the AI-CFO-driven
+ * flow.
+ */
+export interface MccCategory {
+    count: number;
+    mccCodes: string[];
+    name: string;
+}
+export declare const ALL_CARD_POLICY_TEMPLATE_MODES: readonly ["strict", "flexible"];
+export declare const toCardPolicyTemplateMode: (v: string) => "strict" | "flexible";
+export type CardPolicyTemplateMode = ReturnType<typeof toCardPolicyTemplateMode>;
+export declare const ALL_CARD_POLICY_TEMPLATE_STATUSES: readonly ["active", "inactive", "archived"];
+export declare const toCardPolicyTemplateStatus: (v: string) => "active" | "inactive" | "archived";
+export type CardPolicyTemplateStatus = ReturnType<typeof toCardPolicyTemplateStatus>;
+/**
+ * Allow- / block-list pair scoped to a card-policy template. Empty arrays
+ * mean "no restrictions on this dimension".
+ */
+export interface CardPolicyTemplateEntityList {
+    categoryCodes: string[];
+    merchantNames: string[];
+}
+/**
+ * Spend-limit caps configured per template. Only `transaction` is modeled
+ * today; additional cadences (e.g. daily, monthly) will be added if/when
+ * the backend exposes them.
+ *
+ * `transaction` is `number | null`: `null` means the row's toggle is off
+ * (no limit configured), `0` means the user explicitly entered zero with
+ * the toggle on, and any positive value is the configured per-transaction
+ * cap.
+ */
+export interface CardPolicyTemplateSpendLimits {
+    transaction: number | null;
+}
+/**
+ * Mapped (camelCase) representation of a card-policy template returned by
+ * the cards micro-service. Stored on the entity slice keyed by
+ * `templateId` so both the manual policy-creation UI and the AI-CFO flow
+ * can read it.
+ */
+export interface CardPolicyTemplate {
+    allowedEntity: CardPolicyTemplateEntityList;
+    appliedCards: ID[];
+    blockedEntity: CardPolicyTemplateEntityList;
+    cardsCount: number;
+    categoryRestrictions: unknown[];
+    createdAt: ZeniDate;
+    createdBy: ID;
+    description: string;
+    mode: CardPolicyTemplateMode;
+    name: string;
+    /**
+     * Receipt-required threshold in dollars. `null` means the toggle is off
+     * (no receipt requirement); `0` means the user explicitly entered zero
+     * with the toggle on; any positive value is the configured threshold.
+     */
+    requiredReceiptThreshold: number | null;
+    spendLimits: CardPolicyTemplateSpendLimits;
+    status: CardPolicyTemplateStatus;
+    templateId: ID;
+    tenantId: ID;
+    updatedAt: ZeniDate;
+}
+/**
+ * Aggregate counters returned by the list endpoint and reused across
+ * any surface that wants to display tenant-wide policy stats without
+ * triggering an extra fetch.
+ */
+export interface CardPolicyStats {
+    activePolicies: number;
+    totalCards: number;
+    totalTemplates: number;
+}
+/**
+ * FE-side (camelCase) mirror of the wire payload
+ * `ExtractedCardPolicyRulesPayload`. Field names align slice-wise with
+ * `CardPolicyTemplate` (`allowedEntity`, `blockedEntity`,
+ * `requiredReceiptThreshold`) so the pre-fill mapper consumed by both
+ * `CardPolicyCreatePage` (manual) and `CardPolicyInteractiveForm`
+ * (AI CFO) can read either shape uniformly.
+ */
+export interface ExtractedCardPolicyRules {
+    allowedEntity: CardPolicyTemplateEntityList;
+    blockedEntity: CardPolicyTemplateEntityList;
+    confidenceScore: number;
+    policyName: string;
+    requiredReceiptThreshold: number;
+    transactionLimit: number;
+}
+/**
+ * Lifecycle for the `POST /cards/1.0/policy-documents/extract` request.
+ * Lives on the entity slice (rather than a view slice) so both the manual
+ * `CardPolicyCreatePage` and the AI CFO `CardPolicyInteractiveForm` can
+ * read the extracted rules from a single source of truth.
+ *
+ * `uploadedFileName` is captured at request-kickoff time so the UI can
+ * render the "Policy.pdf ×" pill once the request completes without
+ * having to keep a separate local copy of the file.
+ */
+export interface PolicyDocumentExtractionState {
+    fetchState: FetchState;
+    /**
+     * AI CFO answer that owns the in-flight upload, when the extraction
+     * was kicked off from inside an `upload`-mode `CardPolicyInteractiveForm`.
+     * Captured at request-kickoff and read by the bridge epic to chain
+     * `fetchCardPolicyRecommendationFromUpload` against the right answer.
+     * `undefined` for manual `CardPolicyCreatePage` callers.
+     */
+    aiCfoAnswerId?: ID;
+    aiCfoChatSessionId?: ID;
+    error?: ZeniAPIStatus;
+    extractedRules?: ExtractedCardPolicyRules;
+    uploadedFileName?: string;
+}
+/**
+ * Lifecycle for `POST /cards/1.0/ai-cfo/policy-recommendation-from-upload`.
+ * Chained after `extractPolicyDocument` succeeds in the AI CFO `upload`
+ * mode — the FE forwards the just-returned `extracted_rules` and the BE
+ * synthesizes a wizard plan + upload source metadata.
+ *
+ * `answerId` captures which AI CFO answer's `card_policy` payload should
+ * receive the resulting `wizard_plan` patch (via
+ * `updateAiCfoAnswerCardPolicyWizardPlan`). Stored here rather than on
+ * the answer slice so the bridge epic can correlate the extract success
+ * → recommendation kickoff without re-deriving it from the visualization.
+ */
+export interface PolicyRecommendationFromUploadState {
+    fetchState: FetchState;
+    answerId?: ID;
+    chatSessionId?: ID;
+    error?: ZeniAPIStatus;
+}
+/**
+ * Lightweight `{vendorId, name}` row stored on the card-policy slice for
+ * the chip-picker's vendor search dropdown. Sourced from
+ * `/accounting/1.0/vendors` via `fetchCardPolicyVendorOptionsEpic`.
+ *
+ * Intentionally a subset of the full `Vendor` entity — populating this
+ * slice does NOT touch the global `vendor`/`account`/`vendorList`
+ * entities, so a card-policy search session never disturbs the user's
+ * Vendors-tab list state.
+ */
+export interface CardPolicyVendorSearchEntry {
+    name: string;
+    vendorId: ID;
+}
+/**
+ * Lifecycle for the `GET /accounting/1.0/vendors` (card-policy mode)
+ * request. Only one in-flight search at a time; the latest typed search
+ * wins (via `switchMap` in the epic). `searchString` is the text that
+ * produced `vendors`, useful for stale-result guards in the UI.
+ */
+export interface CardPolicyVendorSearchState {
+    fetchState: FetchState;
+    searchString: string;
+    vendors: CardPolicyVendorSearchEntry[];
+    error?: ZeniAPIStatus;
+}
+/**
+ * Slice state for card-policy reference data shared across the manual and
+ * AI-driven policy-creation flows. Each sub-resource tracks its own
+ * `fetchState`/`error` so additional card-policy APIs can be added
+ * alongside without coupling.
+ */
+export interface CardPolicyState {
+    cardPolicyTemplateById: Record<ID, CardPolicyTemplate>;
+    mccCategories: MccCategory[];
+    mccCategoriesFetchState: FetchState;
+    policyDocumentExtraction: PolicyDocumentExtractionState;
+    /**
+     * Lifecycle for the AI CFO `upload`-mode follow-up call. Sibling of
+     * `policyDocumentExtraction`; the two together describe the full
+     * upload chain: drop file → extract → recommend → wizard plan ready.
+     */
+    policyRecommendationFromUpload: PolicyRecommendationFromUploadState;
+    /**
+     * MCC categories suggested by the BE as a default "Allow" seed for the
+     * category chip cloud. Empty when the user lands without prior spend
+     * history. See `suggested_allow_catagories` on the wire payload.
+     */
+    suggestedAllowCategories: MccCategory[];
+    /**
+     * Merchant names suggested by the BE as a default "Allow" seed for the
+     * vendor chip cloud. Empty when the BE has no recommendation. See
+     * `suggested_allow_merchants` on the wire payload.
+     */
+    suggestedAllowMerchants: string[];
+    suggestedBlockCategories: MccCategory[];
+    suggestedBlockMerchants: string[];
+    /**
+     * Server-driven vendor search results powering the chip picker's
+     * search dropdown. Distinct from the global vendor entity store so
+     * the card-policy flow never disturbs the user's Vendors-tab list.
+     */
+    vendorSearch: CardPolicyVendorSearchState;
+    cardPolicyStats?: CardPolicyStats;
+    mccCategoriesError?: ZeniAPIStatus;
+}

package/lib/entity/cardPolicy/cardPolicyState.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCardPolicyTemplateStatus = exports.ALL_CARD_POLICY_TEMPLATE_STATUSES = exports.toCardPolicyTemplateMode = exports.ALL_CARD_POLICY_TEMPLATE_MODES = void 0;
+const stringToUnion_1 = require("../../commonStateTypes/stringToUnion");
+exports.ALL_CARD_POLICY_TEMPLATE_MODES = ['strict', 'flexible'];
+const toCardPolicyTemplateMode = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.ALL_CARD_POLICY_TEMPLATE_MODES);
+exports.toCardPolicyTemplateMode = toCardPolicyTemplateMode;
+exports.ALL_CARD_POLICY_TEMPLATE_STATUSES = [
+    'active',
+    'inactive',
+    'archived',
+];
+const toCardPolicyTemplateStatus = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.ALL_CARD_POLICY_TEMPLATE_STATUSES);
+exports.toCardPolicyTemplateStatus = toCardPolicyTemplateStatus;

package/lib/entity/cardPolicy/extractPolicyDocumentEpic.d.ts

@@ -0,0 +1,18 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { clearPolicyDocumentExtraction, extractPolicyDocument, updatePolicyDocumentExtractionFailure, updatePolicyDocumentExtractionSuccess } from './cardPolicyReducer';
+export type ActionType = ReturnType<typeof extractPolicyDocument> | ReturnType<typeof updatePolicyDocumentExtractionSuccess> | ReturnType<typeof updatePolicyDocumentExtractionFailure> | ReturnType<typeof clearPolicyDocumentExtraction>;
+/**
+ * Listens for `extractPolicyDocument`, POSTs the file(s) as multipart
+ * form-data to the cards micro-service's policy-document extract endpoint,
+ * and dispatches success / failure into the entity slice.
+ *
+ * Consumed by:
+ *  - Manual `CardPolicyCreatePage` (read result via
+ *    `getExtractedCardPolicyRules` then pre-fill the RHF form via
+ *    `applyExtractedPolicyRulesToFormValues` from `@zeniai/web-components`).
+ *  - (Future) AI CFO upload surface — same action + selector contract.
+ */
+export declare const extractPolicyDocumentEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/entity/cardPolicy/extractPolicyDocumentEpic.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPolicyDocumentEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../responsePayload");
+const cardPolicyReducer_1 = require("./cardPolicyReducer");
+/**
+ * Build a multipart `FormData` body for `POST /cards/1.0/policy-documents/extract`.
+ *
+ * Uses the same `attachment_file_<i>` / `attachment_json_<i>` field-naming
+ * convention as the charge-card receipt upload (`uploadReceipts.ts` in
+ * `web-components`) so backends that already support that wire shape
+ * accept this endpoint without bespoke parsing.
+ */
+const buildPolicyDocumentFormData = (files) => {
+    const data = new FormData();
+    files.forEach((file, index) => {
+        data.append(`attachment_file_${index}`, file);
+        const attachmentJson = JSON.stringify({
+            file_name: file.name,
+            content_type: file.type,
+            size: file.size,
+        });
+        data.append(`attachment_json_${index}`, attachmentJson);
+    });
+    return data;
+};
+/**
+ * Listens for `extractPolicyDocument`, POSTs the file(s) as multipart
+ * form-data to the cards micro-service's policy-document extract endpoint,
+ * and dispatches success / failure into the entity slice.
+ *
+ * Consumed by:
+ *  - Manual `CardPolicyCreatePage` (read result via
+ *    `getExtractedCardPolicyRules` then pre-fill the RHF form via
+ *    `applyExtractedPolicyRulesToFormValues` from `@zeniai/web-components`).
+ *  - (Future) AI CFO upload surface — same action + selector contract.
+ */
+const extractPolicyDocumentEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(cardPolicyReducer_1.extractPolicyDocument.match), 
+// `switchMap` (vs `mergeMap`) cancels any in-flight extract whenever a
+// new upload is dispatched. With `mergeMap` an older, slower response
+// could win the race: `updatePolicyDocumentExtractionSuccess` would
+// fire with stale `extractedRules` and the chained bridge epic would
+// pair them with whatever `aiCfoAnswerId` / `aiCfoChatSessionId` are
+// currently in state — recommending the old file's rules against the
+// wrong AI CFO answer.
+(0, operators_1.switchMap)((action) => {
+    const formData = buildPolicyDocumentFormData(action.payload.files);
+    return zeniAPI
+        .postFormData(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-documents/extract`, formData)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessStatus)(response) &&
+            response.data != null &&
+            response.data.extracted_rules != null) {
+            return (0, rxjs_1.of)((0, cardPolicyReducer_1.updatePolicyDocumentExtractionSuccess)(response.data.extracted_rules));
+        }
+        return (0, rxjs_1.of)((0, cardPolicyReducer_1.updatePolicyDocumentExtractionFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, cardPolicyReducer_1.updatePolicyDocumentExtractionFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Extract card-policy document REST API call errored out' +
+        JSON.stringify(error))))), 
+    // `clearPolicyDocumentExtraction` (e.g. user clicks the "× Policy.pdf"
+    // pill) tears down the in-flight extract subscription, so a late
+    // response can't re-flip `policyDocumentExtraction.fetchState` back
+    // to `Completed` or repopulate `extractedRules` after the user
+    // already dismissed the upload.
+    (0, operators_1.takeUntil)(actions$.pipe((0, operators_1.filter)(cardPolicyReducer_1.clearPolicyDocumentExtraction.match))));
+}));
+exports.extractPolicyDocumentEpic = extractPolicyDocumentEpic;

package/lib/entity/cardPolicy/fetchCardPolicyVendorOptionsEpic.d.ts

@@ -0,0 +1,26 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { fetchCardPolicyVendorOptions, updateCardPolicyVendorOptions, updateCardPolicyVendorOptionsFailure } from './cardPolicyReducer';
+export type ActionType = ReturnType<typeof fetchCardPolicyVendorOptions> | ReturnType<typeof updateCardPolicyVendorOptions> | ReturnType<typeof updateCardPolicyVendorOptionsFailure>;
+/**
+ * Card-policy vendor search.
+ *
+ * Listens for `fetchCardPolicyVendorOptions` and hits the same
+ * `/accounting/1.0/vendors` endpoint the Vendors-tab uses, but writes
+ * results onto the dedicated `cardPolicyState.vendorSearch` slice — no
+ * fan-out to the global `vendor` / `account` / `class` / `vendorList`
+ * entities. That isolation is important: the user may be configuring a
+ * card policy in parallel with browsing the Vendors tab, and we don't
+ * want either flow to clobber the other's list state.
+ *
+ * Uses `switchMap` so the latest typed search wins — earlier in-flight
+ * requests are abandoned, which is the right semantics for a
+ * search-as-you-type UX.
+ *
+ * Consumers:
+ *  - Manual `CardPolicyCreate / EditScreen`
+ *  - AI CFO `CardPolicyInteractiveForm` (vendor step)
+ */
+export declare const fetchCardPolicyVendorOptionsEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/entity/cardPolicy/fetchCardPolicyVendorOptionsEpic.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCardPolicyVendorOptionsEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../responsePayload");
+const cardPolicyReducer_1 = require("./cardPolicyReducer");
+const buildQuery = (searchString) => ({
+    view: 'vendor_list',
+    page_token: null,
+    sort_by: 'year_to_date_spend',
+    sort_order: 'desc',
+    search_text: searchString,
+    vendor_name: searchString,
+});
+/**
+ * Card-policy vendor search.
+ *
+ * Listens for `fetchCardPolicyVendorOptions` and hits the same
+ * `/accounting/1.0/vendors` endpoint the Vendors-tab uses, but writes
+ * results onto the dedicated `cardPolicyState.vendorSearch` slice — no
+ * fan-out to the global `vendor` / `account` / `class` / `vendorList`
+ * entities. That isolation is important: the user may be configuring a
+ * card policy in parallel with browsing the Vendors tab, and we don't
+ * want either flow to clobber the other's list state.
+ *
+ * Uses `switchMap` so the latest typed search wins — earlier in-flight
+ * requests are abandoned, which is the right semantics for a
+ * search-as-you-type UX.
+ *
+ * Consumers:
+ *  - Manual `CardPolicyCreate / EditScreen`
+ *  - AI CFO `CardPolicyInteractiveForm` (vendor step)
+ */
+const fetchCardPolicyVendorOptionsEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(cardPolicyReducer_1.fetchCardPolicyVendorOptions.match), (0, operators_1.switchMap)((action) => {
+    const query = buildQuery(action.payload.searchString);
+    const apiUrl = `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/vendors` +
+        `?query=${encodeURIComponent(JSON.stringify(query))}`;
+    return zeniAPI.getJSON(apiUrl).pipe((0, operators_1.switchMap)((response) => {
+        if ((0, responsePayload_1.isSuccessStatus)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, cardPolicyReducer_1.updateCardPolicyVendorOptions)(response.data));
+        }
+        return (0, rxjs_1.of)((0, cardPolicyReducer_1.updateCardPolicyVendorOptionsFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, cardPolicyReducer_1.updateCardPolicyVendorOptionsFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch card policy vendor options REST API call errored out' +
+        JSON.stringify(error))))));
+}));
+exports.fetchCardPolicyVendorOptionsEpic = fetchCardPolicyVendorOptionsEpic;

package/lib/entity/cardPolicy/policyDocumentExtractionToRecommendationBridgeEpic.d.ts

@@ -0,0 +1,25 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { fetchCardPolicyRecommendationFromUpload, updatePolicyDocumentExtractionSuccess } from './cardPolicyReducer';
+export type ActionType = ReturnType<typeof updatePolicyDocumentExtractionSuccess> | ReturnType<typeof fetchCardPolicyRecommendationFromUpload>;
+/**
+ * Bridge epic — chains the AI CFO `upload`-mode flow's two API hops.
+ *
+ * The first hop (`extractPolicyDocument` → multipart POST to
+ * `policy-documents/extract`) lives on the cardPolicy slice and is
+ * shared with the manual `CardPolicyCreatePage`. The second hop
+ * (`fetchCardPolicyRecommendationFromUpload` → JSON POST to
+ * `ai-cfo/policy-recommendation-from-upload`) is AI-CFO only.
+ *
+ * The chain is gated on `policyDocumentExtraction.aiCfoAnswerId` being
+ * populated — manual callers leave it undefined, so the bridge is a
+ * silent no-op there.
+ *
+ * Splitting this off from `policyRecommendationFromUploadEpic` keeps
+ * the wizard component a pure renderer: it dispatches
+ * `extractPolicyDocument(files, answerId, chatSessionId)` once, then
+ * subscribes to `cardPolicyState` lifecycle flags to drive its
+ * "Extracting…" / "Recommending…" pill.
+ */
+export declare const policyDocumentExtractionToRecommendationBridgeEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

package/lib/entity/cardPolicy/policyDocumentExtractionToRecommendationBridgeEpic.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.policyDocumentExtractionToRecommendationBridgeEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const cardPolicyReducer_1 = require("./cardPolicyReducer");
+/**
+ * Bridge epic — chains the AI CFO `upload`-mode flow's two API hops.
+ *
+ * The first hop (`extractPolicyDocument` → multipart POST to
+ * `policy-documents/extract`) lives on the cardPolicy slice and is
+ * shared with the manual `CardPolicyCreatePage`. The second hop
+ * (`fetchCardPolicyRecommendationFromUpload` → JSON POST to
+ * `ai-cfo/policy-recommendation-from-upload`) is AI-CFO only.
+ *
+ * The chain is gated on `policyDocumentExtraction.aiCfoAnswerId` being
+ * populated — manual callers leave it undefined, so the bridge is a
+ * silent no-op there.
+ *
+ * Splitting this off from `policyRecommendationFromUploadEpic` keeps
+ * the wizard component a pure renderer: it dispatches
+ * `extractPolicyDocument(files, answerId, chatSessionId)` once, then
+ * subscribes to `cardPolicyState` lifecycle flags to drive its
+ * "Extracting…" / "Recommending…" pill.
+ */
+const policyDocumentExtractionToRecommendationBridgeEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(cardPolicyReducer_1.updatePolicyDocumentExtractionSuccess.match), (0, operators_1.mergeMap)((action) => {
+    const extraction = state$.value.cardPolicyState.policyDocumentExtraction;
+    const aiCfoAnswerId = extraction.aiCfoAnswerId;
+    const aiCfoChatSessionId = extraction.aiCfoChatSessionId;
+    const extractedRules = extraction.extractedRules;
+    if (aiCfoAnswerId == null ||
+        aiCfoChatSessionId == null ||
+        extractedRules == null) {
+        return rxjs_1.EMPTY;
+    }
+    void action;
+    return (0, rxjs_1.of)((0, cardPolicyReducer_1.fetchCardPolicyRecommendationFromUpload)(aiCfoAnswerId, aiCfoChatSessionId, extractedRules));
+}));
+exports.policyDocumentExtractionToRecommendationBridgeEpic = policyDocumentExtractionToRecommendationBridgeEpic;

package/lib/entity/cardPolicy/policyRecommendationFromUploadEpic.d.ts

@@ -0,0 +1,24 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { updateAiCardPolicyFormDraftFromUploadPlan } from '../../view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyReducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { updateAiCfoAnswerCardPolicyWizardPlan } from '../aiCfo/aiCfoReducer';
+import { clearPolicyDocumentExtraction, fetchCardPolicyRecommendationFromUpload, updatePolicyRecommendationFromUploadFailure, updatePolicyRecommendationFromUploadSuccess } from './cardPolicyReducer';
+export type ActionType = ReturnType<typeof fetchCardPolicyRecommendationFromUpload> | ReturnType<typeof updatePolicyRecommendationFromUploadSuccess> | ReturnType<typeof updatePolicyRecommendationFromUploadFailure> | ReturnType<typeof updateAiCfoAnswerCardPolicyWizardPlan> | ReturnType<typeof updateAiCardPolicyFormDraftFromUploadPlan> | ReturnType<typeof clearPolicyDocumentExtraction>;
+/**
+ * Listens for `fetchCardPolicyRecommendationFromUpload` and POSTs the
+ * just-extracted policy rules to the AI-CFO recommendation endpoint.
+ *
+ * On success — dispatches BOTH:
+ *  - `updatePolicyRecommendationFromUploadSuccess` (flips the
+ *    cardPolicy slice's recommendation lifecycle to `Completed`), and
+ *  - `updateAiCfoAnswerCardPolicyWizardPlan` (patches the in-flight AI
+ *    CFO answer's `CardPolicyInitialData` so the wizard can advance from
+ *    Step 1 → Step 2 in the upload variant).
+ *
+ * The reducer payload originally captured at kickoff (`answerId` +
+ * `chatSessionId`) re-enters via the action so the patch can find the
+ * right answer to merge into.
+ */
+export declare const policyRecommendationFromUploadEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;