@teincfood/core 0.7.8 → 0.8.0

package/dist/hooks/analytics.hooks.js

@@ -0,0 +1,214 @@
+/**
+ * Seller analytics hooks — single source for both apps.
+ * Offline-first: local SQLite aggregates serve instantly; the network
+ * refreshes silently when online.
+ */
+import { useQuery } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { analyticsService } from "../adapters/services";
+import { listLocalOrders } from "../domain/orders/service";
+import { useIsEffectivelyOnline } from "./use-infinite-list";
+export const SELLER_ANALYTICS_KEYS = {
+    all: ["seller-analytics"],
+    analytics: (businessId, period) => [...SELLER_ANALYTICS_KEYS.all, businessId, period],
+};
+export const REVENUE_KEYS = {
+    all: ["revenue-summary"],
+    summary: (businessId, period) => [...REVENUE_KEYS.all, businessId, period],
+};
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+const OFFLINE_FIRST = { retry: false, networkMode: "offlineFirst" };
+/**
+ * Backend-shaped aggregates computed from local SQLite rows (offline).
+ * Field names mirror orders.ex get_seller_analytics / get_revenue_summary
+ * exactly so screens render identically online and offline.
+ */
+function filterByPeriod(orders, period) {
+    const now = new Date();
+    const todayStr = now.toISOString().slice(0, 10);
+    if (period === "today") {
+        return orders.filter((o) => (o.inserted_at ?? "").slice(0, 10) === todayStr);
+    }
+    if (period === "this_week") {
+        const startOfWeek = new Date(now);
+        startOfWeek.setDate(now.getDate() - now.getDay()); // Sunday
+        const startStr = startOfWeek.toISOString().slice(0, 10);
+        return orders.filter((o) => {
+            const d = (o.inserted_at ?? "").slice(0, 10);
+            return d >= startStr && d <= todayStr;
+        });
+    }
+    // this_month
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const startStr = startOfMonth.toISOString().slice(0, 10);
+    return orders.filter((o) => {
+        const d = (o.inserted_at ?? "").slice(0, 10);
+        return d >= startStr && d <= todayStr;
+    });
+}
+function aggregateLocal(orders, period, opts) {
+    const filtered = filterByPeriod(orders, period);
+    const total_revenue_minor = filtered.reduce((s, o) => s + (o.total_minor ?? 0), 0);
+    const total_orders = filtered.length;
+    const average_order_value_minor = total_orders ? Math.round(total_revenue_minor / total_orders) : 0;
+    const byMethod = new Map();
+    const byType = new Map();
+    const byDay = new Map();
+    const byStatus = {};
+    const itemQty = new Map();
+    const itemRev = new Map();
+    for (const o of filtered) {
+        const method = o.pos_payment_method ?? o.payment_mode ?? "cash";
+        const m = byMethod.get(method) ?? { revenue_minor: 0, count: 0 };
+        m.revenue_minor += o.total_minor ?? 0;
+        m.count += 1;
+        byMethod.set(method, m);
+        const t = o.order_type ?? "takeout";
+        const ty = byType.get(t) ?? { revenue_minor: 0, count: 0 };
+        ty.revenue_minor += o.total_minor ?? 0;
+        ty.count += 1;
+        byType.set(t, ty);
+        const day = (o.inserted_at ?? "").slice(0, 10);
+        const d = byDay.get(day) ?? { revenue_minor: 0, count: 0 };
+        d.revenue_minor += o.total_minor ?? 0;
+        d.count += 1;
+        byDay.set(day, d);
+        byStatus[o.status] = (byStatus[o.status] ?? 0) + 1;
+        for (const it of o.items ?? []) {
+            const name = it.menu_item?.name ?? "Unknown";
+            const qty = it.quantity ?? 0;
+            const rev = it.subtotal ?? it.total_price_minor ?? 0;
+            itemQty.set(name, (itemQty.get(name) ?? 0) + qty);
+            itemRev.set(name, (itemRev.get(name) ?? 0) + rev);
+        }
+    }
+    const pct = (v) => (total_revenue_minor > 0 ? Math.round((v / total_revenue_minor) * 1000) / 10 : 0);
+    if (opts.forRevenueSummary) {
+        return {
+            period,
+            total_revenue_minor,
+            total_orders,
+            average_order_value_minor,
+            by_payment_method: [...byMethod.entries()]
+                .map(([method, v]) => ({ method, ...v, percentage: pct(v.revenue_minor) }))
+                .sort((a, b) => b.revenue_minor - a.revenue_minor),
+            by_order_type: [...byType.entries()]
+                .map(([type, v]) => ({ type, ...v }))
+                .sort((a, b) => b.revenue_minor - a.revenue_minor),
+            by_day: [...byDay.entries()]
+                .map(([date, v]) => ({ date, ...v }))
+                .sort((a, b) => a.date.localeCompare(b.date)),
+            offline: true,
+        };
+    }
+    return {
+        period,
+        total_revenue_minor,
+        total_orders,
+        average_order_value_minor,
+        total_refunds_minor: 0,
+        top_items: [...itemQty.entries()]
+            .map(([name, quantity]) => ({ name, quantity, revenue_minor: itemRev.get(name) ?? 0 }))
+            .sort((a, b) => b.revenue_minor - a.revenue_minor)
+            .slice(0, 10),
+        orders_by_status: byStatus,
+        revenue_by_day: [...byDay.entries()]
+            .map(([date, v]) => ({ date, revenue_minor: v.revenue_minor }))
+            .sort((a, b) => a.date.localeCompare(b.date)),
+        offline: true,
+    };
+}
+async function localOrders(businessId) {
+    const { data } = await listLocalOrders(businessId, {}, 1, 500);
+    return (data ?? []);
+}
+export function useSellerAnalyticsQuery(period = "today", enabled = true) {
+    const businessId = useBusinessId();
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: SELLER_ANALYTICS_KEYS.analytics(businessId ?? "", period),
+        queryFn: async () => {
+            if (!online) {
+                try {
+                    return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }) };
+                }
+                catch {
+                    return { data: aggregateLocal([], period, { forRevenueSummary: false }) };
+                }
+            }
+            try {
+                const backendRes = await analyticsService.fetchSellerAnalytics(businessId, period);
+                // Safety net: if backend doesn't filter by period (returns all days regardless), filter locally
+                const backendData = backendRes.data;
+                const byDay = backendData?.revenue_by_day;
+                const shouldFilterLocally = !byDay?.length ||
+                    (period === "today" && byDay.length > 1) ||
+                    (period === "this_week" && byDay.some(d => {
+                        const day = new Date(d.date ?? "");
+                        const now = new Date();
+                        const startOfWeek = new Date(now);
+                        startOfWeek.setDate(now.getDate() - now.getDay());
+                        return day < startOfWeek || day > now;
+                    }));
+                if (shouldFilterLocally) {
+                    const localOrdersData = await localOrders(businessId);
+                    return { data: aggregateLocal(localOrdersData, period, { forRevenueSummary: false }) };
+                }
+                return backendRes;
+            }
+            catch {
+                return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }) };
+            }
+        },
+        enabled: enabled && Boolean(businessId),
+        staleTime: 30000,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useRevenueSummaryQuery(period = "today", enabled = true) {
+    const businessId = useBusinessId();
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: REVENUE_KEYS.summary(businessId ?? "", period),
+        queryFn: async () => {
+            if (!online) {
+                try {
+                    return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }) };
+                }
+                catch {
+                    return { data: aggregateLocal([], period, { forRevenueSummary: true }) };
+                }
+            }
+            try {
+                const backendRes = await analyticsService.fetchRevenueSummary(businessId, period);
+                // Safety net: if backend doesn't filter by period (returns all days regardless), filter locally
+                const backendData = backendRes.data;
+                const byDay = backendData?.by_day;
+                const shouldFilterLocally = !byDay?.length ||
+                    (period === "today" && byDay.length > 1) ||
+                    (period === "this_week" && byDay.some(d => {
+                        const day = new Date(d.date ?? "");
+                        const now = new Date();
+                        const startOfWeek = new Date(now);
+                        startOfWeek.setDate(now.getDate() - now.getDay());
+                        return day < startOfWeek || day > now;
+                    }));
+                if (shouldFilterLocally) {
+                    const localOrdersData = await localOrders(businessId);
+                    return { data: aggregateLocal(localOrdersData, period, { forRevenueSummary: true }) };
+                }
+                return backendRes;
+            }
+            catch {
+                return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }) };
+            }
+        },
+        enabled: enabled && Boolean(businessId),
+        staleTime: 30000,
+        ...OFFLINE_FIRST,
+    });
+}

