@fayz-ai/plugin-tables 0.9.0 → 0.9.2

package/src/data/platform.ts

@@ -1,348 +0,0 @@
-import { createFayzClient, type FayzClientOptions, type FayzTableFilter } from '@fayz-ai/sdk'
-import type {
-  CreateTableInput,
-  RestaurantTable,
-  SeatGuestsInput,
-  TableQuery,
-  TableSession,
-  TablesSummary,
-  TableStatus,
-  UpdateTableStatusInput,
-  Zone,
-} from '../types'
-import type { TablesDataProvider } from './types'
-
-export interface FayzTablesProviderOptions extends FayzClientOptions {
-  projectId?: string
-  tableName?: string
-  schema?: string
-  runtime?: boolean
-  /**
-   * Active tenant id (or a getter) used to scope reads and stamp writes on the
-   * restaurant_tables table. When omitted, scoping is left to runtime/RLS.
-   */
-  tenantId?: string | (() => string | undefined | null)
-}
-
-interface RestaurantTableRow {
-  id: string
-  tenant_id?: string | null
-  name?: string | null
-  number?: number | null
-  seats?: number | null
-  status?: TableStatus | null
-  zone?: string | null
-  zone_name?: string | null
-  shape?: RestaurantTable['shape'] | null
-  grid_col?: number | null
-  grid_row?: number | null
-  is_active?: boolean | null
-  current_session_id?: string | null
-  current_order_id?: string | null
-  current_guests?: number | null
-  current_waiter_name?: string | null
-  current_elapsed_minutes?: number | null
-  current_total?: number | null
-  metadata?: Record<string, unknown> | null
-  created_at?: string | null
-  updated_at?: string | null
-}
-
-const DEFAULT_TABLE_NAME = 'restaurant_tables'
-
-function nowIso(): string {
-  return new Date().toISOString()
-}
-
-function rowToTable(row: RestaurantTableRow): RestaurantTable {
-  const number = row.number ?? 0
-  const zone = row.zone ?? 'indoor'
-  return {
-    id: row.id,
-    name: row.name ?? `Table ${number}`,
-    number,
-    seats: row.seats ?? 4,
-    status: row.status ?? 'available',
-    zone,
-    zoneName: row.zone_name ?? zone,
-    shape: row.shape ?? 'square',
-    gridCol: row.grid_col ?? 0,
-    gridRow: row.grid_row ?? 0,
-    isActive: row.is_active ?? true,
-    currentSessionId: row.current_session_id ?? undefined,
-    currentOrderId: row.current_order_id ?? undefined,
-    currentGuests: row.current_guests ?? undefined,
-    currentWaiterName: row.current_waiter_name ?? undefined,
-    currentElapsedMinutes: row.current_elapsed_minutes ?? undefined,
-    currentTotal: row.current_total ?? undefined,
-    metadata: row.metadata ?? {},
-    tenantId: row.tenant_id ?? 'runtime-tenant',
-    createdAt: row.created_at ?? nowIso(),
-    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
-  }
-}
-
-function tableCreatePayload(input: CreateTableInput): Record<string, unknown> {
-  return {
-    name: input.name,
-    number: input.number,
-    seats: input.seats,
-    zone: input.zone,
-    shape: input.shape ?? 'square',
-    grid_col: input.gridCol ?? 0,
-    grid_row: input.gridRow ?? 0,
-    status: 'available',
-    is_active: true,
-  }
-}
-
-function tableUpdatePayload(data: Partial<RestaurantTable>): Record<string, unknown> {
-  const payload: Record<string, unknown> = {}
-  if (data.name !== undefined) payload.name = data.name
-  if (data.number !== undefined) payload.number = data.number
-  if (data.seats !== undefined) payload.seats = data.seats
-  if (data.status !== undefined) payload.status = data.status
-  if (data.zone !== undefined) payload.zone = data.zone
-  if (data.zoneName !== undefined) payload.zone_name = data.zoneName
-  if (data.shape !== undefined) payload.shape = data.shape
-  if (data.gridCol !== undefined) payload.grid_col = data.gridCol
-  if (data.gridRow !== undefined) payload.grid_row = data.gridRow
-  if (data.isActive !== undefined) payload.is_active = data.isActive
-  if (data.currentSessionId !== undefined) payload.current_session_id = data.currentSessionId
-  if (data.currentOrderId !== undefined) payload.current_order_id = data.currentOrderId
-  if (data.currentGuests !== undefined) payload.current_guests = data.currentGuests
-  if (data.currentWaiterName !== undefined) payload.current_waiter_name = data.currentWaiterName
-  if (data.currentElapsedMinutes !== undefined) payload.current_elapsed_minutes = data.currentElapsedMinutes
-  if (data.currentTotal !== undefined) payload.current_total = data.currentTotal
-  if (data.metadata !== undefined) payload.metadata = data.metadata
-  return payload
-}
-
-function filtersFromQuery(query?: TableQuery): FayzTableFilter[] {
-  const filters: FayzTableFilter[] = [{ column: 'is_active', operator: 'eq', value: true }]
-  if (!query) return filters
-  if (query.zone) filters.push({ column: 'zone', operator: 'eq', value: query.zone })
-  if (query.status && !Array.isArray(query.status)) {
-    filters.push({ column: 'status', operator: 'eq', value: query.status })
-  }
-  return filters
-}
-
-function matchesClientQuery(table: RestaurantTable, query?: TableQuery): boolean {
-  if (!query) return true
-  if (Array.isArray(query.status) && !query.status.includes(table.status)) return false
-  if (query.search) {
-    const search = query.search.toLowerCase()
-    return table.name.toLowerCase().includes(search)
-      || String(table.number).includes(search)
-      || (table.zoneName?.toLowerCase().includes(search) ?? false)
-  }
-  return true
-}
-
-function summarize(tables: RestaurantTable[]): TablesSummary {
-  const availableCount = tables.filter((table) => table.status === 'available').length
-  const occupiedCount = tables.filter((table) => table.status === 'occupied').length
-  const reservedCount = tables.filter((table) => table.status === 'reserved').length
-  const cleaningCount = tables.filter((table) => table.status === 'cleaning').length
-  const totalSeats = tables.reduce((sum, table) => sum + table.seats, 0)
-  const occupiedSeats = tables
-    .filter((table) => table.status === 'occupied')
-    .reduce((sum, table) => sum + (table.currentGuests ?? table.seats), 0)
-
-  return {
-    totalTables: tables.length,
-    availableCount,
-    occupiedCount,
-    reservedCount,
-    cleaningCount,
-    totalSeats,
-    occupiedSeats,
-    averageSessionMinutes: 0,
-  }
-}
-
-export function createFayzTablesProvider(options: FayzTablesProviderOptions = {}): TablesDataProvider {
-  const client = createFayzClient(options)
-  const table = options.tableName ?? DEFAULT_TABLE_NAME
-  const baseOptions = {
-    projectId: options.projectId,
-    table,
-    schema: options.schema,
-    runtime: options.runtime,
-  }
-
-  function resolveTenant(): string | undefined {
-    const value = typeof options.tenantId === 'function' ? options.tenantId() : options.tenantId
-    return value ?? undefined
-  }
-
-  function withTenant(filters: FayzTableFilter[]): FayzTableFilter[] {
-    const tenantId = resolveTenant()
-    return tenantId ? [{ column: 'tenant_id', operator: 'eq', value: tenantId }, ...filters] : filters
-  }
-
-  async function listTables(query?: TableQuery): Promise<RestaurantTable[]> {
-    const response = await client.data.listRows<RestaurantTableRow>({
-      ...baseOptions,
-      filters: withTenant(filtersFromQuery(query)),
-      sortColumn: 'number',
-      sortDirection: 'asc',
-      limit: 500,
-    })
-    return response.rows.map(rowToTable).filter((item) => matchesClientQuery(item, query))
-  }
-
-  async function getById(id: string): Promise<RestaurantTable | null> {
-    const response = await client.data.listRows<RestaurantTableRow>({
-      ...baseOptions,
-      filters: withTenant([{ column: 'id', operator: 'eq', value: id }]),
-      limit: 1,
-    })
-    return response.rows[0] ? rowToTable(response.rows[0]) : null
-  }
-
-  return {
-    async getTables(query?: TableQuery) {
-      return listTables(query)
-    },
-
-    async getTableById(id: string) {
-      return getById(id)
-    },
-
-    async createTable(input: CreateTableInput) {
-      const tenantId = resolveTenant()
-      const row = await client.data.createRow<RestaurantTableRow>({
-        ...baseOptions,
-        row: tenantId ? { ...tableCreatePayload(input), tenant_id: tenantId } : tableCreatePayload(input),
-      })
-      return rowToTable(row)
-    },
-
-    async updateTable(id: string, data: Partial<RestaurantTable>) {
-      const row = await client.data.updateRow<RestaurantTableRow>({
-        ...baseOptions,
-        primaryKeys: { id },
-        row: tableUpdatePayload(data),
-      })
-      return rowToTable(row)
-    },
-
-    async deleteTable(id: string) {
-      await client.data.deleteRows({ ...baseOptions, rows: [{ id }] })
-    },
-
-    async updateTableStatus(input: UpdateTableStatusInput) {
-      return this.updateTable(input.tableId, { status: input.status })
-    },
-
-    async updateTablePositions(positions: Array<{ id: string; gridCol: number; gridRow: number }>) {
-      await Promise.all(positions.map((position) => this.updateTable(position.id, {
-        gridCol: position.gridCol,
-        gridRow: position.gridRow,
-      })))
-    },
-
-    async seatGuests(input: SeatGuestsInput) {
-      const table = await this.updateTable(input.tableId, {
-        status: 'occupied',
-        currentGuests: input.guests,
-        currentWaiterName: input.waiterId ? `Waiter ${input.waiterId}` : undefined,
-        currentElapsedMinutes: 0,
-        currentTotal: 0,
-      })
-      const session: TableSession = {
-        id: table.currentSessionId ?? `runtime-session-${table.id}`,
-        tableId: table.id,
-        tableName: table.name,
-        guests: input.guests,
-        waiterId: input.waiterId,
-        waiterName: table.currentWaiterName,
-        seatedAt: nowIso(),
-        status: 'active',
-        notes: input.notes,
-        tenantId: table.tenantId,
-        createdAt: nowIso(),
-      }
-      return session
-    },
-
-    async closeSession(sessionId: string) {
-      const tables = await listTables()
-      const table = tables.find((item) => item.currentSessionId === sessionId)
-      if (table) await this.updateTable(table.id, {
-        status: 'cleaning',
-        currentSessionId: undefined,
-        currentOrderId: undefined,
-        currentGuests: undefined,
-        currentWaiterName: undefined,
-        currentElapsedMinutes: undefined,
-        currentTotal: undefined,
-      })
-      return {
-        id: sessionId,
-        tableId: table?.id ?? '',
-        tableName: table?.name,
-        guests: table?.currentGuests ?? 0,
-        seatedAt: nowIso(),
-        closedAt: nowIso(),
-        status: 'closed',
-        tenantId: table?.tenantId ?? 'runtime-tenant',
-        createdAt: nowIso(),
-      }
-    },
-
-    async getActiveSessions() {
-      const tables = await listTables({ status: 'occupied' })
-      return tables.map((table) => ({
-        id: table.currentSessionId ?? `runtime-session-${table.id}`,
-        tableId: table.id,
-        tableName: table.name,
-        guests: table.currentGuests ?? table.seats,
-        waiterName: table.currentWaiterName,
-        seatedAt: nowIso(),
-        status: 'active' as const,
-        tenantId: table.tenantId,
-        createdAt: nowIso(),
-      }))
-    },
-
-    async getSessionHistory() {
-      return []
-    },
-
-    async getZones() {
-      const tables = await listTables()
-      const zones = new Map<string, Zone>()
-      for (const table of tables) {
-        if (zones.has(table.zone)) continue
-        zones.set(table.zone, {
-          id: table.zone,
-          name: table.zoneName ?? table.zone,
-          sortOrder: zones.size,
-          isActive: true,
-          tenantId: table.tenantId,
-          createdAt: table.createdAt,
-        })
-      }
-      return [...zones.values()]
-    },
-
-    async createZone() {
-      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
-    },
-
-    async updateZone() {
-      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
-    },
-
-    async deleteZone() {
-      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
-    },
-
-    async getSummary() {
-      return summarize(await listTables())
-    },
-  }
-}

