@fayz-ai/plugin-conversations 0.9.0 → 0.9.1

package/src/data/supabase.ts

@@ -1,264 +0,0 @@
-import { getSupabaseClientOptional } from '@fayz-ai/core'
-import type { ConversationsProvider } from './types'
-import { T } from './tables'
-import { CHANNEL_ACCENT_HEX } from './accents'
-import type {
-  Conversation,
-  Message,
-  ListConversationsQuery,
-  SendMessageInput,
-  CreateConversationInput,
-  ConversationStatus,
-} from '../types'
-
-// ---------------------------------------------------------------------------
-// Supabase-backed conversations provider — reads/writes the project's
-// `conversations` + `conversation_messages` tables (tenant-scoped via RLS +
-// an explicit tenant filter from the active-org context). Mirrors the inline
-// client-casting style of @fayz-ai/core's createSupabaseProvider; the global
-// client is `unknown`-typed so each call narrows the shape it needs.
-//
-// Real channel connectors (Twilio, WhatsApp Cloud, Meta, IMAP) deliver inbound
-// rows into these tables out-of-band; this provider is the read/compose surface.
-// ---------------------------------------------------------------------------
-
-export interface SupabaseConversationsConfig {
-  /** Supabase client; defaults to the global one registered by createFayzApp. */
-  supabaseClient?: unknown
-  /** Active tenant id (value or getter) used to scope reads and stamp writes. */
-  tenantId?: string | (() => string | undefined)
-  /** Display name stamped as the author of outbound messages. */
-  selfAuthor?: string
-}
-
-type Row = Record<string, unknown>
-
-function mapConversation(r: Row): Conversation {
-  return {
-    id: String(r.id),
-    contactName: (r.contact_name as string) ?? '',
-    contactPersonId: (r.contact_person_id as string | null) ?? undefined,
-    contactHandle: (r.contact_handle as string) ?? '',
-    channel: (r.channel as Conversation['channel']) ?? 'sms',
-    lastMessagePreview: (r.last_message_preview as string) ?? '',
-    lastMessageAt: (r.last_message_at as string) ?? '',
-    unreadCount: Number(r.unread_count ?? 0),
-    status: (r.status as ConversationStatus) ?? 'open',
-    assignedTo: (r.assigned_to as string | null) ?? undefined,
-    accent: (r.accent as string) ?? '#6366f1',
-    tags: (r.tags as string[] | null) ?? [],
-    location: (r.location as string | null) ?? undefined,
-    note: (r.note as string | null) ?? undefined,
-  }
-}
-
-function mapMessage(r: Row): Message {
-  return {
-    id: String(r.id),
-    conversationId: String(r.conversation_id),
-    channel: (r.channel as Message['channel']) ?? 'sms',
-    direction: (r.direction as Message['direction']) ?? 'inbound',
-    body: (r.body as string) ?? '',
-    at: (r.at as string) ?? '',
-    author: (r.author as string) ?? '',
-  }
-}
-
-export function createSupabaseConversationsProvider(
-  config?: SupabaseConversationsConfig,
-): ConversationsProvider {
-  const selfAuthor = config?.selfAuthor ?? 'You'
-
-  function resolveTenantId(): string | undefined {
-    if (!config?.tenantId) return undefined
-    return typeof config.tenantId === 'function' ? config.tenantId() : config.tenantId
-  }
-
-  function client(): { from: (t: string) => Row } {
-    const supabase = (config?.supabaseClient ?? getSupabaseClientOptional()) as
-      | { from: (t: string) => Row }
-      | null
-    if (!supabase) {
-      throw new Error(
-        '[plugin-conversations] Supabase client not available. Pass supabaseClient or register the global client via createFayzApp.',
-      )
-    }
-    return supabase
-  }
-
-  return {
-    async listConversations(query?: ListConversationsQuery): Promise<Conversation[]> {
-      let q = (client().from(T.conversations) as { select: (s: string) => Row }).select('*')
-
-      const tenantId = resolveTenantId()
-      if (tenantId) q = (q as { eq: (c: string, v: string) => Row }).eq('tenant_id', tenantId)
-      if (query?.channel && query.channel !== 'all') {
-        q = (q as { eq: (c: string, v: string) => Row }).eq('channel', query.channel)
-      }
-      if (query?.status && query.status !== 'all') {
-        q = (q as { eq: (c: string, v: string) => Row }).eq('status', query.status)
-      }
-      if (query?.search) {
-        const term = `%${query.search}%`
-        q = (q as { or: (c: string) => Row }).or(
-          `contact_name.ilike.${term},last_message_preview.ilike.${term}`,
-        )
-      }
-      q = (q as { order: (c: string, o: unknown) => Row }).order('last_message_at', {
-        ascending: false,
-      })
-
-      const { data, error } = (await q) as { data: Row[] | null; error: unknown }
-      if (error) throw error
-      return (data ?? []).map(mapConversation)
-    },
-
-    async getMessages(conversationId: string): Promise<Message[]> {
-      const selected = (
-        client().from(T.messages) as { select: (s: string) => Row }
-      ).select('*')
-      const filtered = (selected as { eq: (c: string, v: string) => Row }).eq(
-        'conversation_id',
-        conversationId,
-      )
-      const ordered = (filtered as { order: (c: string, o: unknown) => Row }).order('at', {
-        ascending: true,
-      })
-      const { data, error } = (await ordered) as { data: Row[] | null; error: unknown }
-      if (error) throw error
-      return (data ?? []).map(mapMessage)
-    },
-
-    async createConversation(input: CreateConversationInput): Promise<Conversation> {
-      const tenantId = resolveTenantId()
-      // Insert with a null tenant_id fails the plg_conversations RLS WITH CHECK
-      // (tenant_id ∈ user_tenant_ids()) with an opaque Postgres error. When the
-      // active tenant hasn't resolved yet (bootstrap race), fail fast with an
-      // actionable message the compose modal can surface via toast.
-      if (!tenantId) {
-        throw new Error('[plugin-conversations] Active tenant not resolved — cannot create conversation. Try again in a moment.')
-      }
-      const now = new Date().toISOString()
-      const firstMessage = input.firstMessage?.trim()
-
-      const convRow: Row = {
-        contact_name: input.contactName.trim(),
-        // Only written when the picker resolved a real person — an app that
-        // hasn't run migration 002 yet would reject an unknown column, and
-        // omitting it keeps the free-text path working there.
-        ...(input.contactPersonId ? { contact_person_id: input.contactPersonId } : {}),
-        contact_handle: input.contactHandle?.trim() || null,
-        channel: input.channel,
-        last_message_preview: firstMessage || null,
-        last_message_at: now,
-        unread_count: 0,
-        status: 'open',
-        assigned_to: selfAuthor,
-        accent: CHANNEL_ACCENT_HEX[input.channel],
-        tags: [],
-        note: input.note?.trim() || null,
-      }
-      if (tenantId) convRow.tenant_id = tenantId
-
-      const { data: created, error } = (await (
-        (client().from(T.conversations) as { insert: (r: Row) => Row }).insert(convRow) as {
-          select: () => { single: () => Promise<{ data: Row | null; error: unknown }> }
-        }
-      )
-        .select()
-        .single()) as { data: Row | null; error: unknown }
-      if (error) throw error
-      if (!created) throw new Error('Conversation not created')
-
-      // Seed the thread with the first outbound message when provided.
-      if (firstMessage) {
-        const msgRow: Row = {
-          conversation_id: String(created.id),
-          channel: input.channel,
-          direction: 'outbound',
-          body: firstMessage,
-          author: selfAuthor,
-          at: now,
-        }
-        if (tenantId) msgRow.tenant_id = tenantId
-        await (client().from(T.messages) as { insert: (r: Row) => Promise<unknown> }).insert(msgRow)
-      }
-
-      return mapConversation(created)
-    },
-
-    async sendMessage(input: SendMessageInput): Promise<Message> {
-      const tenantId = resolveTenantId()
-
-      // Resolve the channel from the parent conversation so the message matches.
-      const convSelected = (client().from(T.conversations) as { select: (s: string) => Row }).select(
-        'channel',
-      )
-      const convFiltered = (convSelected as { eq: (c: string, v: string) => Row }).eq(
-        'id',
-        input.conversationId,
-      )
-      const { data: conv } = (await (
-        convFiltered as { maybeSingle: () => Promise<{ data: Row | null }> }
-      ).maybeSingle()) as { data: Row | null }
-      const channel = (conv?.channel as Message['channel']) ?? 'sms'
-
-      const at = new Date().toISOString()
-      const row: Row = {
-        conversation_id: input.conversationId,
-        channel,
-        direction: 'outbound',
-        body: input.body,
-        author: selfAuthor,
-        at,
-      }
-      if (tenantId) row.tenant_id = tenantId
-
-      const { data: created, error } = (await (
-        (client().from(T.messages) as { insert: (r: Row) => Row }).insert(row) as {
-          select: () => { single: () => Promise<{ data: Row | null; error: unknown }> }
-        }
-      )
-        .select()
-        .single()) as { data: Row | null; error: unknown }
-      if (error) throw error
-
-      // Roll the parent conversation forward (preview / timestamp / unread / reopen).
-      await (
-        (client().from(T.conversations) as {
-          update: (r: Row) => Row
-        }).update({
-          last_message_preview: input.body,
-          last_message_at: at,
-          unread_count: 0,
-          status: 'open',
-        }) as { eq: (c: string, v: string) => Promise<unknown> }
-      ).eq('id', input.conversationId)
-
-      return mapMessage(created ?? row)
-    },
-
-    async markRead(conversationId: string): Promise<void> {
-      const { error } = (await (
-        (client().from(T.conversations) as { update: (r: Row) => Row }).update({
-          unread_count: 0,
-        }) as { eq: (c: string, v: string) => Promise<{ error: unknown }> }
-      ).eq('id', conversationId)) as { error: unknown }
-      if (error) throw error
-    },
-
-    async setStatus(conversationId: string, status: ConversationStatus): Promise<Conversation> {
-      const updated = (client().from(T.conversations) as { update: (r: Row) => Row }).update({
-        status,
-      })
-      const filtered = (updated as { eq: (c: string, v: string) => Row }).eq('id', conversationId)
-      const selected = (filtered as { select: () => Row }).select()
-      const { data, error } = (await (
-        selected as { single: () => Promise<{ data: Row | null; error: unknown }> }
-      ).single()) as { data: Row | null; error: unknown }
-      if (error) throw error
-      if (!data) throw new Error('Conversation not found')
-      return mapConversation(data)
-    },
-  }
-}

