order3000 0.16.0 → 0.18.0

package/dist/client.d.cts

@@ -14,16 +14,43 @@ declare class TokenManager {
     initialize(): Promise<void>;
     getToken(): Promise<string>;
     getVenueId(): string;
+    /**
+     * Async counterpart to {@link getVenueId}. Fetches the token if it
+     * hasn't been loaded yet (which is what populates `defaultVenueId` via
+     * `setDefaultVenueId`), then returns the venue id.
+     *
+     * Prefer this over `getVenueId()` from request paths — a cold SDK
+     * instance will otherwise synchronously throw "No venue ID available"
+     * before the token has had a chance to load.
+     */
+    getVenueIdAsync(): Promise<string>;
     private refreshToken;
     private setDefaultVenueId;
 }
 
+/**
+ * Per-call cache override. Default behaviour is `cache: 'no-store'`
+ * — correct for live-read endpoints (basket, team-order, payment
+ * intents) where any caching causes stale responses against realtime
+ * mutations. Resources that surface near-static data consumed during
+ * static generation (e.g. `events.getByAccessor` for the Tiffinbox
+ * event schedule) can override with `next: { revalidate: N }` so
+ * Next.js can pre-render the calling page during the build instead
+ * of bailing out to dynamic rendering with `DYNAMIC_SERVER_USAGE`.
+ */
+interface RequestCacheOptions {
+    cache?: RequestCache;
+    next?: {
+        revalidate?: number | false;
+        tags?: string[];
+    };
+}
 declare abstract class BaseResource {
     protected readonly tokenManager: TokenManager;
     protected readonly baseUrl: string;
     protected readonly resourcePath: string;
     constructor(tokenManager: TokenManager, baseUrl: string, resourcePath: string);
-    protected request<T>(method: 'GET' | 'POST' | 'DELETE', path: string, data?: unknown): Promise<T>;
+    protected request<T>(method: 'GET' | 'POST' | 'DELETE', path: string, data?: unknown, cacheOptions?: RequestCacheOptions): Promise<T>;
 }
 
 interface components {
@@ -118,18 +145,20 @@ interface components {
             /** @enum {string|null} */
             paymentMethod?: "card" | "cash" | "voucher" | null;
             /** @enum {string} */
-            paymentStatus?: "unpaid" | "paid" | "refunded";
+            paymentStatus?: "unpaid" | "paid" | "refunded" | "authorized" | "cash_pending";
             taxAmount: number;
             totalAmount: number;
             /** @enum {string} */
             currency?: "EUR" | "CHF";
             /** @enum {string|null} */
             fulfillmentType?: "pickup" | "delivery" | null;
-            fulfillmentAt: unknown;
+            fulfillmentAt?: unknown;
             orderedAt?: unknown;
             orderedBy: string;
             updatedAt?: unknown;
             updatedBy?: string | null;
+            teamOrderId?: string | null;
+            participantDisplayName?: string | null;
         };
         /** PlaceOrderResponse */
         PlaceOrderResponse: {
@@ -144,7 +173,7 @@ interface components {
             /** @enum {string|null} */
             paymentMethod: "card" | "cash" | "voucher" | null;
             /** @enum {string} */
-            paymentStatus: "unpaid" | "paid" | "refunded";
+            paymentStatus: "unpaid" | "paid" | "refunded" | "authorized" | "cash_pending";
             taxAmount: number;
             totalAmount: number;
             /** @enum {string} */
@@ -156,6 +185,8 @@ interface components {
             orderedBy: string;
             updatedAt: unknown;
             updatedBy: string | null;
+            teamOrderId: string | null;
+            participantDisplayName: string | null;
         };
         /**
          * MakeReservationRequest
@@ -316,8 +347,13 @@ type OrderFulfillmentType = 'pickup' | 'delivery';
 type PlaceOrderRequest = Omit<schemas['PlaceOrderRequest'], 'taxAmount' | 'totalAmount' | 'fulfillmentAt'> & {
     /** Fulfillment type for the order (pickup or delivery) */
     fulfillmentType?: OrderFulfillmentType;
-    /** When the order should be fulfilled (ISO 8601 datetime string or Date object) */
-    fulfillmentAt: Date | string;
+    /**
+     * When the order should be fulfilled (ISO 8601 datetime or Date).
+     * Null / omitted in team-order mode — the Lead's pickup-time decision
+     * is attached to the team row and backfilled onto each child order at
+     * submit time.
+     */
+    fulfillmentAt?: Date | string | null;
     /** Guest session identifier for customer lookup */
     sessionId?: string;
     /** Customer first name (for cash orders) */
@@ -326,8 +362,12 @@ type PlaceOrderRequest = Omit<schemas['PlaceOrderRequest'], 'taxAmount' | 'total
     customerLastName?: string;
     /** Customer email address (for cash orders) */
     customerEmail?: string;
-    /** Number of deposit containers the customer declares they will return at pickup */
-    declaredReturningCount?: number;
+    /**
+     * Deposit containers the customer declares they will return at pickup.
+     * Per-template references only — order3000 refuses any inbound deposit
+     * money amount.
+     */
+    declaredReturns?: DeclaredReturn[];
 };
 type PlaceOrderResponse = schemas['PlaceOrderResponse'];
 type MakeReservationRequest = schemas['MakeReservationRequest'];
@@ -533,7 +573,24 @@ interface GetMenuOptions {
     expand?: ('items' | 'assets')[];
 }
 interface MenuBundleDeposit {
+    /**
+     * Primary reference. Clients declare returns against this id +
+     * a count; they never specify a deposit money amount. order3000
+     * refuses to accept a deposit amount on any inbound payload.
+     */
+    depositwareTemplateId: string;
+    /**
+     * Stable, human-readable handle for the underlying depositware
+     * template (e.g. `tiffinbox-3-1ee95d`). Lets app code target a
+     * canonical template by a code-level constant without hardcoding
+     * an environment-specific UUID.
+     */
+    accessor: string;
     name: Record<string, string>;
+    /**
+     * Display-only. Derived from `depositware_templates.deposit_base`.
+     * Never round-trip this value back to the server.
+     */
     amount: number;
     currency: CurrencyCode;
 }
@@ -600,6 +657,102 @@ interface GetEventOptions {
     /** Expand related resources (schedule, timeSlots, menus, posters) */
     expand?: ('schedule' | 'timeSlots' | 'menus' | 'posters')[];
 }
+type AreaBookingMode = 'slot' | 'day';
+type AreaBookingRequestStatus = 'pending' | 'approved' | 'rejected' | 'cancelled';
+type AreaBookingRequestSource = 'website' | 'phone' | 'walk_in';
+type AreaBookingStatus = 'confirmed' | 'arrived' | 'completed' | 'cancelled' | 'no_show';
+interface AreaAsset {
+    id: string;
+    type: 'image' | 'video' | 'document';
+    tags: string[] | null;
+    filename: string;
+    contentType: string;
+    metadata: {
+        width?: number;
+        height?: number;
+        duration?: number;
+    } | null;
+    cropArea: CropArea | null;
+    publicUrl: string;
+}
+interface AreaFeature {
+    icon: string;
+    label: Record<string, string>;
+    description?: Record<string, string>;
+}
+interface Area {
+    id: string;
+    venueId: string;
+    accessor: string;
+    name: Record<string, string>;
+    description: Record<string, string> | null;
+    longDescription: Record<string, string> | null;
+    minCapacity: number | null;
+    maxCapacity: number;
+    currency: Currency;
+    /** Base price in cents (flat price per booking). Null when pricing is per-person only. */
+    basePrice: number | null;
+    /** Per-guest price in cents. Null when pricing is base-only. */
+    perPersonPrice: number | null;
+    features: AreaFeature[] | null;
+    bookingMode: AreaBookingMode;
+    assets?: AreaAsset[];
+}
+interface GetAreaOptions {
+    expand?: 'assets'[];
+}
+interface AreaAvailabilityWindow {
+    /** YYYY-MM-DD */
+    date: string;
+    /** HH:MM:SS, null for day-mode bookings */
+    startTime: string | null;
+    endTime: string | null;
+}
+interface AreaAvailabilityResponse {
+    from: string;
+    to: string;
+    bookingMode: AreaBookingMode;
+    occupied: AreaAvailabilityWindow[];
+}
+interface GetAreaAvailabilityOptions {
+    /** YYYY-MM-DD — defaults to today */
+    from?: string;
+    /** YYYY-MM-DD — defaults to today + 90d */
+    to?: string;
+}
+interface SubmitAreaBookingRequestPayload {
+    /** YYYY-MM-DD */
+    requestedDate: string;
+    /** HH:MM:SS — omit for day-mode bookings */
+    requestedStartTime?: string;
+    requestedEndTime?: string;
+    partySize: number;
+    customerFirstName: string;
+    customerLastName: string;
+    customerEmail: string;
+    customerPhone?: string;
+    message?: string;
+    source?: AreaBookingRequestSource;
+}
+interface AreaBookingRequestResponse {
+    id: string;
+    venueId: string;
+    areaId: string;
+    requestedDate: string;
+    requestedStartTime: string | null;
+    requestedEndTime: string | null;
+    partySize: number;
+    customerFirstName: string;
+    customerLastName: string;
+    customerEmail: string;
+    customerPhone: string | null;
+    message: string | null;
+    source: AreaBookingRequestSource;
+    status: AreaBookingRequestStatus;
+    areaBookingId: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
 type BasketStatus = 'active' | 'abandoned' | 'converted';
 type Currency = 'EUR' | 'CHF';
 /**
@@ -628,6 +781,17 @@ interface BasketItemMetadata {
     price?: number;
     [key: string]: unknown;
 }
+/**
+ * Deposit info on a basket item — **always server-derived** from the row's
+ * `depositware_template_id` column. order3000 refuses any inbound deposit
+ * money amount; this object is outbound-only, for UI display.
+ */
+interface BasketItemDeposit {
+    depositwareTemplateId: string;
+    name: Record<string, string>;
+    amount: number;
+    currency: Currency;
+}
 /**
  * A basket item represents a single physical product in the basket.
  *
@@ -638,6 +802,7 @@ interface BasketItemMetadata {
 interface BasketItem {
     id: string;
     metadata: BasketItemMetadata | null;
+    deposit: BasketItemDeposit | null;
     menuItems: BasketItemMenuItemRef[];
 }
 interface Basket {
@@ -647,10 +812,99 @@ interface Basket {
     currency: Currency;
     items: BasketItem[];
     itemCount: number;
+    /**
+     * Canonical totals computed server-side and shipped inline with the
+     * basket. Computed using `declaredReturns` below, so the deposit
+     * credit is already baked into `effectiveTotal` — clients render the
+     * final value on first paint without a follow-up chip-hydration round
+     * trip. Use `POST /baskets/:id/totals` only when the user interacts
+     * with the stepper to recompute with new counts.
+     */
+    totals: BasketTotals;
+    /**
+     * Server-persisted declared-return counts (from `baskets.declared_returns`).
+     * Reflects the participant's last chip click. Clients seed their
+     * local `declaredReturns` store from this at hydration time so the
+     * chip count + Gesamt are consistent on first paint. Only positive
+     * counts are present; zero entries are stripped.
+     */
+    declaredReturns: DeclaredReturn[];
     expiresAt: string;
     createdAt: string | null;
     updatedAt: string | null;
 }
+/**
+ * Order workflow status (matches `order_status` enum in order3000).
+ */
+type OrderStatus = 'pending' | 'in_progress' | 'ready' | 'completed' | 'cancelled';
+/**
+ * Payment workflow status (matches `payment_status` enum in order3000).
+ */
+type PaymentStatus = 'unpaid' | 'authorized' | 'cash_pending' | 'paid' | 'refunded' | 'failed';
+/**
+ * The most recent non-team order for a guest session, with the captured
+ * basket items + totals + declared returns inlined. Returned by
+ * `orders.getLatest(sessionId)`. Used by thamarai to drive the
+ * post-placement read-only view of the ThermoBox stepper.
+ *
+ * `null` when the session has no qualifying order — fresh sessionIds
+ * and team-only sessions both fall through to `null`.
+ */
+interface LatestOrder {
+    id: string;
+    /** URL-safe non-guessable id (e.g. `ORD-A3B7K2`). Nullable until backfill. */
+    publicId: string | null;
+    /** Cycling 100→999 per venue. Nullable until PaymentIntent assigns. */
+    quickReferenceNumber: number | null;
+    status: OrderStatus;
+    paymentStatus: PaymentStatus;
+    fulfillmentType: OrderFulfillmentType | null;
+    /** ISO timestamp of pickup / delivery. */
+    fulfillmentAt: string | null;
+    orderedAt: string;
+    totalAmount: number;
+    currency: Currency;
+    /** Captured basket items — same shape `Basket.items` uses. */
+    items: BasketItem[];
+    itemCount: number;
+    /** Captured basket totals; `effectiveTotal` already reflects the credit. */
+    totals: BasketTotals;
+    /** Declared-return counts the customer locked in at submit time. */
+    declaredReturns: DeclaredReturn[];
+}
+/**
+ * One "I'll return N of this template" declaration. Canonical deposit
+ * input across every order3000 endpoint — clients never specify a
+ * deposit money amount.
+ */
+interface DeclaredReturn {
+    depositwareTemplateId: string;
+    count: number;
+}
+/**
+ * Canonical basket totals (all cents). The single figure clients read
+ * for every displayed monetary value; replaces every local amount-times-
+ * count multiplication.
+ */
+interface BasketTotals {
+    currency: Currency;
+    /** Food prices summed across basket items (tax-inclusive, no deposits). */
+    itemsTotal: number;
+    /** Tax portion extracted from `itemsTotal`. */
+    taxAmount: number;
+    /** Sum of deposits currently in the basket (one per returnable item). */
+    depositCharge: number;
+    /** `itemsTotal + depositCharge` — what an un-declared customer pays. */
+    grossTotal: number;
+    /** Credit owed for declared returns (bounded per-template by `returnable`). */
+    depositCredit: number;
+    /** `grossTotal − depositCredit`, clamped to zero. */
+    effectiveTotal: number;
+    /** When `depositCredit > grossTotal`, the excess is a cash refund due. */
+    cashRefund: number;
+    /** How many units of each depositware template the basket currently holds. */
+    returnable: DeclaredReturn[];
+}
 /**
  * Request to add an item to the basket.
  *
@@ -670,31 +924,121 @@ interface AddToBasketRequest {
 interface AddToBasketResponse {
     basketItemId: string;
     itemCount: number;
+    deposit: BasketItemDeposit | null;
+    /**
+     * Fresh canonical totals for the mutated basket (declaredReturns=[]).
+     * Clients apply this directly to their store — no extra round trip.
+     */
+    totals: BasketTotals;
 }
 interface RemoveFromBasketResponse {
     success: boolean;
     basketItemId: string;
     itemCount: number;
+    /**
+     * Fresh canonical totals for the mutated basket (declaredReturns=[]).
+     * `null` when the basket has no items left after the removal.
+     */
+    totals: BasketTotals | null;
 }
 interface CreatePaymentIntentRequest {
     basketId: string;
     currency: Currency;
     sessionId: string;
     fulfillmentType?: OrderFulfillmentType;
-    /** When the order should be fulfilled (ISO 8601 datetime string or Date object) */
-    fulfillmentAt: Date | string;
+    /**
+     * Optional — null / omitted in team-order mode. The Lead's pickup-time
+     * decision is stored on the team row and backfilled onto each child
+     * order at submit time.
+     */
+    fulfillmentAt?: Date | string | null;
     /** Customer first name (for Stripe metadata and customer record) */
     customerFirstName?: string;
     /** Customer last name (for Stripe metadata and customer record) */
     customerLastName?: string;
-    /** Number of deposit containers the customer declares they will return at pickup */
-    declaredReturningCount?: number;
+    /**
+     * Deposit containers the customer declares they will return at pickup.
+     * Per-template references only — order3000 refuses any inbound deposit
+     * money amount.
+     */
+    declaredReturns?: DeclaredReturn[];
+    /**
+     * The team order's public identifier (URL `?publicId=…`) when the
+     * caller is checking out as a team participant. Omitted for individual
+     * checkout. The server enters team-participant mode (manual-capture PI
+     * awaiting the Lead's submit) only when this is present AND matches the
+     * basket's attached team. Stale `basket.teamOrderId` without a matching
+     * `teamOrderPublicId` is treated as individual — the basket simply
+     * carries a dead pointer from an abandoned prior session.
+     */
+    teamOrderPublicId?: string;
 }
 interface CreatePaymentIntentResponse {
     clientSecret: string;
     paymentIntentId: string;
     orderId: string;
 }
+interface CreateDeltaPaymentIntentRequest {
+    basketId: string;
+    sessionId: string;
+    currency: Currency;
+    /**
+     * Deposit containers the participant declares they will return at
+     * pickup. Used to apply deposit credit against the delta amount so the
+     * server's `currentTotal` matches the client's displayed effective
+     * total. Per-template references only.
+     */
+    declaredReturns?: DeclaredReturn[];
+}
+interface CreateDeltaPaymentIntentResponse {
+    /** null when Stripe confirmed the off-session PI without further action. */
+    clientSecret: string | null;
+    paymentIntentId: string;
+    orderId: string;
+    /** Delta amount actually charged (cents). */
+    amount: number;
+    /**
+     * Stripe PaymentIntent status after confirm. Typically:
+     *  - 'requires_capture' → one-tap succeeded; capture happens at submit
+     *  - 'requires_action'  → 3DS prompt required; client completes via clientSecret
+     *  - 'succeeded' (rare here, auto-capture would have to be set)
+     */
+    status: string;
+}
+interface ReduceDeltaPaymentIntentRequest {
+    basketId: string;
+    sessionId: string;
+    currency: Currency;
+    /**
+     * Deposit containers the participant declares they will return at pickup.
+     * Per-template references only; order3000 refuses any deposit money
+     * amount on input.
+     */
+    declaredReturns?: DeclaredReturn[];
+}
+interface ReduceDeltaPaymentIntentResponse {
+    orderId: string;
+    /** New authorised total (cents) after the reduction. */
+    paidTotal: number;
+    /** Amount actually released (cents). */
+    released: number;
+}
+interface AddCashDeltaRequest {
+    basketId: string;
+    sessionId: string;
+    /**
+     * Deposit containers the participant declares they will return at pickup.
+     * Per-template references only.
+     */
+    declaredReturns?: DeclaredReturn[];
+}
+interface AddCashDeltaResponse {
+    orderId: string;
+    /** Delta amount (cents) recorded in this call. */
+    amount: number;
+    /** Sum of all active cash payments on this order after the delta row was inserted. */
+    paidTotal: number;
+}
 interface ConfirmOrderRequest {
     paymentIntentId: string;
 }
@@ -702,6 +1046,8 @@ interface ConfirmOrderResponse {
     id: string;
     status: string;
     publicId: string | null;
+    /** Cycling 100→999 short reference printed on receipts and shown to staff. */
+    quickReferenceNumber: number | null;
     /** Customer ID for the order (for client-side tracking) */
     customerId?: string;
 }
@@ -764,6 +1110,27 @@ interface SubscriptionCredit {
     createdAt: string | null;
 }
 
+declare class AreasResource extends BaseResource {
+    constructor(tokenManager: TokenManager, baseUrl: string);
+    /**
+     * List bookable + public areas for the venue.
+     */
+    list(options?: GetAreaOptions): Promise<Area[]>;
+    /**
+     * Fetch a single area by id or accessor.
+     */
+    getByAccessor(accessor: string, options?: GetAreaOptions): Promise<Area>;
+    /**
+     * List occupied date/time windows for an area between `from` and `to`.
+     */
+    getAvailability(accessor: string, options?: GetAreaAvailabilityOptions): Promise<AreaAvailabilityResponse>;
+    /**
+     * Submit a public booking request for an area.
+     */
+    submitBookingRequest(accessor: string, payload: SubmitAreaBookingRequestPayload): Promise<AreaBookingRequestResponse>;
+    private buildExpandQuery;
+}
+
 declare class BasketsResource extends BaseResource {
     constructor(tokenManager: TokenManager, baseUrl: string);
     /**
@@ -790,6 +1157,49 @@ declare class BasketsResource extends BaseResource {
      * @returns The response with item count
      */
     remove(sessionId: string, basketItemId: string): Promise<RemoveFromBasketResponse>;
+    /**
+     * Canonical totals for a basket. Clients read every displayed monetary
+     * figure (effective total, deposit credit, cash refund) from this
+     * endpoint — they never multiply deposit counts by amounts locally.
+     *
+     * Pass `declaredReturns` as references to depositware templates plus a
+     * count. order3000 refuses deposit money amounts on input.
+     */
+    getTotals(basketId: string, body?: {
+        declaredReturns?: DeclaredReturn[];
+    }): Promise<BasketTotals>;
+    /**
+     * Mark every active basket for the session as `abandoned`.
+     *
+     * Used by thamarai's "Neu starten" flow: after a non-team order
+     * has been placed (its basket converted), the user might want to
+     * start a fresh order. A subsequent `add()` call would otherwise
+     * reuse any leftover active basket on the same session — which
+     * can happen if a prior compose flow left an active row behind.
+     * Calling `abandon()` first guarantees the next `add()` inserts a
+     * brand-new active basket with exactly one item.
+     */
+    abandon(sessionId: string): Promise<{
+        abandonedCount: number;
+    }>;
+    /**
+     * Persist per-template declared-return counts onto the basket.
+     *
+     * Used by team-order participants so the Lead's breakdown popover
+     * sees every member's intent in real time (the standard
+     * `useTeamOrderRealtime` postgres-changes subscription on
+     * `baskets` then propagates the change to the team).
+     *
+     * Server validates `sessionId === basket.session_id` — only the
+     * basket's owner can write to its declared returns.
+     */
+    setDeclaredReturns(basketId: string, body: {
+        sessionId: string;
+        declaredReturns: DeclaredReturn[];
+    }): Promise<{
+        basketId: string;
+        declaredReturns: DeclaredReturn[];
+    }>;
 }
 
 declare class EventsResource extends BaseResource {
@@ -855,6 +1265,13 @@ declare class MenusResource extends BaseResource {
 
 declare class OrdersResource extends BaseResource {
     constructor(tokenManager: TokenManager, baseUrl: string);
+    /**
+     * Most recent non-team order for the guest session, with captured
+     * basket items + totals + declared returns inlined. `null` when the
+     * session has no qualifying order yet (fresh session, or only team
+     * orders which go through `teamOrders` instead).
+     */
+    getLatest(sessionId: string): Promise<LatestOrder | null>;
     /**
      * Place a new order.
      *
@@ -873,6 +1290,12 @@ declare class OrdersResource extends BaseResource {
      * the order to 'paid' status.
      */
     confirm(orderId: string, request: ConfirmOrderRequest): Promise<ConfirmOrderResponse>;
+    /**
+     * Record an additional cash handover amount for a team-order participant
+     * who has added items after their initial cash payment. No Stripe
+     * interaction — this updates the handover total the Lead will collect.
+     */
+    addCashDelta(request: AddCashDeltaRequest): Promise<AddCashDeltaResponse>;
 }
 
 declare class PaymentIntentsResource extends BaseResource {
@@ -884,6 +1307,20 @@ declare class PaymentIntentsResource extends BaseResource {
      * for the draft order that was created.
      */
     create(request: CreatePaymentIntentRequest): Promise<CreatePaymentIntentResponse>;
+    /**
+     * Create a delta PaymentIntent for a team-order participant who added
+     * items after paying. Reuses the saved card from the initial auth so the
+     * client only needs one tap (unless Stripe triggers 3DS).
+     */
+    createDelta(request: CreateDeltaPaymentIntentRequest): Promise<CreateDeltaPaymentIntentResponse>;
+    /**
+     * Release part of a team-order participant's existing Stripe authorisation
+     * when they remove items from their basket. Walks payments newest-first,
+     * cancelling fully-consumed PIs and `update({ amount })`-ing the last
+     * partially-trimmed one. No client-side confirmation — lowering a
+     * `requires_capture` PI's amount is a single server round-trip.
+     */
+    reduceDelta(request: ReduceDeltaPaymentIntentRequest): Promise<ReduceDeltaPaymentIntentResponse>;
 }
 
 declare class ReservationsResource extends BaseResource {
@@ -939,6 +1376,443 @@ declare class SubscriptionsResource extends BaseResource {
     getCredits(subscriptionIdOrAccessor: string, subscriberId: string, status?: SubscriptionCreditStatus): Promise<SubscriptionCredit[]>;
 }
 
+/**
+ * Runtime enum objects that mirror order3000's Drizzle `pgEnum` shape —
+ * they carry an `enumValues` tuple. This lets SDK consumers write the exact
+ * same `z.enum(paymentMethodEnum.enumValues)` expression they would write
+ * against a real pgEnum, keeping one consistent pattern across the
+ * codebase (order3000's server imports the actual pgEnum from
+ * `@/drizzle/enums`; thamarai and other SDK consumers import these
+ * shape-compatible objects from 'order3000').
+ *
+ * The tuples themselves must stay in sync with the matching pgEnum in
+ * `apps/order3000/src/drizzle/enums.ts`. That's a manual mirror — the SDK
+ * is a standalone package and can't import from the app's Drizzle schema.
+ */
+declare const paymentMethodEnum: {
+    enumValues: readonly ["card", "cash", "voucher"];
+};
+declare const fulfillmentTypeEnum: {
+    enumValues: readonly ["pickup", "delivery"];
+};
+declare const teamOrderStatusEnum: {
+    enumValues: readonly ["draft", "collecting", "locked", "placed", "ready", "completed", "cancelled"];
+};
+declare const participantStatusEnum: {
+    enumValues: readonly ["browsing", "authorized", "cash_pending", "placed", "completed", "cancelled"];
+};
+type PaymentMethod = (typeof paymentMethodEnum.enumValues)[number];
+type FulfillmentType = (typeof fulfillmentTypeEnum.enumValues)[number];
+type TeamOrderStatus = (typeof teamOrderStatusEnum.enumValues)[number];
+type ParticipantStatus = (typeof participantStatusEnum.enumValues)[number];
+interface TeamDeliveryAddress {
+    street: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+}
+interface CreateTeamOrderRequest {
+    sessionId: string;
+    menuId: string;
+    leadDisplayName: string;
+    teamName?: string;
+    logoUrl?: string;
+    /**
+     * Optional ISO 8601 datetime. The Lead's "close the window" decision —
+     * unset on FAST-share creation. When null, the team never auto-locks;
+     * the Lead explicitly submits when ready.
+     */
+    deadlineAt?: string | null;
+    fulfillmentType: FulfillmentType;
+    /**
+     * Optional ISO 8601 datetime. The Lead's pickup-time decision — unset
+     * at team creation, set later on the Lead's Fulfilment step. Backfilled
+     * onto each child `orders.fulfillmentAt` when `submitTeamOrder` fires.
+     */
+    fulfillmentAt?: string | null;
+    deliveryAddress?: TeamDeliveryAddress;
+    allowedPaymentMethods: PaymentMethod[];
+    eventId?: string;
+}
+interface CreateTeamOrderResponse {
+    publicId: string;
+    teamOrderId: string;
+}
+interface TeamOrderBasketItemMenuItemRef {
+    menuItemId: string;
+    role: string | null;
+    quantity: number;
+    unit: 'grams' | 'kilograms' | 'liters' | 'milliliters' | 'pieces';
+}
+interface TeamOrderBasketItem {
+    id: string;
+    metadata: BasketItemMetadata | null;
+    menuItems: TeamOrderBasketItemMenuItemRef[];
+    /**
+     * `true` when the item's cumulative price (folded across the
+     * participant's basket items in `basket_items.created_at` order)
+     * is fully covered by the participant's `paidTotal`. `false`
+     * when the item is part of an outstanding delta — typically an
+     * item the participant added after their last authorisation but
+     * hasn't run a delta payment for yet. Drives the per-item
+     * "Confirmed" vs "Pending" badge in the team-mode BasketReview;
+     * the Lead therefore can't be tricked into submitting while a
+     * teammate has unpaid items in their cart.
+     */
+    isPaid: boolean;
+}
+/**
+ * Active payment row surfaced for a participant. "Active" excludes voided
+ * and failed rows — those never reach the client.
+ */
+type TeamOrderParticipantPaymentStatus = 'authorized' | 'captured' | 'cash_pending' | 'cash_received';
+interface TeamOrderParticipantPayment {
+    amount: number;
+    method: PaymentMethod;
+    status: TeamOrderParticipantPaymentStatus;
+    createdAt: string;
+    /**
+     * Last 4 digits of the card used for this card payment. Populated
+     * lazily by `fetchTeamOrder` for the *current viewer's* card rows
+     * only (one Stripe round-trip per render, then cached on the
+     * `team_order_payments` row), so the delta-payment UI can render
+     * `Card **** 4242` and tell the user which card will be charged
+     * or refunded. `null` for cash rows or while the lookup hasn't
+     * landed yet.
+     */
+    cardLast4: string | null;
+}
+interface TeamOrderParticipant {
+    customerId: string;
+    basketId: string | null;
+    orderId: string | null;
+    /**
+     * Consecutive, never-reused join-order number. 1 for the lead; 2, 3, ...
+     * for joiners in arrival order. Clients fall back to `Person {n}` when
+     * `displayName` is null. Stays stable even if an earlier participant is
+     * later dropped — numbers are not recycled.
+     */
+    participantNumber: number | null;
+    displayName: string | null;
+    status: ParticipantStatus;
+    bundleCount: number;
+    amount: number;
+    paymentMethod: PaymentMethod | null;
+    isLead: boolean;
+    /** True when this participant is the current caller (session match). */
+    isMe: boolean;
+    joinedAt: string;
+    /**
+     * Participant's current basket contents in SDK format (identical to what
+     * `baskets.get` returns). The thamarai client feeds these straight into
+     * its existing `hydrateBasket` → `transformBasketItem` transform.
+     */
+    items: TeamOrderBasketItem[];
+    /**
+     * Per-participant payment trail — one row per auth (initial + each delta
+     * round). Empty until the participant has checked out.
+     */
+    payments: TeamOrderParticipantPayment[];
+    /** Sum of `payments[].amount` (authorised/collected total). */
+    paidTotal: number;
+    /** `amount` − `paidTotal`, floored at 0. Positive = delta owed. */
+    amountDue: number;
+    /**
+     * Server-persisted declared-return counts per depositware template,
+     * captured the last time the participant authorised payment (or
+     * resubmitted via a delta). Empty until they've checked out — and
+     * always reflects what the server actually has on file (i.e.
+     * `orderDeposits.declaredReturningCount`).
+     *
+     * Clients use this to hydrate the local "I'm returning N empties"
+     * UI on refresh: without it, the local Zustand store starts empty,
+     * so `useBasketTotals` recomputes `effectiveTotal` *without* the
+     * deposit credit that was actually applied at auth time, causing
+     * the delta-payment view to incorrectly demand or refund money.
+     */
+    declaredReturns: Array<{
+        depositwareTemplateId: string;
+        count: number;
+    }>;
+    /**
+     * ISO timestamp the team Lead checked off this participant on
+     * their post-placement settle-up checklist — a private "this
+     * person has handed over what they owe me" tick. `null` while
+     * unchecked. Lead-private; consumer-side rendering decides
+     * whether to surface it.
+     */
+    leadSettledAt: string | null;
+}
+interface ThresholdCheck {
+    meets: boolean;
+    failedConstraints: Array<'quantity' | 'amount'>;
+    requiredQuantity: number | null;
+    currentQuantity: number;
+    requiredAmount: number | null;
+    currentAmount: number;
+}
+interface FetchTeamOrderResponse {
+    teamOrder: {
+        id: string;
+        publicId: string;
+        venueId: string;
+        menuId: string;
+        eventId: string | null;
+        teamName: string | null;
+        logoUrl: string | null;
+        leadDisplayName: string;
+        status: TeamOrderStatus;
+        allowedPaymentMethods: PaymentMethod[];
+        fulfillmentType: FulfillmentType;
+        fulfillmentAt: string | null;
+        deadlineAt: string | null;
+        lockedAt: string | null;
+        placedAt: string | null;
+        cancelledAt: string | null;
+        /**
+         * Free-text reason the Lead provided when dissolving the team order.
+         * Surfaced to non-Lead participants via the `cancelledByLeadToast`
+         * broadcast so they see context alongside the cancellation event.
+         */
+        cancelReason: string | null;
+        deliveryAddressId: string | null;
+        /**
+         * Free-form text the Lead types on the Fulfilment step describing
+         * where the team will sit down to eat (e.g. "Kitchen K3, Building X").
+         * `null` until the Lead enters a value.
+         */
+        diningLocation: string | null;
+        /**
+         * HH:MM time (venue timezone) at which the team starts eating.
+         * Derived server-side from `fulfillmentAt + effectiveOffset` where
+         * `effectiveOffset = dining_offset_minutes ?? 15`. `null` only when
+         * `fulfillmentAt` hasn't been set yet.
+         */
+        diningTime: string | null;
+        /**
+         * Whether the team's menu is configured for delivery fulfillment.
+         * Snapshotted from `menus.metadata.isDeliveryEnabled` at fetch time.
+         * Clients use this to gate the Lead's "Switch to delivery" control.
+         */
+        isDeliveryEnabled: boolean;
+        /**
+         * Cycling 100→999 short reference, repurposed from the Lead's own
+         * `orders.quickReferenceNumber` so the team has exactly one number
+         * — the same number printed on the consolidated kitchen receipt
+         * and surfaced in the customer's Abwicklung view. `null` until the
+         * Lead has authorised payment (the Lead's order row is created at
+         * PaymentIntent time, which is when the quickRef is assigned).
+         */
+        quickReferenceNumber: number | null;
+    };
+    deliveryThreshold: {
+        amount: number | null;
+        quantity: number | null;
+    };
+    participants: TeamOrderParticipant[];
+    aggregatedTotals: {
+        confirmedBundleCount: number;
+        confirmedAmount: number;
+        totalBundleCount: number;
+    };
+    thresholdCheck: ThresholdCheck;
+    isLead: boolean;
+}
+interface JoinTeamOrderRequest {
+    sessionId: string;
+    displayName?: string;
+}
+interface JoinTeamOrderResponse {
+    teamOrderId: string;
+    basketId: string;
+    customerId: string;
+    status: TeamOrderStatus;
+    isLead: boolean;
+    alreadyJoined: boolean;
+}
+interface SubmitTeamOrderResponse {
+    teamOrderId: string;
+    status: TeamOrderStatus;
+    capturedOrderIds: string[];
+    cashPendingOrderIds: string[];
+    droppedBasketIds: string[];
+    placedAt: string;
+}
+interface CancelTeamOrderResponse {
+    teamOrderId: string;
+    status: TeamOrderStatus;
+    voidedPaymentIntentIds: string[];
+    cancelledAt: string;
+}
+interface ExtendDeadlineResponse {
+    teamOrderId: string;
+    status: TeamOrderStatus;
+    deadlineAt: string | null;
+}
+interface SwitchFulfillmentResponse {
+    teamOrderId: string;
+    status: TeamOrderStatus;
+    fulfillmentType: FulfillmentType;
+    deliveryAddressId: string | null;
+}
+interface UpdateDeliveryAddressResponse {
+    teamOrderId: string;
+    deliveryAddressId: string;
+}
+/**
+ * Team Orders SDK resource.
+ *
+ * Mixes venue-scoped and publicId-scoped endpoints, so it doesn't inherit
+ * from BaseResource (which hard-codes /venues/{venueId}). Create goes to
+ * `/venues/{venueId}/team-orders`; everything else targets
+ * `/team-orders/{publicId}/...` because publicId is globally unique and the
+ * venue is resolved server-side via a helper.
+ */
+declare class TeamOrdersResource {
+    private readonly tokenManager;
+    private readonly baseUrl;
+    constructor(tokenManager: TokenManager, baseUrl: string);
+    private request;
+    /**
+     * Lead creates a team order from their active basket.
+     * Returns the unguessable `publicId` the lead shares with coworkers.
+     */
+    create(request: CreateTeamOrderRequest): Promise<CreateTeamOrderResponse>;
+    /**
+     * Public read by publicId. Pass the caller's sessionId so the response
+     * can set `isLead` correctly for UI gating.
+     */
+    get(publicId: string, sessionId?: string): Promise<FetchTeamOrderResponse>;
+    /**
+     * Participant joins a team order. Idempotent: safe to call on every page
+     * mount of the shared URL.
+     */
+    join(publicId: string, request: JoinTeamOrderRequest): Promise<JoinTeamOrderResponse>;
+    /**
+     * Lead submits the team order. Drops basket-only participants, captures
+     * every authorised Stripe PaymentIntent atomically, flips child orders to
+     * `pending`. The "Submit anyways" UX is a client-side confirmation dialog
+     * that calls the same endpoint — no server variant exists.
+     */
+    submit(publicId: string, request: {
+        sessionId: string;
+    }): Promise<SubmitTeamOrderResponse>;
+    /**
+     * Lead cancels pre-placement. Voids every authorised Stripe
+     * PaymentIntent (no refunds needed — nothing was captured).
+     */
+    cancel(publicId: string, request: {
+        sessionId: string;
+        reason?: string;
+    }): Promise<CancelTeamOrderResponse>;
+    /**
+     * Lead pushes the deadline. A `locked` team flips back to `collecting`
+     * when the new deadline is in the future.
+     */
+    extendDeadline(publicId: string, request: {
+        sessionId: string;
+        newDeadlineAt: string;
+    }): Promise<ExtendDeadlineResponse>;
+    /**
+     * Lead commits (or changes) the shared pickup/delivery time. Required
+     * before `submit` — which backfills each child order's `fulfillmentAt`
+     * from this value at capture time.
+     */
+    setFulfillmentAt(publicId: string, request: {
+        sessionId: string;
+        fulfillmentAt: string;
+    }): Promise<{
+        teamOrderId: string;
+        status: TeamOrderStatus;
+        fulfillmentAt: string;
+        /**
+         * Returned so callers can re-sync the deadline wheel — the server
+         * clamps `deadlineAt` down to the new `fulfillmentAt` whenever the
+         * old deadline would have sat past it.
+         */
+        deadlineAt: string | null;
+    }>;
+    /**
+     * Lead sets the free-form "where we'll eat" text on the team order.
+     * Broadcast to participants via the standard realtime refetch path.
+     */
+    setDiningLocation(publicId: string, request: {
+        sessionId: string;
+        diningLocation: string;
+    }): Promise<{
+        teamOrderId: string;
+        status: TeamOrderStatus;
+        diningLocation: string | null;
+    }>;
+    /**
+     * Lead sets when the team will start eating. Client sends HH:MM; server
+     * computes the delta against `fulfillmentAt` and stores it as
+     * `dining_offset_minutes` so the intent survives any later pickup change.
+     */
+    setDiningTime(publicId: string, request: {
+        sessionId: string;
+        diningTime: string;
+    }): Promise<{
+        teamOrderId: string;
+        status: TeamOrderStatus;
+        diningTime: string;
+        diningOffsetMinutes: number;
+    }>;
+    /**
+     * Toggle a participant's "settled" tick on the team Lead's
+     * post-placement settle-up checklist. Writes to
+     * `orders.leadSettledAt` — sets it to `NOW()` when `settled` is
+     * `true`, clears it back to `null` when `false`.
+     *
+     * Authorized only for the team Lead's session — server rejects
+     * non-Lead callers and `orderId`s that don't belong to this team.
+     */
+    setOrderLeadSettled(publicId: string, request: {
+        sessionId: string;
+        orderId: string;
+        settled: boolean;
+    }): Promise<{
+        orderId: string;
+        leadSettledAt: string | null;
+    }>;
+    /**
+     * Any participant proposes an auto-extend when their local clock sees
+     * that `fulfillmentAt` has passed while the team order is still
+     * collecting. Idempotent on the server side: concurrent callers race
+     * but only one write lands.
+     */
+    autoExtendFulfillmentIfExpired(publicId: string, request: {
+        sessionId: string;
+        proposedFulfillmentAt: string;
+    }): Promise<{
+        extended: boolean;
+        teamOrderId: string;
+        status: TeamOrderStatus;
+        fulfillmentAt: string;
+        deadlineAt: string | null;
+        previousFulfillmentAt: string;
+        waitingCount: number;
+    }>;
+    /**
+     * Lead flips pickup ↔ delivery. Pass `deliveryAddress` when switching
+     * TO delivery if no address is already set on the team order.
+     */
+    switchFulfillment(publicId: string, request: {
+        sessionId: string;
+        fulfillmentType: FulfillmentType;
+        deliveryAddress?: TeamDeliveryAddress;
+    }): Promise<SwitchFulfillmentResponse>;
+    /**
+     * Lead replaces the delivery address (inserts a new row in the shared
+     * addresses table with type='PHYSICAL' and links it to the team order).
+     */
+    updateDeliveryAddress(publicId: string, request: {
+        sessionId: string;
+        deliveryAddress: TeamDeliveryAddress;
+    }): Promise<UpdateDeliveryAddressResponse>;
+}
+
 type RealtimeEvent = 'INSERT' | 'UPDATE' | 'DELETE' | '*';
 type RealtimeRow = {
     [key: string]: any;
@@ -1097,6 +1971,7 @@ interface Order3000ClientConfig {
     tokenUrl?: string;
 }
 declare class Order3000Client {
+    areas: AreasResource;
     baskets: BasketsResource;
     events: EventsResource;
     menus: MenusResource;
@@ -1104,11 +1979,12 @@ declare class Order3000Client {
     paymentIntents: PaymentIntentsResource;
     reservations: ReservationsResource;
     subscriptions: SubscriptionsResource;
+    teamOrders: TeamOrdersResource;
     realtime: RealtimeManager;
     private readonly baseUrl;
     private readonly tokenManager;
     constructor(config: Order3000ClientConfig);
 }
 
-export { Order3000Client, getScheduleInfo };
-export type { AddToBasketRequest, AddToBasketResponse, Basket, BasketItem, BasketItemMenuItemRef, BasketItemMetadata, BasketStatus, ConfirmOrderRequest, ConfirmOrderResponse, CreatePaymentIntentRequest, CreatePaymentIntentResponse, CropArea, Currency, DayOfWeek, Event, EventByAccessor, EventMenu, EventPoster, EventRow, GetEventOptions, GetMenuOptions, ListEventsOptions, ListEventsResponse, Menu, MenuAsset, MenuBeverage, MenuBundle, MenuBundleDeposit, MenuDish, MenuItem, MenuItemRow, MenuItemType, MenuSubscription, MenuSubscriptionPoster, Order3000ClientConfig, OrderFulfillmentType, PlaceOrderRequest, Promotion, RealtimeConfig, RealtimeEvent, RealtimeSubscription, RemoveFromBasketResponse, Schedule, ScheduleInfo, ScheduleOverride, ScheduleOverrideRow, ScheduleRow, ScheduleTimeSlot, ScheduleWithTimeSlots, SubscribeRequest, SubscribeResponse, SubscriberStatus, SubscriptionCredit, SubscriptionCreditStatus, SubscriptionOptions, SubscriptionPeriod, TimeSlot, Unit };
+export { Order3000Client, fulfillmentTypeEnum, getScheduleInfo, participantStatusEnum, paymentMethodEnum, teamOrderStatusEnum };
+export type { AddCashDeltaRequest, AddCashDeltaResponse, AddToBasketRequest, AddToBasketResponse, Area, AreaAsset, AreaAvailabilityResponse, AreaAvailabilityWindow, AreaBookingMode, AreaBookingRequestResponse, AreaBookingRequestSource, AreaBookingRequestStatus, AreaBookingStatus, AreaFeature, Basket, BasketItem, BasketItemDeposit, BasketItemMenuItemRef, BasketItemMetadata, BasketStatus, BasketTotals, CancelTeamOrderResponse, ConfirmOrderRequest, ConfirmOrderResponse, CreateDeltaPaymentIntentRequest, CreateDeltaPaymentIntentResponse, CreatePaymentIntentRequest, CreatePaymentIntentResponse, CreateTeamOrderRequest, CreateTeamOrderResponse, CropArea, Currency, DayOfWeek, DeclaredReturn, Event, EventByAccessor, EventMenu, EventPoster, EventRow, ExtendDeadlineResponse as ExtendTeamOrderDeadlineResponse, FetchTeamOrderResponse, GetAreaAvailabilityOptions, GetAreaOptions, GetEventOptions, GetMenuOptions, JoinTeamOrderRequest, JoinTeamOrderResponse, LatestOrder, ListEventsOptions, ListEventsResponse, Menu, MenuAsset, MenuBeverage, MenuBundle, MenuBundleDeposit, MenuDish, MenuItem, MenuItemRow, MenuItemType, MenuSubscription, MenuSubscriptionPoster, Order3000ClientConfig, OrderFulfillmentType, OrderStatus, PaymentStatus, PlaceOrderRequest, Promotion, RealtimeConfig, RealtimeEvent, RealtimeSubscription, RemoveFromBasketResponse, Schedule, ScheduleInfo, ScheduleOverride, ScheduleOverrideRow, ScheduleRow, ScheduleTimeSlot, ScheduleWithTimeSlots, SubmitAreaBookingRequestPayload, SubmitTeamOrderResponse, SubscribeRequest, SubscribeResponse, SubscriberStatus, SubscriptionCredit, SubscriptionCreditStatus, SubscriptionOptions, SubscriptionPeriod, SwitchFulfillmentResponse as SwitchTeamOrderFulfillmentResponse, TeamDeliveryAddress, TeamOrderBasketItem, TeamOrderBasketItemMenuItemRef, FulfillmentType as TeamOrderFulfillmentType, TeamOrderParticipant, ParticipantStatus as TeamOrderParticipantStatus, PaymentMethod as TeamOrderPaymentMethod, TeamOrderStatus, ThresholdCheck as TeamOrderThresholdCheck, TimeSlot, Unit, UpdateDeliveryAddressResponse as UpdateTeamOrderDeliveryAddressResponse };