@porulle/plugin-pos-restaurant 0.1.0

package/src/services/recipe-deduction-service.ts

@@ -0,0 +1,221 @@
+/**
+ * RecipeDeductionService -- resolves recipe ingredient inventory deductions
+ * when a POS transaction completes.
+ *
+ * For each sold item:
+ *   1. Look up the entity's active recipe
+ *   2. For each ingredient with an entityId, calculate deduction quantity
+ *   3. Deduct via inventory service (preferred) or raw SQL (fallback)
+ *
+ * When the ServiceRegistry is provided (normal plugin boot), deductions
+ * go through kernel.services.inventory.adjust() which creates proper
+ * movements, fires hooks, and respects audit trail.
+ *
+ * When the ServiceRegistry is not available (standalone tests, scripts),
+ * falls back to raw SQL with the same atomic guard.
+ */
+
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { posRecipes, posRecipeIngredients } from "../schema.js";
+import type { Db } from "../types.js";
+
+/** Minimal interface for the inventory service methods we need. */
+interface InventoryAdjustFn {
+  adjust(
+    input: { entityId: string; warehouseId?: string; adjustment: number; reason?: string },
+    actor?: unknown,
+  ): Promise<{ ok: boolean; value?: unknown; error?: unknown }>;
+}
+
+interface DeductionItem {
+  entityId: string;
+  variantId: string | null;
+  quantity: number;
+  unit: string;
+  itemName: string;
+  reason: string;
+}
+
+export class RecipeDeductionService {
+  private inventorySvc?: InventoryAdjustFn;
+
+  constructor(
+    private db: Db,
+    services?: Record<string, unknown>,
+  ) {
+    // Extract inventory service if available
+    if (services?.inventory && typeof (services.inventory as Record<string, unknown>).adjust === "function") {
+      this.inventorySvc = services.inventory as InventoryAdjustFn;
+    }
+  }
+
+  /**
+   * Resolve all recipe ingredient deductions for a list of sold items.
+   * Pure query -- no mutations. Returns a flat list to pass to applyDeductions().
+   */
+  async resolveDeductions(
+    orgId: string,
+    items: Array<{ entityId: string; quantity: number }>,
+  ): Promise<PluginResult<DeductionItem[]>> {
+    const deductions: DeductionItem[] = [];
+
+    for (const item of items) {
+      const recipes = await this.db
+        .select()
+        .from(posRecipes)
+        .where(and(
+          eq(posRecipes.organizationId, orgId),
+          eq(posRecipes.entityId, item.entityId),
+          eq(posRecipes.isActive, true),
+        ));
+
+      if (recipes.length === 0) continue;
+      const recipe = recipes[0]!;
+
+      const ingredients = await this.db
+        .select()
+        .from(posRecipeIngredients)
+        .where(eq(posRecipeIngredients.recipeId, recipe.id));
+
+      for (const ing of ingredients) {
+        if (ing.entityId == null) continue;
+
+        const deductQty = Math.ceil((ing.quantity * item.quantity) / recipe.yieldQuantity);
+
+        deductions.push({
+          entityId: ing.entityId,
+          variantId: ing.variantId ?? null,
+          quantity: deductQty,
+          unit: ing.unit,
+          itemName: ing.ingredientName,
+          reason: `Recipe: ${deductQty}${ing.unit} ${ing.ingredientName} for ${item.quantity}x ${recipe.name}`,
+        });
+      }
+    }
+
+    return Ok(deductions);
+  }
+
+  /**
+   * Apply deductions to inventory.
+   *
+   * Strategy 1 (preferred): Use inventory.adjust() via ServiceRegistry.
+   *   - Creates proper inventory_movements with audit trail
+   *   - Fires hooks (e.g., low-stock alerts)
+   *   - Respects the inventory service's stock guard logic
+   *
+   * Strategy 2 (fallback): Raw SQL with atomic WHERE guard.
+   *   - Used when services are not available (standalone scripts, tests)
+   *   - Same oversell protection via UPDATE ... WHERE quantity_on_hand >= N
+   */
+  async applyDeductions(
+    tx: Db,
+    deductions: DeductionItem[],
+    warehouseId: string,
+    referenceType: string,
+    referenceId: string,
+    performedBy: string,
+  ): Promise<PluginResult<number>> {
+    if (this.inventorySvc) {
+      return this.applyViaService(deductions, warehouseId, performedBy);
+    }
+
+    return this.applyViaRawSQL(tx, deductions, warehouseId, referenceType, referenceId, performedBy);
+  }
+
+  /**
+   * Strategy 1: Deduct via kernel.services.inventory.adjust().
+   * Each deduction becomes a negative adjustment with a reason.
+   */
+  private async applyViaService(
+    deductions: DeductionItem[],
+    warehouseId: string,
+    performedBy: string,
+  ): Promise<PluginResult<number>> {
+    const inventory = this.inventorySvc!;
+    const systemActor = {
+      type: "system" as const,
+      userId: performedBy,
+      email: null,
+      name: "Recipe Deduction",
+      vendorId: null,
+      organizationId: null,
+      role: "system",
+      permissions: ["inventory:adjust"],
+    };
+
+    let applied = 0;
+
+    for (const d of deductions) {
+      const result = await inventory.adjust(
+        {
+          entityId: d.entityId,
+          warehouseId,
+          adjustment: -d.quantity,
+          reason: d.reason,
+        },
+        systemActor,
+      );
+
+      if (result.ok) {
+        applied++;
+      }
+      // If adjust fails (insufficient stock), it returns ok: false
+      // and the deduction is skipped -- same behavior as raw SQL guard
+    }
+
+    return Ok(applied);
+  }
+
+  /**
+   * Strategy 2: Raw SQL fallback with atomic oversell guard.
+   * Used when ServiceRegistry is not available.
+   */
+  private async applyViaRawSQL(
+    tx: Db,
+    deductions: DeductionItem[],
+    warehouseId: string,
+    referenceType: string,
+    referenceId: string,
+    performedBy: string,
+  ): Promise<PluginResult<number>> {
+    let applied = 0;
+    // PluginDb (PgDatabase) has .execute() — no cast needed
+    const exec = tx;
+
+    for (const d of deductions) {
+      const variantClause = d.variantId != null
+        ? sql`variant_id = ${d.variantId}`
+        : sql`variant_id IS NULL`;
+
+      // Atomic guard: only deduct if sufficient stock
+      const updateResult = await exec.execute(
+        sql`UPDATE inventory_levels
+            SET quantity_on_hand = quantity_on_hand - ${d.quantity}, updated_at = NOW()
+            WHERE entity_id = ${d.entityId} AND warehouse_id = ${warehouseId} AND ${variantClause}
+              AND quantity_on_hand >= ${d.quantity}
+            RETURNING quantity_on_hand`,
+      );
+
+      const rows = Array.isArray(updateResult) ? updateResult : (updateResult as { rows: unknown[] }).rows;
+      if (rows.length === 0) {
+        await exec.execute(
+          sql`INSERT INTO inventory_movements (entity_id, variant_id, warehouse_id, type, quantity, reference_type, reference_id, reason, performed_by)
+              VALUES (${d.entityId}, ${d.variantId}, ${warehouseId}, 'sale', ${0}, ${referenceType}, ${referenceId}, ${"SKIPPED: insufficient stock for " + d.reason}, ${performedBy})`,
+        );
+        continue;
+      }
+
+      await exec.execute(
+        sql`INSERT INTO inventory_movements (entity_id, variant_id, warehouse_id, type, quantity, reference_type, reference_id, reason, performed_by)
+            VALUES (${d.entityId}, ${d.variantId}, ${warehouseId}, 'sale', ${-d.quantity}, ${referenceType}, ${referenceId}, ${d.reason}, ${performedBy})`,
+      );
+
+      applied++;
+    }
+
+    return Ok(applied);
+  }
+}

