@mohasinac/appkit 4.58.0 → 4.60.0

package/dist/next/routing/route-map.js

@@ -289,6 +289,12 @@ export const DEFAULT_ROUTE_MAP = {
         ORDER_CANCEL: (id) => `/user/orders/${id}/cancel`,
         ORDER_TRACK: (id) => `/user/orders/${id}/track`,
         ORDER_RETURN: (id) => `/user/orders/${id}/return`,
+        /*
+         * The buyer's protection claim. Its own route rather than a tab on the
+         * order page: the form is a decision with a required account of what
+         * happened, and the order page is already the densest surface in the app.
+         */
+        ORDER_CLAIM: (id) => `/user/orders/${id}/claim`,
         ORDER_INVOICE: (id) => `/user/orders/${id}/invoice`,
         ORDER_PAYMENT: (id) => `/user/orders/${id}/payment`,
         NOTIFICATIONS: "/user/notifications",
@@ -427,6 +433,22 @@ export const DEFAULT_ROUTE_MAP = {
     ADMIN: {
         DASHBOARD: "/admin/dashboard",
         SHIPMENTS: "/admin/shipments",
+        INVENTORY: "/admin/inventory",
+        INVENTORY_BOXES: "/admin/inventory/boxes",
+        INVENTORY_BOX_DETAIL: (id) => `/admin/inventory/boxes/${id}`,
+        /*
+         * 🛑 Must sit BEFORE nothing and resolve independently of
+         * `INVENTORY_BOX_DETAIL` — `/admin/inventory/boxes/labels` and
+         * `/admin/inventory/boxes/{id}` share a segment, so Next's static-beats-
+         * dynamic precedence is what keeps `labels` from being read as a box id.
+         * That precedence is the framework's, not ours, but it means a box may
+         * never be registered with the code `labels`: its id would be
+         * `storagebox-labels`, so there is no collision in practice, and this note
+         * exists so nobody "fixes" the route by renaming it.
+         */
+        INVENTORY_BOX_LABELS: "/admin/inventory/boxes/labels",
+        INVENTORY_MOVEMENTS: "/admin/inventory/movements",
+        SHIPMENT_RECEIVE: (id) => `/admin/shipments/${id}/receive`,
         SHIPMENTS_NEW: "/admin/shipments/new",
         SHIPMENTS_EDIT: (id) => `/admin/shipments/${id}/edit`,
         SHIPMENT_LOT_ITEMS: (id, lotId) => `/admin/shipments/${id}/lots/${lotId}/items`,
@@ -524,6 +546,24 @@ export const DEFAULT_ROUTE_MAP = {
         PAYOUTS: "/admin/payouts",
         PAYOUT_DETAIL: (id) => `/admin/payouts/${id}/view`,
         AUDIT_LOG: "/admin/audit-log",
+        /*
+         * 🛑 MONEY_CASES is deliberately NOT under `/admin/maintenance/`.
+         *
+         * Maintenance means "something broke, look when you can" and is granted to
+         * `maintenance_employee`. A payment case can carry a gateway's own
+         * `respond_by`: miss it and the chargeback is lost by default whoever was
+         * right. Burying that beside Cloud Logs is how a deadline is missed, so it
+         * gets its own section and an admin-only permission.
+         *
+         * Gateway events and obligations DO belong under maintenance — they are
+         * diagnostics with no external clock, and the cases they produce are what
+         * carries urgency.
+         */
+        MONEY_CASES: "/admin/money-cases",
+        MONEY_CASE_DETAIL: (id) => `/admin/money-cases/${id}`,
+        PROTECTION_CLAIMS: "/admin/protection-claims",
+        MAINTENANCE_GATEWAY_EVENTS: "/admin/maintenance/gateway-events",
+        MAINTENANCE_OBLIGATIONS: "/admin/maintenance/obligations",
         EVENTS: "/admin/events",
         EVENTS_NEW: "/admin/events/new",
         EVENTS_EDIT: (id) => `/admin/events/${id}/edit`,

package/dist/providers/payment-manual/index.d.ts

@@ -16,7 +16,7 @@
  * `IPaymentProvider` generically rather than the order repository directly.
  */
 import { IPaymentProvider } from "../../contracts";
-import type { PaymentOrder, PaymentCapture, Refund } from "../../contracts";
+import type { PaymentOrder, PaymentCapture, Refund, Dispute, GatewayPaymentRecord } from "../../contracts";
 import type { JsonValue } from "../../schemas/types";
 export declare class ManualPaymentProvider extends IPaymentProvider {
     readonly name = "manual";
@@ -37,4 +37,18 @@ export declare class ManualPaymentProvider extends IPaymentProvider {
      */
     refund(paymentId: string, amount?: number): Promise<Refund>;
     getOrder(orderId: string): Promise<PaymentOrder>;
+    /**
+     * 🛑 `[]` here means "THIS PROVIDER CANNOT ANSWER", not "there are no
+     * payments" — and the difference decides whether a reconciler may conclude
+     * anything. A manual payment exists only as a row we wrote plus a proof the
+     * buyer uploaded; there is no external ledger to compare against, so the
+     * gateway-vs-us check is structurally inapplicable rather than clean.
+     *
+     * The caller is required to treat an empty list as no information (see the
+     * contract), which is why this is honest rather than a silent degrade.
+     */
+    listPayments(): Promise<GatewayPaymentRecord[]>;
+    getDispute(disputeId: string): Promise<Dispute>;
+    listDisputes(): Promise<Dispute[]>;
+    acceptDispute(disputeId: string, _confirmIrrevocable: true): Promise<Dispute>;
 }

package/dist/providers/payment-manual/index.js

@@ -88,4 +88,41 @@ export class ManualPaymentProvider extends IPaymentProvider {
         }
         return order;
     }
+    /*
+     * ── DISPUTES: THERE IS NO SUCH THING HERE ─────────────────────────────────
+     *
+     * A manual payment is a bank transfer or cash the buyer made outside the
+     * system, reconciled by an admin against an uploaded proof. There is no
+     * card network and no acquirer, so there is no chargeback mechanism to
+     * query — a buyer's complaint arrives as a support ticket or a grievance,
+     * which is a different (and human) path.
+     *
+     * 🛑 `listDisputes()` returning `[]` is therefore a FACT, not a silent
+     * degrade: "this provider cannot have chargebacks" is true. The single-
+     * dispute getters throw, because being ASKED for a specific dispute id on a
+     * provider that has none means the caller is confused, and answering a
+     * confident wrong thing is how a reconciler reports clean.
+     */
+    /**
+     * 🛑 `[]` here means "THIS PROVIDER CANNOT ANSWER", not "there are no
+     * payments" — and the difference decides whether a reconciler may conclude
+     * anything. A manual payment exists only as a row we wrote plus a proof the
+     * buyer uploaded; there is no external ledger to compare against, so the
+     * gateway-vs-us check is structurally inapplicable rather than clean.
+     *
+     * The caller is required to treat an empty list as no information (see the
+     * contract), which is why this is honest rather than a silent degrade.
+     */
+    async listPayments() {
+        return [];
+    }
+    async getDispute(disputeId) {
+        throw Object.assign(new Error(`Manual payments have no dispute mechanism — nothing can be fetched for ${disputeId}`), { httpStatus: 400 });
+    }
+    async listDisputes() {
+        return [];
+    }
+    async acceptDispute(disputeId, _confirmIrrevocable) {
+        throw Object.assign(new Error(`Manual payments have no dispute to accept (${disputeId})`), { httpStatus: 400 });
+    }
 }

package/dist/providers/payment-phonepe/index.d.ts

@@ -38,7 +38,7 @@
  */
 import type { JsonValue } from "@mohasinac/appkit";
 import { IPaymentProvider } from "../../contracts";
-import type { PaymentOrder, PaymentCapture, Refund } from "../../contracts";
+import type { PaymentOrder, PaymentCapture, Refund, Dispute, GatewayPaymentRecord } from "../../contracts";
 /**
  * PhonePe's `metaInfo` (udf1-udf5, ≤256 chars each) is the only channel that
  * survives from `createOrder()` through to BOTH the Order Status API AND the
@@ -114,4 +114,17 @@ export declare class PhonePeProvider extends IPaymentProvider {
      * than `capturePayment()` when confirming a payment.
      */
     getOrder(orderId: string): Promise<PaymentOrder>;
+    /**
+     * 🛑 `[]` because PhonePe's PG Checkout API is ORDER-keyed and exposes no
+     * "list my payments in a window" endpoint — not because there are none.
+     * Distinct from the manual provider's reason: there IS an external ledger
+     * here, we simply cannot read it in bulk. A reconciler must therefore not
+     * treat PhonePe as reconciled; it is unreconcilable with this API, which is
+     * a documented limitation rather than a gap being worked (PhonePe is dormant
+     * — Razorpay wins the provider tie-break).
+     */
+    listPayments(): Promise<GatewayPaymentRecord[]>;
+    getDispute(disputeId: string): Promise<Dispute>;
+    listDisputes(): Promise<Dispute[]>;
+    acceptDispute(disputeId: string, _confirmIrrevocable: true): Promise<Dispute>;
 }

package/dist/providers/payment-phonepe/index.js

@@ -218,4 +218,40 @@ export class PhonePeProvider extends IPaymentProvider {
             metadata: intent,
         };
     }
+    /*
+     * ── DISPUTES: NOT EXPOSED BY THIS GATEWAY'S API ───────────────────────────
+     *
+     * Distinct from the manual provider's reason, and the distinction matters.
+     * PhonePe transactions CAN be disputed — UPI has a chargeback process — but
+     * the PG Checkout API this adapter wraps exposes no dispute resource, so we
+     * have no way to read one. A PhonePe chargeback reaches us as an email or a
+     * dashboard notification, not as data.
+     *
+     * So `[]` here means "we cannot see them", not "they cannot exist", and that
+     * is worth saying out loud: a reconciler that treats an empty list as "no
+     * disputes outstanding" would be drawing a false conclusion on this gateway.
+     * PhonePe is currently dormant (Razorpay wins the provider tie-break), which
+     * is why this is a documented limitation rather than a gap being worked.
+     */
+    /**
+     * 🛑 `[]` because PhonePe's PG Checkout API is ORDER-keyed and exposes no
+     * "list my payments in a window" endpoint — not because there are none.
+     * Distinct from the manual provider's reason: there IS an external ledger
+     * here, we simply cannot read it in bulk. A reconciler must therefore not
+     * treat PhonePe as reconciled; it is unreconcilable with this API, which is
+     * a documented limitation rather than a gap being worked (PhonePe is dormant
+     * — Razorpay wins the provider tie-break).
+     */
+    async listPayments() {
+        return [];
+    }
+    async getDispute(disputeId) {
+        throw Object.assign(new Error(`PhonePe exposes no dispute API — cannot fetch ${disputeId}`), { httpStatus: 501 });
+    }
+    async listDisputes() {
+        return [];
+    }
+    async acceptDispute(disputeId, _confirmIrrevocable) {
+        throw Object.assign(new Error(`PhonePe exposes no dispute API — ${disputeId} must be handled in PhonePe's own dashboard`), { httpStatus: 501 });
+    }
 }

