@zeniai/client-epic-state 5.0.65-betaML1 → 5.0.65-betaRR1

package/lib/entity/cardPolicy/cardPolicyPayload.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExtractedCardPolicyRules = exports.toCardPolicyEditFormDraft = exports.toUpdateCardPolicyTemplateRequestBody = exports.toCreateCardPolicyTemplateRequestBody = exports.toCardPolicyTemplate = exports.toCardPolicyTemplateList = exports.toCardPolicyStats = exports.toCardPolicyVendorSearchOption = exports.toMccCategory = void 0;
+const zeniDayJS_1 = require("../../zeniDayJS");
+const cardPolicyState_1 = require("./cardPolicyState");
+const toMccCategory = (payload) => ({
+    count: payload.count,
+    mccCodes: payload.mcc_codes ?? [],
+    name: payload.name,
+});
+exports.toMccCategory = toMccCategory;
+const toCardPolicyVendorSearchOption = (payload) => ({
+    vendorId: payload.vendor_id,
+    name: payload.name,
+});
+exports.toCardPolicyVendorSearchOption = toCardPolicyVendorSearchOption;
+const toCardPolicyStats = (payload) => ({
+    activePolicies: payload.active_policies,
+    totalCards: payload.total_cards,
+    totalTemplates: payload.total_templates,
+});
+exports.toCardPolicyStats = toCardPolicyStats;
+const toCardPolicyTemplateList = (data) => (data.templates ?? []).map((row) => (0, exports.toCardPolicyTemplate)(row.data.template));
+exports.toCardPolicyTemplateList = toCardPolicyTemplateList;
+const toCardPolicyTemplateEntityList = (payload) => ({
+    categoryCodes: payload.category_codes ?? [],
+    merchantNames: payload.merchant_names ?? [],
+});
+const toCardPolicyTemplate = (payload) => ({
+    allowedEntity: toCardPolicyTemplateEntityList(payload.allowed_entity),
+    appliedCards: payload.applied_cards ?? [],
+    blockedEntity: toCardPolicyTemplateEntityList(payload.blocked_entity),
+    cardsCount: payload.cards_count,
+    categoryRestrictions: payload.category_restrictions ?? [],
+    createdAt: (0, zeniDayJS_1.date)(payload.created_at),
+    createdBy: payload.created_by,
+    description: payload.description,
+    mode: (0, cardPolicyState_1.toCardPolicyTemplateMode)(payload.mode),
+    name: payload.name,
+    requiredReceiptThreshold: payload.required_receipt_threshold,
+    spendLimits: {
+        transaction: payload.spend_limits.transaction,
+    },
+    status: (0, cardPolicyState_1.toCardPolicyTemplateStatus)(payload.status),
+    templateId: payload.template_id,
+    tenantId: payload.tenant_id,
+    updatedAt: (0, zeniDayJS_1.date)(payload.updated_at),
+});
+exports.toCardPolicyTemplate = toCardPolicyTemplate;
+/**
+ * Re-shape a camelCase create request into the snake_case wire body.
+ * Used by the epic at request time.
+ */
+const toCreateCardPolicyTemplateRequestBody = (request) => ({
+    allowed_entity: {
+        category_codes: request.allowedEntity.categoryCodes,
+        merchant_names: request.allowedEntity.merchantNames,
+    },
+    apply_to_cards: request.applyToCards,
+    blocked_entity: {
+        category_codes: request.blockedEntity.categoryCodes,
+        merchant_names: request.blockedEntity.merchantNames,
+    },
+    description: request.description,
+    mode: request.mode ?? 'strict',
+    name: request.name,
+    required_receipt_threshold: request.requiredReceiptThreshold,
+    spend_limits: {
+        transaction: request.spendLimits.transaction,
+    },
+});
+exports.toCreateCardPolicyTemplateRequestBody = toCreateCardPolicyTemplateRequestBody;
+// Update body uses the exact same wire shape as create — the PUT
+// endpoint is a full replace.
+exports.toUpdateCardPolicyTemplateRequestBody = exports.toCreateCardPolicyTemplateRequestBody;
+/**
+ * Seed an edit-form draft (`CreateCardPolicyTemplateRequest`) from an
+ * existing camelCased `CardPolicyTemplate`. Used by the detail-fetch
+ * epic so the edit page can render with the saved values pre-populated.
+ */
+const toCardPolicyEditFormDraft = (template) => ({
+    allowedEntity: {
+        categoryCodes: [...template.allowedEntity.categoryCodes],
+        merchantNames: [...template.allowedEntity.merchantNames],
+    },
+    applyToCards: [...template.appliedCards],
+    blockedEntity: {
+        categoryCodes: [...template.blockedEntity.categoryCodes],
+        merchantNames: [...template.blockedEntity.merchantNames],
+    },
+    description: template.description,
+    mode: template.mode,
+    name: template.name,
+    requiredReceiptThreshold: template.requiredReceiptThreshold,
+    spendLimits: { transaction: template.spendLimits.transaction },
+});
+exports.toCardPolicyEditFormDraft = toCardPolicyEditFormDraft;
+const toExtractedCardPolicyRules = (payload) => ({
+    allowedEntity: {
+        categoryCodes: payload.allowed_entity?.category_codes ?? [],
+        merchantNames: payload.allowed_entity?.merchant_names ?? [],
+    },
+    blockedEntity: {
+        categoryCodes: payload.blocked_entity?.category_codes ?? [],
+        merchantNames: payload.blocked_entity?.merchant_names ?? [],
+    },
+    confidenceScore: payload.confidence_score,
+    policyName: payload.policy_name,
+    requiredReceiptThreshold: payload.required_receipt_threshold,
+    transactionLimit: payload.transaction_limit,
+});
+exports.toExtractedCardPolicyRules = toExtractedCardPolicyRules;

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

