@mohasinac/appkit 2.7.11 → 2.7.13

package/dist/_internal/server/jobs/core/assignSpinPrize.js

@@ -3,6 +3,7 @@
  * `crypto.randomInt`. Enforces one spin per user.
  */
 import crypto from "node:crypto";
+import { EVENT_ENTRY_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const EVENTS_COLLECTION = "events";
 const EVENT_ENTRIES_COLLECTION = "eventEntries";
 const COUPONS_COLLECTION = "coupons";
@@ -20,8 +21,8 @@ export async function runAssignSpinPrize(input, ctx) {
     }
     const entriesSnap = await ctx.db
         .collection(EVENT_ENTRIES_COLLECTION)
-        .where("eventId", "==", eventId)
-        .where("userId", "==", userId)
+        .where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", eventId)
+        .where(EVENT_ENTRY_FIELDS.USER_ID, "==", userId)
         .limit(1)
         .get();
     if (entriesSnap.empty) {
@@ -60,11 +61,11 @@ export async function runAssignSpinPrize(input, ctx) {
         }
     }
     await entryDoc.ref.update({
-        spinUsed: true,
-        spinPrizeId: pick.id,
-        spinWonAt: ctx.now,
-        spinPrizeCouponCode: spinPrizeCouponCode ?? null,
-        updatedAt: ctx.now,
+        [EVENT_ENTRY_FIELDS.SPIN_USED]: true,
+        [EVENT_ENTRY_FIELDS.SPIN_PRIZE_ID]: pick.id,
+        [EVENT_ENTRY_FIELDS.SPIN_WON_AT]: ctx.now,
+        [EVENT_ENTRY_FIELDS.SPIN_PRIZE_COUPON_CODE]: spinPrizeCouponCode ?? null,
+        [COMMON_FIELDS.UPDATED_AT]: ctx.now,
     });
     ctx.logger.info("Spin prize assigned", {
         eventId,

package/dist/_internal/server/jobs/core/bundleStockSync.js

@@ -6,41 +6,39 @@
  * `bundleStockStatus`. This sweep recomputes `bundleStockStatus` for
  * every active bundle by inspecting its members' product status.
  */
+import { CATEGORY_FIELDS, PRODUCT_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const CATEGORIES_COLLECTION = "categories";
 const PRODUCT_COLLECTION = "products";
-const UNAVAILABLE = new Set(["sold", "out_of_stock", "discontinued"]);
-const MIN_ACTIVE_DEFAULT = 1;
-async function computeBundleStockStatus(productIds, minActive, ctx) {
+const UNAVAILABLE = new Set([
+    PRODUCT_FIELDS.STATUS_VALUES.SOLD,
+    PRODUCT_FIELDS.STATUS_VALUES.OUT_OF_STOCK,
+    PRODUCT_FIELDS.STATUS_VALUES.DISCONTINUED,
+]);
+async function computeBundleStockStatus(productIds, ctx) {
     if (productIds.length === 0)
         return "out_of_stock";
-    let unavailable = 0;
     for (let i = 0; i < productIds.length; i += 30) {
         const chunk = productIds.slice(i, i + 30);
         const snap = await ctx.db
             .collection(PRODUCT_COLLECTION)
             .where("__name__", "in", chunk)
             .get();
+        if (snap.size < chunk.length)
+            return "out_of_stock";
         for (const doc of snap.docs) {
             const status = doc.data().status;
             if (!status || UNAVAILABLE.has(status))
-                unavailable++;
+                return "out_of_stock";
         }
-        if (snap.size < chunk.length)
-            unavailable += chunk.length - snap.size;
     }
-    const active = productIds.length - unavailable;
-    if (unavailable === 0)
-        return "in_stock";
-    if (active < minActive)
-        return "out_of_stock";
-    return "partial";
+    return "in_stock";
 }
 export async function runBundleStockSync(ctx) {
     ctx.logger.info("Bundle stock sync starting (SB-UNI-V categories)");
     const snap = await ctx.db
         .collection(CATEGORIES_COLLECTION)
-        .where("categoryType", "==", "bundle")
-        .where("isActive", "==", true)
+        .where(CATEGORY_FIELDS.CATEGORY_TYPE, "==", CATEGORY_FIELDS.CATEGORY_TYPE_VALUES.BUNDLE)
+        .where(CATEGORY_FIELDS.IS_ACTIVE, "==", true)
         .limit(500)
         .get();
     if (snap.empty) {
@@ -53,13 +51,12 @@ export async function runBundleStockSync(ctx) {
         const productIds = data.bundleProductIds ?? [];
         if (productIds.length === 0)
             continue;
-        const minActive = data.minActiveMembers ?? MIN_ACTIVE_DEFAULT;
-        const nextStatus = await computeBundleStockStatus(productIds, minActive, ctx);
+        const nextStatus = await computeBundleStockStatus(productIds, ctx);
         if (nextStatus !== data.bundleStockStatus) {
             await bundleDoc.ref.update({
-                bundleStockStatus: nextStatus,
-                bundleQueryResolvedAt: ctx.now,
-                updatedAt: ctx.now,
+                [CATEGORY_FIELDS.BUNDLE_STOCK_STATUS]: nextStatus,
+                [CATEGORY_FIELDS.BUNDLE_QUERY_RESOLVED_AT]: ctx.now,
+                [COMMON_FIELDS.UPDATED_AT]: ctx.now,
             });
             updated++;
         }

package/dist/_internal/server/jobs/core/countersReconcile.js

@@ -1,5 +1,6 @@
 import { categoriesRepository, reviewRepository, storeRepository, } from "../../../../repositories";
 import { ProductStatusValues, PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
+import { ORDER_FIELDS, PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { QUERY_LIMIT } from "../handlers/messages";
 const STORES_COLLECTION = "stores";
 const ORDERS_COLLECTION = "orders";
@@ -18,7 +19,7 @@ async function reconcileCategories(ctx) {
             continue;
         if (!leafCounts[catId])
             leafCounts[catId] = { productIds: [], auctionIds: [] };
-        if (data.listingType === "auction")
+        if (data.listingType === PRODUCT_FIELDS.LISTING_TYPE_VALUES.AUCTION)
             leafCounts[catId].auctionIds.push(doc.id);
         else
             leafCounts[catId].productIds.push(doc.id);
@@ -69,7 +70,7 @@ async function reconcileStores(ctx) {
                 ctx.db
                     .collection(ORDERS_COLLECTION)
                     .where("sellerId", "==", sellerId)
-                    .where("status", "==", "delivered")
+                    .where(ORDER_FIELDS.STATUS, "==", ORDER_FIELDS.STATUS_VALUES.DELIVERED)
                     .limit(QUERY_LIMIT)
                     .get(),
                 reviewRepository.getApprovedRatingAggregateByStore(storeId),

package/dist/_internal/server/jobs/core/onProductStockChange.js

@@ -10,58 +10,56 @@
  * member products (≤16 typically). Caller should skip when the product's
  * status didn't transition between "available" and "unavailable".
  */
+import { CATEGORY_FIELDS, PRODUCT_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const CATEGORIES_COLLECTION = "categories";
 const GROUPED_LISTINGS_COLLECTION = "groupedListings";
 const PRODUCT_COLLECTION = "products";
-const UNAVAILABLE_STATUSES = new Set(["sold", "out_of_stock", "discontinued"]);
+const UNAVAILABLE_STATUSES = new Set([
+    PRODUCT_FIELDS.STATUS_VALUES.SOLD,
+    PRODUCT_FIELDS.STATUS_VALUES.OUT_OF_STOCK,
+    PRODUCT_FIELDS.STATUS_VALUES.DISCONTINUED,
+]);
 const MIN_ACTIVE_DEFAULT = 2;
 export function isAvailable(status) {
     if (!status)
         return false;
     return !UNAVAILABLE_STATUSES.has(status);
 }
-async function recomputeBundleStatus(productIds, minActive, ctx) {
+async function recomputeBundleStatus(productIds, ctx) {
     if (productIds.length === 0)
         return "out_of_stock";
-    let unavailable = 0;
     for (let i = 0; i < productIds.length; i += 30) {
         const chunk = productIds.slice(i, i + 30);
         const snap = await ctx.db
             .collection(PRODUCT_COLLECTION)
             .where("__name__", "in", chunk)
             .get();
+        if (snap.size < chunk.length)
+            return "out_of_stock";
         for (const doc of snap.docs) {
             const status = doc.data().status;
             if (!isAvailable(status))
-                unavailable++;
+                return "out_of_stock";
         }
-        if (snap.size < chunk.length)
-            unavailable += chunk.length - snap.size;
     }
-    const active = productIds.length - unavailable;
-    if (unavailable === 0)
-        return "in_stock";
-    if (active < minActive)
-        return "out_of_stock";
-    return "partial";
+    return "in_stock";
 }
 export async function syncBundlesForProduct(productId, ctx) {
     const snap = await ctx.db
         .collection(CATEGORIES_COLLECTION)
-        .where("categoryType", "==", "bundle")
-        .where("bundleProductIds", "array-contains", productId)
+        .where(CATEGORY_FIELDS.CATEGORY_TYPE, "==", CATEGORY_FIELDS.CATEGORY_TYPE_VALUES.BUNDLE)
+        .where(CATEGORY_FIELDS.BUNDLE_PRODUCT_IDS, "array-contains", productId)
         .get();
     let updated = 0;
     for (const bundleDoc of snap.docs) {
         const data = bundleDoc.data();
         const ids = data.bundleProductIds ?? [];
-        const minActive = data.minActiveMembers ?? 1;
-        const next = await recomputeBundleStatus(ids, minActive, ctx);
+        const next = await recomputeBundleStatus(ids, ctx);
         if (next !== data.bundleStockStatus) {
             await bundleDoc.ref.update({
-                bundleStockStatus: next,
-                bundleQueryResolvedAt: ctx.now,
-                updatedAt: ctx.now,
+                [CATEGORY_FIELDS.BUNDLE_STOCK_STATUS]: next,
+                [CATEGORY_FIELDS.BUNDLE_QUERY_RESOLVED_AT]: ctx.now,
+                [COMMON_FIELDS.UPDATED_AT]: ctx.now,
             });
             updated++;
         }
@@ -99,7 +97,7 @@ export async function syncGroupedListingsForProduct(productId, ctx) {
             await groupDoc.ref.update({
                 activeMemberCount: activeCount,
                 visibilityStatus: nextVisibility,
-                updatedAt: ctx.now,
+                [COMMON_FIELDS.UPDATED_AT]: ctx.now,
             });
             updated++;
         }

package/dist/_internal/server/jobs/core/onProductWrite.js

@@ -4,6 +4,7 @@
  */
 import { categoriesRepository, storeRepository, } from "../../../../repositories";
 import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 const UNAVAILABLE_PRODUCT_STATUSES = new Set([
     ProductStatusValues.SOLD,
     ProductStatusValues.OUT_OF_STOCK,
@@ -23,8 +24,8 @@ export async function handleProductWrite(input, ctx) {
     const afterCategory = after?.category ?? null;
     const beforeStoreId = (before?.storeId || before?.sellerId) ?? null;
     const afterStoreId = (after?.storeId || after?.sellerId) ?? null;
-    const isAuction = after?.listingType === "auction";
-    const beforeIsAuction = before?.listingType === "auction";
+    const isAuction = after?.listingType === PRODUCT_FIELDS.LISTING_TYPE_VALUES.AUCTION;
+    const beforeIsAuction = before?.listingType === PRODUCT_FIELDS.LISTING_TYPE_VALUES.AUCTION;
     const wasPublished = beforeStatus === ProductStatusValues.PUBLISHED;
     const isPublished = afterStatus === ProductStatusValues.PUBLISHED;
     const isDelete = !after;

package/dist/_internal/server/jobs/core/prizeRevealClose.js

@@ -1,11 +1,13 @@
+import { PRODUCT_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const PRODUCT_COLLECTION = "products";
+const PRIZE_DRAW_LISTING_TYPE = "prize-draw";
 export async function runPrizeRevealClose(ctx) {
     ctx.logger.info("Prize reveal close sweep starting");
     const snap = await ctx.db
         .collection(PRODUCT_COLLECTION)
-        .where("listingType", "==", "prize-draw")
-        .where("prizeRevealStatus", "==", "open")
-        .where("prizeRevealWindowEnd", "<=", ctx.now)
+        .where(PRODUCT_FIELDS.LISTING_TYPE, "==", PRIZE_DRAW_LISTING_TYPE)
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_STATUS, "==", PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.OPEN)
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_WINDOW_END, "<=", ctx.now)
         .limit(100)
         .get();
     if (snap.empty) {
@@ -14,8 +16,8 @@ export async function runPrizeRevealClose(ctx) {
     }
     const batch = ctx.db.batch();
     snap.docs.forEach((doc) => batch.update(doc.ref, {
-        prizeRevealStatus: "closed",
-        updatedAt: ctx.now,
+        [PRODUCT_FIELDS.PRIZE_REVEAL_STATUS]: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.CLOSED,
+        [COMMON_FIELDS.UPDATED_AT]: ctx.now,
     }));
     await batch.commit();
     ctx.logger.info("Closed prize draws", { count: snap.size });

package/dist/_internal/server/jobs/core/prizeRevealExpiry.js

@@ -1,12 +1,17 @@
 import { notificationRepository } from "../../../../repositories";
+import { ORDER_FIELDS, PRODUCT_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const ORDER_COLLECTION = "orders";
 export async function runPrizeRevealExpiry(ctx) {
     ctx.logger.info("Prize reveal expiry sweep starting");
     const snap = await ctx.db
         .collection(ORDER_COLLECTION)
-        .where("paymentStatus", "==", "paid")
-        .where("status", "in", ["pending", "confirmed", "processing"])
-        .where("prizeRevealDeadline", "<", ctx.now)
+        .where(ORDER_FIELDS.PAYMENT_STATUS, "==", ORDER_FIELDS.PAYMENT_STATUS_VALUES.PAID)
+        .where(ORDER_FIELDS.STATUS, "in", [
+        ORDER_FIELDS.STATUS_VALUES.PENDING,
+        ORDER_FIELDS.STATUS_VALUES.CONFIRMED,
+        ORDER_FIELDS.STATUS_VALUES.PROCESSING,
+    ])
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_DEADLINE, "<", ctx.now)
         .limit(200)
         .get();
     if (snap.empty) {
@@ -21,11 +26,11 @@ export async function runPrizeRevealExpiry(ctx) {
         if (!order.prizeDrawProductId)
             continue;
         await doc.ref.update({
-            status: "refunded",
-            paymentStatus: "refunded",
+            [ORDER_FIELDS.STATUS]: ORDER_FIELDS.STATUS_VALUES.REFUNDED,
+            [ORDER_FIELDS.PAYMENT_STATUS]: ORDER_FIELDS.PAYMENT_STATUS_VALUES.REFUNDED,
             isNonRefundable: false,
             prizeRevealExpired: true,
-            updatedAt: ctx.now,
+            [COMMON_FIELDS.UPDATED_AT]: ctx.now,
         });
         if (order.userId) {
             try {

package/dist/_internal/server/jobs/core/prizeRevealOpen.js

@@ -1,13 +1,15 @@
 import { notificationRepository } from "../../../../repositories";
+import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
 const PRODUCT_COLLECTION = "products";
 const ORDER_COLLECTION = "orders";
+const PRIZE_DRAW_LISTING_TYPE = "prize-draw";
 export async function runPrizeRevealOpen(ctx) {
     ctx.logger.info("Prize reveal open sweep starting");
     const snap = await ctx.db
         .collection(PRODUCT_COLLECTION)
-        .where("listingType", "==", "prize-draw")
-        .where("prizeRevealStatus", "==", "pending")
-        .where("prizeRevealWindowStart", "<=", ctx.now)
+        .where(PRODUCT_FIELDS.LISTING_TYPE, "==", PRIZE_DRAW_LISTING_TYPE)
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_STATUS, "==", PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.PENDING)
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_WINDOW_START, "<=", ctx.now)
         .limit(100)
         .get();
     if (snap.empty) {
@@ -17,14 +19,18 @@ export async function runPrizeRevealOpen(ctx) {
     for (const doc of snap.docs) {
         const product = doc.data();
         await doc.ref.update({
-            prizeRevealStatus: "open",
-            updatedAt: ctx.now,
+            [PRODUCT_FIELDS.PRIZE_REVEAL_STATUS]: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.OPEN,
+            [COMMON_FIELDS.UPDATED_AT]: ctx.now,
         });
         const orders = await ctx.db
             .collection(ORDER_COLLECTION)
             .where("prizeDrawProductId", "==", doc.id)
-            .where("paymentStatus", "==", "paid")
-            .where("status", "in", ["pending", "confirmed", "processing"])
+            .where(ORDER_FIELDS.PAYMENT_STATUS, "==", ORDER_FIELDS.PAYMENT_STATUS_VALUES.PAID)
+            .where(ORDER_FIELDS.STATUS, "in", [
+            ORDER_FIELDS.STATUS_VALUES.PENDING,
+            ORDER_FIELDS.STATUS_VALUES.CONFIRMED,
+            ORDER_FIELDS.STATUS_VALUES.PROCESSING,
+        ])
             .get();
         let notified = 0;
         for (const orderDoc of orders.docs) {

package/dist/_internal/server/jobs/core/prizeRevealReminder.js

@@ -1,4 +1,5 @@
 import { notificationRepository } from "../../../../repositories";
+import { ORDER_FIELDS, PRODUCT_FIELDS } from "../../../../constants/field-names";
 const ORDER_COLLECTION = "orders";
 const ONE_DAY_MS = 86400000;
 export async function runPrizeRevealReminder(ctx) {
@@ -6,10 +7,14 @@ export async function runPrizeRevealReminder(ctx) {
     const cutoff = new Date(ctx.now.getTime() + ONE_DAY_MS);
     const snap = await ctx.db
         .collection(ORDER_COLLECTION)
-        .where("paymentStatus", "==", "paid")
-        .where("status", "in", ["pending", "confirmed", "processing"])
-        .where("prizeRevealDeadline", "<=", cutoff)
-        .where("prizeRevealDeadline", ">", ctx.now)
+        .where(ORDER_FIELDS.PAYMENT_STATUS, "==", ORDER_FIELDS.PAYMENT_STATUS_VALUES.PAID)
+        .where(ORDER_FIELDS.STATUS, "in", [
+        ORDER_FIELDS.STATUS_VALUES.PENDING,
+        ORDER_FIELDS.STATUS_VALUES.CONFIRMED,
+        ORDER_FIELDS.STATUS_VALUES.PROCESSING,
+    ])
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_DEADLINE, "<=", cutoff)
+        .where(PRODUCT_FIELDS.PRIZE_REVEAL_DEADLINE, ">", ctx.now)
         .limit(500)
         .get();
     let notified = 0;

package/dist/_internal/server/jobs/core/triggerEventRaffle.js

@@ -3,6 +3,7 @@
  * logic keys off the event's `raffleType`.
  */
 import crypto from "node:crypto";
+import { EVENT_ENTRY_FIELDS } from "../../../../constants/field-names";
 const EVENTS_COLLECTION = "events";
 const EVENT_ENTRIES_COLLECTION = "eventEntries";
 export async function runTriggerEventRaffle(input, ctx) {
@@ -28,8 +29,8 @@ export async function runTriggerEventRaffle(input, ctx) {
     const topN = input.topN ?? event.raffleTopN ?? 0;
     const entriesSnap = await ctx.db
         .collection(EVENT_ENTRIES_COLLECTION)
-        .where("eventId", "==", input.eventId)
-        .where("status", "==", "CONFIRMED")
+        .where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", input.eventId)
+        .where(EVENT_ENTRY_FIELDS.STATUS, "==", EVENT_ENTRY_FIELDS.STATUS_VALUES.CONFIRMED)
         .get();
     let pool = entriesSnap.docs.map((d) => ({
         id: d.id,

package/dist/_internal/shared/features/blog/schema.d.ts

@@ -17,9 +17,9 @@ export declare const blogPostInputSchema: z.ZodObject<{
     title: string;
     content: string;
     category: string;
-    slug: string;
     tags: string[];
     isFeatured: boolean;
+    slug: string;
     youtubeId?: string | undefined;
     coverImage?: string | undefined;
     excerpt?: string | undefined;
@@ -31,9 +31,9 @@ export declare const blogPostInputSchema: z.ZodObject<{
     category: string;
     slug: string;
     status?: "draft" | "published" | undefined;
-    youtubeId?: string | undefined;
     tags?: string[] | undefined;
     isFeatured?: boolean | undefined;
+    youtubeId?: string | undefined;
     coverImage?: string | undefined;
     excerpt?: string | undefined;
     metaTitle?: string | undefined;
@@ -57,9 +57,9 @@ export declare const blogPostUpdateSchema: z.ZodObject<Omit<{
     title?: string | undefined;
     content?: string | undefined;
     category?: string | undefined;
-    youtubeId?: string | undefined;
     tags?: string[] | undefined;
     isFeatured?: boolean | undefined;
+    youtubeId?: string | undefined;
     coverImage?: string | undefined;
     excerpt?: string | undefined;
     metaTitle?: string | undefined;
@@ -69,9 +69,9 @@ export declare const blogPostUpdateSchema: z.ZodObject<Omit<{
     title?: string | undefined;
     content?: string | undefined;
     category?: string | undefined;
-    youtubeId?: string | undefined;
     tags?: string[] | undefined;
     isFeatured?: boolean | undefined;
+    youtubeId?: string | undefined;
     coverImage?: string | undefined;
     excerpt?: string | undefined;
     metaTitle?: string | undefined;

package/dist/_internal/shared/features/categories/bundle-copy.d.ts

@@ -108,16 +108,13 @@ export declare const BUNDLE_COPY: {
     };
     readonly stockBadge: {
         readonly in_stock: "In stock";
-        readonly partial: "Some items unavailable";
-        readonly out_of_stock: "Currently out of stock";
+        readonly out_of_stock: "Not active";
         readonly listVariantInStock: "In stock";
-        readonly listVariantPartial: "Partial";
-        readonly listVariantOutOfStock: "Out of stock";
+        readonly listVariantOutOfStock: "Not active";
     };
 };
 /** Stock-status variant mapping (kept here so consumers can drive Badge variant prop). */
 export declare const BUNDLE_STOCK_VARIANT: {
     readonly in_stock: "success";
-    readonly partial: "warning";
-    readonly out_of_stock: "danger";
+    readonly out_of_stock: "warning";
 };

package/dist/_internal/shared/features/categories/bundle-copy.js

@@ -119,16 +119,13 @@ export const BUNDLE_COPY = {
     // Stock badges (shared between list + featured + detail)
     stockBadge: {
         in_stock: "In stock",
-        partial: "Some items unavailable",
-        out_of_stock: "Currently out of stock",
+        out_of_stock: "Not active",
         listVariantInStock: "In stock",
-        listVariantPartial: "Partial",
-        listVariantOutOfStock: "Out of stock",
+        listVariantOutOfStock: "Not active",
     },
 };
 /** Stock-status variant mapping (kept here so consumers can drive Badge variant prop). */
 export const BUNDLE_STOCK_VARIANT = {
     in_stock: "success",
-    partial: "warning",
-    out_of_stock: "danger",
+    out_of_stock: "warning",
 };

package/dist/_internal/shared/features/categories/bundle-schemas.d.ts

@@ -25,34 +25,34 @@ export declare const bundleQueryRuleSchema: z.ZodDiscriminatedUnion<"type", [z.Z
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         listingType: z.ZodOptional<z.ZodEnum<["standard", "pre-order"]>>;
     }, "strip", z.ZodTypeAny, {
-        listingType?: "standard" | "pre-order" | undefined;
-        brandSlug?: string | undefined;
         tags?: string[] | undefined;
-        categorySlug?: string | undefined;
-    }, {
         listingType?: "standard" | "pre-order" | undefined;
+        categorySlug?: string | undefined;
         brandSlug?: string | undefined;
+    }, {
         tags?: string[] | undefined;
+        listingType?: "standard" | "pre-order" | undefined;
         categorySlug?: string | undefined;
+        brandSlug?: string | undefined;
     }>;
     orderBy: z.ZodOptional<z.ZodEnum<["price-asc", "price-desc", "createdAt-desc"]>>;
     limit: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     filter: {
-        listingType?: "standard" | "pre-order" | undefined;
-        brandSlug?: string | undefined;
         tags?: string[] | undefined;
+        listingType?: "standard" | "pre-order" | undefined;
         categorySlug?: string | undefined;
+        brandSlug?: string | undefined;
     };
     type: "dynamic";
     limit: number;
     orderBy?: "price-asc" | "price-desc" | "createdAt-desc" | undefined;
 }, {
     filter: {
-        listingType?: "standard" | "pre-order" | undefined;
-        brandSlug?: string | undefined;
         tags?: string[] | undefined;
+        listingType?: "standard" | "pre-order" | undefined;
         categorySlug?: string | undefined;
+        brandSlug?: string | undefined;
     };
     type: "dynamic";
     limit: number;
@@ -93,34 +93,34 @@ export declare const bundleCreateSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             listingType: z.ZodOptional<z.ZodEnum<["standard", "pre-order"]>>;
         }, "strip", z.ZodTypeAny, {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
-            categorySlug?: string | undefined;
-        }, {
             listingType?: "standard" | "pre-order" | undefined;
+            categorySlug?: string | undefined;
             brandSlug?: string | undefined;
+        }, {
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         }>;
         orderBy: z.ZodOptional<z.ZodEnum<["price-asc", "price-desc", "createdAt-desc"]>>;
         limit: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
         orderBy?: "price-asc" | "price-desc" | "createdAt-desc" | undefined;
     }, {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
@@ -150,10 +150,10 @@ export declare const bundleCreateSchema: z.ZodObject<{
         productIds: string[];
     } | {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
@@ -176,10 +176,10 @@ export declare const bundleCreateSchema: z.ZodObject<{
         productIds: string[];
     } | {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
@@ -215,34 +215,34 @@ export declare const bundleUpdateSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             listingType: z.ZodOptional<z.ZodEnum<["standard", "pre-order"]>>;
         }, "strip", z.ZodTypeAny, {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
-            categorySlug?: string | undefined;
-        }, {
             listingType?: "standard" | "pre-order" | undefined;
+            categorySlug?: string | undefined;
             brandSlug?: string | undefined;
+        }, {
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         }>;
         orderBy: z.ZodOptional<z.ZodEnum<["price-asc", "price-desc", "createdAt-desc"]>>;
         limit: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
         orderBy?: "price-asc" | "price-desc" | "createdAt-desc" | undefined;
     }, {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
@@ -279,10 +279,10 @@ export declare const bundleUpdateSchema: z.ZodObject<{
         productIds: string[];
     } | {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;
@@ -304,10 +304,10 @@ export declare const bundleUpdateSchema: z.ZodObject<{
         productIds: string[];
     } | {
         filter: {
-            listingType?: "standard" | "pre-order" | undefined;
-            brandSlug?: string | undefined;
             tags?: string[] | undefined;
+            listingType?: "standard" | "pre-order" | undefined;
             categorySlug?: string | undefined;
+            brandSlug?: string | undefined;
         };
         type: "dynamic";
         limit: number;