Quickstart

A complete flow: create a category, add a menu item (with variants in TypeScript), customize it with a modifier group, place an order, and advance it through the kitchen lifecycle. The Python flow uses the unified menu resources — items priced directly and orders identified by menu_item_id.

TypeScript

import { WiilClient } from 'wiil-js';
import { MenuOrderType, OrderStatus, PreferredContactMethod } from 'wiil-core-js';

async function setupRestaurant() {
  const client = new WiilClient({ apiKey: process.env.WIIL_API_KEY! });

  // 1. Create customer
  const customer = await client.customers.create({
    phone_number: '+15551234567',
    firstname: 'John',
    lastname: 'Doe',
    preferred_language: 'en',
    preferred_contact_method: PreferredContactMethod.SMS,
    isValidatedNames: false,
  });

  // 2. Create menu categories
  const appetizers = await client.menus.createCategory({ name: 'Appetizers', description: 'Start your meal', displayOrder: 1 });
  const entrees = await client.menus.createCategory({ name: 'Entrees', description: 'Main courses', displayOrder: 2 });

  // 3. Create menu items with required variants
  const wings = await client.menus.createItem({
    categoryId: appetizers.id,
    name: 'Buffalo Wings',
    description: 'Crispy wings with hot sauce',
    price: 11.99,
    isAvailable: true,
    isActive: true,
    preparationTime: 15,
    displayOrder: 1,
    variants: [
      { name: '6 pieces', price: 11.99, isDefault: true, isActive: true, isAvailable: true },
      { name: '12 pieces', price: 19.99, isDefault: false, isActive: true, isAvailable: true },
    ],
  });

  const burger = await client.menus.createItem({
    categoryId: entrees.id,
    name: 'Classic Burger',
    description: 'Angus beef with all the fixings',
    price: 14.99,
    isAvailable: true,
    isActive: true,
    preparationTime: 12,
    displayOrder: 1,
    variants: [
      { name: 'Default', price: 14.99, isDefault: true, isActive: true, isAvailable: true },
    ],
  });

  // 4. Create a modifier group and bind it to the burger
  const toppings = await client.modifiers.createGroup({
    name: 'Extra Toppings',
    description: 'Customize your burger',
    isRequired: false,
    minSelection: 0,
    maxSelection: 3,
    displayOrder: 1,
    isActive: true,
    options: [
      { name: 'Bacon', priceDelta: 2.00, displayOrder: 1, isDefault: false, isActive: true },
      { name: 'Extra Cheese', priceDelta: 1.50, displayOrder: 2, isDefault: false, isActive: true },
      { name: 'Avocado', priceDelta: 2.50, displayOrder: 3, isDefault: false, isActive: true },
    ],
  });

  await client.modifiers.createBinding({
    menuItemId: burger.id,
    modifierGroupId: toppings.id,
    displayOrder: 1,
    isRequired: false,
  });

  // 5. Create an order
  const order = await client.menuOrders.create({
    customerId: customer.id,
    type: MenuOrderType.DINE_IN,
    orderDate: Date.now(),
    items: [
      { menuItemId: wings.id, variantId: wings.variants[1].id, itemName: 'Buffalo Wings (12 pieces)', quantity: 1, unitPrice: 19.99, totalPrice: 19.99 },
      { menuItemId: burger.id, variantId: burger.variants[0].id, itemName: 'Classic Burger', quantity: 2, unitPrice: 14.99, totalPrice: 29.98 },
    ],
    pricing: { subtotal: 49.97, total: 49.97 },
  });

  // 6. Move the order through its lifecycle
  await client.menuOrders.updateStatus(order.id, {
    id: order.id,
    status: OrderStatus.CONFIRMED,
    estimatedReadyTime: null,
    actualReadyTime: null,
  });

  return { customer, categories: [appetizers, entrees], items: [wings, burger], order };
}

setupRestaurant().catch(console.error);

Python

from time import time

from wiil import WiilClient
from wiil.models.business_mgt import (
    CreateBusinessMenuItem,
    CreateMenuCategory,
    CreateMenuOrder,
    MenuOrderItemBase,
    OrderPricing,
)

client = WiilClient(api_key="your-api-key")
now_ms = int(time() * 1000)

# 1. Create a category
category = client.menus.create_category(
    CreateMenuCategory(name="Main Courses", description="Signature entrees", display_order=1)
)

# 2. Create a menu item
menu_item = client.menus.create_item(
    CreateBusinessMenuItem(
        name="Cheeseburger",
        description="Angus beef with aged cheddar",
        price=12.99,
        category_id=category.id,
        ingredients=["beef", "cheese", "lettuce", "tomato", "bun"],
        allergens=["gluten", "dairy"],
        is_available=True,
        preparation_time=15,
        is_active=True,
    )
)

# 3. Place an order (Python order items use menu_item_id)
order = client.menu_orders.create(
    CreateMenuOrder(
        type="takeout",
        items=[
            MenuOrderItemBase(
                menu_item_id=menu_item.id,
                item_name=menu_item.name,
                quantity=2,
                unit_price=menu_item.price,
                total_price=menu_item.price * 2,
            )
        ],
        customer_id="cust_123",
        pricing=OrderPricing(subtotal=25.98, tax=2.60, tip=5.00, total=33.58, currency="USD"),
        order_date=now_ms,
        source="web",
    )
)

# 4. Advance the order, then read it back
confirmed = client.menu_orders.update_status(order.id, "confirmed")
loaded = client.menu_orders.get(order.id)

print("Created menu item:", menu_item.id)
print("Order:", order.id, "->", confirmed.status)

Next steps

• Categories & items — full reference for categories, items, and variants
• Modifiers — customization groups, options, and bindings
• Orders — order fields, pricing, and the kitchen lifecycle