@porulle/plugin-marketplace 0.1.0

package/dist/hooks.js

@@ -0,0 +1,187 @@
+import { eq } from "@porulle/core/drizzle";
+import { vendors, vendorEntities, vendorSubOrders } from "./schema.js";
+import { CommissionService } from "./services/commission.js";
+import { PayoutService } from "./services/payout.js";
+function getDbFromHookArgs(args) {
+    const a = args;
+    return a.context.services.database.db;
+}
+export function buildHooks(options) {
+    return [
+        // ─── catalog.beforeCreate ──────────────────────────────────────────────
+        {
+            key: "catalog.beforeCreate",
+            async handler(args) {
+                const { data } = args;
+                const metadata = data?.metadata;
+                const vendorId = metadata?.vendorId;
+                if (!vendorId)
+                    return data;
+                const db = getDbFromHookArgs(args);
+                const [vendor] = await db.select().from(vendors).where(eq(vendors.id, String(vendorId)));
+                if (!vendor)
+                    throw new Error("Vendor not found.");
+                if (vendor.status === "suspended")
+                    throw new Error("Vendor is suspended and cannot create listings.");
+                if (vendor.status !== "approved")
+                    throw new Error("Vendor must be approved before creating marketplace listings.");
+                // Check approved categories if set
+                const approvedCats = vendor.approvedCategories;
+                if (approvedCats && Array.isArray(approvedCats)) {
+                    const entityType = data.type;
+                    // approvedCategories holds category slugs; entityType may match
+                    // This is a basic check; real implementations would check category assignment
+                }
+                return data;
+            },
+        },
+        // ─── catalog.afterCreate ───────────────────────────────────────────────
+        {
+            key: "catalog.afterCreate",
+            async handler(args) {
+                const { result } = args;
+                const vendorId = result?.metadata?.vendorId;
+                if (!vendorId)
+                    return;
+                const db = getDbFromHookArgs(args);
+                await db.insert(vendorEntities).values({
+                    vendorId: String(vendorId),
+                    entityId: result.id,
+                });
+            },
+        },
+        // ─── catalog.beforeList ────────────────────────────────────────────────
+        {
+            key: "catalog.beforeList",
+            async handler(args) {
+                const { data, context: hookContext } = args;
+                hookContext.context.marketplaceVendorScope = hookContext.actor?.vendorId ?? null;
+                return data;
+            },
+        },
+        // ─── catalog.afterList ─────────────────────────────────────────────────
+        {
+            key: "catalog.afterList",
+            async handler(args) {
+                const { result, context: hookContext } = args;
+                const vendorScope = hookContext.context.marketplaceVendorScope;
+                if (!vendorScope || !Array.isArray(result?.items))
+                    return;
+                const db = getDbFromHookArgs(args);
+                const links = await db.select().from(vendorEntities).where(eq(vendorEntities.vendorId, vendorScope));
+                const linkedEntityIds = new Set(links.map((l) => l.entityId));
+                result.items = result.items.filter((item) => linkedEntityIds.has(item.id));
+            },
+        },
+        // ─── catalog.afterRead ─────────────────────────────────────────────────
+        {
+            key: "catalog.afterRead",
+            async handler(args) {
+                const { result } = args;
+                const db = getDbFromHookArgs(args);
+                const [link] = await db.select().from(vendorEntities).where(eq(vendorEntities.entityId, result.id));
+                if (!link)
+                    return;
+                const [vendor] = await db.select().from(vendors).where(eq(vendors.id, link.vendorId));
+                if (!vendor)
+                    return;
+                result.marketplace = {
+                    vendor: {
+                        id: vendor.id,
+                        name: vendor.name,
+                        slug: vendor.slug,
+                        status: vendor.status,
+                        tier: vendor.tier,
+                        logoUrl: vendor.logoUrl,
+                    },
+                };
+            },
+        },
+        // ─── orders.afterCreate ────────────────────────────────────────────────
+        {
+            key: "orders.afterCreate",
+            async handler(args) {
+                const { result, context: hookContext } = args;
+                const db = getDbFromHookArgs(args);
+                const commissionService = new CommissionService(db, options);
+                const payoutService = new PayoutService(db, options);
+                const grouped = new Map();
+                for (const lineItem of result.lineItems ?? []) {
+                    const [link] = await db.select().from(vendorEntities).where(eq(vendorEntities.entityId, lineItem.entityId));
+                    if (!link)
+                        continue;
+                    const [vendor] = await db.select().from(vendors).where(eq(vendors.id, link.vendorId));
+                    if (!vendor)
+                        continue;
+                    const existing = grouped.get(vendor.id) ?? [];
+                    existing.push({
+                        entityId: lineItem.entityId,
+                        quantity: lineItem.quantity,
+                        totalPrice: lineItem.totalPrice,
+                    });
+                    grouped.set(vendor.id, existing);
+                }
+                for (const [vendorId, lineItems] of grouped.entries()) {
+                    const subtotal = lineItems.reduce((sum, item) => sum + item.totalPrice, 0);
+                    // Resolve commission via rules engine
+                    const commissionRateBps = await commissionService.resolveRate(vendorId);
+                    const commissionAmount = Math.round((subtotal * commissionRateBps) / 10000);
+                    const payoutAmount = subtotal - commissionAmount;
+                    const [subOrder] = await db.insert(vendorSubOrders).values({
+                        orderId: result.id,
+                        vendorId,
+                        status: "pending",
+                        subtotal,
+                        commissionAmount,
+                        payoutAmount,
+                        notified: true,
+                        lineItems,
+                        metadata: {},
+                    }).returning();
+                    if (!subOrder)
+                        continue;
+                    // Credit vendor balance with full subtotal
+                    await payoutService.addLedgerEntry({
+                        vendorId,
+                        type: "sale",
+                        amountCents: subtotal,
+                        referenceType: "sub_order",
+                        referenceId: subOrder.id,
+                        description: `Sale from order ${result.id.slice(0, 8)}`,
+                    });
+                    // Record commission as separate entry
+                    await payoutService.addLedgerEntry({
+                        vendorId,
+                        type: "commission",
+                        amountCents: -commissionAmount,
+                        referenceType: "sub_order",
+                        referenceId: subOrder.id,
+                        description: `Commission (${commissionRateBps}bps) on order ${result.id.slice(0, 8)}`,
+                    });
+                    hookContext.logger.info("marketplace_sub_order_created", {
+                        orderId: result.id,
+                        subOrderId: subOrder.id,
+                        vendorId,
+                        commissionRateBps,
+                    });
+                }
+            },
+        },
+        // ─── orders.beforeStatusChange ─────────────────────────────────────────
+        {
+            key: "orders.beforeStatusChange",
+            async handler(args) {
+                const { data } = args;
+                if (data.newStatus !== "fulfilled")
+                    return data;
+                const db = getDbFromHookArgs(args);
+                const related = await db.select().from(vendorSubOrders).where(eq(vendorSubOrders.orderId, data.orderId));
+                const allDelivered = related.every((subOrder) => subOrder.status === "delivered");
+                if (!allDelivered) {
+                    throw new Error("Cannot fulfill parent order until all marketplace sub-orders are delivered.");
+                }
+                return data;
+            },
+        },
+    ];
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { MarketplacePluginOptions } from "./types.js";
+export type { MarketplacePluginOptions } from "./types.js";
+export declare function marketplacePlugin(options?: MarketplacePluginOptions): import("@porulle/core").CommercePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,wBAAwB,EAAM,MAAM,YAAY,CAAC;AAE/D,YAAY,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AA4C3D,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,0CA4CvE"}

package/dist/index.js

@@ -0,0 +1,97 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { MARKETPLACE_ANALYTICS_MODELS } from "./analytics-models.js";
+import { vendors, vendorEntities, vendorSubOrders, vendorPayouts, vendorDocuments, commissionRules, vendorBalances, disputes, vendorReviews, returnRequests, rfqs, rfqResponses, contractPrices, } from "./schema.js";
+import { VendorService } from "./services/vendor.js";
+import { SubOrderService } from "./services/sub-order.js";
+import { CommissionService } from "./services/commission.js";
+import { PayoutService } from "./services/payout.js";
+import { DisputeService } from "./services/dispute.js";
+import { ReturnService } from "./services/return.js";
+import { ReviewService } from "./services/review.js";
+import { RFQService } from "./services/rfq.js";
+import { ContractPriceService } from "./services/contract-price.js";
+import { buildHooks } from "./hooks.js";
+import { buildVendorRoutes } from "./routes/vendors.js";
+import { buildVendorPortalRoutes } from "./routes/vendor-portal.js";
+import { buildSubOrderRoutes } from "./routes/sub-orders.js";
+import { buildCommissionRoutes } from "./routes/commission.js";
+import { buildPayoutRoutes } from "./routes/payouts.js";
+import { buildDisputesReturnsReviewsRoutes } from "./routes/disputes-returns-reviews.js";
+import { buildB2BRoutes } from "./routes/b2b.js";
+function createServices(db, options, kernelServices) {
+    const vendor = new VendorService(db);
+    const commission = new CommissionService(db, options);
+    const payout = new PayoutService(db, options);
+    const dispute = new DisputeService(db, options);
+    const returnSvc = new ReturnService(db);
+    const review = new ReviewService(db, options);
+    const rfq = options.b2b?.rfq ? new RFQService(db) : undefined;
+    const contractPrice = options.b2b?.contractPricing ? new ContractPriceService(db) : undefined;
+    // Cancel callback: release inventory on parent order + reverse balance
+    const subOrder = new SubOrderService(db, async (sub) => {
+        // Release inventory for cancelled vendor's line items
+        const inventory = kernelServices?.inventory;
+        if (inventory?.release && sub.lineItems) {
+            for (const item of sub.lineItems) {
+                await inventory.release({
+                    entityId: item.entityId,
+                    quantity: item.quantity,
+                    orderId: sub.orderId,
+                    performedBy: "marketplace",
+                });
+            }
+        }
+        // Reverse balance: debit the sale credit
+        if (sub.payoutAmount > 0) {
+            await payout.addLedgerEntry({
+                vendorId: sub.vendorId,
+                type: "refund_deduction",
+                amountCents: -sub.payoutAmount,
+                referenceType: "sub_order",
+                referenceId: sub.id,
+                description: `Cancelled sub-order ${sub.id.slice(0, 8)}`,
+            });
+        }
+    });
+    return { vendor, subOrder, commission, payout, dispute, return: returnSvc, review, rfq, contractPrice };
+}
+export function marketplacePlugin(options = {}) {
+    return defineCommercePlugin({
+        id: "marketplace",
+        version: "2.0.0",
+        schema: () => ({
+            vendors,
+            vendorEntities,
+            vendorSubOrders,
+            vendorPayouts,
+            vendorDocuments,
+            commissionRules,
+            vendorBalances,
+            disputes,
+            vendorReviews,
+            returnRequests,
+            rfqs,
+            rfqResponses,
+            contractPrices,
+        }),
+        hooks: () => buildHooks(options),
+        routes: (ctx) => {
+            const db = ctx.database.db;
+            const services = db ? createServices(db, options, ctx.services) : null;
+            if (!services)
+                return [];
+            return [
+                ...buildVendorRoutes(services, options),
+                ...buildVendorPortalRoutes(services),
+                ...buildSubOrderRoutes(services),
+                ...buildCommissionRoutes(services),
+                ...buildPayoutRoutes(services),
+                ...buildDisputesReturnsReviewsRoutes(services),
+                ...(options.b2b?.rfq || options.b2b?.contractPricing
+                    ? buildB2BRoutes(services, options)
+                    : []),
+            ];
+        },
+        analyticsModels: () => MARKETPLACE_ANALYTICS_MODELS,
+    });
+}

package/dist/routes/b2b.d.ts

@@ -0,0 +1,9 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { RFQService } from "../services/rfq.js";
+import type { ContractPriceService } from "../services/contract-price.js";
+import type { MarketplacePluginOptions } from "../types.js";
+export declare function buildB2BRoutes(services: {
+    rfq?: RFQService | undefined;
+    contractPrice?: ContractPriceService | undefined;
+}, options: MarketplacePluginOptions): PluginRouteRegistration[];
+//# sourceMappingURL=b2b.d.ts.map

package/dist/routes/b2b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"b2b.d.ts","sourceRoot":"","sources":["../../src/routes/b2b.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAU5D,wBAAgB,cAAc,CAAC,QAAQ,EAAE;IACvC,GAAG,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAC7B,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAClD,EAAE,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,EAAE,CAgK/D"}

package/dist/routes/b2b.js

@@ -0,0 +1,156 @@
+import { router } from "@porulle/core";
+import { CreateRFQBodySchema, RespondRFQBodySchema, AwardRFQBodySchema, CreateContractPriceBodySchema, UpdateContractPriceBodySchema, } from "../schemas/b2b.js";
+import { stripUndefined } from "./util.js";
+export function buildB2BRoutes(services, options) {
+    const allRoutes = [];
+    // ═══════════════════════════════════════════════════════════════════════════
+    // RFQ (Request for Quote)
+    // ═══════════════════════════════════════════════════════════════════════════
+    if (services.rfq) {
+        const rfqSvc = services.rfq;
+        const rfq = router("Marketplace - B2B", "/marketplace/rfq");
+        rfq.post("/")
+            .summary("Create a Request for Quote")
+            .auth()
+            .input(CreateRFQBodySchema)
+            .handler(async ({ input }) => {
+            const body = input;
+            return rfqSvc.create(stripUndefined({
+                buyerId: body.buyerId,
+                title: body.title,
+                description: body.description,
+                categorySlug: body.categorySlug,
+                quantity: body.quantity,
+                budgetCents: body.budgetCents,
+                currency: body.currency,
+                deadlineAt: body.deadlineAt ? new Date(body.deadlineAt) : undefined,
+                metadata: body.metadata,
+            }));
+        });
+        rfq.get("/")
+            .summary("List Requests for Quote")
+            .auth()
+            .handler(async ({ query }) => {
+            return rfqSvc.list(stripUndefined({
+                status: query.status,
+                categorySlug: query.categorySlug,
+            }));
+        });
+        rfq.get("/{id}")
+            .summary("Get RFQ detail")
+            .auth()
+            .handler(async ({ params }) => {
+            const item = await rfqSvc.getById(params.id);
+            if (!item)
+                throw new Error("RFQ not found");
+            const responses = await rfqSvc.getResponses(item.id);
+            return { ...item, responses };
+        });
+        rfq.post("/{id}/respond")
+            .summary("Submit a vendor response to an RFQ")
+            .auth()
+            .input(RespondRFQBodySchema)
+            .handler(async ({ params, input }) => {
+            const body = input;
+            const item = await rfqSvc.getById(params.id);
+            if (!item)
+                throw new Error("RFQ not found");
+            return rfqSvc.respond(item.id, stripUndefined({
+                vendorId: body.vendorId,
+                unitPriceCents: body.unitPriceCents,
+                totalPriceCents: body.totalPriceCents,
+                leadTimeDays: body.leadTimeDays,
+                notes: body.notes,
+            }));
+        });
+        rfq.post("/{id}/award")
+            .summary("Award an RFQ to a vendor")
+            .auth()
+            .permission("marketplace:admin")
+            .input(AwardRFQBodySchema)
+            .handler(async ({ params, input }) => {
+            const body = input;
+            const updated = await rfqSvc.award(params.id, body.vendorId);
+            if (!updated)
+                throw new Error("RFQ not found");
+            return updated;
+        });
+        rfq.post("/{id}/close")
+            .summary("Close an RFQ")
+            .auth()
+            .permission("marketplace:admin")
+            .handler(async ({ params }) => {
+            const updated = await rfqSvc.close(params.id);
+            if (!updated)
+                throw new Error("RFQ not found");
+            return updated;
+        });
+        allRoutes.push(...rfq.routes());
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CONTRACT PRICES
+    // ═══════════════════════════════════════════════════════════════════════════
+    if (services.contractPrice) {
+        const cpSvc = services.contractPrice;
+        const cp = router("Marketplace - B2B", "/marketplace/contract-prices");
+        cp.get("/")
+            .summary("List contract prices")
+            .auth()
+            .handler(async ({ query }) => {
+            return cpSvc.list(stripUndefined({
+                vendorId: query.vendorId,
+                buyerId: query.buyerId,
+            }));
+        });
+        cp.post("/")
+            .summary("Create a contract price")
+            .auth()
+            .permission("marketplace:admin")
+            .input(CreateContractPriceBodySchema)
+            .handler(async ({ input }) => {
+            const body = input;
+            return cpSvc.create(stripUndefined({
+                vendorId: body.vendorId,
+                buyerId: body.buyerId,
+                entityId: body.entityId,
+                variantId: body.variantId,
+                priceCents: body.priceCents,
+                minQuantity: body.minQuantity,
+                currency: body.currency,
+                validFrom: body.validFrom ? new Date(body.validFrom) : undefined,
+                validUntil: body.validUntil ? new Date(body.validUntil) : undefined,
+            }));
+        });
+        cp.patch("/{id}")
+            .summary("Update a contract price")
+            .auth()
+            .permission("marketplace:admin")
+            .input(UpdateContractPriceBodySchema)
+            .handler(async ({ params, input }) => {
+            const body = input;
+            const updateData = {};
+            if (body.priceCents !== undefined)
+                updateData.priceCents = body.priceCents;
+            if (body.minQuantity !== undefined)
+                updateData.minQuantity = body.minQuantity;
+            if (body.validFrom !== undefined)
+                updateData.validFrom = body.validFrom ? new Date(body.validFrom) : null;
+            if (body.validUntil !== undefined)
+                updateData.validUntil = body.validUntil ? new Date(body.validUntil) : null;
+            const updated = await cpSvc.update(params.id, updateData);
+            if (!updated)
+                throw new Error("Contract price not found");
+            return updated;
+        });
+        cp.delete("/{id}")
+            .summary("Delete a contract price")
+            .auth()
+            .permission("marketplace:admin")
+            .handler(async ({ params }) => {
+            await cpSvc.delete(params.id);
+            return { deleted: true };
+        });
+        allRoutes.push(...cp.routes());
+    }
+    return allRoutes;
+}

package/dist/routes/commission.d.ts

@@ -0,0 +1,6 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { CommissionService } from "../services/commission.js";
+export declare function buildCommissionRoutes(services: {
+    commission: CommissionService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=commission.d.ts.map

package/dist/routes/commission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commission.d.ts","sourceRoot":"","sources":["../../src/routes/commission.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAQnE,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAC9C,UAAU,EAAE,iBAAiB,CAAC;CAC/B,GAAG,uBAAuB,EAAE,CAiF5B"}

package/dist/routes/commission.js

@@ -0,0 +1,85 @@
+import { router } from "@porulle/core";
+import { CreateCommissionRuleBodySchema, UpdateCommissionRuleBodySchema, PreviewCommissionBodySchema, } from "../schemas/commission.js";
+import { stripUndefined } from "./util.js";
+export function buildCommissionRoutes(services) {
+    const r = router("Marketplace - Commission", "/marketplace/commission-rules");
+    // ─── List commission rules ─────────────────────────────────────────────────
+    r.get("/")
+        .summary("List all commission rules")
+        .permission("marketplace:admin")
+        .handler(async () => {
+        return services.commission.listRules();
+    });
+    // ─── Create commission rule ────────────────────────────────────────────────
+    r.post("/")
+        .summary("Create a commission rule")
+        .permission("marketplace:admin")
+        .input(CreateCommissionRuleBodySchema)
+        .handler(async ({ input }) => {
+        const body = input;
+        return services.commission.createRule(stripUndefined({
+            name: body.name,
+            type: body.type,
+            rateBps: body.rateBps,
+            categorySlug: body.categorySlug,
+            vendorId: body.vendorId,
+            vendorTier: body.vendorTier,
+            minVolumeCents: body.minVolumeCents,
+            maxVolumeCents: body.maxVolumeCents,
+            validFrom: body.validFrom ? new Date(body.validFrom) : undefined,
+            validUntil: body.validUntil ? new Date(body.validUntil) : undefined,
+            priority: body.priority,
+        }));
+    });
+    // ─── Update commission rule ────────────────────────────────────────────────
+    r.patch("/{id}")
+        .summary("Update a commission rule")
+        .permission("marketplace:admin")
+        .input(UpdateCommissionRuleBodySchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        const updateData = {};
+        if (body.name !== undefined)
+            updateData.name = body.name;
+        if (body.rateBps !== undefined)
+            updateData.rateBps = body.rateBps;
+        if (body.categorySlug !== undefined)
+            updateData.categorySlug = body.categorySlug;
+        if (body.vendorTier !== undefined)
+            updateData.vendorTier = body.vendorTier;
+        if (body.minVolumeCents !== undefined)
+            updateData.minVolumeCents = body.minVolumeCents;
+        if (body.maxVolumeCents !== undefined)
+            updateData.maxVolumeCents = body.maxVolumeCents;
+        if (body.validFrom !== undefined)
+            updateData.validFrom = body.validFrom ? new Date(body.validFrom) : null;
+        if (body.validUntil !== undefined)
+            updateData.validUntil = body.validUntil ? new Date(body.validUntil) : null;
+        if (body.priority !== undefined)
+            updateData.priority = body.priority;
+        if (body.isActive !== undefined)
+            updateData.isActive = body.isActive;
+        const updated = await services.commission.updateRule(params.id, updateData);
+        if (!updated)
+            throw new Error("Commission rule not found");
+        return updated;
+    });
+    // ─── Delete commission rule ────────────────────────────────────────────────
+    r.delete("/{id}")
+        .summary("Delete a commission rule")
+        .permission("marketplace:admin")
+        .handler(async ({ params }) => {
+        await services.commission.deleteRule(params.id);
+        return { deleted: true };
+    });
+    // ─── Preview commission rate ───────────────────────────────────────────────
+    r.post("/preview")
+        .summary("Preview the commission rate for a vendor")
+        .permission("marketplace:admin")
+        .input(PreviewCommissionBodySchema)
+        .handler(async ({ input }) => {
+        const body = input;
+        return services.commission.previewRate(body.vendorId, body.categorySlug, body.volumeCents);
+    });
+    return r.routes();
+}

package/dist/routes/disputes-returns-reviews.d.ts

@@ -0,0 +1,10 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { DisputeService } from "../services/dispute.js";
+import type { ReturnService } from "../services/return.js";
+import type { ReviewService } from "../services/review.js";
+export declare function buildDisputesReturnsReviewsRoutes(services: {
+    dispute: DisputeService;
+    return: ReturnService;
+    review: ReviewService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=disputes-returns-reviews.d.ts.map

package/dist/routes/disputes-returns-reviews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disputes-returns-reviews.d.ts","sourceRoot":"","sources":["../../src/routes/disputes-returns-reviews.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAa3D,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE;IAC1D,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;CACvB,GAAG,uBAAuB,EAAE,CA0L5B"}