package/dist/providers/payment-razorpay/index.d.ts

@@ -52,7 +52,7 @@
  */
 import type { JsonValue } from "@mohasinac/appkit";
 import { IPaymentProvider } from "../../contracts";
-import type { PaymentOrder, PaymentCapture, Refund } from "../../contracts";
+import type { PaymentOrder, PaymentCapture, Refund, Dispute, GatewayPaymentRecord } from "../../contracts";
 export { verifyPaymentSignature, verifyWebhookSignature, type RazorpayPaymentResult, } from "./signature";
 export interface RazorpayConfig {
     /** Publishable key (`rzp_test_…` / `rzp_live_…`). Safe to expose to the browser. */
@@ -122,4 +122,47 @@ export declare class RazorpayProvider extends IPaymentProvider {
      * (see point 1 of the class comment).
      */
     getOrder(orderId: string): Promise<PaymentOrder>;
+    /**
+     * Typed STRUCTURALLY rather than against the SDK's `Disputes.RazorpayDispute`
+     * namespace type.
+     *
+     * Two reasons: the namespace is declared inside `types/disputes.d.ts` and is
+     * not part of the package's documented export surface, so importing it couples
+     * us to an internal; and naming only the fields we read makes the mapping
+     * auditable against the SDK by eye. Every field below was checked against the
+     * installed 2.9.8 declaration — `id`, `payment_id`, `amount`, `currency`,
+     * `amount_deducted`, `reason_code`, `respond_by`, `status`, `phase`,
+     * `created_at` — rather than recalled.
+     *
+     * `status` and `phase` are `string` in the SDK too, so nothing is lost by not
+     * importing it.
+     */
+    private toDispute;
+    /**
+     * Payments in a window, for reconciliation.
+     *
+     * 🛑 `from`/`to` are Unix timestamps in **SECONDS** and `count` is capped at
+     * **100 by the API** (verified in `RazorpayPaginationOptions`). The cap is
+     * NOT raised by asking: a caller wanting more must page with `skip`, and this
+     * method deliberately does not, because an unbounded page loop inside a 540 s
+     * function is how a reconciler turns into a timeout. At this project's volume
+     * one page is several days of payments; the count is logged so the day that
+     * stops being true is visible rather than silently truncating.
+     */
+    listPayments(opts: {
+        from: Date;
+        to: Date;
+        limit?: number;
+    }): Promise<GatewayPaymentRecord[]>;
+    getDispute(disputeId: string): Promise<Dispute>;
+    listDisputes(): Promise<Dispute[]>;
+    /**
+     * Accept liability — irreversible.
+     *
+     * `confirmIrrevocable` is required by the contract and is not read here, and
+     * that is the point: its job is to make the CALLER state intent at the call
+     * site. A runtime check would be theatre, since the type already makes
+     * `false` uncompilable.
+     */
+    acceptDispute(disputeId: string, _confirmIrrevocable: true): Promise<Dispute>;
 }

package/dist/providers/payment-razorpay/index.js

@@ -53,6 +53,7 @@
 import Razorpay from "razorpay";
 import { IPaymentProvider } from "../../contracts/index.js";
 import { getDefaultCurrency } from "../../core/baseline-resolver.js";
+import { paiseToRupees } from "../../core/money.js";
 import { verifyWebhookSignature } from "./signature.js";
 export { verifyPaymentSignature, verifyWebhookSignature, } from "./signature.js";
 /** Razorpay's own order status vocabulary → the contract's. */
@@ -229,4 +230,102 @@ export class RazorpayProvider extends IPaymentProvider {
             metadata: order.notes,
         };
     }