package/src/data/types.ts

@@ -1,31 +0,0 @@
-import type {
-  RestaurantTable, TableSession, Zone,
-  CreateTableInput, SeatGuestsInput, UpdateTableStatusInput,
-  TableQuery, TablesSummary,
-} from '../types'
-
-export interface TablesDataProvider {
-  // Tables
-  getTables(query?: TableQuery): Promise<RestaurantTable[]>
-  getTableById(id: string): Promise<RestaurantTable | null>
-  createTable(input: CreateTableInput): Promise<RestaurantTable>
-  updateTable(id: string, data: Partial<RestaurantTable>): Promise<RestaurantTable>
-  deleteTable(id: string): Promise<void>
-  updateTableStatus(input: UpdateTableStatusInput): Promise<RestaurantTable>
-  updateTablePositions(positions: Array<{ id: string; gridCol: number; gridRow: number }>): Promise<void>
-
-  // Sessions
-  seatGuests(input: SeatGuestsInput): Promise<TableSession>
-  closeSession(sessionId: string): Promise<TableSession>
-  getActiveSessions(): Promise<TableSession[]>
-  getSessionHistory(tableId?: string): Promise<TableSession[]>
-
-  // Zones
-  getZones(): Promise<Zone[]>
-  createZone(data: Partial<Zone>): Promise<Zone>
-  updateZone(id: string, data: Partial<Zone>): Promise<Zone>
-  deleteZone(id: string): Promise<void>
-
-  // Summary
-  getSummary(): Promise<TablesSummary>
-}

