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

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

@@ -0,0 +1,277 @@
+import { ID } from '../../commonStateTypes/common';
+import { ZeniAPIResponse } from '../../responsePayload';
+import { CardPolicyStats, CardPolicyTemplate, CardPolicyTemplateEntityList, CardPolicyTemplateMode, CardPolicyTemplateSpendLimits, ExtractedCardPolicyRules, MccCategory } from './cardPolicyState';
+export interface MccCategoryPayload {
+    count: number;
+    mcc_codes: string[];
+    name: string;
+}
+/**
+ * Wire shape for `GET /cards/1.0/cards/mcc-codes`. Beyond the universe of
+ * MCC categories used to populate the category search dropdown, the
+ * endpoint also ships **suggested** allow / block merchants and categories
+ * that the chip-pickers seed into their cloud body before the user starts
+ * editing.
+ *
+ * Field spellings (`*_catagories`) preserve the BE wire format verbatim;
+ * the camelCase mapper below corrects to `Categories`.
+ */
+export interface CardPolicyMccCategoriesPayload {
+    categories: MccCategoryPayload[];
+    suggested_allow_catagories?: MccCategoryPayload[];
+    suggested_allow_merchants?: string[];
+    suggested_block_catagories?: MccCategoryPayload[];
+    suggested_block_merchants?: string[];
+}
+export type CardPolicyMccCategoriesResponse = ZeniAPIResponse<CardPolicyMccCategoriesPayload>;
+export declare const toMccCategory: (payload: MccCategoryPayload) => MccCategory;
+/**
+ * Vendor row returned by `/accounting/1.0/vendors`. The card-policy
+ * vendor search dropdown only needs `vendor_id` + `vendor_name`; we
+ * deliberately ignore the rest of the payload to keep this slice
+ * independent of the heavy `vendor` entity store.
+ */
+export interface CardPolicyVendorSearchVendorPayload {
+    vendor_id: string;
+    vendor_name: string;
+}
+export interface CardPolicyVendorSearchData {
+    vendors: CardPolicyVendorSearchVendorPayload[];
+}
+export type CardPolicyVendorSearchResponse = ZeniAPIResponse<CardPolicyVendorSearchData>;
+export interface CardPolicyVendorSearchOption {
+    name: string;
+    vendorId: string;
+}
+export declare const toCardPolicyVendorSearchOption: (payload: CardPolicyVendorSearchVendorPayload) => CardPolicyVendorSearchOption;
+interface CardPolicyTemplateEntityListPayload {
+    category_codes: string[];
+    merchant_names: string[];
+}
+interface CardPolicyTemplateSpendLimitsPayload {
+    transaction: number | null;
+}
+/**
+ * Per-template request shape. `POST /cards/1.0/policy-templates` now
+ * accepts a bulk wrapper (`CreateCardPolicyTemplatesRequest`); this
+ * interface describes a single entry inside the `templates` array.
+ *
+ * `PUT /cards/1.0/policy-templates/{id}` (update) still consumes this
+ * shape directly — see `UpdateCardPolicyTemplateRequest` below.
+ */
+export interface CreateCardPolicyTemplateRequest {
+    allowedEntity: CardPolicyTemplateEntityList;
+    applyToCards: ID[];
+    blockedEntity: CardPolicyTemplateEntityList;
+    description: string;
+    mode: CardPolicyTemplateMode;
+    name: string;
+    /**
+     * `null` indicates the require-receipt toggle is off (no threshold
+     * configured). The BE accepts `null` and treats it as "no requirement";
+     * `0` means the user explicitly entered zero with the toggle on.
+     */
+    requiredReceiptThreshold: number | null;
+    spendLimits: CardPolicyTemplateSpendLimits;
+}
+export interface CreateCardPolicyTemplateRequestBody {
+    allowed_entity: CardPolicyTemplateEntityListPayload;
+    apply_to_cards: ID[];
+    blocked_entity: CardPolicyTemplateEntityListPayload;
+    description: string;
+    mode: string;
+    name: string;
+    required_receipt_threshold: number | null;
+    spend_limits: CardPolicyTemplateSpendLimitsPayload;
+}
+/**
+ * Bulk request for `POST /cards/1.0/policy-templates`. The single-policy
+ * create flow wraps its one request in a length-1 `templates` array;
+ * future multi-policy submit (AI CFO review step) sends N entries in a
+ * single round-trip.
+ *
+ * `sourceChatSessionId` ties the submit back to an AI CFO chat session so
+ * the BE can attribute the created templates to it. Manual create-page
+ * callers omit it.
+ */
+export interface CreateCardPolicyTemplatesRequest {
+    templates: CreateCardPolicyTemplateRequest[];
+    sourceChatSessionId?: string;
+}
+export interface CreateCardPolicyTemplatesRequestBody {
+    templates: CreateCardPolicyTemplateRequestBody[];
+    source_chat_session_id?: string;
+}
+export interface CardPolicyTemplatePayload {
+    allowed_entity: CardPolicyTemplateEntityListPayload;
+    applied_cards: ID[];
+    blocked_entity: CardPolicyTemplateEntityListPayload;
+    cards_count: number;
+    category_restrictions: unknown[];
+    created_at: string;
+    created_by: ID;
+    description: string;
+    mode: string;
+    name: string;
+    required_receipt_threshold: number | null;
+    spend_limits: CardPolicyTemplateSpendLimitsPayload;
+    status: string;
+    template_id: ID;
+    tenant_id: ID;
+    updated_at: string;
+}
+/**
+ * Per-template response envelope. Still returned by `PUT /policy-templates/{id}`,
+ * `GET /policy-templates/{id}`, and (as the row payload) the list endpoint.
+ * Also nested inside `CreateCardPolicyTemplatesResponseData.templates_created`.
+ */
+export interface CreateCardPolicyTemplateResponseData {
+    cards_applied: number;
+    template: CardPolicyTemplatePayload;
+}
+export type CreateCardPolicyTemplateResponse = ZeniAPIResponse<CreateCardPolicyTemplateResponseData>;
+/**
+ * Per-item error returned by the bulk POST when one or more templates in
+ * the request fail validation / persistence. The exact field shape is
+ * **TBD** with the BE — `message` is the only guaranteed field today; the
+ * rest are best-effort placeholders that callers should not assume to be
+ * present.
+ *
+ * TODO: lock down the shape (`index`, `name`, `code`) once the BE
+ * documents it. See plan §"Open question to resolve with BE".
+ */
+export interface BulkCreateCardPolicyTemplateErrorPayload {
+    message: string;
+    code?: string;
+    index?: number;
+    name?: string;
+}
+/**
+ * Wire shape returned by the bulk `POST /cards/1.0/policy-templates`.
+ * Partial success is allowed — `templates_created` holds the successfully
+ * created rows (each in the same envelope as the single endpoint), and
+ * `errors` holds per-item failures for the rest. `status.message` follows
+ * the "N of M templates created" convention.
+ */
+export interface CreateCardPolicyTemplatesResponseData {
+    errors: BulkCreateCardPolicyTemplateErrorPayload[];
+    templates_created: CreateCardPolicyTemplateResponseData[];
+}
+export type CreateCardPolicyTemplatesResponse = ZeniAPIResponse<CreateCardPolicyTemplatesResponseData>;
+/**
+ * Camel-cased mirror of `BulkCreateCardPolicyTemplateErrorPayload` stored
+ * on the create-card-policy view slice so the UI can render a partial-success
+ * banner without re-touching the wire types.
+ */
+export interface BulkCreateCardPolicyTemplateError {
+    message: string;
+    code?: string;
+    index?: number;
+    name?: string;
+}
+export type UpdateCardPolicyTemplateRequest = CreateCardPolicyTemplateRequest;
+export type UpdateCardPolicyTemplateRequestBody = CreateCardPolicyTemplateRequestBody;
+export type UpdateCardPolicyTemplateResponseData = CreateCardPolicyTemplateResponseData;
+export type UpdateCardPolicyTemplateResponse = CreateCardPolicyTemplateResponse;
+export type CardPolicyDetailResponseData = CreateCardPolicyTemplateResponseData;
+export type CardPolicyDetailResponse = CreateCardPolicyTemplateResponse;
+/**
+ * Aggregate counters returned alongside the templates list. Stored on
+ * the entity slice (alongside `cardPolicyTemplateById`) so any list
+ * surface can read it without re-fetching.
+ */
+export interface CardPolicyStatsPayload {
+    active_policies: number;
+    total_cards: number;
+    total_templates: number;
+}
+/**
+ * Each list row is wrapped in the same `{cards_applied, template}`
+ * envelope the create endpoint returns. Only the `template` portion is
+ * stored on the entity slice; `cards_applied` is a one-shot summary
+ * carried over from create and not surfaced in the list state today.
+ */
+export interface CardPolicyListRowPayload {
+    data: CreateCardPolicyTemplateResponseData;
+}
+export interface ListCardPolicyTemplatesResponseData {
+    stats: CardPolicyStatsPayload;
+    templates: CardPolicyListRowPayload[];
+}
+export type ListCardPolicyTemplatesResponse = ZeniAPIResponse<ListCardPolicyTemplatesResponseData>;
+export declare const toCardPolicyStats: (payload: CardPolicyStatsPayload) => CardPolicyStats;
+export declare const toCardPolicyTemplateList: (data: ListCardPolicyTemplatesResponseData) => CardPolicyTemplate[];
+export declare const toCardPolicyTemplate: (payload: CardPolicyTemplatePayload) => CardPolicyTemplate;
+/**
+ * Re-shape a single camelCase create request into the snake_case wire
+ * body. Used by the bulk-create mapper to build each entry of the
+ * `templates` array, and directly by the update epic (PUT) since the
+ * update endpoint still consumes a single object.
+ */
+export declare const toCreateCardPolicyTemplateRequestBody: (request: CreateCardPolicyTemplateRequest) => CreateCardPolicyTemplateRequestBody;
+/**
+ * Re-shape a bulk create request into the snake_case wire body for
+ * `POST /cards/1.0/policy-templates`. Maps each entry through
+ * `toCreateCardPolicyTemplateRequestBody` and only emits
+ * `source_chat_session_id` when the camelCase counterpart is defined,
+ * so manual-create callers don't ship a stray `undefined` over the wire.
+ */
+export declare const toCreateCardPolicyTemplatesRequestBody: (request: CreateCardPolicyTemplatesRequest) => CreateCardPolicyTemplatesRequestBody;
+/**
+ * Map a single bulk-response error payload to its camelCased view shape.
+ * Defensive against missing optional fields (see `BulkCreateCardPolicyTemplateErrorPayload`
+ * docstring — the BE contract isn't fully locked yet).
+ */
+export declare const toBulkCreateCardPolicyTemplateError: (payload: BulkCreateCardPolicyTemplateErrorPayload) => BulkCreateCardPolicyTemplateError;
+export declare const toUpdateCardPolicyTemplateRequestBody: (request: CreateCardPolicyTemplateRequest) => CreateCardPolicyTemplateRequestBody;
+/**
+ * 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.
+ */
+export declare const toCardPolicyEditFormDraft: (template: CardPolicyTemplate) => CreateCardPolicyTemplateRequest;
+/**
+ * Wire shape returned by `POST /cards/1.0/policy-documents/extract`.
+ * The backend OCRs / parses an uploaded policy document (PDF, image, etc.)
+ * and returns a best-effort set of policy rules + a confidence score.
+ *
+ * Consumers (manual `CardPolicyCreatePage` + AI CFO `CardPolicyInteractiveForm`)
+ * use `toExtractedCardPolicyRules` to map this onto the camelCase FE shape
+ * and then feed the result through `applyExtractedPolicyRulesToFormValues`
+ * (`@zeniai/web-components`) to seed the RHF form.
+ */
+export interface ExtractedCardPolicyRulesPayload {
+    allowed_entity: CardPolicyTemplateEntityListPayload;
+    blocked_entity: CardPolicyTemplateEntityListPayload;
+    confidence_score: number;
+    policy_name: string;
+    required_receipt_threshold: number;
+    transaction_limit: number;
+}
+export interface PolicyDocumentExtractResponseData {
+    extracted_rules: ExtractedCardPolicyRulesPayload;
+    message: string;
+}
+export type PolicyDocumentExtractResponse = ZeniAPIResponse<PolicyDocumentExtractResponseData>;
+export declare const toExtractedCardPolicyRules: (payload: ExtractedCardPolicyRulesPayload) => ExtractedCardPolicyRules;
+/**
+ * Wire shape returned by `POST /cards/1.0/ai-cfo/policy-recommendation-from-upload`.
+ * Chained after `extractPolicyDocument` succeeds in the AI CFO `upload`
+ * flow: the FE forwards the just-returned `extracted_rules` and the BE
+ * synthesizes a wizard plan + upload source metadata.
+ *
+ * The response mirrors the same `mode`-discriminated envelope the
+ * controller API ships for `auto` / `guided`, but always with `mode:
+ * "upload"` and a populated `wizard_plan.step_5_review`. The FE merges
+ * the returned `wizard_plan` + `source` into the in-flight AI CFO
+ * answer's `CardPolicyInitialData` via
+ * `updateAiCfoAnswerCardPolicyWizardPlan`.
+ */
+export interface CardPolicyRecommendationFromUploadResponseData {
+    mode: 'upload';
+    source: import('../aiCfo/aiCfoPayload').CardPolicyUploadSourcePayload;
+    tenant_id: string;
+    wizard_plan: import('../aiCfo/aiCfoPayload').CardPolicyWizardPlanPayload;
+}
+export type CardPolicyRecommendationFromUploadResponse = ZeniAPIResponse<CardPolicyRecommendationFromUploadResponseData>;
+export {};