+    /*
+     * ── DISPUTES ──────────────────────────────────────────────────────────────
+     *
+     * Razorpay is the only registered provider that HAS disputes, so this is the
+     * only real implementation of the three.
+     *
+     * 🛑 Two unit conversions, both easy to get wrong and both silent when wrong:
+     *
+     *   amount / amount_deducted — currency SUBUNITS → decimal rupees.
+     *   respond_by / created_at  — Unix timestamp in SECONDS → Date.
+     *
+     * The second is the nastier one. `new Date(1761000000)` is 21 January 1970,
+     * so a missed `* 1000` does not throw and does not look like a unit bug — it
+     * looks like corrupt data, and on a dispute it would make a live `respondBy`
+     * deadline sort as 55 years overdue, which an escalation query would then
+     * either flood on or ignore. The existing `refund`/`getOrder` methods above
+     * already multiply, which is the precedent to copy.
+     */
+    /**
+     * Typed STRUCTURALLY rather than against the SDK's `Disputes.RazorpayDispute`
+     * namespace type.
+     *
+     * Two reasons: the namespace is declared inside `types/disputes.d.ts` and is
+     * not part of the package's documented export surface, so importing it couples
+     * us to an internal; and naming only the fields we read makes the mapping
+     * auditable against the SDK by eye. Every field below was checked against the
+     * installed 2.9.8 declaration — `id`, `payment_id`, `amount`, `currency`,
+     * `amount_deducted`, `reason_code`, `respond_by`, `status`, `phase`,
+     * `created_at` — rather than recalled.
+     *
+     * `status` and `phase` are `string` in the SDK too, so nothing is lost by not
+     * importing it.
+     */
+    toDispute(d) {
+        return {
+            id: String(d.id),
+            paymentId: String(d.payment_id),
+            amount: paiseToRupees(Number(d.amount)),
+            currency: String(d.currency),
+            amountDeducted: paiseToRupees(Number(d.amount_deducted ?? 0)),
+            reasonCode: String(d.reason_code ?? ""),
+            respondBy: new Date(Number(d.respond_by) * 1000),
+            status: String(d.status ?? ""),
+            phase: String(d.phase ?? ""),
+            createdAt: new Date(Number(d.created_at) * 1000),
+            gateway: this.name,
+        };
+    }
+    /**
+     * Payments in a window, for reconciliation.
+     *
+     * 🛑 `from`/`to` are Unix timestamps in **SECONDS** and `count` is capped at
+     * **100 by the API** (verified in `RazorpayPaginationOptions`). The cap is
+     * NOT raised by asking: a caller wanting more must page with `skip`, and this
+     * method deliberately does not, because an unbounded page loop inside a 540 s
+     * function is how a reconciler turns into a timeout. At this project's volume
+     * one page is several days of payments; the count is logged so the day that
+     * stops being true is visible rather than silently truncating.
+     */
+    async listPayments(opts) {
+        const result = await this.razorpay.payments.all({
+            from: Math.floor(opts.from.getTime() / 1000),
+            to: Math.ceil(opts.to.getTime() / 1000),
+            count: Math.min(opts.limit ?? 100, 100),
+        });
+        return (result.items ?? []).map((p) => {
+            const captured = Number(p.created_at);
+            return {
+                id: String(p.id),
+                ...(p.order_id ? { orderId: String(p.order_id) } : {}),
+                amount: paiseToRupees(Number(p.amount)),
+                currency: String(p.currency),
+                status: String(p.status),
+                amountRefunded: paiseToRupees(Number(p.amount_refunded ?? 0)),
+                ...(p.refund_status ? { refundStatus: String(p.refund_status) } : {}),
+                ...(Number.isFinite(captured) ? { capturedAt: new Date(captured * 1000) } : {}),
+                gateway: this.name,
+            };
+        });
+    }
+    async getDispute(disputeId) {
+        return this.toDispute(await this.razorpay.disputes.fetch(disputeId));
+    }
+    async listDisputes() {
+        const result = await this.razorpay.disputes.all();
+        return (result.items ?? []).map((d) => this.toDispute(d));
+    }
+    /**
+     * Accept liability — irreversible.
+     *
+     * `confirmIrrevocable` is required by the contract and is not read here, and
+     * that is the point: its job is to make the CALLER state intent at the call
+     * site. A runtime check would be theatre, since the type already makes
+     * `false` uncompilable.
+     */
+    async acceptDispute(disputeId, _confirmIrrevocable) {
+        return this.toDispute(await this.razorpay.disputes.accept(disputeId));
+    }
 }

