@teincfood/core 0.7.8 → 0.8.0

package/dist/sync/device-lease.service.js

@@ -3,20 +3,13 @@
  * Backend authority: POST /businesses/:id/devices/lease
  * KV persists device_number per businessId.
  */
-import { getItemSync as getSync, setItemSync as setSync } from "../adapters/kv";
+import { getItemSync as getSync, setItemSync as setSync, removeItemSync, getItem } from "../adapters/kv";
 import { getHttpClient } from "../adapters/http";
-import { generateUUID } from "../utils/uuid";
 import { syncLogger } from "../utils/sync-logger";
+import { getAppInstanceIdAsync } from "../adapters/devices";
+import { getConnectivityState } from "../adapters/connectivity";
 const LEASE_KEY = (businessId) => `teinc_device_number:${businessId}`;
 const LEASE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-function getAppInstanceId() {
-    let id = getSync("teinc_app_instance_id");
-    if (!id) {
-        id = generateUUID();
-        setSync("teinc_app_instance_id", id);
-    }
-    return id;
-}
 export function getDeviceNumber(businessId) {
     const v = getSync(LEASE_KEY(businessId));
     if (v && /^(0[1-9]|[1-9][0-9])$/.test(v))
@@ -27,32 +20,99 @@ export function isOnlineOnly(businessId) {
     return getDeviceNumber(businessId) == null;
 }
 export async function ensureLease(businessId) {
-    const existing = getDeviceNumber(businessId);
-    if (existing)
-        return existing;
+    // Offline-first: keep leased DD even offline — if online check/lease fails, return cached
+    const existingSync = getDeviceNumber(businessId);
+    if (existingSync) {
+        // Opportunistically refresh touch if online, but never discard cached on failure
+        if (getConnectivityState().isOnline) {
+            try {
+                const leasedAt = getSync(`${LEASE_KEY(businessId)}:leased_at`);
+                const needsRefresh = !leasedAt || Date.now() - new Date(leasedAt).getTime() > LEASE_TTL_MS - 24 * 60 * 60 * 1000;
+                if (needsRefresh)
+                    await refreshLease(businessId);
+            }
+            catch {
+                // keep existing on any refresh failure
+            }
+        }
+        return existingSync;
+    }
+    // No sync cache — try async KV (covers boot race where sync cache not yet hydrated from kv.json)
+    try {
+        const asyncCached = await getItem(LEASE_KEY(businessId));
+        if (asyncCached && /^(0[1-9]|[1-9][0-9])$/.test(asyncCached)) {
+            // hydrate sync cache for next getDeviceNumber calls
+            try {
+                setSync(LEASE_KEY(businessId), asyncCached);
+            }
+            catch { }
+            return asyncCached;
+        }
+    }
+    catch { }
+    // No cached DD — must lease online. If offline, keep null (caller blocks POS with clear message)
+    if (!getConnectivityState().isOnline) {
+        syncLogger.debug("DeviceLease", "Offline and no cached DD — need online once", { businessId });
+        return null;
+    }
     try {
         const http = getHttpClient();
-        const deviceUuid = getAppInstanceId();
+        const deviceUuid = await getAppInstanceIdAsync();
         const res = await http.post(`/businesses/${businessId}/devices/lease`, { device_uuid: deviceUuid, app_instance_id: deviceUuid });
         const data = res.data?.data ?? res.data;
         const dn = data.device_number;
         if (dn && /^(0[1-9]|[1-9][0-9])$/.test(dn)) {
             setSync(LEASE_KEY(businessId), dn);
             setSync(`${LEASE_KEY(businessId)}:leased_at`, new Date().toISOString());
+            try {
+                await getItem(LEASE_KEY(businessId));
+            }
+            catch { }
             syncLogger.info("DeviceLease", "Leased device number", { businessId, device_number: dn });
             return dn;
         }
     }
     catch (e) {
         const apiErr = e;
-        if (apiErr?.status === 429 || e?.message?.includes("DEVICE_LIMIT_REACHED")) {
+        const msg = String(e?.message ?? "");
+        const isAuth = apiErr?.status === 401 || msg.includes("TOKEN_MISSING") || msg.includes("No authentication token");
+        if (isAuth) {
+            syncLogger.debug("DeviceLease", "No auth yet — lease deferred until login", { businessId });
+            // fallback to any async cache that may have appeared concurrently
+            try {
+                const fallback = await getItem(LEASE_KEY(businessId));
+                if (fallback && /^(0[1-9]|[1-9][0-9])$/.test(fallback))
+                    return fallback;
+            }
+            catch { }
+            const again = getDeviceNumber(businessId);
+            if (again)
+                return again;
+            return null;
+        }
+        if (apiErr?.status === 429 || msg.includes("DEVICE_LIMIT_REACHED")) {
             syncLogger.warn("DeviceLease", "Device limit reached — online only", { businessId });
             return null;
         }
-        syncLogger.warn("DeviceLease", "Lease failed — will operate online-only until next boot", {
+        // Network/offline failure while leasing — keep any cached that may exist
+        syncLogger.warn("DeviceLease", "Lease failed — keep cached if any", {
             businessId,
             error: String(e),
         });
+        try {
+            const fallback = await getItem(LEASE_KEY(businessId));
+            if (fallback && /^(0[1-9]|[1-9][0-9])$/.test(fallback)) {
+                try {
+                    setSync(LEASE_KEY(businessId), fallback);
+                }
+                catch { }
+                return fallback;
+            }
+        }
+        catch { }
+        const again = getDeviceNumber(businessId);
+        if (again)
+            return again;
     }
     return null;
 }
@@ -68,7 +128,8 @@ export async function refreshLease(businessId) {
     }
     try {
         const http = getHttpClient();
-        await http.patch(`/businesses/${businessId}/devices/${getAppInstanceId()}/touch`, {});
+        const uuid = await getAppInstanceIdAsync();
+        await http.patch(`/businesses/${businessId}/devices/${uuid}/touch`, {});
         setSync(`${LEASE_KEY(businessId)}:leased_at`, new Date().toISOString());
     }
     catch {
@@ -76,8 +137,6 @@ export async function refreshLease(businessId) {
     }
 }
 export function clearLeaseForTests(businessId) {
-    // test helper
-    const { removeItemSync } = require("../adapters/kv");
     removeItemSync(LEASE_KEY(businessId));
     removeItemSync(`${LEASE_KEY(businessId)}:leased_at`);
 }
@@ -86,5 +145,6 @@ export const deviceLeaseService = {
     isOnlineOnly,
     ensureLease,
     refreshLease,
-    getAppInstanceId,
+    getAppInstanceId: getAppInstanceIdAsync,
+    getAppInstanceIdAsync,
 };

package/dist/sync/engine.d.ts

@@ -32,7 +32,9 @@ export declare class SyncEngine {
      * internet connection falls back to the Local Node (or the offline outbox)
      * quickly instead of blocking the terminal for the full HTTP timeout.
      */
-    execute(command: Command): Promise<DomainEvent[]>;
+    execute(command: Command, opts?: {
+        forReplay?: boolean;
+    }): Promise<DomainEvent[]>;
     /**
      * Trigger replay of queued commands when connectivity returns.
      */

package/dist/sync/engine.js

@@ -18,6 +18,9 @@ import { getConnectivityState, setConnectivityState } from "../adapters/connecti
 import { ApiError } from "../adapters/http";
 import { syncLogger } from "../utils/sync-logger";
 import { CLOUD_COMMAND_TIMEOUT_MS } from "../utils/constants";
+import { CAPABILITY_BY_COMMAND } from "../reference/capabilities";
+import { getReferenceData } from "../reference/operations";
+import { openSyncDatabase } from "../db/connection";
 function withTimeout(promise, ms) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
@@ -49,15 +52,12 @@ export class SyncEngine {
      * internet connection falls back to the Local Node (or the offline outbox)
      * quickly instead of blocking the terminal for the full HTTP timeout.
      */
-    async execute(command) {
+    async execute(command, opts) {
         syncLogger.command(command, "issued");
         // Perms guard (offline-capable): block before routing
-        const { CAPABILITY_BY_COMMAND } = await import("../reference/capabilities");
         const required = CAPABILITY_BY_COMMAND[command.command_type];
         if (required) {
             try {
-                const { getReferenceData } = await import("../reference/operations");
-                const { openSyncDatabase } = await import("../db/connection");
                 const db = await openSyncDatabase();
                 const rec = await getReferenceData(db, command.business_id, "capabilities");
                 const caps = rec?.payload?.data?.capabilities ?? [];
@@ -84,8 +84,42 @@ export class SyncEngine {
             lan_available: localNodeTransport.isAvailable(),
         });
         if (strategy === "queue") {
+            // Replays must never re-enqueue-then-delete (the command would eat
+            // itself without executing). If no real transport is available, leave
+            // the row untouched for a later trigger.
+            if (opts?.forReplay) {
+                throw new Error("ReplayDeferred: no transport available, keeping command queued");
+            }
             const event = await commandQueueService.enqueue(command);
             this.broadcast(event);
+            // Menu writes need a visible local effect while queued: patch the
+            // durable reference cache optimistically and fan out
+            // reference_data.changed so reconciliation applies it locally and
+            // relays it to LAN peers (replay re-applies idempotently; the backend
+            // owns versions on cloud convergence).
+            if (command.command_type.startsWith("menu:")) {
+                try {
+                    const { applyMenuCommandLocal } = await import("../reference/menu-apply");
+                    const { keys } = await applyMenuCommandLocal(command.business_id, command);
+                    if (keys.length) {
+                        const { REFERENCE_CHANGED_EVENT_TYPE } = await import("../reference/events");
+                        const { generateEventId } = await import("../utils/uuid");
+                        this.broadcast({
+                            event_id: generateEventId(),
+                            event_type: REFERENCE_CHANGED_EVENT_TYPE,
+                            event_version: "1.0",
+                            entity_id: command.business_id,
+                            user_id: command.user_id,
+                            device_id: command.device_id,
+                            payload: { business_id: command.business_id, keys },
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+                catch (e) {
+                    syncLogger.debug("SyncEngine", "queued menu optimistic apply failed", { err: String(e) });
+                }
+            }
             return [event];
         }
         if (strategy === "cloud") {
@@ -130,6 +164,12 @@ export class SyncEngine {
                 setConnectivityState({ isCloudReachable: "unreachable" });
                 strategy = this.resolveStrategy(command);
                 if (strategy === "queue") {
+                    // Replays must never re-enqueue-then-delete (the command would eat
+                    // itself without executing). If no real transport is available, leave
+                    // the row untouched for a later trigger.
+                    if (opts?.forReplay) {
+                        throw new Error("ReplayDeferred: no transport available, keeping command queued");
+                    }
                     const event = await commandQueueService.enqueue(command);
                     this.broadcast(event);
                     return [event];

package/dist/sync/full-sync.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Full sync: push → pull → push.
+ * Push first so local edits (already HLC-bumped) reach server before pull
+ * overwrites them; then pull merges; final drain pushes any remainder.
+ */
+export declare function performFullSync(businessId?: string): Promise<void>;

package/dist/sync/full-sync.js

@@ -0,0 +1,72 @@
+/**
+ * Full sync: push → pull → push.
+ * Push first so local edits (already HLC-bumped) reach server before pull
+ * overwrites them; then pull merges; final drain pushes any remainder.
+ */
+import { getConnectivityState } from "../adapters/connectivity";
+import { getAuthToken } from "../adapters/auth";
+import { getActiveBusiness } from "../adapters/business";
+import { syncLogger } from "../utils/sync-logger";
+import { referenceSyncService } from "../reference/service";
+import { pullRemoteOrders, drainPending } from "./sync-jobs.service";
+let inFlight = null;
+export async function performFullSync(businessId) {
+    const bid = businessId ?? getActiveBusiness()?.id;
+    if (!bid)
+        return;
+    const s = getConnectivityState();
+    if (!s.isOnline || s.isCloudReachable === "unreachable")
+        return;
+    if (!getAuthToken())
+        return;
+    if (inFlight) {
+        try {
+            await inFlight;
+        }
+        catch { }
+        return;
+    }
+    const p = (async () => {
+        try {
+            syncLogger.info("FullSync", "Starting push→pull→push", { businessId: bid });
+            // 1. Push pending FIFO first — HLC-bumped local edits outrank stale server
+            try {
+                await drainPending(bid);
+            }
+            catch (e) {
+                syncLogger.warn("FullSync", "drainPending(pre) failed", { err: String(e) });
+            }
+            // 2. Pull remote orders (HLC-guarded) and reference (LWW merge)
+            try {
+                await pullRemoteOrders(bid);
+            }
+            catch (e) {
+                syncLogger.warn("FullSync", "pullRemoteOrders failed", { err: String(e) });
+            }
+            try {
+                await referenceSyncService.sync({ businessId: bid });
+            }
+            catch (e) {
+                syncLogger.warn("FullSync", "reference sync failed", { err: String(e) });
+            }
+            // 3. Final drain — anything newly queued or retried after pull
+            try {
+                await drainPending(bid);
+            }
+            catch (e) {
+                syncLogger.warn("FullSync", "drainPending(post) failed", { err: String(e) });
+            }
+            syncLogger.info("FullSync", "Complete", { businessId: bid });
+        }
+        catch (e) {
+            syncLogger.warn("FullSync", "Failed", { err: String(e) });
+        }
+    })();
+    inFlight = p;
+    try {
+        await p;
+    }
+    finally {
+        inFlight = null;
+    }
+}

package/dist/sync/health-probe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Core Health Probe — periodic cloud reachability check.
+ *
+ * Probes `GET /health` using the injected HttpClient with a short timeout.
+ * On success: marks cloud reachable (triggers sync replay via connectivity
+ * subscribers). On failure: marks unreachable and schedules a retry with
+ * exponential backoff (2s → 5min cap, ±20% jitter).
+ *
+ * Started automatically by `createTeincCore()`. Host apps should not need
+ * to call this directly.
+ */
+/**
+ * Single probe attempt. Returns true if cloud is reachable.
+ */
+export declare function probeCloudHealth(): Promise<boolean>;
+/**
+ * Start the health probe. Safe to call multiple times (idempotent).
+ * Returns a stop function.
+ */
+export declare function startHealthProbe(): () => void;
+/**
+ * Stop the health probe and clean up all timers.
+ */
+export declare function stopHealthProbe(): void;

package/dist/sync/health-probe.js

@@ -0,0 +1,138 @@
+/**
+ * Core Health Probe — periodic cloud reachability check.
+ *
+ * Probes `GET /health` using the injected HttpClient with a short timeout.
+ * On success: marks cloud reachable (triggers sync replay via connectivity
+ * subscribers). On failure: marks unreachable and schedules a retry with
+ * exponential backoff (2s → 5min cap, ±20% jitter).
+ *
+ * Started automatically by `createTeincCore()`. Host apps should not need
+ * to call this directly.
+ */
+import { getConnectivityState, setCloudReachable, subscribeConnectivity } from "../adapters/connectivity";
+import { getHttpClient } from "../adapters/http";
+import { API_BASE_URL } from "../utils/constants";
+import { syncLogger } from "../utils/sync-logger";
+import { BackoffTracker } from "./backoff";
+import { getActiveBusiness } from "../adapters/business";
+import { getAuthToken } from "../adapters/auth";
+const PROBE_URL = "/health";
+const PROBE_TIMEOUT_MS = 4000;
+const PROBE_INTERVAL_MS = 60000;
+const UNREACHABLE_COOLDOWN_MS = 15000;
+const INITIAL_DELAY_MS = 3000;
+let probeTimer = null;
+let cooldownTimer = null;
+let stopFn = null;
+const backoff = new BackoffTracker();
+/**
+ * Single probe attempt. Returns true if cloud is reachable.
+ */
+export async function probeCloudHealth() {
+    const http = (() => { try {
+        return getHttpClient();
+    }
+    catch {
+        return null;
+    } })();
+    if (!http)
+        return false;
+    const { isOnline } = getConnectivityState();
+    if (!isOnline)
+        return false;
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+        await http.get(PROBE_URL, { signal: controller.signal });
+        clearTimeout(timer);
+        backoff.reset("health");
+        const was = getConnectivityState().isCloudReachable;
+        setCloudReachable("reachable");
+        if (was !== "reachable") {
+            syncLogger.info("HealthProbe", "Cloud reachable", { previous: was });
+            // Kick off pull→merge→push without blocking probe.
+            try {
+                const bid = getActiveBusiness()?.id;
+                if (bid && getAuthToken()) {
+                    void import("./full-sync").then((m) => m.performFullSync(bid).catch(() => { }));
+                }
+            }
+            catch { }
+        }
+        return true;
+    }
+    catch {
+        // Don't mark unreachable here — the sync engine already handles that
+        // when a command times out. This probe only detects recovery.
+        // Log and backoff so we re-check later.
+        syncLogger.debug("HealthProbe", "Probe failed — will retry", {
+            previous: getConnectivityState().isCloudReachable,
+        });
+        scheduleRetry();
+        return false;
+    }
+}
+function scheduleRetry() {
+    if (cooldownTimer)
+        return;
+    const delay = Math.max(UNREACHABLE_COOLDOWN_MS, backoff.next("health"));
+    syncLogger.debug("HealthProbe", "Scheduling retry", { delay });
+    cooldownTimer = setTimeout(() => {
+        cooldownTimer = null;
+        void probeCloudHealth();
+    }, delay);
+}
+function startPeriodicProbe() {
+    if (probeTimer)
+        return;
+    probeTimer = setInterval(() => void probeCloudHealth(), PROBE_INTERVAL_MS);
+}
+function stopPeriodicProbe() {
+    if (probeTimer) {
+        clearInterval(probeTimer);
+        probeTimer = null;
+    }
+    if (cooldownTimer) {
+        clearTimeout(cooldownTimer);
+        cooldownTimer = null;
+    }
+}
+/**
+ * Start the health probe. Safe to call multiple times (idempotent).
+ * Returns a stop function.
+ */
+export function startHealthProbe() {
+    if (stopFn)
+        return stopFn;
+    syncLogger.debug("HealthProbe", "Starting", { probeUrl: `${API_BASE_URL}${PROBE_URL}` });
+    // Initial probe (deferred so host bridges can set up first)
+    cooldownTimer = setTimeout(() => {
+        cooldownTimer = null;
+        void probeCloudHealth();
+    }, INITIAL_DELAY_MS);
+    // Periodic probe
+    startPeriodicProbe();
+    // Re-probe when network regains
+    let prevOnline = getConnectivityState().isOnline;
+    const unsub = subscribeConnectivity(() => {
+        const { isOnline } = getConnectivityState();
+        if (isOnline && !prevOnline) {
+            syncLogger.debug("HealthProbe", "Network regained — probing");
+            void probeCloudHealth();
+        }
+        prevOnline = isOnline;
+    });
+    stopFn = () => {
+        stopPeriodicProbe();
+        unsub();
+        stopFn = null;
+    };
+    return stopFn;
+}
+/**
+ * Stop the health probe and clean up all timers.
+ */
+export function stopHealthProbe() {
+    if (stopFn)
+        stopFn();
+}

package/dist/sync/offline-capable.js

@@ -12,8 +12,10 @@
  */
 import { syncEngine } from "./engine";
 import { buildCommand } from "./command-builder";
+import { assertOnlineFor } from "./online-gates";
 import { syncLogger } from "../utils/sync-logger";
 import { ApiError } from "../adapters/http";
+import { getConnectivityState } from "../adapters/connectivity";
 import { CAPABILITY_BY_COMMAND } from "../reference/capabilities";
 import { openSyncDatabase } from "../db/connection";
 import { getReferenceData } from "../reference/operations";
@@ -21,6 +23,23 @@ export async function runOfflineCapableMutation(options) {
     // Per-command capability guard before even attempting direct call
     const required = CAPABILITY_BY_COMMAND[options.commandType];
     if (required) {
+        // Online-required gate first: these commands can never succeed offline —
+        // throw loud immediately instead of queuing what no transport can fulfill.
+        assertOnlineFor(options.commandType, options.payload);
+        // Local-first for engine-routed domains (menu:*): commit locally via the
+        // engine and resolve immediately. Network is sync transport only — never a
+        // mutation delay. The engine cloud path carries the same 2.5s cap and
+        // returns the backend response when online.
+        if (options.commandType.startsWith("menu:")) {
+            const command = buildCommand({
+                commandType: options.commandType,
+                businessId: options.businessId,
+                entityId: options.entityId,
+                payload: options.payload,
+            });
+            const events = await syncEngine.execute(command);
+            return events[0]?.payload;
+        }
         try {
             const db = await openSyncDatabase();
             const rec = await getReferenceData(db, options.businessId, "capabilities");
@@ -35,6 +54,12 @@ export async function runOfflineCapableMutation(options) {
         }
     }
     try {
+        // Cloud already known unreachable (or no network): skip the direct REST
+        // attempt entirely — it would only burn a timeout before falling back.
+        const cs = getConnectivityState();
+        if (!cs.isOnline || cs.isCloudReachable === "unreachable") {
+            throw new Error("offline-capable: cloud known unreachable, engine route");
+        }
         return await options.run();
     }
     catch (error) {

package/dist/sync/online-gates.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Online-required allowlist — single source for what can NEVER work offline.
+ *
+ * Everything else is offline-first (SQLite read, local commit, engine sync).
+ * These commands throw immediately when the cloud is unreachable: queuing
+ * them would be dishonest because no transport (LAN or outbox replay) can
+ * ever fulfill them without the backend.
+ */
+/** Command types that require the cloud, unconditionally. */
+export declare const ONLINE_REQUIRED: Record<string, string>;
+export declare function isOnlineCapable(): boolean;
+/**
+ * Throw when a command cannot proceed offline. Handles payload-dependent
+ * cases: order:create with delivery type or prepaid/mobile-money payment,
+ * and delivery/order transitions the domain already gates.
+ */
+export declare function assertOnlineFor(commandType: string, payload?: Record<string, unknown>): void;

package/dist/sync/online-gates.js

@@ -0,0 +1,55 @@
+/**
+ * Online-required allowlist — single source for what can NEVER work offline.
+ *
+ * Everything else is offline-first (SQLite read, local commit, engine sync).
+ * These commands throw immediately when the cloud is unreachable: queuing
+ * them would be dishonest because no transport (LAN or outbox replay) can
+ * ever fulfill them without the backend.
+ */
+import { getConnectivityState } from "../adapters/connectivity";
+/** Command types that require the cloud, unconditionally. */
+export const ONLINE_REQUIRED = {
+    "order:assign_rider": "Assign rider requires online",
+    "order:confirm_handover": "Handover confirmation requires online",
+    "chat:send": "Chat requires online",
+    "notification:register": "Notifications require online",
+    "member:invite": "Member invites require online",
+    "member:manage": "Member management requires online",
+    "fleet:manage": "Fleet changes require online",
+    "settings:manage": "Settings changes require online",
+    "kyc:submit": "KYC submission requires online",
+    "wallet:withdraw": "Withdrawals require online",
+    "wallet:payout": "Payouts require online",
+    "payment:charge_online": "Online payment requires online",
+    "device:lease": "Device lease requires online (first lease only)",
+};
+export function isOnlineCapable() {
+    const s = getConnectivityState();
+    return s.isOnline && s.isCloudReachable !== "unreachable";
+}
+/**
+ * Throw when a command cannot proceed offline. Handles payload-dependent
+ * cases: order:create with delivery type or prepaid/mobile-money payment,
+ * and delivery/order transitions the domain already gates.
+ */
+export function assertOnlineFor(commandType, payload) {
+    const fixed = ONLINE_REQUIRED[commandType];
+    if (fixed) {
+        if (!isOnlineCapable())
+            throw new Error(fixed);
+        return;
+    }
+    if (commandType === "order:create" && payload) {
+        const orderType = payload.order_type;
+        if (orderType === "delivery" || payload.delivery_params) {
+            if (!isOnlineCapable())
+                throw new Error("Delivery orders require online");
+            return;
+        }
+        const method = payload.pos_payment_method;
+        if (typeof method === "string" && method !== "cash") {
+            if (!isOnlineCapable())
+                throw new Error("Online payment requires online — use cash while offline");
+        }
+    }
+}

package/dist/sync/order-number.d.ts

@@ -5,15 +5,15 @@
  * CCC = callout 001-999 global monotonic per device, wraps to 001 (new RRR on wrap)
  * Example: "10-123-001"
  */
-export declare function peekCallout(): number;
-export declare function generateOrderNumber(deviceNumber: string): {
+export declare function peekCallout(businessId?: string | null): number;
+export declare function generateOrderNumber(deviceNumber: string, businessId?: string | null): {
     orderNumber: string;
     callout: number;
     random: number;
 };
 export declare function generateLocalOrderNumber(): string;
 export declare function generateOrderNumberForBusiness(businessId: string): string;
-export declare function generateLocalCalloutNumber(): number;
+export declare function generateLocalCalloutNumber(businessId?: string | null): number;
 export declare function isLocalOrderNumber(orderNumber: string): boolean;
 export declare function isOfflineOrderNumber(orderNumber: string): boolean;
 export declare function parseOrderNumber(orderNumber: string): {
@@ -21,4 +21,4 @@ export declare function parseOrderNumber(orderNumber: string): {
     random: string;
     callout: string;
 } | null;
-export declare function resetCalloutForTests(): void;
+export declare function resetCalloutForTests(businessId?: string | null): void;