package/src/data/tables.ts

@@ -1,7 +0,0 @@
-// Physical table names for the conversations plugin (plg_conversations* prefix).
-// Import T and reference T.<key> in the data provider so a rename lands in
-// exactly one place.
-export const T = {
-  conversations: 'plg_conversations',
-  messages: 'plg_conversation_messages',
-} as const

package/src/data/types.ts

@@ -1,17 +0,0 @@
-import type {
-  Conversation,
-  Message,
-  ListConversationsQuery,
-  SendMessageInput,
-  CreateConversationInput,
-  ConversationStatus,
-} from '../types'
-
-export interface ConversationsProvider {
-  listConversations(query?: ListConversationsQuery): Promise<Conversation[]>
-  getMessages(conversationId: string): Promise<Message[]>
-  createConversation(input: CreateConversationInput): Promise<Conversation>
-  sendMessage(input: SendMessageInput): Promise<Message>
-  markRead(conversationId: string): Promise<void>
-  setStatus(conversationId: string, status: ConversationStatus): Promise<Conversation>
-}

package/src/index.ts

@@ -1,190 +0,0 @@
-import React from 'react'
-import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
-import { getActiveTenantId, getSupabaseClientOptional, registerTranslations } from '@fayz-ai/core'
-import type { EntityLookup } from '@fayz-ai/saas'
-import { ConversationsPage } from './ConversationsPage'
-import type { ResolvedConversationsConfig } from './ConversationsContext'
-import type { ConversationsProvider } from './data/types'
-import { createMockConversationsProvider } from './data/mock'
-import { createSupabaseConversationsProvider } from './data/supabase'
-import { createConversationsStore } from './store'
-import { conversationsLocales } from './locales'
-import { MIGRATION_001_CONVERSATIONS, MIGRATION_002_CONTACT_PERSON } from './migrations'
-
-// ---------------------------------------------------------------------------
-// @fayz-ai/plugin-conversations — the GoHighLevel "Conversations" equivalent:
-// one omni-channel inbox (SMS / WhatsApp / Instagram / Email / Web chat).
-// Universal plugin — reusable by any vertical (beauty, resto, agency…).
-//
-// Supabase-backed (plg_conversations / plg_conversation_messages, tenant-scoped
-// via RLS) when a client is registered; a persisted mock inbox otherwise. Real
-// channel connectors (Twilio, WhatsApp Cloud, Meta, IMAP) deliver inbound rows
-// out-of-band; this plugin is the read/compose surface.
-// ---------------------------------------------------------------------------
-
-export interface ConversationsPluginOptions {
-  navPosition?: number
-  navSection?: 'main' | 'secondary' | 'settings'
-  navLabel?: string
-  scope?: PluginScope
-  verticalId?: VerticalId
-  dataProvider?: ConversationsProvider
-
-  /**
-   * `people.kind` for contacts created from the compose modal's picker. Each
-   * vertical names its people differently (beauty 'client', agency 'lead'),
-   * hence a knob rather than a hardcoded value. Default: 'contact'.
-   */
-  contactKind?: string
-  /**
-   * Per-vertical extension table linked by `person_id` (e.g. 'clients'). Pools
-   * without it live off `public.people` alone — absent is not an error.
-   */
-  contactExtensionTable?: string
-  /** Custom search source for the picker. Defaults to the person archetype lookup. */
-  contactLookup?: EntityLookup
-}
-
-function createSafeProvider(): ConversationsProvider {
-  // Real data when a Supabase client is registered; mock inbox otherwise.
-  // Resolution is LAZY (per call): createConversationsPlugin runs at module
-  // scope in the app config, BEFORE the Supabase client is registered — an
-  // eager check here would capture the mock forever even on live backends.
-  let real: ConversationsProvider | null = null
-  let mock: ConversationsProvider | null = null
-  const resolve = (): ConversationsProvider => {
-    if (getSupabaseClientOptional()) {
-      real ??= createSupabaseConversationsProvider({ tenantId: () => getActiveTenantId() })
-      return real
-    }
-    mock ??= createMockConversationsProvider({ tenantId: () => getActiveTenantId() })
-    return mock
-  }
-  return {
-    listConversations: (...a) => resolve().listConversations(...a),
-    getMessages: (...a) => resolve().getMessages(...a),
-    sendMessage: (...a) => resolve().sendMessage(...a),
-    markRead: (...a) => resolve().markRead(...a),
-    setStatus: (...a) => resolve().setStatus(...a),
-    createConversation: (...a) => resolve().createConversation(...a),
-  }
-}
-
-export function createConversationsPlugin(options?: ConversationsPluginOptions): PluginManifest {
-  registerTranslations(conversationsLocales)
-  const provider = options?.dataProvider ?? createSafeProvider()
-  const store = createConversationsStore(provider)
-
-  const config: ResolvedConversationsConfig = {
-    contactKind: options?.contactKind ?? 'contact',
-    contactExtensionTable: options?.contactExtensionTable,
-    contactLookup: options?.contactLookup,
-  }
-
-  const PageComponent: React.ComponentType<unknown> = () =>
-    React.createElement(ConversationsPage, { store, config })
-  PageComponent.displayName = 'ConversationsPage'
-
-  return {
-    id: 'conversations',
-    name: options?.navLabel ?? 'Conversations',
-    icon: 'MessageCircle',
-    version: '1.0.0',
-    scope: options?.scope ?? 'universal',
-    verticalId: options?.verticalId,
-    defaultEnabled: true,
-    dependencies: [],
-    declaredFeatures: [{ id: 'conversations', label: 'Conversations', group: 'Engage' }],
-    // Recurring monthly quota — counts conversation threads created this month.
-    declaredLimits: [
-      { key: 'conversations_month', label: 'Conversations this month', table: 'plg_conversations', period: 'month' },
-    ],
-    navigation: [
-      {
-        section: options?.navSection ?? 'main',
-        position: options?.navPosition ?? 1,
-        label: options?.navLabel ?? 'Conversations',
-        route: '/conversations',
-        icon: 'MessageCircle',
-        permission: { feature: 'conversations', action: 'read' as const },
-      },
-    ],
-    routes: [
-      {
-        path: '/conversations',
-        component: PageComponent,
-        fullBleed: true,
-        permission: { feature: 'conversations', action: 'read' as const },
-      },
-    ],
-    widgets: [],
-    events: [
-      { name: 'conversations.message.received', description: 'An inbound message arrived on any channel' },
-      { name: 'conversations.message.sent', description: 'An outbound message was sent' },
-    ],
-    aiTools: [
-      {
-        id: 'conversations.list-threads',
-        name: 'listConversations',
-        description: 'Lists open conversations across all channels, optionally filtered by channel.',
-        icon: 'MessageCircle',
-        mode: 'read' as const,
-        category: 'Conversations',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            channel: {
-              type: 'string' as const,
-              enum: ['all', 'sms', 'whatsapp', 'instagram', 'email', 'webchat'],
-            },
-          },
-        },
-        suggestions: [
-          { label: 'Show unread conversations' },
-          { label: 'Any new WhatsApp messages?' },
-        ],
-        permission: { feature: 'conversations', action: 'read' as const },
-      },
-      {
-        id: 'conversations.send-message',
-        name: 'sendMessage',
-        description: 'Sends a reply in a conversation thread.',
-        icon: 'Send',
-        mode: 'persist' as const,
-        category: 'Conversations',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            conversationId: { type: 'string' as const, description: 'Conversation id' },
-            body: { type: 'string' as const, description: 'Message body' },
-          },
-          required: ['conversationId', 'body'],
-        },
-        permission: { feature: 'conversations', action: 'create' as const },
-      },
-    ],
-    migrations: [
-      {
-        id: 'conversations-001-base-tables',
-        version: '1.0.0',
-        sql: MIGRATION_001_CONVERSATIONS,
-        description: 'Create plg_conversations and plg_conversation_messages (tenant-scoped RLS)',
-      },
-      {
-        id: 'conversations-002-contact-person',
-        version: '1.1.0',
-        sql: MIGRATION_002_CONTACT_PERSON,
-        description: 'Link threads to public.people via contact_person_id (nullable, ON DELETE SET NULL)',
-      },
-    ],
-    locales: conversationsLocales,
-  }
-}
-
-export type { ConversationsProvider } from './data/types'
-export type { Conversation, Message, Channel, CreateConversationInput } from './types'
-export { createMockConversationsProvider, type MockConversationsConfig } from './data/mock'
-export {
-  createSupabaseConversationsProvider,
-  type SupabaseConversationsConfig,
-} from './data/supabase'