package/dist/providers/shipping-shiprocket/index.d.ts

@@ -99,6 +99,24 @@ export declare class ShiprocketShippingProvider extends IShippingProvider {
     private call;
     /** Their order payload wants the address flattened across many keys. */
     private addressFields;
+    /**
+     * 🛑 WIRING A CALLER FOR THIS OWES ONE EXTRA WRITE: set
+     * `order.platformBookedShipment = true` in the same commit.
+     *
+     * That flag is the gate `isReimbursableShipment()`
+     * (`_internal/shared/shipping/quote.ts`) uses to decide whether a seller may
+     * be reimbursed for postage. It FAILS OPEN — absent means "the seller shipped
+     * it themselves", which is correct and deliberate, because a self-shipped
+     * parcel has no flag to set and a fail-closed gate would refuse every
+     * legitimate claim.
+     *
+     * Measured 2026-10-21: this method has **no callers**, and the flag has
+     * **no writers**. Those two facts cancel out — there are no platform-booked
+     * parcels, so nothing is wrongly reimbursed. Wire this without the flag and
+     * they stop cancelling out: the platform pays the courier here, then
+     * reimburses the seller for that same spend on approval. Postage paid twice,
+     * silently, because the gate has no way to know we booked it.
+     */
     createShipment(data: CreateShipmentInput): Promise<Shipment>;
     trackShipment(trackingId: string): Promise<TrackingInfo>;
     cancelShipment(shipmentId: string): Promise<void>;

package/dist/providers/shipping-shiprocket/index.js

@@ -249,6 +249,24 @@ export class ShiprocketShippingProvider extends IShippingProvider {
             [`${p}_phone`]: a.phone,
         };
     }