package/src/services/recipe-service.ts

@@ -0,0 +1,115 @@
+/**
+ * RecipeService — Recipe/BOM management and COGS calculation.
+ *
+ * URY: Recipe mapping using Bill of Materials (BOM). Links menu items
+ * to raw ingredients for COGS calculation in Daily P&L.
+ * URY uses ERPNext's BOM doctype + Item Price for buying cost.
+ *
+ * Our implementation: pos_recipes + pos_recipe_ingredients tables.
+ * COGS = sum(ingredient.quantity * ingredient.costPerUnit) / yieldQuantity.
+ */
+
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { posRecipes, posRecipeIngredients } from "../schema.js";
+import type { Db } from "../types.js";
+
+export class RecipeService {
+  constructor(private db: Db) {}
+
+  async createRecipe(orgId: string, input: {
+    entityId: string;
+    name: string;
+    yieldQuantity?: number;
+    ingredients: Array<{
+      ingredientName: string;
+      quantity: number;
+      unit: string;
+      costPerUnit: number;
+      entityId?: string;   // optional: link to inventory entity for deduction
+      variantId?: string;  // optional: specific variant to deduct
+    }>;
+  }): Promise<PluginResult<{ id: string; name: string; costPerUnit: number }>> {
+    const rows = await this.db
+      .insert(posRecipes)
+      .values({
+        organizationId: orgId,
+        entityId: input.entityId,
+        name: input.name,
+        yieldQuantity: input.yieldQuantity ?? 1,
+      })
+      .returning();
+
+    const recipe = rows[0]!;
+
+    let totalCost = 0;
+    for (let i = 0; i < input.ingredients.length; i++) {
+      const ing = input.ingredients[i]!;
+      await this.db.insert(posRecipeIngredients).values({
+        recipeId: recipe.id,
+        ingredientName: ing.ingredientName,
+        quantity: ing.quantity,
+        unit: ing.unit,
+        costPerUnit: ing.costPerUnit,
+        entityId: ing.entityId,
+        variantId: ing.variantId,
+        sortOrder: i,
+      });
+      totalCost += ing.quantity * ing.costPerUnit;
+    }
+
+    const costPerUnit = Math.round(totalCost / (input.yieldQuantity ?? 1));
+
+    return Ok({ id: recipe.id, name: recipe.name, costPerUnit });
+  }
+
+  async getRecipeWithIngredients(recipeId: string): Promise<PluginResult<{
+    recipe: typeof posRecipes.$inferSelect;
+    ingredients: Array<typeof posRecipeIngredients.$inferSelect>;
+    totalCost: number;
+    costPerUnit: number;
+  }>> {
+    const recipes = await this.db.select().from(posRecipes).where(eq(posRecipes.id, recipeId));
+    if (recipes.length === 0) return Err("Recipe not found");
+    const recipe = recipes[0]!;
+
+    const ingredients = await this.db
+      .select()
+      .from(posRecipeIngredients)
+      .where(eq(posRecipeIngredients.recipeId, recipeId))
+      .orderBy(posRecipeIngredients.sortOrder);
+
+    const totalCost = ingredients.reduce((sum, i) => sum + i.quantity * i.costPerUnit, 0);
+    const costPerUnit = Math.round(totalCost / recipe.yieldQuantity);
+
+    return Ok({ recipe, ingredients, totalCost, costPerUnit });
+  }
+
+  async calculateCOGS(orgId: string, entityId: string, quantity: number): Promise<number> {
+    const recipes = await this.db
+      .select()
+      .from(posRecipes)
+      .where(and(eq(posRecipes.organizationId, orgId), eq(posRecipes.entityId, entityId), eq(posRecipes.isActive, true)));
+
+    if (recipes.length === 0) return 0;
+    const recipe = recipes[0]!;
+
+    const ingredients = await this.db
+      .select()
+      .from(posRecipeIngredients)
+      .where(eq(posRecipeIngredients.recipeId, recipe.id));
+
+    const costPerYield = ingredients.reduce((sum, i) => sum + i.quantity * i.costPerUnit, 0);
+    const costPerUnit = costPerYield / recipe.yieldQuantity;
+    return Math.round(costPerUnit * quantity);
+  }
+
+  async listRecipes(orgId: string): Promise<PluginResult<Array<typeof posRecipes.$inferSelect>>> {
+    const rows = await this.db
+      .select()
+      .from(posRecipes)
+      .where(eq(posRecipes.organizationId, orgId));
+    return Ok(rows);
+  }
+}