package/src/locales/en.ts

@@ -1,68 +0,0 @@
-export const en: Record<string, string> = {
-  'conversations.title': 'Conversations',
-  'conversations.subtitle': 'Unified inbox across every channel',
-
-  // Conversation list
-  'conversations.list.search': 'Search conversations',
-  'conversations.list.loading': 'Loading…',
-  'conversations.list.empty': 'No conversations',
-  'conversations.list.new': 'New conversation',
-
-  // Channel filters
-  'conversations.filter.all': 'All',
-  'conversations.filter.whatsapp': 'WhatsApp',
-  'conversations.filter.sms': 'SMS',
-  'conversations.filter.instagram': 'Instagram',
-  'conversations.filter.email': 'Email',
-  'conversations.filter.webchat': 'Web',
-
-  // Status labels
-  'conversations.status.open': 'Open',
-  'conversations.status.snoozed': 'Snoozed',
-  'conversations.status.closed': 'Closed',
-
-  // Empty state
-  'conversations.empty.select': 'Select a conversation to start chatting',
-
-  // Thread
-  'conversations.thread.back': 'Back to conversations',
-  'conversations.thread.snooze': 'Snooze',
-  'conversations.thread.close': 'Close',
-  'conversations.thread.details': 'Toggle contact details',
-  'conversations.thread.empty': 'No messages yet',
-  'conversations.thread.reply': 'Reply via {{channel}}…',
-  'conversations.thread.send': 'Send',
-
-  // Contact panel
-  'conversations.contact.details': 'Details',
-  'conversations.contact.closeDetails': 'Close details',
-  'conversations.contact.channel': 'Channel',
-  'conversations.contact.status': 'Status',
-  'conversations.contact.assignedTo': 'Assigned to',
-  'conversations.contact.location': 'Location',
-  'conversations.contact.tags': 'Tags',
-  'conversations.contact.note': 'Note',
-  'conversations.contact.linkedRecords': 'Linked records',
-  'conversations.contact.noLinkedRecords': 'No linked records yet.',
-
-  // New-conversation modal
-  'conversations.new.title': 'New conversation',
-  'conversations.new.channel': 'Channel',
-  'conversations.new.contactName': 'Contact name',
-  'conversations.new.contactNamePlaceholder': 'e.g. Jane Doe',
-  'conversations.new.handle': 'Phone / handle / email',
-  'conversations.new.handlePlaceholder': '+1 555 000 0000',
-  // The handle field only surfaces when the picked contact has nothing usable
-  // for the active channel — otherwise it is derived and shown on the chip.
-  'conversations.new.addHandle': 'Add {label}',
-  'conversations.new.handleLabel.phone': 'phone',
-  'conversations.new.handleLabel.email': 'email',
-  'conversations.new.handleLabel.instagram': 'Instagram handle',
-  'conversations.new.handleLabel.webchat': 'web chat id',
-  'conversations.new.firstMessage': 'First message',
-  'conversations.new.firstMessagePlaceholder': 'Write the first message (optional)…',
-  'conversations.new.cancel': 'Cancel',
-  'conversations.new.create': 'Start conversation',
-  'conversations.new.creating': 'Starting…',
-  'conversations.new.createFailed': 'Could not create the conversation',
-}

