@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/features/payments/repository/__tests__/payout.repository.test.js

@@ -0,0 +1,292 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockTxn } = makeMockDb();
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+    };
+});
+vi.mock("../../../../security", () => ({
+    encryptPiiFields: (d) => d,
+    decryptPiiFields: (d) => d,
+    addPiiIndices: (d) => d,
+    encryptPayoutBankAccount: (d) => d,
+    decryptPayoutBankAccount: (d) => d,
+    PAYOUT_PII_FIELDS: ["sellerName", "sellerEmail"],
+    PAYOUT_PII_INDEX_MAP: {},
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { PayoutRepository } from "../payout.repository";
+const repo = new PayoutRepository();
+function makePayoutDoc(overrides = {}) {
+    return {
+        id: "payout-misty-20260101-a1b2c3",
+        storeId: "store-pokemon-palace",
+        sellerName: "Misty Singh",
+        sellerEmail: "misty@pokemon.com",
+        amount: 50000, // paise
+        netAmount: 50000,
+        status: "pending",
+        orderIds: ["order-1-20260101-abc", "order-2-20260101-def"],
+        requestedAt: new Date(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        refundDeductions: [],
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
+    mockTxn.get.mockResolvedValue(makeSnap(null));
+    mockTxn.update.mockReturnValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.create", () => {
+    it("creates payout with status: pending", async () => {
+        const result = await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(result.status).toBe("pending");
+    });
+    it("persists the payout to Firestore", async () => {
+        await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("sets requestedAt timestamp", async () => {
+        const result = await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(result.requestedAt).toBeInstanceOf(Date);
+    });
+});
+// ---------------------------------------------------------------------------
+// markProcessing
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.markProcessing", () => {
+    it("sets status: processing on the provided ref", async () => {
+        await repo.markProcessing(mockDocRef);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "processing" }));
+    });
+    it("sets processedAt timestamp", async () => {
+        await repo.markProcessing(mockDocRef);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ processedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// recordSuccess
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.recordSuccess", () => {
+    it("stores razorpayPayoutId on the payout", async () => {
+        await repo.recordSuccess(mockDocRef, "razorpay-payout-123", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayPayoutId: "razorpay-payout-123" }));
+    });
+    it("stores razorpayStatus on the payout", async () => {
+        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayStatus: "processed" }));
+    });
+    it("sets updatedAt timestamp", async () => {
+        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// recordFailure
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.recordFailure", () => {
+    it("isFinal=true → sets status: failed", async () => {
+        await repo.recordFailure(mockDocRef, 3, "Insufficient funds", true);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "failed" }));
+    });
+    it("isFinal=false → keeps status: pending (retry)", async () => {
+        await repo.recordFailure(mockDocRef, 1, "Timeout", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "pending" }));
+    });
+    it("stores failureCount", async () => {
+        await repo.recordFailure(mockDocRef, 2, "Network error", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ failureCount: 2 }));
+    });
+    it("stores lastFailureReason", async () => {
+        await repo.recordFailure(mockDocRef, 1, "Account blocked", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lastFailureReason: "Account blocked" }));
+    });
+});
+// ---------------------------------------------------------------------------
+// applyRefundDeduction
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.applyRefundDeduction", () => {
+    it("throws when payout not found in transaction", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.applyRefundDeduction("payout-ghost", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        })).rejects.toThrow(/not found/i);
+    });
+    it("throws when payout status is not pending", async () => {
+        const payout = makePayoutDoc({ status: "completed" });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        await expect(repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        })).rejects.toThrow(/status/i);
+    });
+    it("computes netAmount = amount - totalDeducted", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 10000,
+        });
+        expect(result.netAmount).toBe(40000);
+    });
+    it("netAmount is floored at 0 when deduction exceeds amount", async () => {
+        const payout = makePayoutDoc({ amount: 5000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 10000, // more than amount
+        });
+        expect(result.netAmount).toBe(0);
+    });
+    it("accumulates multiple deductions correctly", async () => {
+        const existing = [{ orderId: "order-old", deductedAmount: 5000, appliedAt: new Date() }];
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: existing });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-new",
+            deductedAmount: 10000,
+        });
+        // total deducted = 5000 + 10000 = 15000, net = 50000 - 15000 = 35000
+        expect(result.netAmount).toBe(35000);
+    });
+    it("sets appliedAt on the deduction entry", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        });
+        const lastDeduction = result.refundDeductions[result.refundDeductions.length - 1];
+        expect(lastDeduction.appliedAt).toBeInstanceOf(Date);
+    });
+    it("uses a Firestore transaction for atomic read-modify-write", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+        expect(mockTxn.get).toHaveBeenCalledOnce();
+        expect(mockTxn.update).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// findPendingByStore
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.findPendingByStore", () => {
+    it("returns null when no pending payout found", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const result = await repo.findPendingByStore("store-1");
+        expect(result).toBeNull();
+    });
+    it("queries storeId AND status=pending", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.findPendingByStore("store-abc");
+        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-abc");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "pending");
+    });
+    it("applies limit of 1 (most recent only)", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.findPendingByStore("store-abc");
+        expect(mockQuery.limit).toHaveBeenCalledWith(1);
+    });
+    it("returns the payout when found", async () => {
+        const payout = makePayoutDoc({ status: "pending" });
+        mockQuery.get.mockResolvedValue({
+            docs: [{ id: payout.id, data: () => payout }],
+            empty: false,
+            size: 1,
+        });
+        const result = await repo.findPendingByStore("store-pokemon-palace");
+        expect(result).not.toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// getPaidOutOrderIds
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.getPaidOutOrderIds", () => {
+    it("returns empty Set when no matching payouts", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const ids = await repo.getPaidOutOrderIds("store-1");
+        expect(ids.size).toBe(0);
+    });
+    it("collects all orderIds from matching payout documents", async () => {
+        const payout1 = makePayoutDoc({ orderIds: ["order-A", "order-B"] });
+        const payout2 = makePayoutDoc({ id: "payout-2", orderIds: ["order-C"] });
+        mockQuery.get.mockResolvedValue({
+            docs: [
+                { id: payout1.id, data: () => payout1 },
+                { id: payout2.id, data: () => payout2 },
+            ],
+            empty: false,
+            size: 2,
+        });
+        const ids = await repo.getPaidOutOrderIds("store-pokemon-palace");
+        expect(ids.has("order-A")).toBe(true);
+        expect(ids.has("order-B")).toBe(true);
+        expect(ids.has("order-C")).toBe(true);
+    });
+    it("queries storeId AND status in [pending, processing, completed]", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.getPaidOutOrderIds("store-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-1");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "in", expect.arrayContaining(["pending", "processing", "completed"]));
+    });
+    it("handles payout with no orderIds field gracefully", async () => {
+        const payout = { ...makePayoutDoc(), orderIds: undefined };
+        mockQuery.get.mockResolvedValue({
+            docs: [{ id: payout.id, data: () => payout }],
+            empty: false,
+            size: 1,
+        });
+        const ids = await repo.getPaidOutOrderIds("store-1");
+        expect(ids.size).toBe(0);
+    });
+});