package/src/index.ts

@@ -1,179 +0,0 @@
-import React from 'react'
-import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
-import type { TablesDataProvider } from './data/types'
-import type { TableSession } from './types'
-import { createMockTablesProvider } from './data/mock'
-import { createTablesStore } from './store'
-import { tablesRegistries } from './registries'
-import { tablesLocales } from './locales'
-import { PluginSettingsPanel } from '@fayz-ai/saas'
-
-const TablesPage = React.lazy(() => import('./TablesPage').then((m) => ({ default: m.TablesPage })))
-
-// ---------------------------------------------------------------------------
-// Labels
-// ---------------------------------------------------------------------------
-
-export interface TablesPluginLabels {
-  pageTitle: string
-  floorPlan: string
-  zones: string
-  sessionHistory: string
-}
-
-const DEFAULT_LABELS: TablesPluginLabels = {
-  pageTitle: 'Tables',
-  floorPlan: 'Floor Plan',
-  zones: 'Zones',
-  sessionHistory: 'Session History',
-}
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface TablesPluginOptions {
-  modules?: {
-    reservations?: boolean
-    sessionHistory?: boolean
-  }
-  labels?: Partial<TablesPluginLabels>
-  defaultZones?: Array<{ name: string; color?: string }>
-  navPosition?: number
-  navSection?: 'main' | 'secondary' | 'settings'
-  scope?: PluginScope
-  verticalId?: VerticalId
-  dataProvider?: TablesDataProvider
-  onTableSeated?: (session: TableSession) => Promise<string | undefined>
-  onTableClosed?: (session: TableSession) => Promise<void>
-}
-
-// ---------------------------------------------------------------------------
-// Config resolver
-// ---------------------------------------------------------------------------
-
-function resolveConfig(options?: TablesPluginOptions) {
-  return {
-    modules: {
-      reservations: options?.modules?.reservations === true,
-      sessionHistory: options?.modules?.sessionHistory !== false,
-    },
-    labels: { ...DEFAULT_LABELS, ...options?.labels } as any,
-    defaultZones: options?.defaultZones ?? [
-      { name: 'Indoor', color: '#3b82f6' },
-      { name: 'Outdoor', color: '#22c55e' },
-      { name: 'Bar', color: '#f59e0b' },
-    ],
-    onTableSeated: options?.onTableSeated,
-    onTableClosed: options?.onTableClosed,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createTablesPlugin(options?: TablesPluginOptions): PluginManifest {
-  const config = resolveConfig(options)
-  const provider = options?.dataProvider ?? createMockTablesProvider()
-  const store = createTablesStore(provider)
-
-  const PageComponent: React.FC<any> = () =>
-    React.createElement(React.Suspense, { fallback: null },
-      React.createElement(TablesPage, { config, provider, store, registries: tablesRegistries })
-    )
-
-  return {
-    id: 'tables',
-    name: config.labels.pageTitle,
-    icon: 'MapPin',
-    version: '1.0.0',
-    scope: options?.scope ?? 'vertical',
-    verticalId: options?.verticalId,
-    defaultEnabled: true,
-    dependencies: [],
-    navigation: [
-      {
-        section: options?.navSection ?? 'main',
-        position: options?.navPosition ?? 4,
-        label: config.labels.pageTitle,
-        route: '/tables',
-        icon: 'MapPin',
-        permission: { feature: 'tables', action: 'read' as const },
-      },
-    ],
-    routes: [
-      {
-        path: '/tables',
-        component: PageComponent,
-        permission: { feature: 'tables', action: 'read' as const },
-      },
-    ],
-    widgets: [],
-    aiTools: [
-      {
-        id: 'tables.availability',
-        name: 'getTableAvailability',
-        description: 'Returns which tables are available, occupied, reserved, or being cleaned.',
-        icon: 'MapPin',
-        mode: 'read' as const,
-        category: 'Tables',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            zone: { type: 'string' as const, description: 'Filter by zone name' },
-            status: { type: 'string' as const, enum: ['available', 'occupied', 'reserved', 'cleaning'] },
-          },
-        },
-        suggestions: [
-          { label: 'Which tables are available right now?' },
-          { label: 'How many tables are occupied?' },
-        ],
-      },
-      {
-        id: 'tables.seat-guests',
-        name: 'seatGuests',
-        description: 'Seats guests at a specific table.',
-        icon: 'UserPlus',
-        mode: 'persist' as const,
-        category: 'Tables',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            tableNumber: { type: 'number' as const, description: 'Table number' },
-            guests: { type: 'number' as const, description: 'Number of guests' },
-          },
-          required: ['tableNumber', 'guests'],
-        },
-        permission: { feature: 'tables', action: 'edit' as const },
-      },
-    ],
-    registries: tablesRegistries,
-    settings: [
-      {
-        id: 'tables',
-        label: config.labels.pageTitle,
-        icon: 'MapPin',
-        component: (() => {
-          const TablesSettingsTab: React.ComponentType<unknown> = () =>
-            React.createElement(PluginSettingsPanel, {
-              title: 'Tables Settings',
-              subtitle: 'Zones and floor plan configuration',
-              registries: tablesRegistries,
-              routeBase: '/settings/tables',
-            })
-          TablesSettingsTab.displayName = 'TablesSettingsTab'
-          return TablesSettingsTab
-        })(),
-        order: 21,
-        permission: { feature: 'tables', action: 'read' as const },
-      },
-    ],
-    locales: tablesLocales,
-  }
-}
-
-export type { TablesDataProvider } from './data/types'
-export { createFayzTablesProvider } from './data/platform'
-export type { FayzTablesProviderOptions } from './data/platform'
-export type { ResolvedTablesConfig } from './TablesContext'