package/dist/hooks/business-hours.hooks.d.ts

@@ -0,0 +1,8 @@
+import { type BusinessOpenState } from "../utils/business-hours";
+import type { OperatingHoursEntry } from "../types/api/business.api";
+export declare const BUSINESS_HOURS_KEYS: {
+    all: readonly ["business-hours"];
+    open: (bid?: string) => readonly ["business-hours", "open", string | undefined];
+};
+export declare function useBusinessOpenNow(businessId?: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<BusinessOpenState, Error>;
+export declare function useOperatingHours(businessId?: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<OperatingHoursEntry[], Error>;

package/dist/hooks/business-hours.hooks.js

@@ -0,0 +1,45 @@
+/**
+ * Business open/closed hook — reads the offline-first SQLite reference cache.
+ * Refetches on a minute cadence so the flag flips at hour boundaries, and on
+ * any reference-change invalidation (hours edited locally or background-synced).
+ */
+import { useQuery } from "@tanstack/react-query";
+import { isBusinessOpenNow } from "../utils/business-hours";
+import { getReferenceData } from "../reference/operations";
+import { openSyncDatabase } from "../db/connection";
+export const BUSINESS_HOURS_KEYS = {
+    all: ["business-hours"],
+    open: (bid) => [...BUSINESS_HOURS_KEYS.all, "open", bid],
+};
+export function useBusinessOpenNow(businessId, enabled = true) {
+    return useQuery({
+        queryKey: BUSINESS_HOURS_KEYS.open(businessId),
+        queryFn: async () => {
+            if (!businessId)
+                throw new Error("No business");
+            return isBusinessOpenNow(businessId);
+        },
+        enabled: enabled && !!businessId,
+        staleTime: 30 * 1000,
+        refetchInterval: 60 * 1000,
+        networkMode: "offlineFirst",
+    });
+}
+export function useOperatingHours(businessId, enabled = true) {
+    return useQuery({
+        queryKey: BUSINESS_HOURS_KEYS.open(businessId).concat(["entries"]),
+        queryFn: async () => {
+            if (!businessId)
+                throw new Error("No business");
+            const db = await openSyncDatabase();
+            const rec = await getReferenceData(db, businessId, "operating-hours");
+            if (!rec)
+                return [];
+            const payload = rec.payload;
+            return Array.isArray(payload) ? payload : (payload.data ?? []);
+        },
+        enabled: enabled && !!businessId,
+        staleTime: 30 * 1000,
+        networkMode: "offlineFirst",
+    });
+}

package/dist/hooks/dashboard.hooks.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Seller dashboard hooks — single source for both apps.
+ * Offline-first: local SQLite aggregates serve instantly; the network
+ * refreshes silently when online.
+ */
+import type { SellerDashboardMetrics } from "../types/api/seller.api";
+export declare const SELLER_DASHBOARD_KEYS: {
+    all: readonly ["seller-dashboard"];
+    metrics: (businessId?: string) => readonly ["seller-dashboard", "metrics", string | undefined];
+    recentOrders: (businessId?: string) => readonly ["seller-dashboard", "recent-orders", string | undefined];
+    full: (businessId?: string) => readonly ["seller-dashboard", "full", string | undefined];
+};
+export declare function useSellerDashboardMetricsQuery(businessId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<SellerDashboardMetrics, Error>;
+export declare function useSellerDashboardRecentOrdersQuery(businessId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    order_number: string;
+    status: string;
+    total_minor: number;
+    item_count: number;
+}[], Error>;
+export declare function useSellerDashboardQuery(businessId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    metrics: SellerDashboardMetrics;
+    recent_orders: {
+        id: string;
+        order_number: string;
+        status: string;
+        total_minor: number;
+        item_count: number;
+    }[];
+}, Error>;

package/dist/hooks/dashboard.hooks.js

@@ -0,0 +1,132 @@
+/**
+ * Seller dashboard hooks — single source for both apps.
+ * Offline-first: local SQLite aggregates serve instantly; the network
+ * refreshes silently when online.
+ */
+import { useQuery } from "@tanstack/react-query";
+import { dashboardService } from "../adapters/services";
+import { listLocalOrders } from "../domain/orders/service";
+import { useIsEffectivelyOnline } from "./use-infinite-list";
+export const SELLER_DASHBOARD_KEYS = {
+    all: ["seller-dashboard"],
+    metrics: (businessId) => [...SELLER_DASHBOARD_KEYS.all, "metrics", businessId],
+    recentOrders: (businessId) => [...SELLER_DASHBOARD_KEYS.all, "recent-orders", businessId],
+    full: (businessId) => [...SELLER_DASHBOARD_KEYS.all, "full", businessId],
+};
+const EMPTY_METRICS = {
+    today_orders: 0,
+    today_revenue_minor: 0,
+    pending_orders: 0,
+    active_orders: 0,
+    average_rating: 0,
+};
+/**
+ * Local SQLite aggregates — instant, even online. Single source for all
+ * three dashboard queries so metrics/recent/full never diverge.
+ */
+async function computeLocalDashboard(businessId) {
+    const { data } = await listLocalOrders(businessId, {}, 1, 200);
+    const orders = (data ?? []);
+    const todayStr = new Date().toISOString().slice(0, 10);
+    const todayOrders = orders.filter((o) => (o.inserted_at ?? "").slice(0, 10) === todayStr);
+    const todayRevenue = todayOrders.reduce((sum, o) => sum + (o.total_minor ?? 0), 0);
+    const pending = orders.filter((o) => ["pending", "awaiting_payment", "accepted"].includes(o.status)).length;
+    const active = orders.filter((o) => !["delivered", "cancelled", "rejected"].includes(o.status)).length;
+    const recent = [...orders]
+        .sort((a, b) => (b.inserted_at ?? "").localeCompare(a.inserted_at ?? ""))
+        .slice(0, 5)
+        .map((o) => ({ id: o.id, order_number: o.order_number, status: o.status, total_minor: o.total_minor, item_count: 1 }));
+    return {
+        metrics: { today_orders: todayOrders.length, today_revenue_minor: todayRevenue, pending_orders: pending, active_orders: active, average_rating: 0 },
+        recent_orders: recent,
+    };
+}
+export function useSellerDashboardMetricsQuery(businessId, enabled = true) {
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: SELLER_DASHBOARD_KEYS.metrics(businessId),
+        queryFn: async () => {
+            // DB first — instant, even online.
+            let local = null;
+            try {
+                local = (await computeLocalDashboard(businessId)).metrics;
+            }
+            catch { }
+            if (!online)
+                return local ?? EMPTY_METRICS;
+            try {
+                const res = (await dashboardService.fetchSellerDashboard(businessId));
+                return res.data.metrics ?? local ?? EMPTY_METRICS;
+            }
+            catch {
+                return local ?? EMPTY_METRICS;
+            }
+        },
+        enabled: enabled && Boolean(businessId),
+        staleTime: 1000 * 60 * 2,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+export function useSellerDashboardRecentOrdersQuery(businessId, enabled = true) {
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: SELLER_DASHBOARD_KEYS.recentOrders(businessId),
+        queryFn: async () => {
+            // DB first — instant, even online.
+            let local = [];
+            try {
+                local = (await computeLocalDashboard(businessId)).recent_orders;
+            }
+            catch { }
+            if (!online)
+                return local;
+            try {
+                const res = (await dashboardService.fetchSellerDashboard(businessId));
+                return local.length > 0 ? local : res.data.recent_orders;
+            }
+            catch {
+                return local;
+            }
+        },
+        enabled: enabled && Boolean(businessId),
+        staleTime: 1000 * 60 * 2,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+export function useSellerDashboardQuery(businessId, enabled = true) {
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: SELLER_DASHBOARD_KEYS.full(businessId),
+        queryFn: async () => {
+            // Local SQLite aggregates first — instant, even online.
+            let localRecent = [];
+            let localMetrics = null;
+            try {
+                const local = await computeLocalDashboard(businessId);
+                localRecent = local.recent_orders;
+                localMetrics = local.metrics;
+            }
+            catch { }
+            if (!online) {
+                return { metrics: localMetrics ?? EMPTY_METRICS, recent_orders: localRecent };
+            }
+            try {
+                const res = (await dashboardService.fetchSellerDashboard(businessId));
+                const backend = res.data;
+                return {
+                    metrics: backend.metrics ?? localMetrics,
+                    recent_orders: localRecent.length > 0 ? localRecent : backend.recent_orders,
+                };
+            }
+            catch {
+                return { metrics: localMetrics ?? EMPTY_METRICS, recent_orders: localRecent };
+            }
+        },
+        enabled: enabled && Boolean(businessId),
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}

package/dist/hooks/delivery.hooks.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Business deliveries hooks — single source for both apps.
+ * Offline-first: local orders with delivery_id serve instantly; the network
+ * refreshes silently when online.
+ */
+import type { BusinessDelivery } from "../types/api/seller.api";
+import { type ListPage } from "./use-infinite-list";
+export declare const DELIVERY_KEYS: {
+    all: readonly ["business-deliveries"];
+    list: (businessId?: string, filters?: Record<string, unknown>) => readonly ["business-deliveries", string | undefined, Record<string, unknown> | undefined];
+};
+export declare const DELIVERY_DETAIL_KEYS: {
+    all: readonly ["delivery"];
+    detail: (id: string) => readonly ["delivery", "detail", string];
+};
+export declare function useDeliveryDetailQuery(deliveryId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export interface DeliveryFilters {
+    status?: string;
+    search?: string;
+}
+export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?: DeliveryFilters): {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    data: BusinessDelivery[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    data: BusinessDelivery[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'pending';
+    data: BusinessDelivery[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: 'success';
+    data: BusinessDelivery[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: 'error';
+    data: BusinessDelivery[] | undefined;
+} | {
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: 'success';
+    data: BusinessDelivery[] | undefined;
+};