@consilioweb/payload-support 0.5.1

package/src/endpoints/export-csv.ts

@@ -0,0 +1,84 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+
+/**
+ * GET /api/support/export-csv
+ * Admin-only endpoint to export all tickets as CSV.
+ */
+export function createExportCsvEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/export-csv',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        const PAGE_SIZE = 500
+        let page = 1
+        let hasMore = true
+        const allDocs: Array<Record<string, unknown>> = []
+
+        while (hasMore) {
+          const batch = await payload.find({
+            collection: slugs.tickets as any,
+            limit: PAGE_SIZE,
+            page,
+            depth: 1,
+            sort: '-createdAt',
+            overrideAccess: true,
+          })
+          allDocs.push(...(batch.docs as unknown as Array<Record<string, unknown>>))
+          hasMore = batch.hasNextPage ?? false
+          page++
+        }
+
+        const csvHeaders = [
+          'N° Ticket', 'Sujet', 'Statut', 'Priorité', 'Catégorie',
+          'Client', 'Email Client', 'Projet', 'Tags', 'Assigné à',
+          'Temps (min)', 'Créé le', 'Première réponse', 'Résolu le',
+        ]
+
+        const csvRows = allDocs.map((t) => {
+          const client = typeof t.client === 'object' ? (t.client as Record<string, unknown>) : null
+          const project = typeof t.project === 'object' ? (t.project as Record<string, unknown>) : null
+          const assignedTo = typeof t.assignedTo === 'object' ? (t.assignedTo as Record<string, unknown>) : null
+          const tags = Array.isArray(t.tags) ? t.tags.join(', ') : ''
+
+          return [
+            String(t.ticketNumber || ''),
+            `"${String(t.subject || '').replace(/"/g, '""')}"`,
+            String(t.status || ''),
+            String(t.priority || ''),
+            String(t.category || ''),
+            client ? `"${String(client.company || '').replace(/"/g, '""')}"` : '',
+            client ? String(client.email || '') : '',
+            project ? `"${String(project.name || '').replace(/"/g, '""')}"` : '',
+            `"${tags}"`,
+            assignedTo ? String(assignedTo.email || '') : '',
+            String(t.totalTimeMinutes || 0),
+            t.createdAt ? new Date(String(t.createdAt)).toISOString() : '',
+            t.firstResponseAt ? new Date(String(t.firstResponseAt)).toISOString() : '',
+            t.resolvedAt ? new Date(String(t.resolvedAt)).toISOString() : '',
+          ].join(',')
+        })
+
+        const csv = [csvHeaders.join(','), ...csvRows].join('\n')
+
+        return new Response(csv, {
+          headers: {
+            'Content-Type': 'text/csv; charset=utf-8',
+            'Content-Disposition': `attachment; filename="tickets-export-${new Date().toISOString().split('T')[0]}.csv"`,
+          },
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[export-csv] Error:', error)
+        return Response.json({ error: 'Internal error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/export-data.ts

@@ -0,0 +1,104 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireClient, handleAuthError } from '../utils/auth'
+
+/**
+ * GET /api/support/export-data
+ * RGPD Data Export — allows support clients to download all their personal data.
+ */
+export function createExportDataEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/export-data',
+    method: 'get',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireClient(req, slugs)
+
+        const [clientData, ticketsResult, messagesResult, surveysResult] = await Promise.all([
+          payload.findByID({
+            collection: slugs.supportClients as any,
+            id: req.user.id,
+            depth: 0,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.tickets as any,
+            where: { client: { equals: req.user.id } },
+            limit: 1000,
+            depth: 0,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.ticketMessages as any,
+            where: {
+              'ticket.client': { equals: req.user.id },
+              authorType: { equals: 'client' },
+            },
+            limit: 5000,
+            depth: 0,
+            overrideAccess: true,
+          }),
+          payload.find({
+            collection: slugs.satisfactionSurveys as any,
+            where: { client: { equals: req.user.id } },
+            limit: 500,
+            depth: 0,
+            overrideAccess: true,
+          }),
+        ])
+
+        const c = clientData as any
+        const exportData = {
+          exportDate: new Date().toISOString(),
+          exportType: 'RGPD - Export des données personnelles',
+          profile: {
+            email: c.email,
+            firstName: c.firstName,
+            lastName: c.lastName,
+            company: c.company,
+            phone: c.phone || null,
+            createdAt: c.createdAt,
+            updatedAt: c.updatedAt,
+          },
+          tickets: ticketsResult.docs.map((t: any) => ({
+            ticketNumber: t.ticketNumber,
+            subject: t.subject,
+            status: t.status,
+            priority: t.priority,
+            category: t.category,
+            createdAt: t.createdAt,
+            updatedAt: t.updatedAt,
+          })),
+          messages: messagesResult.docs.map((m: any) => ({
+            ticketId: m.ticket,
+            body: m.body,
+            createdAt: m.createdAt,
+          })),
+          surveys: surveysResult.docs.map((s: any) => ({
+            ticketId: s.ticket,
+            rating: s.rating,
+            comment: s.comment,
+            createdAt: s.createdAt,
+          })),
+        }
+
+        const json = JSON.stringify(exportData, null, 2)
+
+        return new Response(json, {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Disposition': `attachment; filename="support-export-${req.user.id}-${new Date().toISOString().slice(0, 10)}.json"`,
+          },
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[export-data] Error:', error)
+        return Response.json({ error: 'Erreur interne' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/import-conversation.ts

@@ -0,0 +1,307 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { RateLimiter } from '../utils/rateLimiter'
+import { readSupportSettings } from '../utils/readSettings'
+import crypto from 'crypto'
+
+interface ParsedConversation {
+  client: { email: string; name: string; company: string }
+  subject: string
+  messages: { from: 'client' | 'admin'; name: string; date: string; content: string }[]
+}
+
+const importLimiter = new RateLimiter(3_600_000, 10) // 10 per hour
+
+function parseStructuredMarkdown(markdown: string): ParsedConversation | null {
+  const clientMatch = markdown.match(
+    /\*\*Client\s*:\*\*\s*(.+?)\s*[—–-]\s*(.+?)\s*\(([^)]+@[^)]+)\)/i,
+  )
+  const subjectMatch = markdown.match(/\*\*Sujet\s*:\*\*\s*(.+)/i)
+
+  if (!clientMatch || !subjectMatch) return null
+
+  const client = {
+    name: clientMatch[1]!.trim(),
+    company: clientMatch[2]!.trim(),
+    email: clientMatch[3]!.trim().toLowerCase(),
+  }
+
+  const subject = subjectMatch[1]!.trim()
+  const adminEmail = (process.env.CONTACT_EMAIL || 'admin@example.com').toLowerCase()
+
+  const blocks = markdown.split(/## Message \d+/).slice(1)
+  const messages: ParsedConversation['messages'] = []
+
+  for (const block of blocks) {
+    const fromMatch = block.match(/\*\*De\s*:\*\*\s*(.+?)\s*\(([^)]+)\)/)
+    const dateMatch = block.match(/\*\*Date\s*:\*\*\s*(.+)/)
+
+    if (!fromMatch) continue
+
+    const name = fromMatch[1]!.trim()
+    const email = fromMatch[2]!.trim().toLowerCase()
+    const date = dateMatch ? dateMatch[1]!.trim() : ''
+
+    const lines = block.split('\n')
+    let contentStart = 0
+    let foundDate = false
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i]!.startsWith('**Date')) { foundDate = true; continue }
+      if (foundDate && lines[i]!.trim() === '') { contentStart = i + 1; break }
+    }
+
+    const content = lines.slice(contentStart).join('\n').replace(/\n---\s*$/s, '').trim()
+    if (!content) continue
+
+    messages.push({
+      from: email === adminEmail ? 'admin' : 'client',
+      name,
+      date,
+      content,
+    })
+  }
+
+  if (messages.length === 0) return null
+  return { client, subject, messages }
+}
+
+async function parseMarkdownWithAI(markdown: string): Promise<ParsedConversation | null> {
+  if (!process.env.ANTHROPIC_API_KEY) return null
+
+  try {
+    const Anthropic = require('@anthropic-ai/sdk').default
+    const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+
+    const response = await anthropic.messages.create({
+      model: 'claude-haiku-4-5-20251001',
+      max_tokens: 4096,
+      messages: [
+        {
+          role: 'user',
+          content: `Parse this email conversation markdown and return strict JSON.
+
+Extract:
+- Client info (the external person, NOT the admin)
+- Subject
+- All messages chronologically
+
+The admin email is: ${process.env.CONTACT_EMAIL || 'admin@example.com'}
+
+Return JSON: { "client": { "email": "", "name": "", "company": "" }, "subject": "", "messages": [{ "from": "client"|"admin", "name": "", "date": "", "content": "" }] }
+
+Markdown:
+---
+${markdown}
+---
+
+ONLY JSON, nothing else.`,
+        },
+      ],
+    })
+
+    const text = response.content[0]?.type === 'text' ? response.content[0].text.trim() : ''
+    const jsonMatch = text.match(/\{[\s\S]*\}/)
+    if (!jsonMatch) return null
+
+    const parsed = JSON.parse(jsonMatch[0])
+    if (!parsed.client?.email || !parsed.messages?.length) return null
+
+    return {
+      client: {
+        email: parsed.client.email.toLowerCase().trim(),
+        name: parsed.client.name || parsed.client.email.split('@')[0],
+        company: parsed.client.company || 'Non renseigné',
+      },
+      subject: parsed.subject || 'Conversation importée',
+      messages: parsed.messages.map((m: any) => ({
+        from: m.from === 'admin' ? 'admin' : 'client',
+        name: m.name || '',
+        date: m.date || '',
+        content: m.content || '',
+      })),
+    }
+  } catch (err) {
+    console.error('[import-conversation] AI parsing failed:', err)
+    return null
+  }
+}
+
+/**
+ * POST /api/support/import-conversation
+ * Import a conversation from markdown into the ticket system.
+ */
+export function createImportConversationEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/import-conversation',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        // Auth: admin session OR webhook secret
+        const webhookSecret = req.headers.get('x-webhook-secret')
+        let isAuthed = false
+
+        if (webhookSecret && process.env.SUPPORT_WEBHOOK_SECRET && webhookSecret === process.env.SUPPORT_WEBHOOK_SECRET) {
+          isAuthed = true
+        } else if (req.user && req.user.collection === slugs.users) {
+          isAuthed = true
+        }
+
+        if (!isAuthed) {
+          return Response.json({ error: 'Unauthorized' }, { status: 401 })
+        }
+
+        const ip = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || 'unknown'
+        if (importLimiter.check(ip)) {
+          return Response.json({ error: 'Rate limit exceeded. Maximum 10 imports per hour.' }, { status: 429 })
+        }
+
+        let body: { markdown?: string; previewOnly?: boolean }
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+        const { markdown, previewOnly } = body
+
+        if (!markdown || typeof markdown !== 'string') {
+          return Response.json({ error: 'markdown field is required (string)' }, { status: 400 })
+        }
+
+        if (markdown.length > 512_000) {
+          return Response.json({ error: 'Markdown too large (max 500KB)' }, { status: 400 })
+        }
+
+        let conversation = parseStructuredMarkdown(markdown)
+        let parseMethod = 'structured'
+
+        if (!conversation) {
+          conversation = await parseMarkdownWithAI(markdown)
+          parseMethod = 'ai'
+        }
+
+        if (!conversation) {
+          return Response.json({
+            error: 'Could not parse conversation. Expected format: **Client :** Name — Company (email), **Sujet :** Subject, ## Message N blocks.',
+          }, { status: 422 })
+        }
+
+        if (previewOnly) {
+          return Response.json({
+            action: 'preview',
+            parseMethod,
+            client: conversation.client,
+            subject: conversation.subject,
+            messageCount: conversation.messages.length,
+            messages: conversation.messages.map((m) => ({
+              from: m.from,
+              name: m.name,
+              date: m.date,
+              preview: m.content.length > 100 ? m.content.substring(0, 100) + '...' : m.content,
+            })),
+          })
+        }
+
+        if (!conversation.client.email.includes('@')) {
+          return Response.json({ error: 'Invalid client email extracted' }, { status: 422 })
+        }
+
+        const settings = await readSupportSettings(payload)
+        const adminEmail = (process.env.CONTACT_EMAIL || '').toLowerCase()
+        const blockedEmails = [adminEmail, settings.email.replyToAddress || process.env.SUPPORT_REPLY_TO || ''].filter(Boolean)
+        if (blockedEmails.includes(conversation.client.email)) {
+          return Response.json({ error: 'Cannot create ticket from system email address' }, { status: 400 })
+        }
+
+        // Find or create support client
+        const clientResult = await payload.find({
+          collection: slugs.supportClients as any,
+          where: { email: { equals: conversation.client.email } },
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+
+        let client = clientResult.docs[0]
+        let isNewClient = false
+
+        if (!client) {
+          const nameParts = conversation.client.name.split(' ')
+          const randomPassword = crypto.randomBytes(48).toString('base64url')
+
+          client = await payload.create({
+            collection: slugs.supportClients as any,
+            data: {
+              email: conversation.client.email,
+              password: randomPassword,
+              firstName: nameParts[0] || 'Inconnu',
+              lastName: nameParts.slice(1).join(' ') || conversation.client.email.split('@')[0] || 'Inconnu',
+              company: conversation.client.company || 'Non renseigné',
+            },
+            overrideAccess: true,
+          })
+          isNewClient = true
+        }
+
+        // Find admin user for authorAdmin
+        const adminUsers = await payload.find({
+          collection: slugs.users as any,
+          limit: 1,
+          depth: 0,
+          overrideAccess: true,
+        })
+        const adminUserId = adminUsers.docs[0]?.id
+
+        // Create ticket
+        const ticket = await payload.create({
+          collection: slugs.tickets as any,
+          data: {
+            subject: conversation.subject,
+            client: client.id,
+            status: 'open',
+            priority: 'normal',
+            category: 'question',
+          },
+          overrideAccess: true,
+        }) as any
+
+        // Import messages
+        let importedCount = 0
+        for (const msg of conversation.messages) {
+          const isAdmin = msg.from === 'admin'
+
+          await payload.create({
+            collection: slugs.ticketMessages as any,
+            data: {
+              ticket: ticket.id,
+              body: msg.content,
+              authorType: isAdmin ? 'admin' : 'email',
+              ...(isAdmin && adminUserId ? { authorAdmin: adminUserId } : {}),
+              ...(!isAdmin ? { authorClient: client.id } : {}),
+              isInternal: false,
+              skipNotification: true,
+            },
+            overrideAccess: true,
+          })
+          importedCount++
+        }
+
+        return Response.json({
+          action: 'conversation_imported',
+          parseMethod,
+          ticketNumber: ticket.ticketNumber,
+          ticketId: ticket.id,
+          clientEmail: conversation.client.email,
+          clientName: conversation.client.name,
+          clientCompany: conversation.client.company,
+          isNewClient,
+          messagesImported: importedCount,
+        })
+      } catch (error) {
+        console.error('[import-conversation] Error:', error)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/endpoints/index.ts

@@ -0,0 +1,154 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import type { SupportFeatures } from '../types'
+
+import { createAiEndpoint } from './ai'
+import { createSearchEndpoint } from './search'
+import { createBulkActionEndpoint } from './bulk-action'
+import { createMergeTicketsEndpoint } from './merge-tickets'
+import { createSplitTicketEndpoint } from './split-ticket'
+import { createTypingPostEndpoint, createTypingGetEndpoint } from './typing'
+import { createPresencePostEndpoint, createPresenceGetEndpoint } from './presence'
+import { createSettingsGetEndpoint, createSettingsPostEndpoint } from './settings'
+import { createSignatureGetEndpoint, createSignaturePostEndpoint } from './signature'
+import { createRoundRobinConfigGetEndpoint, createRoundRobinConfigPostEndpoint } from './round-robin-config'
+import { createSlaCheckEndpoint } from './sla-check'
+import { createAutoCloseEndpoint } from './auto-close'
+import { createStatusesEndpoint } from './statuses'
+import { createApplyMacroEndpoint } from './apply-macro'
+import { createPurgeLogsEndpoint } from './purge-logs'
+import { createChatbotEndpoint } from './chatbot'
+import { createChatGetEndpoint, createChatPostEndpoint } from './chat'
+import { createChatStreamEndpoint } from './chat-stream'
+import { createAdminChatGetEndpoint, createAdminChatPostEndpoint } from './admin-chat'
+import { createAdminChatStreamEndpoint } from './admin-chat-stream'
+import { createAdminStatsEndpoint } from './admin-stats'
+import { createBillingEndpoint } from './billing'
+import { createEmailStatsEndpoint } from './email-stats'
+import { createSatisfactionEndpoint } from './satisfaction'
+import { createTrackOpenEndpoint } from './track-open'
+import { createExportCsvEndpoint } from './export-csv'
+import { createExportDataEndpoint } from './export-data'
+import { createPendingEmailsProcessEndpoint } from './pending-emails-process'
+import { createResendNotificationEndpoint } from './resend-notification'
+import { createSeedKbEndpoint } from './seed-kb'
+import { createLoginEndpoint } from './login'
+import { createAuth2faEndpoint } from './auth-2fa'
+import { createOAuthGoogleEndpoint, type OAuthGoogleOptions } from './oauth-google'
+import { createDeleteAccountEndpoint } from './delete-account'
+import { createMergeClientsEndpoint } from './merge-clients'
+import { createImportConversationEndpoint } from './import-conversation'
+import { createProcessScheduledEndpoint } from './process-scheduled'
+import { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
+
+// Re-export all individual endpoint creators
+export { createAiEndpoint } from './ai'
+export { createSearchEndpoint } from './search'
+export { createBulkActionEndpoint } from './bulk-action'
+export { createMergeTicketsEndpoint } from './merge-tickets'
+export { createSplitTicketEndpoint } from './split-ticket'
+export { createTypingPostEndpoint, createTypingGetEndpoint } from './typing'
+export { createPresencePostEndpoint, createPresenceGetEndpoint } from './presence'
+export { createSettingsGetEndpoint, createSettingsPostEndpoint } from './settings'
+export { createSignatureGetEndpoint, createSignaturePostEndpoint } from './signature'
+export { createRoundRobinConfigGetEndpoint, createRoundRobinConfigPostEndpoint } from './round-robin-config'
+export { createSlaCheckEndpoint } from './sla-check'
+export { createAutoCloseEndpoint } from './auto-close'
+export { createStatusesEndpoint } from './statuses'
+export { createApplyMacroEndpoint } from './apply-macro'
+export { createPurgeLogsEndpoint } from './purge-logs'
+export { createChatbotEndpoint } from './chatbot'
+export { createChatGetEndpoint, createChatPostEndpoint } from './chat'
+export { createChatStreamEndpoint } from './chat-stream'
+export { createAdminChatGetEndpoint, createAdminChatPostEndpoint } from './admin-chat'
+export { createAdminChatStreamEndpoint } from './admin-chat-stream'
+export { createAdminStatsEndpoint } from './admin-stats'
+export { createBillingEndpoint } from './billing'
+export { createEmailStatsEndpoint } from './email-stats'
+export { createSatisfactionEndpoint } from './satisfaction'
+export { createTrackOpenEndpoint } from './track-open'
+export { createExportCsvEndpoint } from './export-csv'
+export { createExportDataEndpoint } from './export-data'
+export { createPendingEmailsProcessEndpoint } from './pending-emails-process'
+export { createResendNotificationEndpoint } from './resend-notification'
+export { createSeedKbEndpoint } from './seed-kb'
+export { createLoginEndpoint } from './login'
+export { createAuth2faEndpoint } from './auth-2fa'
+export { createOAuthGoogleEndpoint } from './oauth-google'
+export { createDeleteAccountEndpoint } from './delete-account'
+export { createMergeClientsEndpoint } from './merge-clients'
+export { createImportConversationEndpoint } from './import-conversation'
+export { createProcessScheduledEndpoint } from './process-scheduled'
+export { createUserPrefsGetEndpoint, createUserPrefsPostEndpoint } from './user-prefs'
+export type { UserPrefs } from './user-prefs'
+
+export interface SupportEndpointOptions {
+  oauth?: OAuthGoogleOptions
+  features?: Required<SupportFeatures>
+}
+
+/**
+ * Create all support endpoints for the Payload plugin.
+ * Returns an array of Endpoint objects to be registered via `endpoints` in the plugin config.
+ * Endpoints are conditionally included based on feature flags.
+ */
+export function createSupportEndpoints(slugs: CollectionSlugs, options?: SupportEndpointOptions): Endpoint[] {
+  const f = options?.features
+
+  // Core endpoints (always present)
+  const endpoints: Endpoint[] = [
+    createSearchEndpoint(slugs),
+    createSettingsGetEndpoint(slugs),
+    createSettingsPostEndpoint(slugs),
+    createAdminStatsEndpoint(slugs),
+    createExportCsvEndpoint(slugs),
+    createExportDataEndpoint(slugs),
+    createSeedKbEndpoint(slugs),
+    createLoginEndpoint(slugs),
+    createAuth2faEndpoint(slugs),
+    createOAuthGoogleEndpoint(slugs, options?.oauth),
+    createDeleteAccountEndpoint(slugs),
+    createMergeClientsEndpoint(slugs),
+    createImportConversationEndpoint(slugs),
+    createPurgeLogsEndpoint(slugs),
+    createResendNotificationEndpoint(slugs),
+    createUserPrefsGetEndpoint(slugs),
+    createUserPrefsPostEndpoint(slugs),
+  ]
+
+  // Conditional endpoints based on feature flags
+  if (!f || f.ai !== false) endpoints.push(createAiEndpoint(slugs))
+  if (!f || f.bulkActions !== false) endpoints.push(createBulkActionEndpoint(slugs))
+  if (!f || f.merge !== false) endpoints.push(createMergeTicketsEndpoint(slugs))
+  if (!f || f.splitTicket !== false) endpoints.push(createSplitTicketEndpoint(slugs))
+  if (!f || f.collisionDetection !== false) {
+    endpoints.push(createTypingPostEndpoint(slugs), createTypingGetEndpoint(slugs))
+    endpoints.push(createPresencePostEndpoint(slugs), createPresenceGetEndpoint(slugs))
+  }
+  if (!f || f.signatures !== false) {
+    endpoints.push(createSignatureGetEndpoint(slugs), createSignaturePostEndpoint(slugs))
+  }
+  if (!f || f.sla !== false) endpoints.push(createSlaCheckEndpoint(slugs))
+  if (!f || f.autoClose !== false) endpoints.push(createAutoCloseEndpoint(slugs))
+  if (!f || f.customStatuses !== false) endpoints.push(createStatusesEndpoint(slugs))
+  if (!f || f.macros !== false) endpoints.push(createApplyMacroEndpoint(slugs))
+  if (!f || f.roundRobin !== false) {
+    endpoints.push(createRoundRobinConfigGetEndpoint(slugs), createRoundRobinConfigPostEndpoint(slugs))
+  }
+  if (!f || f.chatbot !== false) endpoints.push(createChatbotEndpoint(slugs))
+  if (!f || f.chat !== false) {
+    endpoints.push(createChatGetEndpoint(slugs), createChatPostEndpoint(slugs))
+    endpoints.push(createChatStreamEndpoint(slugs))
+    endpoints.push(createAdminChatGetEndpoint(slugs), createAdminChatPostEndpoint(slugs))
+    endpoints.push(createAdminChatStreamEndpoint(slugs))
+  }
+  if (!f || f.timeTracking !== false) endpoints.push(createBillingEndpoint(slugs))
+  if (!f || f.satisfaction !== false) endpoints.push(createSatisfactionEndpoint(slugs))
+  if (!f || f.emailTracking !== false) {
+    endpoints.push(createEmailStatsEndpoint(slugs), createTrackOpenEndpoint(slugs))
+  }
+  if (!f || f.pendingEmails !== false) endpoints.push(createPendingEmailsProcessEndpoint(slugs))
+  if (!f || f.scheduledReplies !== false) endpoints.push(createProcessScheduledEndpoint(slugs))
+
+  return endpoints
+}