@@ -0,0 +1,13 @@
+import { ZeniAPIStatus } from '../../responsePayload';
+import { CardPolicyMccCategoriesPayload, CardPolicyTemplatePayload, CardPolicyVendorSearchData, ExtractedCardPolicyRulesPayload } from './cardPolicyPayload';
+import { CardPolicyState, CardPolicyStats, CardPolicyTemplate } from './cardPolicyState';
+export declare const initialState: CardPolicyState;
+export declare const fetchCardPolicyMccCategories: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cardPolicy/fetchCardPolicyMccCategories">, fetchCardPolicyVendorOptions: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[searchString?: string | undefined], {
+    searchString: string;
+}, "cardPolicy/fetchCardPolicyVendorOptions", never, never>, updateCardPolicyMccCategories: import("@reduxjs/toolkit").ActionCreatorWithPayload<CardPolicyMccCategoriesPayload, "cardPolicy/updateCardPolicyMccCategories">, updateCardPolicyMccCategoriesFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "cardPolicy/updateCardPolicyMccCategoriesFailure">, updateCardPolicyVendorOptions: import("@reduxjs/toolkit").ActionCreatorWithPayload<CardPolicyVendorSearchData, "cardPolicy/updateCardPolicyVendorOptions">, updateCardPolicyVendorOptionsFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "cardPolicy/updateCardPolicyVendorOptionsFailure">, updateCreatedCardPolicyTemplate: import("@reduxjs/toolkit").ActionCreatorWithPayload<CardPolicyTemplatePayload, "cardPolicy/updateCreatedCardPolicyTemplate">, updateCardPolicyTemplates: import("@reduxjs/toolkit").ActionCreatorWithPayload<CardPolicyTemplate[], "cardPolicy/updateCardPolicyTemplates">, removeCardPolicyTemplate: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "cardPolicy/removeCardPolicyTemplate">, updateCardPolicyStats: import("@reduxjs/toolkit").ActionCreatorWithPayload<CardPolicyStats, "cardPolicy/updateCardPolicyStats">, extractPolicyDocument: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[files: File[]], {
+    files: File[];
+}, "cardPolicy/extractPolicyDocument", never, {
+    uploadedFileName: string;
+}>, updatePolicyDocumentExtractionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<ExtractedCardPolicyRulesPayload, "cardPolicy/updatePolicyDocumentExtractionSuccess">, updatePolicyDocumentExtractionFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "cardPolicy/updatePolicyDocumentExtractionFailure">, clearPolicyDocumentExtraction: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cardPolicy/clearPolicyDocumentExtraction">, clearCardPolicy: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cardPolicy/clearCardPolicy">;
+declare const _default: import("redux").Reducer<CardPolicyState>;
+export default _default;

package/lib/entity/cardPolicy/cardPolicyReducer.js