package/src/locales/en.ts

@@ -1,45 +0,0 @@
-export const en: Record<string, string> = {
-  'tables.title': 'Tables',
-  'tables.nav.floorPlan': 'Floor Plan',
-  'tables.nav.zones': 'Zones',
-  'tables.nav.history': 'Session History',
-  'tables.floorPlan.title': 'Floor Plan',
-  'tables.floorPlan.subtitle': 'Manage table layout and seating',
-  'tables.floorPlan.available': 'Available',
-  'tables.floorPlan.occupied': 'Occupied',
-  'tables.floorPlan.reserved': 'Reserved',
-  'tables.floorPlan.cleaning': 'Cleaning',
-  'tables.floorPlan.seats': 'seats',
-  'tables.floorPlan.noTables': 'No tables configured',
-  'tables.floorPlan.noTablesDesc': 'Add your first table to get started',
-  'tables.floorPlan.addTable': 'Add Table',
-  'tables.floorPlan.occupiedOf': '{occupied} occupied, {available} available of {total} tables',
-  'tables.floorPlan.selectTable': 'Select a table',
-  'tables.floorPlan.selectTableDesc': 'Click on any table to see details and actions',
-  'tables.floorPlan.min': 'min',
-  'tables.floorPlan.zone': 'Zone',
-  'tables.floorPlan.order': 'Order',
-  'tables.floorPlan.checkIn': 'Check In',
-  'tables.detail.currentSession': 'Current Session',
-  'tables.detail.guests': 'Guests',
-  'tables.detail.waiter': 'Waiter',
-  'tables.detail.elapsed': 'Elapsed',
-  'tables.detail.total': 'Running Total',
-  'tables.detail.viewOrder': 'View Order',
-  'tables.detail.seatGuests': 'Seat Guests',
-  'tables.detail.closeTable': 'Close Table',
-  'tables.detail.markClean': 'Mark Ready',
-  'tables.detail.cancel': 'Cancel',
-  'tables.seat.title': 'Seat Guests',
-  'tables.seat.guestCount': 'Number of guests',
-  'tables.seat.waiter': 'Waiter',
-  'tables.seat.notes': 'Notes',
-  'tables.seat.confirm': 'Seat',
-  'tables.history.title': 'Session History',
-  'tables.history.table': 'Table',
-  'tables.history.guests': 'Guests',
-  'tables.history.waiter': 'Waiter',
-  'tables.history.duration': 'Duration',
-  'tables.history.noSessions': 'No session history yet',
-  'tables.settings.title': 'Tables Settings',
-}