+    /**
+     * 🛑 WIRING A CALLER FOR THIS OWES ONE EXTRA WRITE: set
+     * `order.platformBookedShipment = true` in the same commit.
+     *
+     * That flag is the gate `isReimbursableShipment()`
+     * (`_internal/shared/shipping/quote.ts`) uses to decide whether a seller may
+     * be reimbursed for postage. It FAILS OPEN — absent means "the seller shipped
+     * it themselves", which is correct and deliberate, because a self-shipped
+     * parcel has no flag to set and a fail-closed gate would refuse every
+     * legitimate claim.
+     *
+     * Measured 2026-10-21: this method has **no callers**, and the flag has
+     * **no writers**. Those two facts cancel out — there are no platform-booked
+     * parcels, so nothing is wrongly reimbursed. Wire this without the flag and
+     * they stop cancelling out: the platform pays the courier here, then
+     * reimburses the seller for that same spend on approval. Postage paid twice,
+     * silently, because the gate has no way to know we booked it.
+     */
     async createShipment(data) {
         const body = {
             order_id: data.orderId,

package/dist/schemas/registry.d.ts

@@ -2122,11 +2122,11 @@ export declare const SCHEMAS: {
                 minAmount: import("zod").ZodEffects<import("zod").ZodNumber, number, number>;
                 discountValue: import("zod").ZodNumber;
             }, "strip", import("zod").ZodTypeAny, {
-                discountValue: number;
                 minAmount: number;
-            }, {
                 discountValue: number;
+            }, {
                 minAmount: number;
+                discountValue: number;
             }>, "many">>;
             usage: import("zod").ZodObject<{
                 totalLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -2265,8 +2265,8 @@ export declare const SCHEMAS: {
                 applicableCategories?: string[] | undefined;
             } | undefined;
             tiers?: {
-                discountValue: number;
                 minAmount: number;
+                discountValue: number;
             }[] | undefined;
         }, {
             code: string;
@@ -2323,8 +2323,8 @@ export declare const SCHEMAS: {
                 applicableCategories?: string[] | undefined;
             } | undefined;
             tiers?: {
-                discountValue: number;
                 minAmount: number;
+                discountValue: number;
             }[] | undefined;
         }>;
         readonly couponUsage: import("zod").ZodObject<{
@@ -2871,6 +2871,7 @@ export declare const SCHEMAS: {
                 amount: import("zod").ZodEffects<import("zod").ZodNumber, number, number>;
                 itemIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
                 reason: import("zod").ZodString;
+                reasonCode: import("zod").ZodOptional<import("zod").ZodString>;
                 refundedAt: import("zod").ZodUnion<[import("zod").ZodDate, import("zod").ZodString, import("zod").ZodObject<{
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
@@ -2879,7 +2880,12 @@ export declare const SCHEMAS: {
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, import("zod").ZodTypeAny, "passthrough">>]>;
                 refundedBy: import("zod").ZodString;
+                status: import("zod").ZodOptional<import("zod").ZodEnum<["reserved", "processed", "failed"]>>;
+                failureReason: import("zod").ZodOptional<import("zod").ZodString>;
+                gatewayRefundId: import("zod").ZodOptional<import("zod").ZodString>;
+                gateway: import("zod").ZodOptional<import("zod").ZodString>;
                 phonepeRefundId: import("zod").ZodOptional<import("zod").ZodString>;
+                razorpayRefundId: import("zod").ZodOptional<import("zod").ZodString>;
                 manualTransactionId: import("zod").ZodOptional<import("zod").ZodString>;
                 proofDocumentUrl: import("zod").ZodOptional<import("zod").ZodString>;
                 proofDocumentMimeType: import("zod").ZodOptional<import("zod").ZodString>;
@@ -2893,8 +2899,14 @@ export declare const SCHEMAS: {
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, import("zod").ZodTypeAny, "passthrough">;
                 refundedBy: string;
+                status?: "failed" | "processed" | "reserved" | undefined;
+                failureReason?: string | undefined;
+                gateway?: string | undefined;
                 itemIds?: string[] | undefined;
+                reasonCode?: string | undefined;
+                gatewayRefundId?: string | undefined;
                 phonepeRefundId?: string | undefined;
+                razorpayRefundId?: string | undefined;
                 manualTransactionId?: string | undefined;
                 proofDocumentUrl?: string | undefined;
                 proofDocumentMimeType?: string | undefined;
@@ -2908,8 +2920,14 @@ export declare const SCHEMAS: {
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, import("zod").ZodTypeAny, "passthrough">;
                 refundedBy: string;
+                status?: "failed" | "processed" | "reserved" | undefined;
+                failureReason?: string | undefined;
+                gateway?: string | undefined;
                 itemIds?: string[] | undefined;
+                reasonCode?: string | undefined;
+                gatewayRefundId?: string | undefined;
                 phonepeRefundId?: string | undefined;
+                razorpayRefundId?: string | undefined;
                 manualTransactionId?: string | undefined;
                 proofDocumentUrl?: string | undefined;
                 proofDocumentMimeType?: string | undefined;
@@ -3083,8 +3101,14 @@ export declare const SCHEMAS: {
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, import("zod").ZodTypeAny, "passthrough">;
                 refundedBy: string;
+                status?: "failed" | "processed" | "reserved" | undefined;
+                failureReason?: string | undefined;
+                gateway?: string | undefined;
                 itemIds?: string[] | undefined;
+                reasonCode?: string | undefined;
+                gatewayRefundId?: string | undefined;
                 phonepeRefundId?: string | undefined;
+                razorpayRefundId?: string | undefined;
                 manualTransactionId?: string | undefined;
                 proofDocumentUrl?: string | undefined;
                 proofDocumentMimeType?: string | undefined;
@@ -3231,8 +3255,14 @@ export declare const SCHEMAS: {
                     toDate: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodDate>;
                 }, import("zod").ZodTypeAny, "passthrough">;
                 refundedBy: string;
+                status?: "failed" | "processed" | "reserved" | undefined;
+                failureReason?: string | undefined;
+                gateway?: string | undefined;
                 itemIds?: string[] | undefined;
+                reasonCode?: string | undefined;
+                gatewayRefundId?: string | undefined;
                 phonepeRefundId?: string | undefined;
+                razorpayRefundId?: string | undefined;
                 manualTransactionId?: string | undefined;
                 proofDocumentUrl?: string | undefined;
                 proofDocumentMimeType?: string | undefined;
@@ -4593,6 +4623,7 @@ export declare const SCHEMAS: {
             seoTitle: import("zod").ZodOptional<import("zod").ZodString>;
             seoDescription: import("zod").ZodOptional<import("zod").ZodString>;
             barcodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            sku: import("zod").ZodOptional<import("zod").ZodString>;
             startingBid: import("zod").ZodOptional<import("zod").ZodNumber>;
             reservePrice: import("zod").ZodOptional<import("zod").ZodNumber>;
             buyNowPrice: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -4683,6 +4714,7 @@ export declare const SCHEMAS: {
             seoTitle: import("zod").ZodOptional<import("zod").ZodString>;
             seoDescription: import("zod").ZodOptional<import("zod").ZodString>;
             barcodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            sku: import("zod").ZodOptional<import("zod").ZodString>;
             startingBid: import("zod").ZodOptional<import("zod").ZodNumber>;
             reservePrice: import("zod").ZodOptional<import("zod").ZodNumber>;
             buyNowPrice: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -4773,6 +4805,7 @@ export declare const SCHEMAS: {
             seoTitle: import("zod").ZodOptional<import("zod").ZodString>;
             seoDescription: import("zod").ZodOptional<import("zod").ZodString>;
             barcodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            sku: import("zod").ZodOptional<import("zod").ZodString>;
             startingBid: import("zod").ZodOptional<import("zod").ZodNumber>;
             reservePrice: import("zod").ZodOptional<import("zod").ZodNumber>;
             buyNowPrice: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -5282,16 +5315,16 @@ export declare const SCHEMAS: {
             status: import("zod").ZodEnum<["under-review", "actioned", "dismissed"]>;
             resolution: import("zod").ZodOptional<import("zod").ZodString>;
         }, "strict", import("zod").ZodTypeAny, {
-            status: "dismissed" | "under-review" | "actioned";
+            status: "under-review" | "actioned" | "dismissed";
             resolution?: string | undefined;
         }, {
-            status: "dismissed" | "under-review" | "actioned";
+            status: "under-review" | "actioned" | "dismissed";
             resolution?: string | undefined;
         }>, {
-            status: "dismissed" | "under-review" | "actioned";
+            status: "under-review" | "actioned" | "dismissed";
             resolution?: string | undefined;
         }, {
-            status: "dismissed" | "under-review" | "actioned";
+            status: "under-review" | "actioned" | "dismissed";
             resolution?: string | undefined;
         }>;
         readonly reportCreate: import("zod").ZodObject<{
@@ -6044,7 +6077,7 @@ export declare const SCHEMAS: {
             phones: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
             upiIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
             emails: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-            scamType: import("zod").ZodString;
+            scamType: import("zod").ZodEffects<import("zod").ZodString, import("..").ScamType, string>;
             scamPlatform: import("zod").ZodString;
             amountLost: import("zod").ZodOptional<import("zod").ZodNumber>;
             itemInvolved: import("zod").ZodOptional<import("zod").ZodString>;
@@ -6054,7 +6087,7 @@ export declare const SCHEMAS: {
         }, "strip", import("zod").ZodTypeAny, {
             displayName: string;
             description: string;
-            scamType: string;
+            scamType: import("..").ScamType;
             scamPlatform: string;
             agreed: true;
             reportedByAnon?: boolean | undefined;
@@ -6078,7 +6111,7 @@ export declare const SCHEMAS: {
         }>, {
             displayName: string;
             description: string;
-            scamType: string;
+            scamType: import("..").ScamType;
             scamPlatform: string;
             agreed: true;
             reportedByAnon?: boolean | undefined;

package/dist/server-entry.d.ts

@@ -69,6 +69,8 @@ export { getCategoryForDetail, listRootCategories, listFeaturedCategories, listM
 export { getGroupedListingForDetail, getGroupedListingWithItems, listGroupedListings, listFeaturedGroupedListings, listSitemapGroupedListings, getGroupsForProduct, getGroupsWithItemsForProduct, GROUPED_LISTINGS_PAGE_SIZE, GROUPED_LISTINGS_FEATURED_LIMIT, GROUPED_LISTINGS_SITEMAP_LIMIT, buildGroupedListingMetadata, renderGroupedListingOg, type GroupedListingWithItems, type ListGroupedListingsParams, type SitemapGroupedListing, type GroupedListingMetadataOptions, } from "./_internal/server/features/grouped/index";
 export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceGatewayOrderAction, previewCheckoutPricing, resolveShippingCost, formatShippingAddress, CHECKOUT_DEFAULT_COMMISSIONS, CHECKOUT_PAYMENT_METHODS, type CreateCheckoutOrderInput, type VerifyAndPlaceGatewayOrderInput, type CheckoutOrderResult, type CheckoutPaymentMethod, type CheckoutPricingPreviewInput, type CheckoutPricingPreview, } from "./_internal/server/features/checkout/index";
 export { unitPriceFor, lineTotalFor, sumGroupGst, computePreOrderDepositAmount, type GroupGstSummary, type GstRateSlice, } from "./_internal/shared/checkout/order-math";
+export { computeGroupCouponDiscount, computeCartCouponDiscount, type GroupCouponDiscountResult, } from "./_internal/shared/checkout/coupon-discount";
+export { refundCapacity, refundableBase, committedRefundTotal, platformFeeWithheld, wouldBeFullRefund, MONEY_EPSILON, type RefundCapacity, type RefundableOrderLike, } from "./_internal/shared/checkout/refundable-base";
 export { processRefundAction, type ProcessRefundInput, } from "./_internal/server/features/refunds/actions";
 export { getSublistingCategoryForDetail } from "./_internal/server/features/sublisting-categories/index";
 export { getStoreForDetail, listStoreProductsInitial, listStoreAuctionsInitial, listStorePreOrdersInitial, listSitemapStores, STORES_PAGE_SIZE, STORES_PRODUCTS_PAGE_SIZE, STORES_SITEMAP_LIMIT, STORES_FEATURED_LIMIT, } from "./_internal/server/features/stores/index";

package/dist/server-entry.js

@@ -107,6 +107,33 @@ export { createCheckoutOrderAction, attachPaymentAction, verifyAndPlaceGatewayOr
 // order recorded none — with the verify-side mismatch guard omitting it too, so
 // the three were consistently wrong and the undercharge was undetectable.
 export { unitPriceFor, lineTotalFor, sumGroupGst, computePreOrderDepositAmount, } from "./_internal/shared/checkout/order-math.js";
+/*
+ * The coupon discount, exported for the SAME reason `sumGroupGst` above was —
+ * and it is the third defect of that exact shape in this one route.
+ *
+ * `/api/payment/create-order` decides what the gateway CAPTURES, and it had no
+ * coupon term anywhere in the file (measured: zero occurrences). So a buyer
+ * with a coupon was shown ₹X−discount, charged ₹X, and had ₹X−discount
+ * recorded against their order. The post-capture guard is one-sided
+ * (`paid < expected − 1`), so an OVER-capture never trips it — which is why
+ * this survived: every number inside our own system agreed, and only the
+ * buyer's card statement disagreed.
+ *
+ * Pure math, no Firestore, no server-only imports — same contract as the
+ * order-math block above.
+ */
+export { computeGroupCouponDiscount, computeCartCouponDiscount, } from "./_internal/shared/checkout/coupon-discount.js";
+/*
+ * Refund capacity. Exported because the admin refund ROUTE carried its own
+ * copy of the `amount >= totalPrice` test (D3) — a second answer to "is this
+ * refund full", already wrong, in a file that cannot deep-import
+ * `_internal/shared`. One implementation, or they drift again.
+ *
+ * `platformFeeWithheld` is the single worst money defect's fix (D32): it
+ * returns the fee ACTUALLY CHARGED, never a recomputed percentage, which is
+ * how a ₹5,000 order came to withhold ₹118 from a buyer who paid ₹11.80.
+ */
+export { refundCapacity, refundableBase, committedRefundTotal, platformFeeWithheld, wouldBeFullRefund, MONEY_EPSILON, } from "./_internal/shared/checkout/refundable-base.js";
 // S-SBUNI-RULES: refund action
 export { processRefundAction, } from "./_internal/server/features/refunds/actions.js";
 // S3: sublisting categories data layer