package/lib/entity/cardPolicy/cardPolicyPayload.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExtractedCardPolicyRules = exports.toCardPolicyEditFormDraft = exports.toUpdateCardPolicyTemplateRequestBody = exports.toBulkCreateCardPolicyTemplateError = exports.toCreateCardPolicyTemplatesRequestBody = 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.vendor_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 single camelCase create request into the snake_case wire
+ * body. Used by the bulk-create mapper to build each entry of the
+ * `templates` array, and directly by the update epic (PUT) since the
+ * update endpoint still consumes a single object.
+ */
+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;
+/**
+ * Re-shape a bulk create request into the snake_case wire body for
+ * `POST /cards/1.0/policy-templates`. Maps each entry through
+ * `toCreateCardPolicyTemplateRequestBody` and only emits
+ * `source_chat_session_id` when the camelCase counterpart is defined,
+ * so manual-create callers don't ship a stray `undefined` over the wire.
+ */
+const toCreateCardPolicyTemplatesRequestBody = (request) => {
+    const body = {
+        templates: request.templates.map(exports.toCreateCardPolicyTemplateRequestBody),
+    };
+    if (request.sourceChatSessionId != null) {
+        body.source_chat_session_id = request.sourceChatSessionId;
+    }
+    return body;
+};
+exports.toCreateCardPolicyTemplatesRequestBody = toCreateCardPolicyTemplatesRequestBody;
+/**
+ * Map a single bulk-response error payload to its camelCased view shape.
+ * Defensive against missing optional fields (see `BulkCreateCardPolicyTemplateErrorPayload`
+ * docstring — the BE contract isn't fully locked yet).
+ */
+const toBulkCreateCardPolicyTemplateError = (payload) => ({
+    message: payload.message,
+    code: payload.code,
+    index: payload.index,
+    name: payload.name,
+});
+exports.toBulkCreateCardPolicyTemplateError = toBulkCreateCardPolicyTemplateError;
+// Update body uses the exact same wire shape as create — the PUT
+// endpoint is a full replace and was not affected by the bulk migration.
+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,19 @@
+import { ZeniAPIStatus } from '../../responsePayload';
+import { CardPolicyMccCategoriesPayload, CardPolicyTemplatePayload, CardPolicyVendorSearchData, ExtractedCardPolicyRulesPayload } from './cardPolicyPayload';
+import { CardPolicyState, CardPolicyStats, CardPolicyTemplate, ExtractedCardPolicyRules } 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[], aiCfoAnswerId?: string | undefined, aiCfoChatSessionId?: string | undefined], {
+    files: File[];
+    aiCfoAnswerId: string | undefined;
+    aiCfoChatSessionId: string | undefined;
+}, "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">, fetchCardPolicyRecommendationFromUpload: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[answerId: string, chatSessionId: string, extractedRules: ExtractedCardPolicyRules], {
+    answerId: string;
+    chatSessionId: string;
+    extractedRules: ExtractedCardPolicyRules;
+}, "cardPolicy/fetchCardPolicyRecommendationFromUpload", never, never>, updatePolicyRecommendationFromUploadSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"cardPolicy/updatePolicyRecommendationFromUploadSuccess">, updatePolicyRecommendationFromUploadFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "cardPolicy/updatePolicyRecommendationFromUploadFailure">, 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,175 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCardPolicy = exports.updatePolicyRecommendationFromUploadFailure = exports.updatePolicyRecommendationFromUploadSuccess = exports.fetchCardPolicyRecommendationFromUpload = 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");
+// `buildVendorChipId(name)` calls `name.trim().toLowerCase()`; empty/whitespace names would crash or collapse into one colliding chip-id.
+const isUsableMerchantName = (name) => typeof name === 'string' && name.trim() !== '';
+const initialPolicyDocumentExtractionState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    extractedRules: undefined,
+    uploadedFileName: undefined,
+};
+const initialPolicyRecommendationFromUploadState = {
+    fetchState: 'Not-Started',
+    answerId: undefined,
+    chatSessionId: undefined,
+    error: undefined,
+};
+const initialVendorSearchState = {
+    fetchState: 'Not-Started',
+    searchString: '',
+    vendors: [],
+    error: undefined,
+};
+exports.initialState = {
+    cardPolicyTemplateById: {},
+    mccCategories: [],
+    mccCategoriesError: undefined,
+    mccCategoriesFetchState: 'Not-Started',
+    policyDocumentExtraction: initialPolicyDocumentExtractionState,
+    policyRecommendationFromUpload: initialPolicyRecommendationFromUploadState,
+    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);
+            // BE-suggested seeds pre-populate the chip cloud; `isUsableMerchantName` drops names that would break `buildVendorChipId`.
+            draft.suggestedAllowMerchants = (action.payload.suggested_allow_merchants ?? []).filter(isUsableMerchantName);
+            draft.suggestedBlockMerchants = (action.payload.suggested_block_merchants ?? []).filter(isUsableMerchantName);
+            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;
+        },
+        updateCreatedCardPolicyTemplate(draft, action) {
+            const template = (0, cardPolicyPayload_1.toCardPolicyTemplate)(action.payload);
+            draft.cardPolicyTemplateById[template.templateId] = template;
+        },
+        // Full replace so server-side deletes evict locally too; the view slice owns the ordered ID list.
+        updateCardPolicyTemplates(draft, action) {
+            const byId = {};
+            for (const template of action.payload) {
+                byId[template.templateId] = template;
+            }
+            draft.cardPolicyTemplateById = byId;
+        },
+        removeCardPolicyTemplate(draft, action) {
+            delete draft.cardPolicyTemplateById[action.payload];
+        },
+        updateCardPolicyStats(draft, action) {
+            draft.cardPolicyStats = action.payload;
+        },
+        // Captures the first file name so the upload pill can render without callers retaining a File ref.
+        extractPolicyDocument: {
+            reducer(draft, action) {
+                draft.policyDocumentExtraction.fetchState = 'In-Progress';
+                draft.policyDocumentExtraction.error = undefined;
+                draft.policyDocumentExtraction.extractedRules = undefined;
+                draft.policyDocumentExtraction.uploadedFileName =
+                    action.meta.uploadedFileName;
+                draft.policyDocumentExtraction.aiCfoAnswerId =
+                    action.payload.aiCfoAnswerId;
+                draft.policyDocumentExtraction.aiCfoChatSessionId =
+                    action.payload.aiCfoChatSessionId;
+                // Extraction + recommendation model one upload lifecycle; reset together so a re-upload doesn't read stale lifecycle from the prior chain.
+                draft.policyRecommendationFromUpload = {
+                    ...initialPolicyRecommendationFromUploadState,
+                };
+            },
+            prepare(files, aiCfoAnswerId, aiCfoChatSessionId) {
+                return {
+                    payload: { files, aiCfoAnswerId, aiCfoChatSessionId },
+                    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,
+            };
+            // Pair with extractPolicyDocument: the two sub-slices reset and advance together.
+            draft.policyRecommendationFromUpload = {
+                ...initialPolicyRecommendationFromUploadState,
+            };
+        },
+        // Chained after extractPolicyDocument; epic merges the returned wizard plan into the AI CFO answer identified by answerId + chatSessionId.
+        fetchCardPolicyRecommendationFromUpload: {
+            reducer(draft, action) {
+                draft.policyRecommendationFromUpload.fetchState = 'In-Progress';
+                draft.policyRecommendationFromUpload.answerId = action.payload.answerId;
+                draft.policyRecommendationFromUpload.chatSessionId =
+                    action.payload.chatSessionId;
+                draft.policyRecommendationFromUpload.error = undefined;
+            },
+            prepare(answerId, chatSessionId, extractedRules) {
+                return { payload: { answerId, chatSessionId, extractedRules } };
+            },
+        },
+        updatePolicyRecommendationFromUploadSuccess(draft) {
+            draft.policyRecommendationFromUpload.fetchState = 'Completed';
+            draft.policyRecommendationFromUpload.error = undefined;
+        },
+        updatePolicyRecommendationFromUploadFailure(draft, action) {
+            draft.policyRecommendationFromUpload.fetchState = 'Error';
+            draft.policyRecommendationFromUpload.error = action.payload;
+        },
+        // Empty searchString = top vendors by YTD spend; non-empty filters server-side.
+        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) {
+            // Same `buildVendorChipId` guard as the suggested-merchants seeds above.
+            draft.vendorSearch.vendors = (action.payload.vendors ?? [])
+                .map(cardPolicyPayload_1.toCardPolicyVendorSearchOption)
+                .filter((vendor) => isUsableMerchantName(vendor.name));
+            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.fetchCardPolicyRecommendationFromUpload = _a.fetchCardPolicyRecommendationFromUpload, exports.updatePolicyRecommendationFromUploadSuccess = _a.updatePolicyRecommendationFromUploadSuccess, exports.updatePolicyRecommendationFromUploadFailure = _a.updatePolicyRecommendationFromUploadFailure, exports.clearCardPolicy = _a.clearCardPolicy;
+exports.default = cardPolicy.reducer;

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

@@ -0,0 +1,32 @@
+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 getPolicyRecommendationFromUploadFetchState(state: CardPolicyState): FetchState;
+export declare function getPolicyRecommendationFromUploadError(state: CardPolicyState): ZeniAPIStatus | undefined;
+export declare function getPolicyRecommendationFromUploadAnswerId(state: CardPolicyState): ID | undefined;
+export declare function getPolicyRecommendationFromUploadChatSessionId(state: CardPolicyState): ID | 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;