@mohasinac/appkit 4.12.3 → 4.13.0

package/dist/_internal/server/features/brands/actions.js

@@ -37,7 +37,12 @@ function brandInputToCategoryFields(input) {
 }
 export async function createBrandAction(input) {
     return wrapAction(async () => {
-        await requireRoleUser("admin");
+        // Sellers create brands inline from the product form's brand picker
+        // (BrandInlineSelect -> BrandQuickCreateForm); there is no /store/brands
+        // page. Mirrors ROLES_STORE_WRITE on the only caller,
+        // src/app/api/admin/brands/route.ts. Kept as a gate rather than dropped:
+        // this is a "use server" export and is independently callable.
+        const actor = await requireRoleUser(["admin", "seller"]);
         const parsed = brandInputSchema.safeParse(input);
         if (!parsed.success)
             throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid brand input");
@@ -73,7 +78,7 @@ export async function createBrandAction(input) {
             },
             seo: { title: parsed.data.name, description: parsed.data.description ?? "", keywords: [parsed.data.name] },
             ancestors: [],
-            createdBy: "admin",
+            createdBy: actor.uid,
             createdAt: new Date(),
             updatedAt: new Date(),
             ...fields,

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

@@ -13,6 +13,7 @@ import { runHardBanCascade } from "./hardBanCascade";
 import { runResetOtpVerification } from "./resetOtpVerification";
 import { runWhatsAppNotify } from "./whatsappNotify";
 import { runNewsletterExport } from "./newsletterExport";
+import { runWhatsAppCatalogImport } from "./whatsappCatalogImport";
 async function runPayoutsWeeklyJob(_payload, ctx) {
     const { payoutsCreated, ordersProcessed, payoutIds } = await runWeeklyPayoutEligibility(ctx);
     return {
@@ -45,10 +46,14 @@ async function runWhatsAppNotifyJob(payload, ctx) {
 async function runNewsletterExportJob(_payload, ctx) {
     return runNewsletterExport(ctx);
 }
+async function runWhatsAppCatalogImportJob(payload, ctx) {
+    return runWhatsAppCatalogImport({ storeSlug: String(payload.storeSlug ?? "") }, ctx);
+}
 export const JOB_RUNNERS = {
     payoutsWeekly: runPayoutsWeeklyJob,
     hardBanCascade: runHardBanCascadeJob,
     resetOtpVerification: runResetOtpVerificationJob,
     whatsappNotify: runWhatsAppNotifyJob,
     newsletterExport: runNewsletterExportJob,
+    whatsappCatalogImport: runWhatsAppCatalogImportJob,
 };

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

@@ -2,6 +2,7 @@ import { normalizeError } from "../../../../errors/normalize";
 import { storeRepository, userRepository } from "../../../../repositories";
 import { decryptPii } from "../../../../security/index";
 import { sendWhatsAppBusinessMessage, buildPurchaseAnnouncementMessage, } from "../../../../features/whatsapp-bot/server";
+import { resolveKeys } from "../../../../core/integration-keys";
 async function sendAnnouncement(ctx, toPhone, message, phoneNumberId, accessToken, label, orderId) {
     try {
         const sent = await sendWhatsAppBusinessMessage({
@@ -44,10 +45,40 @@ async function notifyStoreOwner(ctx, storeId, message, phoneNumberId, accessToke
         ctx.logger.error("Store owner lookup failed (non-fatal)", err, { orderId, storeId });
     }
 }
+/**
+ * Seeded credentials are `*_PLACEHOLDER` strings rather than empty, so an
+ * emptiness test alone would happily send with a fake token. Mirrors the guard
+ * in checkout-value-otp-actions.ts.
+ */
+function usable(value) {
+    const v = value?.trim() ?? "";
+    return v && !v.includes("PLACEHOLDER") ? v : "";
+}
+async function resolveWhatsAppCredentials(ctx, orderId) {
+    let db = {};
+    try {
+        db = await resolveKeys();
+    }
+    catch (err) {
+        void normalizeError(err);
+        // Firestore unreachable from the Functions runtime — env-only is still a
+        // valid configuration, so this is a warning, not a failure.
+        ctx.logger.warn("Credential lookup failed — falling back to env", { orderId });
+    }
+    return {
+        phoneNumberId: usable(db.whatsappPhoneNumberId) || usable(ctx.env("WHATSAPP_PHONE_NUMBER_ID")),
+        accessToken: usable(db.whatsappCloudApiToken) || usable(ctx.env("WHATSAPP_CLOUD_API_TOKEN")),
+        adminNumbersRaw: usable(db.whatsappAdminNotifyNumbers) || usable(ctx.env("WHATSAPP_ADMIN_NOTIFY_NUMBERS")),
+    };
+}
 export async function handleOrderCreate(input, ctx) {
     const { orderId, order } = input;
-    const phoneNumberId = ctx.env("WHATSAPP_PHONE_NUMBER_ID") ?? "";
-    const accessToken = ctx.env("WHATSAPP_CLOUD_API_TOKEN") ?? "";
+    // Credentials resolve DB-first (Admin → Site Settings → WhatsApp) with an env
+    // fallback, matching resolveKeys() and every other WhatsApp send path. This
+    // read ctx.env() ONLY until 2026-08-22, so credentials saved in Site Settings
+    // never reached the order-placed announcement — it silently no-op'd unless the
+    // Functions runtime also carried the env vars.
+    const { phoneNumberId, accessToken, adminNumbersRaw } = await resolveWhatsAppCredentials(ctx, orderId);
     if (!phoneNumberId || !accessToken) {
         ctx.logger.info("WhatsApp Cloud API not configured — skipping announcement", { orderId });
         return;
@@ -64,7 +95,6 @@ export async function handleOrderCreate(input, ctx) {
         totalAmount: order.totalPrice ?? 0,
         orderId,
     });
-    const adminNumbersRaw = ctx.env("WHATSAPP_ADMIN_NOTIFY_NUMBERS") ?? "";
     const adminNumbers = adminNumbersRaw
         .split(",")
         .map((n) => n.trim().replace(/\D/g, ""))

package/dist/_internal/server/jobs/core/whatsappCatalogImport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Core: async WhatsApp Business Catalog import (`whatsappCatalogImport` job).
+ *
+ * `POST /api/store/whatsapp-settings/catalog-import` used to do this inline:
+ * one Meta fetch capped at `limit=250`, then a sequential per-item loop doing
+ * up to 2 `findBySlug` reads plus 1 `create` write EACH — a real 10s-timeout
+ * risk on Vercel Hobby (CLAUDE.md Rule #6) well before the cap was reached.
+ * It also declared `paging.next` in its response type and never followed it,
+ * so a catalog larger than 250 items silently imported only the first page.
+ *
+ * Running here instead buys the Function's 300s budget, which is what makes
+ * following `paging.next` safe rather than making the timeout worse.
+ *
+ * Two efficiency changes vs. the old route:
+ *  - Existing-slug detection is ONE `findByStore` read into a Set, not 2 reads
+ *    per item. A seller's WA catalog is populated by pushing their own store's
+ *    products, so store-scoped lookup is equivalent to the old global
+ *    `findBySlug` here while costing a single query.
+ *  - That Set is updated as we create, so duplicate rows within one Meta
+ *    response can't produce two products.
+ */
+import type { JobContext } from "../runtime/types";
+import type { JobRunResult } from "./jobRunners";
+export interface WhatsAppCatalogImportPayload {
+    storeSlug: string;
+}
+export declare function runWhatsAppCatalogImport(payload: WhatsAppCatalogImportPayload, ctx: JobContext): Promise<JobRunResult>;

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

@@ -0,0 +1,172 @@
+/**
+ * Core: async WhatsApp Business Catalog import (`whatsappCatalogImport` job).
+ *
+ * `POST /api/store/whatsapp-settings/catalog-import` used to do this inline:
+ * one Meta fetch capped at `limit=250`, then a sequential per-item loop doing
+ * up to 2 `findBySlug` reads plus 1 `create` write EACH — a real 10s-timeout
+ * risk on Vercel Hobby (CLAUDE.md Rule #6) well before the cap was reached.
+ * It also declared `paging.next` in its response type and never followed it,
+ * so a catalog larger than 250 items silently imported only the first page.
+ *
+ * Running here instead buys the Function's 300s budget, which is what makes
+ * following `paging.next` safe rather than making the timeout worse.
+ *
+ * Two efficiency changes vs. the old route:
+ *  - Existing-slug detection is ONE `findByStore` read into a Set, not 2 reads
+ *    per item. A seller's WA catalog is populated by pushing their own store's
+ *    products, so store-scoped lookup is equivalent to the old global
+ *    `findBySlug` here while costing a single query.
+ *  - That Set is updated as we create, so duplicate rows within one Meta
+ *    response can't produce two products.
+ */
+import { normalizeError } from "../../../../errors/normalize";
+import { storeRepository, productRepository } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+const META_GRAPH_BASE = "https://graph.facebook.com/v20.0";
+const SLUG_PREFIX = "product-";
+const PAGE_SIZE = 250;
+/**
+ * Defensive stop. 40 pages x 250 = 10,000 items, far beyond any realistic
+ * seller catalog — this exists so a malformed/looping `paging.next` from Meta
+ * can't spin until the Function's 300s ceiling kills the job mid-write.
+ */
+const MAX_PAGES = 40;
+/** Meta returns "<amount> <currency>", e.g. "450.00 INR". */
+function parseMetaPrice(raw) {
+    if (!raw)
+        return 0;
+    const digits = raw.replace(/[^0-9.]/g, "");
+    return Math.round((parseFloat(digits) || 0) * 100) / 100;
+}
+/**
+ * The LetItRip slug a Meta item claims to correspond to, if any. Items we
+ * pushed carry it in `description` (see catalog-sync's field mapping) and/or
+ * `retailer_id`; items authored natively in Meta carry neither.
+ */
+function claimedSlug(item) {
+    const description = (item.description ?? "").trim();
+    if (description.startsWith(SLUG_PREFIX))
+        return description;
+    const retailerId = (item.retailer_id ?? "").trim();
+    if (retailerId.startsWith(SLUG_PREFIX))
+        return retailerId;
+    return null;
+}
+export async function runWhatsAppCatalogImport(payload, ctx) {
+    const { storeSlug } = payload;
+    const empty = { total: 0, succeeded: 0, skipped: 0, failed: 0 };
+    const store = await storeRepository.findBySlug(storeSlug);
+    if (!store) {
+        return {
+            summary: empty,
+            succeeded: [],
+            skipped: [],
+            failed: [{ id: storeSlug, reason: "Store not found" }],
+        };
+    }
+    const cfg = store.whatsappConfig;
+    const token = cfg?.accessToken ? decryptPii(cfg.accessToken) : null;
+    // Re-checked here even though the route gates on the same conditions — the
+    // job doc outlives the request, and the seller could disconnect in between.
+    if (!cfg?.connected || !cfg.catalogId || !token) {
+        return {
+            summary: empty,
+            succeeded: [],
+            skipped: [],
+            failed: [{ id: storeSlug, reason: "WhatsApp is not connected for this store" }],
+        };
+    }
+    const existing = await productRepository.findByStore(store.storeSlug);
+    const knownSlugs = new Set(existing.map((p) => p.slug).filter((s) => Boolean(s)));
+    const imported = [];
+    const skipped = [];
+    const failed = [];
+    let url = `${META_GRAPH_BASE}/${cfg.catalogId}/products` +
+        `?fields=name,price,currency,image_url,description,retailer_id&limit=${PAGE_SIZE}`;
+    let page = 0;
+    let truncated = false;
+    while (url) {
+        if (page >= MAX_PAGES) {
+            truncated = true;
+            ctx.logger.warn("whatsappCatalogImport: page cap reached — catalog truncated", {
+                storeSlug,
+                maxPages: MAX_PAGES,
+                importedSoFar: imported.length,
+            });
+            break;
+        }
+        page++;
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            const reason = body.error?.message ?? res.statusText;
+            ctx.logger.error("whatsappCatalogImport: Meta fetch failed", null, { storeSlug, page, reason });
+            failed.push({ id: `page-${page}`, reason: `Meta fetch failed: ${reason}` });
+            break;
+        }
+        const body = (await res.json());
+        const items = body.data ?? [];
+        for (const item of items) {
+            const slug = claimedSlug(item);
+            if (slug && knownSlugs.has(slug)) {
+                skipped.push(item.id);
+                continue;
+            }
+            const input = {
+                title: item.name ?? `WhatsApp Import ${item.id}`,
+                description: "",
+                slug: "",
+                listingType: "standard",
+                status: "draft",
+                price: parseMetaPrice(item.price),
+                currency: "INR",
+                mainImage: item.image_url ?? "",
+                images: [],
+                stockQuantity: 1,
+                condition: "new",
+                storeId: store.id,
+                storeName: store.storeName,
+                tags: ["whatsapp-import"],
+                categorySlugs: [],
+                featured: false,
+            };
+            try {
+                const created = await productRepository.create(input);
+                // Guard against the same item appearing twice in one Meta response.
+                if (slug)
+                    knownSlugs.add(slug);
+                if (created.slug)
+                    knownSlugs.add(created.slug);
+                imported.push(created.id);
+            }
+            catch (err) {
+                void normalizeError(err);
+                failed.push({
+                    id: item.id,
+                    reason: err instanceof Error ? err.message : "Product create failed",
+                });
+            }
+        }
+        url = body.paging?.next;
+    }
+    ctx.logger.info("whatsappCatalogImport: complete", {
+        storeSlug,
+        pages: page,
+        imported: imported.length,
+        skipped: skipped.length,
+        failed: failed.length,
+        truncated,
+    });
+    return {
+        summary: {
+            total: imported.length + skipped.length + failed.length,
+            succeeded: imported.length,
+            skipped: skipped.length,
+            failed: failed.length,
+        },
+        succeeded: imported,
+        skipped,
+        failed,
+        data: { imported: imported.length, skipped: skipped.length, pages: page, truncated },
+    };
+}

package/dist/core/hooks/useSiteSettings.d.ts

@@ -1 +1 @@
-export declare function useSiteSettings<T = unknown>(endpoint?: "/api/site-settings", staleTime?: number): import("@tanstack/react-query").UseQueryResult<NoInfer<T>, Error>;
+export declare function useSiteSettings<T = unknown>(endpoint?: "/api/site-settings", staleTime?: number): import("@tanstack/react-query").UseQueryResult<T, Error>;

package/dist/features/account/hooks/useAccount.d.ts

@@ -5,9 +5,9 @@ interface UseProfileOptions {
     endpoint?: string;
 }
 export declare function useProfile(userId: string, opts?: UseProfileOptions): {
-    profile: NoInfer<UserProfile> | undefined;
+    profile: UserProfile | undefined;
     isLoading: boolean;
     error: Error | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<UserProfile>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<UserProfile, Error>>;
 };
 export {};

package/dist/features/account/hooks/useAddressSelector.d.ts

@@ -18,7 +18,7 @@ export declare function useAddressSelector(options?: {
 }): {
     addresses: SavedAddress[];
     isLoading: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<SavedAddress[]>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SavedAddress[], Error>>;
     createAddress: import("@tanstack/react-query").UseMutateFunction<CreateAddressApiResponse, Error, AddressFormData, unknown>;
     isSaving: boolean;
 };

package/dist/features/account/hooks/useAddresses.d.ts

@@ -36,11 +36,11 @@ export declare function useAddresses(options?: {
     enabled?: boolean;
     listEndpoint?: string;
     filters?: AddressFilterParams;
-}): import("@tanstack/react-query").UseQueryResult<NoInfer<Address[]>, Error>;
+}): import("@tanstack/react-query").UseQueryResult<Address[], Error>;
 export declare function useAddress(id: string, options?: {
     enabled?: boolean;
     byIdEndpoint?: (id: string) => string;
-}): import("@tanstack/react-query").UseQueryResult<NoInfer<Address>, Error>;
+}): import("@tanstack/react-query").UseQueryResult<Address, Error>;
 export declare function useCreateAddress(options?: {
     listEndpoint?: string;
     onSuccess?: (data: Address) => void;

package/dist/features/account/hooks/useNotifications.d.ts

@@ -17,7 +17,7 @@ export declare function useNotifications<TNotification = any>(limit?: number, op
     notifications: TNotification[];
     unreadCount: number;
     isLoading: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<NotificationsResponse<TNotification>>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NotificationsResponse<TNotification>, Error>>;
     markRead: import("@tanstack/react-query").UseMutateFunction<unknown, Error, string, unknown>;
     markAllRead: import("@tanstack/react-query").UseMutateFunction<unknown, Error, void, unknown>;
     isMarkingAll: boolean;

package/dist/features/account/hooks/useProfile.d.ts

@@ -40,7 +40,7 @@ export interface UpdateCurrentProfileInput {
 export declare function useCurrentProfile(options?: {
     enabled?: boolean;
     endpoint?: string;
-}): import("@tanstack/react-query").UseQueryResult<NoInfer<UserProfile>, Error>;
+}): import("@tanstack/react-query").UseQueryResult<UserProfile, Error>;
 export declare function useUpdateCurrentProfile(options?: {
     onSuccess?: (data: JsonValue) => void;
     onError?: (error: Error) => void;

package/dist/features/account/hooks/usePublicProfile.d.ts

@@ -71,8 +71,8 @@ export declare function usePublicProfile(userId: string, options?: PublicProfile
     loading: boolean;
     profileError: string;
     isSeller: boolean;
-    productsData: NoInfer<ProductsApiResponse> | undefined;
+    productsData: ProductsApiResponse | undefined;
     productsLoading: boolean;
-    reviewsData: NoInfer<SellerReviewsData> | undefined;
+    reviewsData: SellerReviewsData | undefined;
     reviewsLoading: boolean;
 };

package/dist/features/admin/hooks/useAdmin.d.ts

@@ -3,7 +3,7 @@ export declare function useDashboardStats(opts?: {
     initialData?: DashboardStats;
     enabled?: boolean;
 }): {
-    stats: NoInfer<DashboardStats> | undefined;
+    stats: DashboardStats | undefined;
     isLoading: boolean;
     error: Error | null;
 };

package/dist/features/admin/hooks/useAdminSectionsListing.d.ts

@@ -23,6 +23,6 @@ export declare function useAdminSectionsListing({ page, pageSize, sorts, filters
     hasMore: boolean;
     isLoading: boolean;
     errorMessage: string | undefined;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AdminSectionsListingResponse>, ApiClientError>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<AdminSectionsListingResponse, ApiClientError>>;
 };
 export {};

package/dist/features/admin/hooks/useChat.d.ts

@@ -16,7 +16,7 @@ export interface UseChatReturn {
 export declare function useChat(chatId: string | null, options?: {
     realtimeProvider?: IClientRealtimeProvider;
 }): UseChatReturn;
-export declare function useChatRooms(): import("@tanstack/react-query").UseQueryResult<NoInfer<unknown[]>, Error>;
+export declare function useChatRooms(): import("@tanstack/react-query").UseQueryResult<unknown[], Error>;
 export declare function useCreateChatRoom(): import("@tanstack/react-query").UseMutationResult<unknown, import("@mohasinac/appkit/client").ApiError, {
     orderId: string;
     ownerId: string;

package/dist/features/auctions/hooks/useAuctions.d.ts

@@ -17,22 +17,22 @@ interface UseAuctionDetailOptions {
     bidsQueryKeyPrefix?: string;
 }
 export declare function useAuctions(params?: AuctionListQuery, opts?: UseAuctionsOptions): {
-    data: NoInfer<AuctionListResponse> | undefined;
+    data: AuctionListResponse | undefined;
     auctions: AuctionItem[];
     total: number;
     totalPages: number;
     hasMore: boolean;
     isLoading: boolean;
     error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuctionListResponse>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<AuctionListResponse, Error>>;
 };
 export declare function useAuction(slug: string, opts?: {
     enabled?: boolean;
 }): {
-    auction: NonNullable<NoInfer<AuctionItem | null>> | null;
+    auction: AuctionItem | null;
     isLoading: boolean;
     error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuctionItem | null>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<AuctionItem | null, Error>>;
 };
 export declare function useAuctionBids(auctionSlug: string, limit?: number, opts?: {
     enabled?: boolean;
@@ -43,9 +43,9 @@ export declare function useAuctionBids(auctionSlug: string, limit?: number, opts
     error: string | null;
 };
 export declare function useAuctionDetail(id: string, opts?: UseAuctionDetailOptions): {
-    productQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<ProductItem | null>, Error>;
-    product: NonNullable<NoInfer<ProductItem | null>> | null;
-    bidsQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<PublicBid[]>, Error>;
-    bids: NoInfer<PublicBid[]>;
+    productQuery: import("@tanstack/react-query").UseQueryResult<ProductItem | null, Error>;
+    product: ProductItem | null;
+    bidsQuery: import("@tanstack/react-query").UseQueryResult<PublicBid[], Error>;
+    bids: PublicBid[];
 };
 export {};

package/dist/features/auth/hooks/useAuth.d.ts

@@ -5,11 +5,11 @@ interface UseCurrentUserOptions {
     enabled?: boolean;
 }
 export declare function useCurrentUser(opts?: UseCurrentUserOptions): {
-    user: NonNullable<NoInfer<AuthUser | null>> | null;
+    user: AuthUser | null;
     isLoading: boolean;
     isAuthenticated: boolean;
     error: Error | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthUser | null>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<AuthUser | null, Error>>;
 };
 export interface LoginCredentials {
     email: string;

package/dist/features/cart/hooks/useCart.d.ts

@@ -12,6 +12,6 @@ export declare function useCart(userIdOrSession: string, opts?: UseCartOptions):
     itemCount: number;
     isLoading: boolean;
     error: Error | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<CartData>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<CartData, Error>>;
 };
 export {};

package/dist/features/cart/hooks/useCartQuery.d.ts

@@ -5,5 +5,5 @@ interface UseCartQueryOptions<TData> {
     enabled?: boolean;
     initialData?: TData;
 }
-export declare function useCartQuery<TData = unknown>(options: UseCartQueryOptions<TData>): import("@tanstack/react-query").UseQueryResult<NoInfer<TData>, Error>;
+export declare function useCartQuery<TData = unknown>(options: UseCartQueryOptions<TData>): import("@tanstack/react-query").UseQueryResult<TData, Error>;
 export {};

package/dist/features/cart/hooks/useCheckoutReadQueries.d.ts

@@ -9,7 +9,7 @@ interface UseCheckoutReadQueriesOptions<TAddress, TCart> {
     initialCart?: TCart;
 }
 export declare function useCheckoutReadQueries<TAddress = unknown, TCart = unknown>(options: UseCheckoutReadQueriesOptions<TAddress, TCart>): {
-    addressQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<TAddress[]>, Error>;
-    cartQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<TCart>, Error>;
+    addressQuery: import("@tanstack/react-query").UseQueryResult<TAddress[], Error>;
+    cartQuery: import("@tanstack/react-query").UseQueryResult<TCart, Error>;
 };
 export {};

package/dist/features/cart/hooks/useOrder.d.ts

@@ -5,9 +5,9 @@ interface UseOrderOptions<TOrder> {
     initialData?: TOrder | null;
 }
 export declare function useOrder<TOrder = unknown>(orderId: string | null, options?: UseOrderOptions<TOrder>): {
-    order: NonNullable<NoInfer<TOrder | null>> | null;
+    order: NonNullable<TOrder> | null;
     isLoading: boolean;
     error: Error | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<TOrder | null>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TOrder | null, Error>>;
 };
 export {};

package/dist/features/categories/hooks/useCategories.d.ts

@@ -4,7 +4,7 @@ interface UseCategoriesListOptions {
     enabled?: boolean;
 }
 export declare function useCategoriesList(opts?: UseCategoriesListOptions): {
-    categories: NoInfer<CategoryItem[]>;
+    categories: CategoryItem[];
     total: number;
     isLoading: boolean;
     error: Error | null;
@@ -37,8 +37,8 @@ interface UseCategoryDetailOptions {
     childrenEndpoint?: string;
 }
 export declare function useCategoryDetail(slug: string, opts?: UseCategoryDetailOptions): {
-    category: NonNullable<NoInfer<CategoryItem | null>> | null;
-    children: NoInfer<CategoryItem[]>;
+    category: CategoryItem | null;
+    children: CategoryItem[];
     isLoading: boolean;
     childrenLoading: boolean;
     error: Error | null;

package/dist/features/categories/hooks/useCategorySelector.d.ts

@@ -9,16 +9,16 @@ export interface UseCategorySelectorOptions {
 export declare function useCategorySelector(options?: UseCategorySelectorOptions): {
     categories: CategoryItem[];
     isLoading: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<CategoryItem[]>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<CategoryItem[], Error>>;
     createCategory: import("@tanstack/react-query").UseMutateFunction<CategoryItem, Error, Record<string, JsonValue>, unknown>;
     isCreating: boolean;
 };
 export declare function useCategories(options?: {
     endpoint?: string;
 }): {
-    categories: NoInfer<CategoryItem[]>;
+    categories: CategoryItem[];
     isLoading: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<CategoryItem[]>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<CategoryItem[], Error>>;
 };
 export declare function useCreateCategory(options?: {
     endpoint?: string;

package/dist/features/categories/hooks/useCategoryTree.d.ts

@@ -7,7 +7,7 @@ import type { CategoryItem } from "../types";
 export declare function useCategoryTree(opts?: {
     enabled?: boolean;
 }): {
-    categories: NoInfer<CategoryItem[]>;
+    categories: CategoryItem[];
     isLoading: boolean;
 };
 /** Convert category tree to FacetOption[] with indentation prefix for tier > 0. */

package/dist/features/checkout/hooks/useCheckoutApi.d.ts

@@ -62,8 +62,8 @@ interface UseCheckoutOptions<TAddress = any, TCart = any> {
     initialCart?: CartApiResponse<TCart>;
 }
 export declare function useCheckout<TAddress = any, TCart = any>(options?: UseCheckoutOptions<TAddress, TCart>): {
-    addressQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<TAddress[]>, Error>;
-    cartQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<CartApiResponse<TCart>>, Error>;
+    addressQuery: import("@tanstack/react-query").UseQueryResult<TAddress[], Error>;
+    cartQuery: import("@tanstack/react-query").UseQueryResult<CartApiResponse<TCart>, Error>;
     preflightMutation: import("@tanstack/react-query").UseMutationResult<PreflightResponse, Error, string, unknown>;
     placeCodOrderMutation: import("@tanstack/react-query").UseMutationResult<PlaceOrderResponse, Error, PlaceOrderPayload, unknown>;
     createPaymentOrderMutation: import("@tanstack/react-query").UseMutationResult<CreatePaymentOrderResponse, Error, CreatePaymentOrderPayload, unknown>;

package/dist/features/collections/hooks/useCollections.d.ts

@@ -1,7 +1,7 @@
 import type { CollectionItem, CollectionListItem } from "../types";
 export declare function useCollections(opts?: {
     endpoint?: string;
-}): import("@tanstack/react-query").UseQueryResult<NoInfer<CollectionListItem[]>, Error>;
+}): import("@tanstack/react-query").UseQueryResult<CollectionListItem[], Error>;
 export declare function useCollection(slug: string | undefined, opts?: {
     endpoint?: string;
-}): import("@tanstack/react-query").UseQueryResult<NoInfer<CollectionItem | null>, Error>;
+}): import("@tanstack/react-query").UseQueryResult<CollectionItem | null, Error>;

package/dist/features/events/hooks/useEvent.d.ts

@@ -16,7 +16,7 @@ export declare function useEvent<T extends EventItem = EventItem>(id: string, op
     event: T | null;
     isLoading: boolean;
     error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<EventItem | null>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventItem | null, Error>>;
 };
 export declare function useEventEntries(eventId: string, params?: {
     page?: number;
@@ -30,13 +30,13 @@ export declare function useEventEntries(eventId: string, params?: {
     total: number;
     isLoading: boolean;
     error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<EventEntryListResponse>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventEntryListResponse, Error>>;
 };
 export declare function useEventLeaderboard(eventId: string, limit?: number, opts?: {
     enabled?: boolean;
     endpoint?: string;
 }): {
-    leaderboard: NoInfer<LeaderboardEntry[]>;
+    leaderboard: LeaderboardEntry[];
     isLoading: boolean;
     error: string | null;
 };

package/dist/features/events/hooks/useEvents.d.ts

@@ -23,6 +23,6 @@ export declare function useEvents<T extends EventItem = EventItem>(params?: Even
     hasMore: boolean;
     isLoading: boolean;
     error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<EventListResponse>, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventListResponse, Error>>;
 };
 export {};

package/dist/features/faq/hooks/useFAQs.d.ts

@@ -15,7 +15,7 @@ export declare function useFAQ(id: string, opts?: {
     enabled?: boolean;
     endpoint?: string;
 }): {
-    faq: NoInfer<FAQ> | undefined;
+    faq: FAQ | undefined;
     isLoading: boolean;
     error: Error | null;
 };