package/src/locales/index.ts

@@ -1,4 +0,0 @@
-import { en } from './en'
-import { ptBR } from './pt-BR'
-
-export const tablesLocales: Record<string, Record<string, string>> = { en, 'pt-BR': ptBR }

package/src/locales/pt-BR.ts

@@ -1,45 +0,0 @@
-export const ptBR: Record<string, string> = {
-  'tables.title': 'Mesas',
-  'tables.nav.floorPlan': 'Mapa de Mesas',
-  'tables.nav.zones': 'Áreas',
-  'tables.nav.history': 'Histórico',
-  'tables.floorPlan.title': 'Mapa de Mesas',
-  'tables.floorPlan.subtitle': 'Gerencie o layout e a ocupação das mesas',
-  'tables.floorPlan.available': 'Disponível',
-  'tables.floorPlan.occupied': 'Ocupada',
-  'tables.floorPlan.reserved': 'Reservada',
-  'tables.floorPlan.cleaning': 'Limpeza',
-  'tables.floorPlan.seats': 'lugares',
-  'tables.floorPlan.noTables': 'Nenhuma mesa configurada',
-  'tables.floorPlan.noTablesDesc': 'Adicione a primeira mesa para começar',
-  'tables.floorPlan.addTable': 'Adicionar Mesa',
-  'tables.floorPlan.occupiedOf': '{occupied} ocupadas, {available} disponíveis de {total} mesas',
-  'tables.floorPlan.selectTable': 'Selecione uma mesa',
-  'tables.floorPlan.selectTableDesc': 'Clique em uma mesa para ver detalhes e ações',
-  'tables.floorPlan.min': 'min',
-  'tables.floorPlan.zone': 'Área',
-  'tables.floorPlan.order': 'Pedido',
-  'tables.floorPlan.checkIn': 'Check-in',
-  'tables.detail.currentSession': 'Sessão Atual',
-  'tables.detail.guests': 'Pessoas',
-  'tables.detail.waiter': 'Garçom',
-  'tables.detail.elapsed': 'Tempo',
-  'tables.detail.total': 'Total Parcial',
-  'tables.detail.viewOrder': 'Ver Pedido',
-  'tables.detail.seatGuests': 'Sentar Clientes',
-  'tables.detail.closeTable': 'Fechar Mesa',
-  'tables.detail.markClean': 'Marcar Pronta',
-  'tables.detail.cancel': 'Cancelar',
-  'tables.seat.title': 'Sentar Clientes',
-  'tables.seat.guestCount': 'Número de pessoas',
-  'tables.seat.waiter': 'Garçom',
-  'tables.seat.notes': 'Observações',
-  'tables.seat.confirm': 'Sentar',
-  'tables.history.title': 'Histórico de Sessões',
-  'tables.history.table': 'Mesa',
-  'tables.history.guests': 'Pessoas',
-  'tables.history.waiter': 'Garçom',
-  'tables.history.duration': 'Duração',
-  'tables.history.noSessions': 'Nenhum histórico de sessões',
-  'tables.settings.title': 'Configurações de Mesas',
-}

