@fayz-ai/plugin-agenda 0.1.3

package/src/locales/pt-BR.ts

@@ -0,0 +1,207 @@
+// agenda.* — merged plugin-own + saas-core central i18n
+export const ptBR: Record<string, string> = {
+  "agenda.appointment.addDescription": "Adicionar descrição...",
+  "agenda.appointment.addService": "Adicionar serviço",
+  "agenda.appointment.cancel": "Cancelar",
+  "agenda.appointment.clientTab": "Cliente",
+  "agenda.appointment.noClientData": "Dados do cliente não disponíveis",
+  "agenda.appointment.client": "Cliente",
+  "agenda.appointment.conflict": "Conflito de horário — este profissional já está reservado neste horário.",
+  "agenda.appointment.create": "Criar",
+  "agenda.appointment.createClientFailed": "Falha ao criar cliente",
+  "agenda.appointment.creating": "Criando...",
+  "agenda.appointment.delete": "Excluir",
+  "agenda.appointment.deleteConfirm": "Excluir este agendamento?",
+  "agenda.appointment.confirmDelete": "Excluir",
+  "agenda.appointment.deleting": "Excluindo…",
+  "agenda.appointment.edit": "Editar Agendamento",
+  "agenda.appointment.emailOptional": "E-mail (opcional)",
+  "agenda.appointment.location": "Local",
+  "agenda.appointment.name": "Nome",
+  "agenda.appointment.new": "Novo Agendamento",
+  "agenda.appointment.newClient": "Novo cliente",
+  "agenda.appointment.notes": "Observações",
+  "agenda.appointment.phone": "Telefone",
+  "agenda.appointment.professional": "Profissional",
+  "agenda.appointment.save": "Salvar",
+  "agenda.appointment.saving": "Salvando...",
+  "agenda.appointment.searchClient": "Buscar cliente...",
+  "agenda.appointment.searchService": "Buscar serviço para adicionar...",
+  "agenda.appointment.selectLocation": "Selecionar local...",
+  "agenda.appointment.selectProfessional": "Selecionar profissional...",
+  "agenda.appointment.services": "Serviços",
+  "agenda.appointment.status": "Status",
+  "agenda.appointment.to": "até",
+  "agenda.appointment.total": "Total",
+  "agenda.appointment.update": "Atualizar",
+  "agenda.payment.title": "Recebimento",
+  "agenda.payment.generateInvoice": "Gerar recebimento",
+  "agenda.payment.generating": "Gerando…",
+  "agenda.payment.pending": "Pendente",
+  "agenda.payment.partial": "Parcial",
+  "agenda.payment.paid": "Pago",
+  "agenda.payment.collect": "Receber",
+  "agenda.payment.overdue": "Vencido",
+  "agenda.payment.cancelled": "Cancelado",
+  "agenda.payment.none": "Recebimento",
+  "agenda.payment.pay": "Pagar",
+  "agenda.payment.paying": "Pagando…",
+  "agenda.payment.remaining": "Restante",
+  "agenda.payment.installment": "Parcela",
+  "agenda.payment.total": "Total",
+  "agenda.payment.noInvoice": "Sem recebimento gerado",
+  "agenda.payment.selectAccount": "Selecionar conta",
+  "agenda.payment.registerPayment": "Registrar recebimento",
+  "agenda.payment.registerPaymentHint": "Registrar pagamento deste agendamento",
+  "agenda.payment.pendingHint": "Fatura gerada, aguardando pagamento",
+  "agenda.payment.partialHint": "Parcialmente pago, toque para completar",
+  "agenda.payment.paidHint": "Pagamento realizado",
+  "agenda.payment.overdueHint": "Pagamento vencido",
+  "agenda.payment.backToAppointment": "Voltar ao agendamento",
+  "agenda.payment.checkout": "Confirmar",
+  "agenda.payment.checkingOut": "Processando…",
+  "agenda.payment.serviceSummary": "Resumo do atendimento",
+  "agenda.payment.paymentMethod": "Forma de pagamento",
+  "agenda.payment.noMethods": "Nenhuma forma de pagamento configurada.",
+  "agenda.payment.configureMethods": "Configurar formas de pagamento",
+  "agenda.payment.checkoutComplete": "Pagamento confirmado",
+  "agenda.payment.card": "Cartão",
+  "agenda.payment.method": "Método",
+  "agenda.payment.select": "Selecionar…",
+  "agenda.payment.cardBrand": "Bandeira",
+  "agenda.payment.selectBrand": "Selecionar bandeira…",
+  "agenda.payment.cardInstallments": "Parcelas",
+  "agenda.payment.bankAccount": "Conta",
+  "agenda.payment.viewInvoice": "Ver detalhes da fatura",
+  "agenda.calendar.agendas": "Agendas",
+  "agenda.calendar.create": "Criar",
+  "agenda.calendar.next": "Próximo",
+  "agenda.calendar.previous": "Anterior",
+  "agenda.calendar.status": "Status",
+  "agenda.calendar.today": "Hoje",
+  "agenda.calendar.viewAgenda": "Agenda",
+  "agenda.calendar.viewDay": "Dia",
+  "agenda.calendar.viewMonth": "Mês",
+  "agenda.calendar.viewWeek": "Semana",
+  "agenda.confirmations.confirmed": "Confirmado:",
+  "agenda.confirmations.empty": "Nenhuma confirmação pendente",
+  "agenda.confirmations.emptySubtitle": "Todos os agendamentos futuros foram confirmados",
+  "agenda.confirmations.loading": "Carregando...",
+  "agenda.confirmations.subtitle": "Agendamentos futuros pendentes de confirmação",
+  "agenda.confirmations.unknownClient": "Cliente desconhecido",
+  "agenda.confirmations.sendWhatsApp": "Enviar WhatsApp",
+  "agenda.confirmations.call": "Ligar",
+  "agenda.confirmations.markConfirmed": "Marcar Confirmado",
+  "agenda.confirmations.markCancelled": "Marcar Cancelado",
+  "agenda.contextMenu.changeStatus": "Alterar status",
+  "agenda.contextMenu.delete": "Excluir",
+  "agenda.contextMenu.edit": "Editar",
+  "agenda.contextMenu.notAvailable": "(indisponível)",
+  "agenda.index.settingsSubtitle": "Horários de funcionamento, preferências de agendamento e confirmações",
+  "agenda.index.settingsTitle": "Configurações da Agenda",
+  "settings.plugin.agenda-working-hours": "Horário de Funcionamento",
+  "agenda.popover.unknown": "Desconhecido",
+  "agenda.settings.autoConfirm": "Confirmar Automaticamente",
+  "agenda.settings.autoConfirmDesc": "Confirmar automaticamente novos agendamentos",
+  "agenda.settings.autoCreateOrder": "Criar Pedido Automaticamente",
+  "agenda.settings.autoCreateOrderDesc": "Criar automaticamente um pedido financeiro para novos agendamentos",
+  "agenda.settings.blockOutside": "Bloquear Fora do Horário",
+  "agenda.settings.blockOutsideDesc": "Impedir agendamentos fora do horário de funcionamento",
+  "agenda.settings.calendarDisplay": "Exibição do Calendário",
+  "agenda.settings.calendarDisplayDesc": "Configurações visuais do calendário",
+  "agenda.settings.cancelAlerts": "Alertas de Cancelamento",
+  "agenda.settings.cancelAlertsDesc": "Notificar quando um agendamento é cancelado",
+  "agenda.settings.compact": "Modo Compacto",
+  "agenda.settings.compactDesc": "Usar blocos de eventos menores",
+  "agenda.settings.confirmations": "Confirmações",
+  "agenda.settings.confirmationsDesc": "Configurações de confirmação de agendamento",
+  "agenda.settings.conflictDetection": "Detecção de Conflitos",
+  "agenda.settings.conflictDetectionDesc": "Alertar quando agendamentos se sobrepõem",
+  "agenda.settings.dragDrop": "Arrastar e Soltar",
+  "agenda.settings.dragDropDesc": "Permitir reagendamento arrastando eventos",
+  "agenda.settings.enableConfirmations": "Habilitar Confirmações",
+  "agenda.settings.enableConfirmationsDesc": "Exigir confirmação para novos agendamentos",
+  "agenda.settings.enableLocation": "Habilitar Seleção de Local",
+  "agenda.settings.enableLocationDesc": "Mostrar seletor de local no modal de agendamento",
+  "agenda.settings.enableWorkingHours": "Habilitar Horário de Funcionamento",
+  "agenda.settings.enableWorkingHoursDesc": "Mostrar sobreposição de horário de funcionamento no calendário",
+  "agenda.settings.locations": "Locais",
+  "agenda.settings.locationsDesc": "Configurações de múltiplos locais",
+  "agenda.settings.newBookingNotif": "Alertas de Novo Agendamento",
+  "agenda.settings.newBookingNotifDesc": "Notificar quando um novo agendamento é criado",
+  "agenda.settings.noShowTracking": "Rastreamento de Ausências",
+  "agenda.settings.noShowTrackingDesc": "Rastrear e alertar sobre ausências",
+  "agenda.settings.notifications": "Notificações",
+  "agenda.settings.notificationsDesc": "Preferências de notificação",
+  "agenda.settings.reminder": "Lembretes",
+  "agenda.settings.reminderDesc": "Enviar lembretes antes dos compromissos",
+  "agenda.settings.scheduling": "Agendamento",
+  "agenda.settings.schedulingDesc": "Configurar comportamento do agendamento",
+  "agenda.settings.showCancelled": "Mostrar Cancelados",
+  "agenda.settings.showCancelledDesc": "Exibir agendamentos cancelados no calendário",
+  "agenda.settings.showNoShow": "Mostrar Ausências",
+  "agenda.settings.showNoShowDesc": "Exibir ausências no calendário",
+  "agenda.settings.workingHours": "Horário de Funcionamento",
+  "agenda.settings.workingHoursDesc": "Horários e disponibilidade",
+  "agenda.sidebar.agendas": "Agendas",
+  "agenda.sidebar.allLocations": "Todos os locais",
+  "agenda.sidebar.create": "Criar",
+  "agenda.sidebar.location": "Local",
+  "agenda.sidebar.status": "Status",
+  "agenda.toolbar.next": "Próximo",
+  "agenda.toolbar.previous": "Anterior",
+  "agenda.toolbar.today": "Hoje",
+  "agenda.workingHours.addBreak": "Adicionar intervalo",
+  "agenda.workingHours.copyToAll": "Copiar para todos",
+  "agenda.workingHours.dayOff": "Folga",
+  "agenda.workingHours.removePeriod": "Remover período",
+  "agenda.workingHours.professional": "Profissional",
+  "agenda.workingHours.save": "Salvar",
+  "agenda.workingHours.saveFailed": "Falha ao salvar",
+  "agenda.workingHours.saved": "Horários de trabalho salvos",
+  "agenda.workingHours.saving": "Salvando...",
+  "agenda.workingHours.subtitle": "Gerenciar horários de trabalho por profissional",
+  "agenda.workingHours.to": "até",
+  "agenda.title": "Agenda",
+  "agenda.calendar.title": "Calendário",
+  "agenda.calendar.noScheduleConfirm": "Este horário não possui agenda aberta para este profissional. Deseja agendar mesmo assim?",
+  "agenda.calendar.newAppointment": "Novo Agendamento",
+  "agenda.booking.create": "Novo Agendamento",
+  "agenda.booking.edit": "Editar Agendamento",
+  "agenda.booking.delete": "Excluir Agendamento",
+  "agenda.booking.deleteConfirm": "Tem certeza que deseja excluir este agendamento?",
+  "agenda.booking.client": "Cliente",
+  "agenda.booking.professional": "Profissional",
+  "agenda.booking.services": "Serviços",
+  "agenda.booking.date": "Data",
+  "agenda.booking.time": "Horário",
+  "agenda.booking.duration": "Duração",
+  "agenda.booking.notes": "Observações",
+  "agenda.booking.status": "Status",
+  "agenda.booking.save": "Salvar Agendamento",
+  "agenda.booking.saving": "Salvando...",
+  "agenda.confirmations.title": "Confirmações",
+  "agenda.confirmations.pending": "Confirmações Pendentes",
+  "agenda.confirmations.emptyDescription": "Todos os agendamentos futuros foram confirmados",
+  "agenda.confirmations.confirm": "Confirmar",
+  "agenda.confirmations.cancel": "Cancelar",
+  "agenda.workingHours.title": "Horário de Trabalho",
+  "agenda.workingHours.addPeriod": "Adicionar período",
+  "agenda.workingHours.loading": "Carregando...",
+  "agenda.appointment.addClient": "Adicionar cliente",
+  "agenda.appointment.addServiceFirst": "Adicionar serviço",
+  "agenda.appointment.addNotes": "Adicionar observações",
+  "agenda.appointment.duration": "Duração (minutos)",
+  "agenda.appointment.price": "Preço",
+  "agenda.bookingType.appointment": "Agendamento",
+  "agenda.bookingType.task": "Tarefa",
+  "agenda.bookingType.out_of_office": "Ausência",
+  "agenda.bookingType.block": "Bloqueio",
+  "agenda.settings.title": "Configurações da Agenda",
+  "agenda.settings.slotDuration": "Duração do Intervalo",
+  "agenda.settings.bookingKind": "Tipo de Agendamento",
+  "agenda.settings.dayStartTime": "Horário de Início",
+  "agenda.settings.dayStartTimeDesc": "Primeiro horário exibido no calendário",
+  "agenda.settings.dayEndTime": "Horário de Término",
+  "agenda.settings.dayEndTimeDesc": "Último horário exibido no calendário",
+}