@@ -0,0 +1,184 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCardPolicy = exports.clearPolicyDocumentExtraction = exports.updatePolicyDocumentExtractionFailure = exports.updatePolicyDocumentExtractionSuccess = exports.extractPolicyDocument = exports.updateCardPolicyStats = exports.removeCardPolicyTemplate = exports.updateCardPolicyTemplates = exports.updateCreatedCardPolicyTemplate = exports.updateCardPolicyVendorOptionsFailure = exports.updateCardPolicyVendorOptions = exports.updateCardPolicyMccCategoriesFailure = exports.updateCardPolicyMccCategories = exports.fetchCardPolicyVendorOptions = exports.fetchCardPolicyMccCategories = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const cardPolicyPayload_1 = require("./cardPolicyPayload");
+const initialPolicyDocumentExtractionState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    extractedRules: undefined,
+    uploadedFileName: undefined,
+};
+const initialVendorSearchState = {
+    fetchState: 'Not-Started',
+    searchString: '',
+    vendors: [],
+    error: undefined,
+};
+exports.initialState = {
+    cardPolicyTemplateById: {},
+    mccCategories: [],
+    mccCategoriesError: undefined,
+    mccCategoriesFetchState: 'Not-Started',
+    policyDocumentExtraction: initialPolicyDocumentExtractionState,
+    suggestedAllowCategories: [],
+    suggestedAllowMerchants: [],
+    suggestedBlockCategories: [],
+    suggestedBlockMerchants: [],
+    vendorSearch: initialVendorSearchState,
+    cardPolicyStats: undefined,
+};
+const cardPolicy = (0, toolkit_1.createSlice)({
+    name: 'cardPolicy',
+    initialState: exports.initialState,
+    reducers: {
+        fetchCardPolicyMccCategories(draft) {
+            draft.mccCategoriesFetchState = 'In-Progress';
+            draft.mccCategoriesError = undefined;
+        },
+        updateCardPolicyMccCategories(draft, action) {
+            draft.mccCategories = (action.payload.categories ?? []).map(cardPolicyPayload_1.toMccCategory);
+            // Persist BE-suggested allow / block seeds alongside the universe.
+            // Both flows (manual create page + AI CFO interactive form) read
+            // these to pre-populate the chip cloud body before the user edits.
+            draft.suggestedAllowMerchants =
+                action.payload.suggested_allow_merchants ?? [];
+            draft.suggestedBlockMerchants =
+                action.payload.suggested_block_merchants ?? [];
+            draft.suggestedAllowCategories = (action.payload.suggested_allow_catagories ?? []).map(cardPolicyPayload_1.toMccCategory);
+            draft.suggestedBlockCategories = (action.payload.suggested_block_catagories ?? []).map(cardPolicyPayload_1.toMccCategory);
+            draft.mccCategoriesFetchState = 'Completed';
+            draft.mccCategoriesError = undefined;
+        },
+        updateCardPolicyMccCategoriesFailure(draft, action) {
+            draft.mccCategoriesFetchState = 'Error';
+            draft.mccCategoriesError = action.payload;
+        },
+        /**
+         * Store a newly-created (or refreshed) card-policy template keyed by
+         * `templateId`. Dispatched by the create / list / get epics; consumed
+         * by both manual and AI-CFO policy flows via `getCardPolicyTemplateById`.
+         */
+        updateCreatedCardPolicyTemplate(draft, action) {
+            const template = (0, cardPolicyPayload_1.toCardPolicyTemplate)(action.payload);
+            draft.cardPolicyTemplateById[template.templateId] = template;
+        },
+        /**
+         * Replace the entity store's `cardPolicyTemplateById` map with the
+         * full list returned by the templates-list endpoint. Full replace is
+         * intentional — templates that no longer exist on the server should be
+         * dropped from local state too. The view slice keeps the server-order
+         * ID list separately for stable list rendering.
+         */
+        updateCardPolicyTemplates(draft, action) {
+            const byId = {};
+            for (const template of action.payload) {
+                byId[template.templateId] = template;
+            }
+            draft.cardPolicyTemplateById = byId;
+        },
+        /**
+         * Drop a single template from the entity map. Dispatched by the
+         * archive (DELETE) epic on success; also usable by any future flow
+         * that needs to evict a template (e.g. AI-CFO rejection).
+         */
+        removeCardPolicyTemplate(draft, action) {
+            delete draft.cardPolicyTemplateById[action.payload];
+        },
+        /**
+         * Replace the tenant-wide policy stats. Dispatched alongside
+         * `updateCardPolicyTemplates` from the list epic, but lives on the
+         * entity slice so any consumer can read it without re-fetching the
+         * list.
+         */
+        updateCardPolicyStats(draft, action) {
+            draft.cardPolicyStats = action.payload;
+        },
+        /**
+         * Kick off the `POST /cards/1.0/policy-documents/extract` request.
+         *
+         * Synchronously flips the sub-slice to `In-Progress` and captures the
+         * first uploaded file's name (used by the manual `CardPolicyCreatePage`
+         * to render the "Policy.pdf ×" pill once the request completes) so
+         * downstream callers don't have to keep their own file refs.
+         *
+         * The accompanying `extractPolicyDocumentEpic` listens for this action,
+         * POSTs multipart form-data to the cards micro-service, and dispatches
+         * either `updatePolicyDocumentExtractionSuccess` or
+         * `updatePolicyDocumentExtractionFailure`.
+         *
+         * Designed to be dispatched from both the manual create page and a
+         * future AI CFO composer/upload surface — selectors return a single
+         * source of truth.
+         */
+        extractPolicyDocument: {
+            reducer(draft, action) {
+                draft.policyDocumentExtraction.fetchState = 'In-Progress';
+                draft.policyDocumentExtraction.error = undefined;
+                draft.policyDocumentExtraction.extractedRules = undefined;
+                draft.policyDocumentExtraction.uploadedFileName =
+                    action.meta.uploadedFileName;
+            },
+            prepare(files) {
+                return {
+                    payload: { files },
+                    meta: { uploadedFileName: files[0]?.name },
+                };
+            },
+        },
+        updatePolicyDocumentExtractionSuccess(draft, action) {
+            draft.policyDocumentExtraction.fetchState = 'Completed';
+            draft.policyDocumentExtraction.error = undefined;
+            draft.policyDocumentExtraction.extractedRules =
+                (0, cardPolicyPayload_1.toExtractedCardPolicyRules)(action.payload);
+        },
+        updatePolicyDocumentExtractionFailure(draft, action) {
+            draft.policyDocumentExtraction.fetchState = 'Error';
+            draft.policyDocumentExtraction.error = action.payload;
+            draft.policyDocumentExtraction.extractedRules = undefined;
+        },
+        clearPolicyDocumentExtraction(draft) {
+            draft.policyDocumentExtraction = {
+                ...initialPolicyDocumentExtractionState,
+            };
+        },
+        /**
+         * Kick off `GET /accounting/1.0/vendors` (card-policy mode). When
+         * `searchString` is empty the BE returns the top vendors sorted by
+         * year-to-date spend; with a non-empty value it filters server-side.
+         *
+         * The accompanying `fetchCardPolicyVendorOptionsEpic` listens for
+         * this action, builds the `query` JSON (matching `fetchVendorsList`'s
+         * `view: "vendor_list"` shape) and dispatches success / failure.
+         *
+         * Designed to be dispatched from both the manual `CardPolicyCreate /
+         * EditScreen` (on mount + on every chip-picker keystroke, debounced)
+         * and the AI CFO interactive form's vendor step.
+         */
+        fetchCardPolicyVendorOptions: {
+            reducer(draft, action) {
+                draft.vendorSearch.fetchState = 'In-Progress';
+                draft.vendorSearch.searchString = action.payload.searchString;
+                draft.vendorSearch.error = undefined;
+            },
+            prepare(searchString) {
+                return { payload: { searchString: searchString ?? '' } };
+            },
+        },
+        updateCardPolicyVendorOptions(draft, action) {
+            draft.vendorSearch.vendors = (action.payload.vendors ?? []).map(cardPolicyPayload_1.toCardPolicyVendorSearchOption);
+            draft.vendorSearch.fetchState = 'Completed';
+            draft.vendorSearch.error = undefined;
+        },
+        updateCardPolicyVendorOptionsFailure(draft, action) {
+            draft.vendorSearch.fetchState = 'Error';
+            draft.vendorSearch.error = action.payload;
+        },
+        clearCardPolicy(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = cardPolicy.actions, exports.fetchCardPolicyMccCategories = _a.fetchCardPolicyMccCategories, exports.fetchCardPolicyVendorOptions = _a.fetchCardPolicyVendorOptions, exports.updateCardPolicyMccCategories = _a.updateCardPolicyMccCategories, exports.updateCardPolicyMccCategoriesFailure = _a.updateCardPolicyMccCategoriesFailure, exports.updateCardPolicyVendorOptions = _a.updateCardPolicyVendorOptions, exports.updateCardPolicyVendorOptionsFailure = _a.updateCardPolicyVendorOptionsFailure, exports.updateCreatedCardPolicyTemplate = _a.updateCreatedCardPolicyTemplate, exports.updateCardPolicyTemplates = _a.updateCardPolicyTemplates, exports.removeCardPolicyTemplate = _a.removeCardPolicyTemplate, exports.updateCardPolicyStats = _a.updateCardPolicyStats, exports.extractPolicyDocument = _a.extractPolicyDocument, exports.updatePolicyDocumentExtractionSuccess = _a.updatePolicyDocumentExtractionSuccess, exports.updatePolicyDocumentExtractionFailure = _a.updatePolicyDocumentExtractionFailure, exports.clearPolicyDocumentExtraction = _a.clearPolicyDocumentExtraction, exports.clearCardPolicy = _a.clearCardPolicy;
+exports.default = cardPolicy.reducer;

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

@@ -0,0 +1,28 @@
+import { FetchState, ID } from '../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { CardPolicyState, CardPolicyStats, CardPolicyTemplate, CardPolicyVendorSearchEntry, ExtractedCardPolicyRules, MccCategory } from './cardPolicyState';
+export declare function getCardPolicyMccCategories(state: CardPolicyState): MccCategory[];
+export declare function getCardPolicyMccCategoriesFetchState(state: CardPolicyState): FetchState;
+export declare function getCardPolicyMccCategoriesError(state: CardPolicyState): ZeniAPIStatus | undefined;
+export declare function getCardPolicyTemplateById(state: CardPolicyState, templateId: ID): CardPolicyTemplate | undefined;
+export declare function getAllCardPolicyTemplates(state: CardPolicyState): CardPolicyTemplate[];
+/**
+ * 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.
+ */
+export declare function getCardPolicyTemplatesByIds(state: CardPolicyState, templateIds: ID[]): CardPolicyTemplate[];
+export declare function getCardPolicyStats(state: CardPolicyState): CardPolicyStats | undefined;
+export declare function getPolicyDocumentExtractionFetchState(state: CardPolicyState): FetchState;
+export declare function getPolicyDocumentExtractionError(state: CardPolicyState): ZeniAPIStatus | undefined;
+export declare function getExtractedCardPolicyRules(state: CardPolicyState): ExtractedCardPolicyRules | undefined;
+export declare function getUploadedPolicyDocumentFileName(state: CardPolicyState): string | undefined;
+export declare function getCardPolicySuggestedAllowMerchants(state: CardPolicyState): string[];
+export declare function getCardPolicySuggestedBlockMerchants(state: CardPolicyState): string[];
+export declare function getCardPolicySuggestedAllowCategories(state: CardPolicyState): MccCategory[];
+export declare function getCardPolicySuggestedBlockCategories(state: CardPolicyState): MccCategory[];
+export declare function getCardPolicyVendorSearchOptions(state: CardPolicyState): CardPolicyVendorSearchEntry[];
+export declare function getCardPolicyVendorSearchFetchState(state: CardPolicyState): FetchState;
+export declare function getCardPolicyVendorSearchString(state: CardPolicyState): string;

package/lib/entity/cardPolicy/cardPolicySelector.js

@@ -0,0 +1,86 @@
+"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.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;
+}
+// ── Policy document extraction ───────────────────────────────────────
+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;
+}
+// ── Suggested allow / block seeds (shipped alongside MCC categories) ─
+function getCardPolicySuggestedAllowMerchants(state) {
+    return state.suggestedAllowMerchants;
+}
+function getCardPolicySuggestedBlockMerchants(state) {
+    return state.suggestedBlockMerchants;
+}
+function getCardPolicySuggestedAllowCategories(state) {
+    return state.suggestedAllowCategories;
+}
+function getCardPolicySuggestedBlockCategories(state) {
+    return state.suggestedBlockCategories;
+}
+// ── Vendor search dropdown ───────────────────────────────────────────
+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,162 @@
+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.
+ */
+export interface CardPolicyTemplateSpendLimits {
+    transaction: number;
+}
+/**
+ * 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;
+    requiredReceiptThreshold: number;
+    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;
+    error?: ZeniAPIStatus;
+    extractedRules?: ExtractedCardPolicyRules;
+    uploadedFileName?: string;
+}
+/**
+ * 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;
+    /**
+     * 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 { extractPolicyDocument, updatePolicyDocumentExtractionFailure, updatePolicyDocumentExtractionSuccess } from './cardPolicyReducer';
+export type ActionType = ReturnType<typeof extractPolicyDocument> | ReturnType<typeof updatePolicyDocumentExtractionSuccess> | ReturnType<typeof updatePolicyDocumentExtractionFailure>;
+/**
+ * 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>;