package/src/registries.ts

@@ -1,32 +0,0 @@
-import type { PluginRegistryDef } from '@fayz-ai/core'
-import type { EntityDef } from '@fayz-ai/core'
-
-const zoneEntity: EntityDef = {
-  name: 'Zone',
-  namePlural: 'Zones',
-  icon: 'MapPin',
-  displayField: 'name',
-  defaultSort: 'sortOrder',
-  fields: [
-    { key: 'name', label: 'Name', type: 'text', required: true, showInTable: true },
-    { key: 'color', label: 'Color', type: 'text', showInTable: true },
-    { key: 'sortOrder', label: 'Order', type: 'number', showInTable: true, defaultValue: 0 },
-    { key: 'isActive', label: 'Active', type: 'boolean', showInTable: true, defaultValue: true },
-  ],
-  data: { table: 'restaurant_zones', tenantScoped: true },
-}
-
-export const tablesRegistries: PluginRegistryDef[] = [
-  {
-    id: 'zones',
-    entity: zoneEntity,
-    icon: 'MapPin',
-    description: 'Floor plan zones (indoor, outdoor, bar, etc.)',
-    display: 'table',
-    seedData: [
-      { id: 'z-indoor', name: 'Indoor', color: '#3b82f6', sortOrder: 0, isActive: true },
-      { id: 'z-outdoor', name: 'Outdoor', color: '#22c55e', sortOrder: 1, isActive: true },
-      { id: 'z-bar', name: 'Bar', color: '#f59e0b', sortOrder: 2, isActive: true },
-    ],
-  },
-]