package/src/registries.ts

@@ -0,0 +1,36 @@
+import type { PluginRegistryDef } from '@fayz-ai/core'
+import type { EntityDef } from '@fayz-ai/core'
+
+// ---------------------------------------------------------------------------
+// Holidays (saas_core.holidays — tenant-scoped)
+// ---------------------------------------------------------------------------
+
+const holidayEntity: EntityDef = {
+  name: 'Holiday',
+  namePlural: 'Holidays',
+  icon: 'TreePalm',
+  displayField: 'name',
+  defaultSort: 'date',
+  defaultSortDir: 'asc',
+  fields: [
+    { key: 'name', label: 'Name', type: 'text', required: true, showInTable: true },
+    { key: 'date', label: 'Date', type: 'date', required: true, showInTable: true, sortable: true },
+    { key: 'recurring', label: 'Recurring Annually', type: 'boolean', showInTable: true, defaultValue: false },
+    { key: 'description', label: 'Description', type: 'text', showInTable: false },
+    { key: 'isActive', label: 'Active', type: 'boolean', showInTable: true, defaultValue: true },
+  ],
+  data: {
+    table: 'holidays',
+    schema: 'saas_core',
+    tenantScoped: true,
+  },
+}
+
+export const agendaRegistries: PluginRegistryDef[] = [
+  {
+    id: 'holidays',
+    entity: holidayEntity,
+    icon: 'TreePalm',
+    description: 'Non-working days and recurring holidays',
+  },
+]