package/src/services/table-service.ts

@@ -0,0 +1,260 @@
+/**
+ * TableService — Table CRUD, status management, assignment, and transfer.
+ *
+ * Informed by URY's table management patterns:
+ * - URY Table: room-based (restaurant_room), binary occupied flag, floor plan layout,
+ *   shape (Circle/Square/Rectangle), is_take_away
+ * - table_transfer(): validates same room, target not occupied, updates KOT links
+ * - captain_transfer(): reassigns waiter, validates room access in multi-cashier mode
+ * - restrict_existing_order(): prevents double-booking (no 2 draft invoices on 1 table)
+ *
+ * Improvements over URY:
+ * - 4-state status machine (available -> occupied -> bill_requested -> cleaning)
+ *   instead of binary occupied flag
+ * - Multi-table assignments (large party across 2+ tables) via pos_table_assignments
+ * - Server section assignment (assignedOperatorId) as first-class field
+ * - Zone-based grouping instead of room doctype FK
+ */
+
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { posTables, posTableAssignments } from "../schema.js";
+import type { Db, Table, TableAssignment, TableStatus } from "../types.js";
+
+const VALID_TRANSITIONS: Record<TableStatus, TableStatus[]> = {
+  available: ["occupied"],
+  occupied: ["bill_requested", "available"],
+  bill_requested: ["cleaning", "available"],
+  cleaning: ["available"],
+};
+
+export class TableService {
+  constructor(private db: Db) {}
+
+  // ─── CRUD ──────────────────────────────────────────────────────────
+
+  async create(orgId: string, input: {
+    number: string;
+    zone: string;
+    capacity?: number;
+    minimumSeats?: number;
+    shape?: "rectangle" | "square" | "circle";
+    isTakeaway?: boolean;
+    layoutX?: number;
+    layoutY?: number;
+  }): Promise<PluginResult<Table>> {
+    // Check for duplicate number in org
+    const existing = await this.db
+      .select()
+      .from(posTables)
+      .where(and(eq(posTables.organizationId, orgId), eq(posTables.number, input.number)));
+
+    if (existing.length > 0) return Err(`Table '${input.number}' already exists`);
+
+    const rows = await this.db
+      .insert(posTables)
+      .values({
+        organizationId: orgId,
+        number: input.number,
+        zone: input.zone,
+        capacity: input.capacity ?? 4,
+        minimumSeats: input.minimumSeats ?? 1,
+        shape: input.shape ?? "rectangle",
+        isTakeaway: input.isTakeaway ?? false,
+        layoutX: input.layoutX ?? 0,
+        layoutY: input.layoutY ?? 0,
+      })
+      .returning();
+
+    return Ok(rows[0]!);
+  }
+
+  async list(orgId: string, zone?: string): Promise<PluginResult<Table[]>> {
+    const conditions = [eq(posTables.organizationId, orgId)];
+    if (zone) conditions.push(eq(posTables.zone, zone));
+
+    const rows = await this.db
+      .select()
+      .from(posTables)
+      .where(and(...conditions))
+      .orderBy(posTables.number);
+
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<Table>> {
+    const rows = await this.db
+      .select()
+      .from(posTables)
+      .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)));
+
+    if (rows.length === 0) return Err("Table not found");
+    return Ok(rows[0]!);
+  }
+
+  async update(orgId: string, id: string, input: {
+    number?: string;
+    zone?: string;
+    capacity?: number;
+    shape?: "rectangle" | "square" | "circle";
+    assignedOperatorId?: string | null;
+    metadata?: Record<string, unknown>;
+  }): Promise<PluginResult<Table>> {
+    const rows = await this.db
+      .update(posTables)
+      .set({ ...input, updatedAt: new Date() })
+      .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)))
+      .returning();
+
+    if (rows.length === 0) return Err("Table not found");
+    return Ok(rows[0]!);
+  }
+
+  // ─── Status Management ─────────────────────────────────────────────
+
+  async setStatus(orgId: string, id: string, newStatus: TableStatus): Promise<PluginResult<Table>> {
+    const table = await this.getById(orgId, id);
+    if (!table.ok) return table;
+
+    const current = table.value.status as TableStatus;
+    const allowed = VALID_TRANSITIONS[current];
+    if (!allowed?.includes(newStatus)) {
+      return Err(`Cannot transition table from '${current}' to '${newStatus}'`);
+    }
+
+    const rows = await this.db
+      .update(posTables)
+      .set({ status: newStatus, updatedAt: new Date() })
+      .where(eq(posTables.id, id))
+      .returning();
+
+    return Ok(rows[0]!);
+  }
+
+  // ─── Assignment ────────────────────────────────────────────────────
+  // Links a table to a POS transaction. Sets table status to "occupied".
+  // URY equivalent: sync_order() setting occupied=1 + latest_invoice_time.
+
+  async assignToTransaction(orgId: string, tableId: string, transactionId: string): Promise<PluginResult<TableAssignment>> {
+    // Lock the table row to prevent concurrent double-seating
+    const locked = await this.db
+      .select()
+      .from(posTables)
+      .where(and(eq(posTables.id, tableId), eq(posTables.organizationId, orgId)))
+      .for("update");
+
+    if (locked.length === 0) return Err("Table not found");
+    const table = locked[0]!;
+    if (table.status !== "available") {
+      return Err(`Table '${table.number}' is not available (current: ${table.status})`);
+    }
+
+    // Set table to occupied (under lock — no race condition)
+    await this.db
+      .update(posTables)
+      .set({ status: "occupied", updatedAt: new Date() })
+      .where(eq(posTables.id, tableId));
+
+    // Create assignment
+    const rows = await this.db
+      .insert(posTableAssignments)
+      .values({ tableId, transactionId, seatedAt: new Date() })
+      .returning();
+
+    return Ok(rows[0]!);
+  }
+
+  // ─── Clear ─────────────────────────────────────────────────────────
+  // Clears a table: removes assignments and sets status to "available".
+
+  async clear(orgId: string, tableId: string): Promise<PluginResult<Table>> {
+    // Delete assignments
+    await this.db
+      .delete(posTableAssignments)
+      .where(eq(posTableAssignments.tableId, tableId));
+
+    // Set available
+    const rows = await this.db
+      .update(posTables)
+      .set({ status: "available", updatedAt: new Date() })
+      .where(and(eq(posTables.id, tableId), eq(posTables.organizationId, orgId)))
+      .returning();
+
+    if (rows.length === 0) return Err("Table not found");
+    return Ok(rows[0]!);
+  }
+
+  // ─── Transfer ──────────────────────────────────────────────────────
+  // Moves a transaction from one table to another.
+  // URY equivalent: table_transfer() — validates same room, target not occupied.
+  // We validate same zone (our equivalent of URY's room).
+
+  async transfer(orgId: string, fromTableId: string, toTableId: string): Promise<PluginResult<{ from: Table; to: Table }>> {
+    const fromTable = await this.getById(orgId, fromTableId);
+    if (!fromTable.ok) return fromTable;
+
+    const toTable = await this.getById(orgId, toTableId);
+    if (!toTable.ok) return toTable;
+
+    // Same zone required (URY: same room)
+    if (fromTable.value.zone !== toTable.value.zone) {
+      return Err(`Cannot transfer between different zones ('${fromTable.value.zone}' -> '${toTable.value.zone}')`);
+    }
+
+    // Target must be available
+    if (toTable.value.status !== "available") {
+      return Err(`Target table '${toTable.value.number}' is not available`);
+    }
+
+    // Move assignments
+    await this.db
+      .update(posTableAssignments)
+      .set({ tableId: toTableId })
+      .where(eq(posTableAssignments.tableId, fromTableId));
+
+    // Update statuses
+    await this.db.update(posTables).set({ status: "available", updatedAt: new Date() }).where(eq(posTables.id, fromTableId));
+    await this.db.update(posTables).set({ status: "occupied", updatedAt: new Date() }).where(eq(posTables.id, toTableId));
+
+    const updatedFrom = (await this.getById(orgId, fromTableId)).ok ? (await this.getById(orgId, fromTableId)) : fromTable;
+    const updatedTo = (await this.getById(orgId, toTableId)).ok ? (await this.getById(orgId, toTableId)) : toTable;
+
+    if (!updatedFrom.ok || !updatedTo.ok) return Err("Transfer failed");
+    return Ok({ from: updatedFrom.value, to: updatedTo.value });
+  }
+
+  // ─── Layout ────────────────────────────────────────────────────────
+  // Updates floor plan position. URY equivalent: updateTableLayout() in table-api.ts.
+
+  async updateLayout(orgId: string, id: string, layout: {
+    layoutX?: number;
+    layoutY?: number;
+    layoutWidth?: number;
+    layoutHeight?: number;
+  }): Promise<PluginResult<Table>> {
+    const rows = await this.db
+      .update(posTables)
+      .set({ ...layout, updatedAt: new Date() })
+      .where(and(eq(posTables.id, id), eq(posTables.organizationId, orgId)))
+      .returning();
+
+    if (rows.length === 0) return Err("Table not found");
+    return Ok(rows[0]!);
+  }
+
+  // ─── Zones ─────────────────────────────────────────────────────────
+
+  async listZones(orgId: string): Promise<PluginResult<Array<{ zone: string; count: number }>>> {
+    const rows = await this.db
+      .select({
+        zone: posTables.zone,
+        count: sql<number>`COUNT(*)`.as("count"),
+      })
+      .from(posTables)
+      .where(eq(posTables.organizationId, orgId))
+      .groupBy(posTables.zone);
+
+    return Ok(rows.map((r) => ({ zone: r.zone, count: Number(r.count) })));
+  }
+}