package/src/locales/index.ts

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

package/src/locales/pt-BR.ts

@@ -1,68 +0,0 @@
-export const ptBR: Record<string, string> = {
-  'conversations.title': 'Conversas',
-  'conversations.subtitle': 'Caixa de entrada unificada de todos os canais',
-
-  // Lista de conversas
-  'conversations.list.search': 'Buscar conversas',
-  'conversations.list.loading': 'Carregando…',
-  'conversations.list.empty': 'Nenhuma conversa',
-  'conversations.list.new': 'Nova conversa',
-
-  // Filtros de canal
-  'conversations.filter.all': 'Todas',
-  'conversations.filter.whatsapp': 'WhatsApp',
-  'conversations.filter.sms': 'SMS',
-  'conversations.filter.instagram': 'Instagram',
-  'conversations.filter.email': 'E-mail',
-  'conversations.filter.webchat': 'Web',
-
-  // Rótulos de status
-  'conversations.status.open': 'Aberta',
-  'conversations.status.snoozed': 'Adiada',
-  'conversations.status.closed': 'Encerrada',
-
-  // Estado vazio
-  'conversations.empty.select': 'Selecione uma conversa para começar a conversar',
-
-  // Thread
-  'conversations.thread.back': 'Voltar às conversas',
-  'conversations.thread.snooze': 'Adiar',
-  'conversations.thread.close': 'Encerrar',
-  'conversations.thread.details': 'Alternar detalhes do contato',
-  'conversations.thread.empty': 'Nenhuma mensagem ainda',
-  'conversations.thread.reply': 'Responder via {{channel}}…',
-  'conversations.thread.send': 'Enviar',
-
-  // Painel do contato
-  'conversations.contact.details': 'Detalhes',
-  'conversations.contact.closeDetails': 'Fechar detalhes',
-  'conversations.contact.channel': 'Canal',
-  'conversations.contact.status': 'Status',
-  'conversations.contact.assignedTo': 'Responsável',
-  'conversations.contact.location': 'Localização',
-  'conversations.contact.tags': 'Etiquetas',
-  'conversations.contact.note': 'Nota',
-  'conversations.contact.linkedRecords': 'Registros vinculados',
-  'conversations.contact.noLinkedRecords': 'Nenhum registro vinculado ainda.',
-
-  // Modal de nova conversa
-  'conversations.new.title': 'Nova conversa',
-  'conversations.new.channel': 'Canal',
-  'conversations.new.contactName': 'Nome do contato',
-  'conversations.new.contactNamePlaceholder': 'ex.: Maria Silva',
-  'conversations.new.handle': 'Telefone / usuário / e-mail',
-  'conversations.new.handlePlaceholder': '+55 11 99999-0000',
-  // O campo de handle só aparece quando o contato escolhido não tem o dado do
-  // canal ativo — caso contrário ele é derivado e mostrado no chip.
-  'conversations.new.addHandle': 'Adicionar {label}',
-  'conversations.new.handleLabel.phone': 'telefone',
-  'conversations.new.handleLabel.email': 'e-mail',
-  'conversations.new.handleLabel.instagram': '@ do Instagram',
-  'conversations.new.handleLabel.webchat': 'id do chat',
-  'conversations.new.firstMessage': 'Primeira mensagem',
-  'conversations.new.firstMessagePlaceholder': 'Escreva a primeira mensagem (opcional)…',
-  'conversations.new.cancel': 'Cancelar',
-  'conversations.new.create': 'Iniciar conversa',
-  'conversations.new.creating': 'Iniciando…',
-  'conversations.new.createFailed': 'Não foi possível criar a conversa',
-}