package/src/store.ts

@@ -0,0 +1,304 @@
+import { createStore, type StoreApi } from 'zustand/vanilla'
+import { dedup } from '@fayz-ai/saas'
+import { toast } from '@fayz-ai/ui'
+import { getScheduleBlockConfig, setScheduleBlockConfig } from '@fayz-ai/saas'
+import type { AgendaDataProvider } from './data/types'
+import type { AgendaFinancialBridge } from './financial-bridge'
+import type {
+  CalendarBooking, Professional, Schedule,
+  CreateBookingInput, UpdateBookingInput, BookingQuery,
+} from './types'
+
+// ---------------------------------------------------------------------------
+// Store state
+// ---------------------------------------------------------------------------
+
+export interface AgendaUIState {
+  // Calendar data
+  bookings: CalendarBooking[]
+  bookingsLoading: boolean
+  dateRange: { start: string; end: string }
+  currentView: string
+  selectedDate: string
+
+  // Resources
+  professionals: Professional[]
+  professionalsLoading: boolean
+
+  // Filters
+  selectedProfessionalIds: string[]
+  selectedLocationId: string | null
+  selectedStatuses: string[]
+
+  // Locations
+  locations: Array<{ id: string; name: string }>
+
+  // Schedules
+  schedules: Schedule[]
+  schedulesLoading: boolean
+
+  // Confirmations
+  pendingConfirmations: CalendarBooking[]
+  confirmationsLoading: boolean
+
+  // Modal state
+  appointmentModal: {
+    open: boolean
+    mode: 'create' | 'edit'
+    bookingId?: string
+    prefill?: Partial<CreateBookingInput> & { endsAt?: string }
+    initialTab?: string
+  }
+
+  // Actions
+  fetchBookings(range: { start: string; end: string }): Promise<void>
+  fetchProfessionals(): Promise<void>
+  fetchLocations(): Promise<void>
+  fetchSchedules(professionalId?: string): Promise<void>
+  fetchConfirmations(): Promise<void>
+  createBooking(input: CreateBookingInput): Promise<CalendarBooking>
+  updateBooking(id: string, data: UpdateBookingInput): Promise<CalendarBooking>
+  deleteBooking(id: string): Promise<void>
+  updateBookingStatus(id: string, status: string): Promise<void>
+  rescheduleBooking(id: string, newStart: string, newEnd: string, newProfessionalId?: string): Promise<void>
+  setFilters(filters: Partial<{ professionalIds: string[]; locationId: string | null; statuses: string[] }>): void
+  setView(view: string): void
+  setSelectedDate(date: string): void
+  openAppointmentModal(mode: 'create' | 'edit', options?: { bookingId?: string; prefill?: Partial<CreateBookingInput> & { endsAt?: string }; initialTab?: string }): void
+  closeAppointmentModal(): void
+}
+
+// ---------------------------------------------------------------------------
+// Store factory
+// ---------------------------------------------------------------------------
+
+function getCurrentBookingQuery(state: AgendaUIState, dateRange = state.dateRange): BookingQuery {
+  return {
+    dateRange,
+    professionalIds: state.selectedProfessionalIds.length ? state.selectedProfessionalIds : undefined,
+    locationId: state.selectedLocationId ?? undefined,
+    statuses: state.selectedStatuses.length ? state.selectedStatuses : undefined,
+  }
+}
+
+export function createAgendaStore(provider: AgendaDataProvider, financialBridge?: AgendaFinancialBridge): StoreApi<AgendaUIState> {
+  return createStore<AgendaUIState>((set, get) => ({
+    bookings: [],
+    bookingsLoading: false,
+    dateRange: { start: '', end: '' },
+    currentView: 'resourceTimeGridDay',
+    selectedDate: new Date().toISOString().slice(0, 10),
+
+    professionals: [],
+    professionalsLoading: false,
+
+    selectedProfessionalIds: [],
+    selectedLocationId: null,
+    selectedStatuses: ['scheduled', 'confirmed', 'in_progress', 'completed'],
+
+    locations: [],
+
+    schedules: [],
+    schedulesLoading: false,
+
+    pendingConfirmations: [],
+    confirmationsLoading: false,
+
+    appointmentModal: { open: false, mode: 'create' },
+
+    async fetchBookings(range) {
+      const key = `agenda:bookings:${range.start}:${range.end}`
+      return dedup(key, async () => {
+        set({ bookingsLoading: true, dateRange: range })
+        const state = get()
+        const query = getCurrentBookingQuery(state, range)
+        let bookings = await provider.getBookings(query)
+
+        // Enrich with payment status if financial bridge is available
+        if (financialBridge) {
+          const orderIds = bookings.map((b) => b.orderId).filter((id): id is string => !!id)
+          if (orderIds.length > 0) {
+            try {
+              const statuses = await financialBridge.resolvePaymentStatuses(orderIds)
+              bookings = bookings.map((b) => {
+                if (!b.orderId) return b
+                const summary = statuses.get(b.orderId)
+                return summary ? { ...b, paymentStatus: summary.status } : b
+              })
+            } catch { /* non-blocking */ }
+          }
+        }
+
+        set({ bookings, bookingsLoading: false })
+      })
+    },
+
+    async fetchProfessionals() {
+      return dedup('agenda:professionals', async () => {
+        set({ professionalsLoading: true })
+        const professionals = await provider.getProfessionals()
+        set({ professionals, professionalsLoading: false })
+      })
+    },
+
+    async fetchLocations() {
+      return dedup('agenda:locations', async () => {
+        if (!provider.getLocations) return
+        const locations = await provider.getLocations()
+        set({ locations })
+        // Update global schedule block config so ScheduleEditor picks up locations
+        const current = getScheduleBlockConfig()
+        if (current) {
+          setScheduleBlockConfig({ ...current, locations })
+        }
+      })
+    },
+
+    async fetchSchedules(professionalId) {
+      return dedup('agenda:schedules:' + (professionalId ?? 'all'), async () => {
+        set({ schedulesLoading: true })
+        const schedules = await provider.getSchedules(professionalId)
+        set({ schedules, schedulesLoading: false })
+      })
+    },
+
+    async fetchConfirmations() {
+      return dedup('agenda:confirmations', async () => {
+        set({ confirmationsLoading: true })
+        const pendingConfirmations = await provider.getConfirmationsPending()
+        set({ pendingConfirmations, confirmationsLoading: false })
+      })
+    },
+
+    async createBooking(input) {
+      try {
+        const booking = await provider.createBooking(input)
+        // Refresh bookings for current range
+        const state = get()
+        if (state.dateRange.start && state.dateRange.end) {
+          const bookings = await provider.getBookings(getCurrentBookingQuery(state))
+          set({ bookings })
+        }
+        toast.success('Appointment created')
+        return booking
+      } catch (err: any) {
+        toast.error('Failed to create appointment', { description: err?.message })
+        throw err
+      }
+    },
+
+    async updateBooking(id, data) {
+      try {
+        const booking = await provider.updateBooking(id, data)
+        const state = get()
+        if (state.dateRange.start && state.dateRange.end) {
+          const bookings = await provider.getBookings(getCurrentBookingQuery(state))
+          set({ bookings })
+        }
+        toast.success('Appointment updated')
+        return booking
+      } catch (err: any) {
+        toast.error('Failed to update appointment', { description: err?.message })
+        throw err
+      }
+    },
+
+    async deleteBooking(id) {
+      try {
+        await provider.deleteBooking(id)
+        const state = get()
+        if (state.dateRange.start && state.dateRange.end) {
+          const bookings = await provider.getBookings(getCurrentBookingQuery(state))
+          set({ bookings })
+        }
+        toast.success('Appointment deleted')
+      } catch (err: any) {
+        toast.error('Failed to delete appointment', { description: err?.message })
+        throw err
+      }
+    },
+
+    async updateBookingStatus(id, status) {
+      // Optimistic update — change color immediately
+      const prev = get().bookings
+      set({ bookings: prev.map((b) => b.id === id ? { ...b, status: status as any } : b) })
+      try {
+        await provider.updateBookingStatus(id, status)
+        // Refresh from server to get full data
+        const state = get()
+        if (state.dateRange.start && state.dateRange.end) {
+          const bookings = await provider.getBookings(getCurrentBookingQuery(state))
+          set({ bookings })
+        }
+        toast.success('Status updated')
+      } catch (err: any) {
+        // Rollback on failure
+        set({ bookings: prev })
+        toast.error('Failed to update status', { description: err?.message })
+        throw err
+      }
+    },
+
+    async rescheduleBooking(id, newStart, newEnd, newProfessionalId) {
+      try {
+        // Check for conflicts
+        const existing = get().bookings.find((b) => b.id === id)
+        const assigneeId = newProfessionalId ?? existing?.professionalId
+        if (assigneeId) {
+          const hasConflict = await provider.checkConflict({
+            assigneeId,
+            startsAt: newStart,
+            endsAt: newEnd,
+            excludeBookingId: id,
+          })
+          if (hasConflict) {
+            toast.error('Time conflict detected', { description: 'This professional already has an appointment at this time.' })
+            throw new Error('Time conflict')
+          }
+        }
+        await provider.updateBooking(id, {
+          startsAt: newStart,
+          endsAt: newEnd,
+          ...(newProfessionalId && { professionalId: newProfessionalId }),
+        })
+        const state = get()
+        if (state.dateRange.start && state.dateRange.end) {
+          const bookings = await provider.getBookings(getCurrentBookingQuery(state))
+          set({ bookings })
+        }
+        toast.success('Appointment rescheduled')
+      } catch (err: any) {
+        if (err?.message !== 'Time conflict') {
+          toast.error('Failed to reschedule', { description: err?.message })
+        }
+        throw err
+      }
+    },
+
+    setFilters(filters) {
+      set({
+        ...(filters.professionalIds !== undefined && { selectedProfessionalIds: filters.professionalIds }),
+        ...(filters.locationId !== undefined && { selectedLocationId: filters.locationId }),
+        ...(filters.statuses !== undefined && { selectedStatuses: filters.statuses }),
+      })
+      // Re-fetch with new filters
+      const { dateRange } = get()
+      if (dateRange.start && dateRange.end) {
+        get().fetchBookings(dateRange)
+      }
+    },
+
+    setView(view) { set({ currentView: view }) },
+    setSelectedDate(date) { set({ selectedDate: date }) },
+
+    openAppointmentModal(mode, options) {
+      set({ appointmentModal: { open: true, mode, bookingId: options?.bookingId, prefill: options?.prefill, initialTab: options?.initialTab } })
+    },
+
+    closeAppointmentModal() {
+      // Only toggle open — keep mode/bookingId/prefill intact so layout
+      // doesn't shift during the close animation
+      set((state) => ({ appointmentModal: { ...state.appointmentModal, open: false } }))
+    },
+  }))
+}