package/src/types.ts

@@ -0,0 +1,63 @@
+export type { PluginDb as Db } from "@porulle/core";
+import type {
+  posModifierGroups,
+  posModifierOptions,
+  posTables,
+  posTableAssignments,
+  kdsStations,
+  kdsStationItemGroups,
+  kdsTickets,
+  kdsTicketItems,
+} from "./schema.js";
+
+// ─── Modifier Types ─────────────────────────────────────────────────────
+
+export type ModifierGroup = typeof posModifierGroups.$inferSelect;
+export type ModifierGroupInsert = typeof posModifierGroups.$inferInsert;
+export type ModifierOption = typeof posModifierOptions.$inferSelect;
+export type ModifierOptionInsert = typeof posModifierOptions.$inferInsert;
+
+// ─── Table Types ────────────────────────────────────────────────────────
+
+export type Table = typeof posTables.$inferSelect;
+export type TableInsert = typeof posTables.$inferInsert;
+export type TableAssignment = typeof posTableAssignments.$inferSelect;
+export type TableAssignmentInsert = typeof posTableAssignments.$inferInsert;
+
+export type TableStatus = "available" | "occupied" | "bill_requested" | "cleaning";
+export type TableShape = "rectangle" | "square" | "circle";
+
+// ─── KDS Types ──────────────────────────────────────────────────────────
+
+export type KDSStation = typeof kdsStations.$inferSelect;
+export type KDSStationInsert = typeof kdsStations.$inferInsert;
+export type KDSStationItemGroup = typeof kdsStationItemGroups.$inferSelect;
+export type KDSTicket = typeof kdsTickets.$inferSelect;
+export type KDSTicketInsert = typeof kdsTickets.$inferInsert;
+export type KDSTicketItem = typeof kdsTicketItems.$inferSelect;
+export type KDSTicketItemInsert = typeof kdsTicketItems.$inferInsert;
+
+export type TicketType = "new_order" | "modified" | "cancelled" | "partially_cancelled";
+export type TicketStatus = "pending" | "preparing" | "ready" | "served";
+export type TicketItemStatus = "pending" | "preparing" | "done";
+export type OrderType = "dine_in" | "takeaway" | "delivery";
+
+// ─── Plugin Options ─────────────────────────────────────────────────────
+
+export interface POSRestaurantPluginOptions {
+  /** Enable kitchen display system. Default: true */
+  enableKDS?: boolean;
+  /** Enable tip collection on payments. Default: true */
+  enableTips?: boolean;
+  /** Enable item modifiers. Default: true */
+  enableModifiers?: boolean;
+  /** Minutes before KDS ticket turns red. Default: 15 */
+  kdsAlertMinutes?: number;
+}
+
+export const DEFAULT_RESTAURANT_OPTIONS: Required<POSRestaurantPluginOptions> = {
+  enableKDS: true,
+  enableTips: true,
+  enableModifiers: true,
+  kdsAlertMinutes: 15,
+};