package/dist/features/payments/schemas/firestore.d.ts

@@ -2,6 +2,7 @@
  * Payouts Firestore Document Types & Constants
  */
 import { type GeneratePayoutIdInput } from "../../../utils/id-generators";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export interface PayoutBankAccount {
     accountHolderName: string;
     accountNumberMasked: string;
@@ -32,8 +33,7 @@ export declare const PayoutStatusValues: {
     readonly FAILED: "failed";
 };
 export type PayoutPaymentMethod = "bank_transfer" | "upi";
-export interface PayoutDocument {
-    id: string;
+export interface PayoutDocument extends BaseDocument {
     storeId: string;
     sellerName: string;
     sellerEmail: string;
@@ -66,8 +66,6 @@ export interface PayoutDocument {
     netAmount?: number;
     requestedAt: Date;
     processedAt?: Date;
-    createdAt: Date;
-    updatedAt: Date;
 }
 export declare const PAYOUT_COLLECTION: "payouts";
 export declare const PAYOUT_INDEXED_FIELDS: readonly ["storeId", "status", "requestedAt", "createdAt"];

package/dist/features/pre-orders/schemas/index.d.ts

@@ -45,8 +45,8 @@ export declare const preorderItemSchema: z.ZodObject<{
     active: z.ZodDefault<z.ZodBoolean>;
     createdAt: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     slug: string;
+    id: string;
     name: string;
     active: boolean;
     isFeatured: boolean;
@@ -66,8 +66,8 @@ export declare const preorderItemSchema: z.ZodObject<{
     franchise?: string | undefined;
     preorderShipDate?: string | undefined;
 }, {
-    id: string;
     slug: string;
+    id: string;
     name: string;
     salePrice: number;
     regularPrice: number;

package/dist/features/products/api/[id]/route.d.ts

@@ -16,14 +16,14 @@ type RouteContext = {
     }>;
 };
 export declare function GET(_request: Request, context: RouteContext): Promise<NextResponse>;
-export declare const PATCH: (request: Request, context: {
+export declare const PATCH: (request: Request, context?: {
     params: Promise<{
         id: string;
     }>;
-}) => Promise<Response>;
-export declare const DELETE: (request: Request, context: {
+} | undefined) => Promise<Response>;
+export declare const DELETE: (request: Request, context?: {
     params: Promise<{
         id: string;
     }>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;
 export { GET as productItemGET, PATCH as productItemPATCH, DELETE as productItemDELETE, };

package/dist/features/products/api/route.d.ts

@@ -14,6 +14,6 @@
  */
 import { NextResponse } from "next/server.js";
 export declare function GET(request: Request): Promise<NextResponse>;
-export declare const POST: (request: Request, context: {
+export declare const POST: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/products/constants/action-defs.d.ts

@@ -96,16 +96,32 @@ export declare const DETAIL_ACTIONS: {
     readonly auction: readonly ["place-bid", "buy-now-auction", "watch-auction", "share"];
     /** Pre-order: reserve, wishlist, share */
     readonly preorder: readonly ["reserve-now", "add-to-wishlist", "share"];
+    /** Prize draw: enter, wishlist, share */
+    readonly "prize-draw": readonly ["enter-prize-draw", "add-to-wishlist", "share"];
+    /** Classified: offer, share */
+    readonly classified: readonly ["make-offer", "share"];
+    /** Digital code: buy now, share */
+    readonly "digital-code": readonly ["buy-now", "share"];
+    /** Live item: buy now, wishlist, share */
+    readonly live: readonly ["buy-now", "add-to-wishlist", "share"];
 };
 export declare const MOBILE_PRIMARY_ACTIONS: {
     readonly product: readonly ["buy-now", "add-to-cart"];
     readonly auction: readonly ["place-bid", "buy-now-auction"];
     readonly preorder: readonly ["reserve-now"];
+    readonly "prize-draw": readonly ["enter-prize-draw"];
+    readonly classified: readonly ["make-offer"];
+    readonly "digital-code": readonly ["buy-now"];
+    readonly live: readonly ["buy-now"];
 };
 export declare const LISTING_BULK_ACTIONS: {
     readonly products: readonly ["add-to-cart", "add-to-wishlist", "compare"];
     readonly auctions: readonly ["watch-auction", "unwatch-auction", "compare"];
     readonly preorders: readonly ["add-to-cart", "add-to-wishlist", "compare"];
+    readonly prizeDraws: readonly ActionId[];
+    readonly classifieds: readonly ActionId[];
+    readonly digitalCodes: readonly ActionId[];
+    readonly live: readonly ActionId[];
     readonly stores: ActionId[];
 };
 /** Maximum number of items the Compare overlay (BK3) supports at once. */

package/dist/features/products/constants/action-defs.js

@@ -137,18 +137,34 @@ export const DETAIL_ACTIONS = {
     auction: [ACTION_ID.PLACE_BID, ACTION_ID.BUY_NOW_AUCTION, ACTION_ID.WATCH_AUCTION, ACTION_ID.SHARE],
     /** Pre-order: reserve, wishlist, share */
     preorder: [ACTION_ID.RESERVE_NOW, ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.SHARE],
+    /** Prize draw: enter, wishlist, share */
+    "prize-draw": [ACTION_ID.ENTER_PRIZE_DRAW, ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.SHARE],
+    /** Classified: offer, share */
+    classified: [ACTION_ID.MAKE_OFFER, ACTION_ID.SHARE],
+    /** Digital code: buy now, share */
+    "digital-code": [ACTION_ID.BUY_NOW, ACTION_ID.SHARE],
+    /** Live item: buy now, wishlist, share */
+    live: [ACTION_ID.BUY_NOW, ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.SHARE],
 };
 // Mobile bottom bar — 1–2 primary CTAs only (limited horizontal space)
 export const MOBILE_PRIMARY_ACTIONS = {
     product: [ACTION_ID.BUY_NOW, ACTION_ID.ADD_TO_CART],
     auction: [ACTION_ID.PLACE_BID, ACTION_ID.BUY_NOW_AUCTION],
     preorder: [ACTION_ID.RESERVE_NOW],
+    "prize-draw": [ACTION_ID.ENTER_PRIZE_DRAW],
+    classified: [ACTION_ID.MAKE_OFFER],
+    "digital-code": [ACTION_ID.BUY_NOW],
+    live: [ACTION_ID.BUY_NOW],
 };
 // Listing page bulk actions — shown in the bottom action bar when items are selected
 export const LISTING_BULK_ACTIONS = {
     products: [ACTION_ID.ADD_TO_CART, ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
     auctions: [ACTION_ID.WATCH_AUCTION, ACTION_ID.UNWATCH_AUCTION, ACTION_ID.COMPARE],
     preorders: [ACTION_ID.ADD_TO_CART, ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
+    prizeDraws: [ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
+    classifieds: [ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
+    digitalCodes: [ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
+    live: [ACTION_ID.ADD_TO_WISHLIST, ACTION_ID.COMPARE],
     stores: [ACTION_ID.COMPARE],
 };
 /** Maximum number of items the Compare overlay (BK3) supports at once. */

package/dist/features/products/constants/listing-tabs.d.ts

@@ -40,6 +40,18 @@ export declare const CATEGORY_PAGE_TABS: readonly [{
     readonly id: "bundles";
     readonly label: "Bundles";
     readonly collection: "bundles";
+}, {
+    readonly id: "classifieds";
+    readonly label: "Classifieds";
+    readonly listingType: "classified";
+}, {
+    readonly id: "digital-codes";
+    readonly label: "Digital Codes";
+    readonly listingType: "digital-code";
+}, {
+    readonly id: "live";
+    readonly label: "Live Items";
+    readonly listingType: "live";
 }, {
     readonly id: "stores";
     readonly label: "Stores";
@@ -67,6 +79,18 @@ export declare const STORE_PAGE_TABS: readonly [{
     readonly id: "bundles";
     readonly label: "Bundles";
     readonly collection: "bundles";
+}, {
+    readonly id: "classifieds";
+    readonly label: "Classifieds";
+    readonly listingType: "classified";
+}, {
+    readonly id: "digital-codes";
+    readonly label: "Digital Codes";
+    readonly listingType: "digital-code";
+}, {
+    readonly id: "live";
+    readonly label: "Live Items";
+    readonly listingType: "live";
 }];
 export type StoreTabId = (typeof STORE_PAGE_TABS)[number]["id"];
 /** Tabs shown on the seller-dashboard listings view + admin products list. */
@@ -89,6 +113,18 @@ export declare const SELLER_LISTING_TABS: readonly [{
     readonly id: "prize-draws";
     readonly label: "Prize Draws";
     readonly listingType: "prize-draw";
+}, {
+    readonly id: "classifieds";
+    readonly label: "Classifieds";
+    readonly listingType: "classified";
+}, {
+    readonly id: "digital-codes";
+    readonly label: "Digital Codes";
+    readonly listingType: "digital-code";
+}, {
+    readonly id: "live";
+    readonly label: "Live Items";
+    readonly listingType: "live";
 }];
 export type SellerListingTabId = (typeof SELLER_LISTING_TABS)[number]["id"];
 /** Tabs shown on `/search` results. */
@@ -115,5 +151,17 @@ export declare const SEARCH_RESULT_TABS: readonly [{
     readonly id: "bundles";
     readonly label: "Bundles";
     readonly collection: "bundles";
+}, {
+    readonly id: "classifieds";
+    readonly label: "Classifieds";
+    readonly listingType: "classified";
+}, {
+    readonly id: "digital-codes";
+    readonly label: "Digital Codes";
+    readonly listingType: "digital-code";
+}, {
+    readonly id: "live";
+    readonly label: "Live Items";
+    readonly listingType: "live";
 }];
 export type SearchTabId = (typeof SEARCH_RESULT_TABS)[number]["id"];

package/dist/features/products/constants/listing-tabs.js

@@ -15,6 +15,9 @@ export const CATEGORY_PAGE_TABS = [
     { id: "pre-orders", label: "Pre-Orders", listingType: "pre-order" },
     { id: "prize-draws", label: "Prize Draws", listingType: "prize-draw" },
     { id: "bundles", label: "Bundles", collection: "bundles" },
+    { id: "classifieds", label: "Classifieds", listingType: "classified" },
+    { id: "digital-codes", label: "Digital Codes", listingType: "digital-code" },
+    { id: "live", label: "Live Items", listingType: "live" },
     { id: "stores", label: "Stores", entity: "stores" },
 ];
 /** Tabs shown on the public `/stores/[slug]` nav bar. */
@@ -24,6 +27,9 @@ export const STORE_PAGE_TABS = [
     { id: "pre-orders", label: "Pre-Orders", listingType: "pre-order" },
     { id: "prize-draws", label: "Prize Draws", listingType: "prize-draw" },
     { id: "bundles", label: "Bundles", collection: "bundles" },
+    { id: "classifieds", label: "Classifieds", listingType: "classified" },
+    { id: "digital-codes", label: "Digital Codes", listingType: "digital-code" },
+    { id: "live", label: "Live Items", listingType: "live" },
 ];
 /** Tabs shown on the seller-dashboard listings view + admin products list. */
 export const SELLER_LISTING_TABS = [
@@ -32,6 +38,9 @@ export const SELLER_LISTING_TABS = [
     { id: "auctions", label: "Auctions", listingType: "auction" },
     { id: "pre-orders", label: "Pre-Orders", listingType: "pre-order" },
     { id: "prize-draws", label: "Prize Draws", listingType: "prize-draw" },
+    { id: "classifieds", label: "Classifieds", listingType: "classified" },
+    { id: "digital-codes", label: "Digital Codes", listingType: "digital-code" },
+    { id: "live", label: "Live Items", listingType: "live" },
 ];
 /** Tabs shown on `/search` results. */
 export const SEARCH_RESULT_TABS = [
@@ -41,4 +50,7 @@ export const SEARCH_RESULT_TABS = [
     { id: "pre-orders", label: "Pre-Orders", listingType: "pre-order" },
     { id: "prize-draws", label: "Prize Draws", listingType: "prize-draw" },
     { id: "bundles", label: "Bundles", collection: "bundles" },
+    { id: "classifieds", label: "Classifieds", listingType: "classified" },
+    { id: "digital-codes", label: "Digital Codes", listingType: "digital-code" },
+    { id: "live", label: "Live Items", listingType: "live" },
 ];

package/dist/features/products/repository/__tests__/product-features.repository.test.d.ts

@@ -0,0 +1 @@
+export {};