@open-mercato/core 0.4.2-canary-ed15f2e753 → 0.4.2-canary-e2aeb1a7bf

package/src/modules/notifications/data/entities.ts

@@ -0,0 +1,99 @@
+import { Entity, PrimaryKey, Property, Index, OptionalProps } from '@mikro-orm/core'
+import type { NotificationActionData } from '@open-mercato/shared/modules/notifications/types'
+
+export type NotificationStatus = 'unread' | 'read' | 'actioned' | 'dismissed'
+export type NotificationSeverity = 'info' | 'warning' | 'success' | 'error'
+
+@Entity({ tableName: 'notifications' })
+@Index({ name: 'notifications_recipient_status_idx', properties: ['recipientUserId', 'status', 'createdAt'] })
+@Index({ name: 'notifications_source_idx', properties: ['sourceEntityType', 'sourceEntityId'] })
+@Index({ name: 'notifications_tenant_idx', properties: ['tenantId', 'organizationId'] })
+@Index({ name: 'notifications_expires_idx', properties: ['expiresAt'] })
+@Index({ name: 'notifications_group_idx', properties: ['groupKey', 'recipientUserId'] })
+export class Notification {
+  [OptionalProps]?: 'status' | 'severity' | 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'recipient_user_id', type: 'uuid' })
+  recipientUserId!: string
+
+  @Property({ name: 'type', type: 'text' })
+  type!: string
+
+  // i18n keys (preferred for i18n-first approach)
+  @Property({ name: 'title_key', type: 'text', nullable: true })
+  titleKey?: string | null
+
+  @Property({ name: 'body_key', type: 'text', nullable: true })
+  bodyKey?: string | null
+
+  // Template variables for i18n interpolation (stored as JSONB)
+  @Property({ name: 'title_variables', type: 'json', nullable: true })
+  titleVariables?: Record<string, string> | null
+
+  @Property({ name: 'body_variables', type: 'json', nullable: true })
+  bodyVariables?: Record<string, string> | null
+
+  // Fallback text (for backward compatibility or when keys are not available)
+  @Property({ name: 'title', type: 'text' })
+  title!: string
+
+  @Property({ name: 'body', type: 'text', nullable: true })
+  body?: string | null
+
+  @Property({ name: 'icon', type: 'text', nullable: true })
+  icon?: string | null
+
+  @Property({ name: 'severity', type: 'text', default: 'info' })
+  severity: NotificationSeverity = 'info'
+
+  @Property({ name: 'status', type: 'text', default: 'unread' })
+  status: NotificationStatus = 'unread'
+
+  @Property({ name: 'action_data', type: 'json', nullable: true })
+  actionData?: NotificationActionData | null
+
+  @Property({ name: 'action_result', type: 'json', nullable: true })
+  actionResult?: Record<string, unknown> | null
+
+  @Property({ name: 'action_taken', type: 'text', nullable: true })
+  actionTaken?: string | null
+
+  @Property({ name: 'source_module', type: 'text', nullable: true })
+  sourceModule?: string | null
+
+  @Property({ name: 'source_entity_type', type: 'text', nullable: true })
+  sourceEntityType?: string | null
+
+  @Property({ name: 'source_entity_id', type: 'uuid', nullable: true })
+  sourceEntityId?: string | null
+
+  @Property({ name: 'link_href', type: 'text', nullable: true })
+  linkHref?: string | null
+
+  @Property({ name: 'group_key', type: 'text', nullable: true })
+  groupKey?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'read_at', type: Date, nullable: true })
+  readAt?: Date | null
+
+  @Property({ name: 'actioned_at', type: Date, nullable: true })
+  actionedAt?: Date | null
+
+  @Property({ name: 'dismissed_at', type: Date, nullable: true })
+  dismissedAt?: Date | null
+
+  @Property({ name: 'expires_at', type: Date, nullable: true })
+  expiresAt?: Date | null
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+}

package/src/modules/notifications/data/validators.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod'
+import { isSafeNotificationHref } from '../lib/safeHref'
+
+export const notificationStatusSchema = z.enum(['unread', 'read', 'actioned', 'dismissed'])
+export const notificationSeveritySchema = z.enum(['info', 'warning', 'success', 'error'])
+
+export const safeRelativeHrefSchema = z.string().min(1).refine(
+  (href) => isSafeNotificationHref(href),
+  { message: 'Href must be a same-origin relative path starting with /' }
+)
+
+export const notificationActionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  labelKey: z.string().optional(),
+  variant: z.enum(['default', 'secondary', 'destructive', 'outline', 'ghost']).optional(),
+  icon: z.string().optional(),
+  commandId: z.string().optional(),
+  href: safeRelativeHrefSchema.optional(),
+  confirmRequired: z.boolean().optional(),
+  confirmMessage: z.string().optional(),
+})
+
+const baseNotificationFieldsSchema = z.object({
+  type: z.string().min(1).max(100),
+  titleKey: z.string().min(1).max(200).optional(),
+  bodyKey: z.string().min(1).max(200).optional(),
+  titleVariables: z.record(z.string(), z.string()).optional(),
+  bodyVariables: z.record(z.string(), z.string()).optional(),
+  title: z.string().min(1).max(500).optional(),
+  body: z.string().max(2000).optional(),
+  icon: z.string().max(100).optional(),
+  severity: notificationSeveritySchema.optional().default('info'),
+  actions: z.array(notificationActionSchema).optional(),
+  primaryActionId: z.string().optional(),
+  sourceModule: z.string().optional(),
+  sourceEntityType: z.string().optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  linkHref: safeRelativeHrefSchema.optional(),
+  groupKey: z.string().optional(),
+  expiresAt: z.string().datetime().optional(),
+})
+
+const titleRequiredRefinement = {
+  refine: (data: { titleKey?: string; title?: string }) => data.titleKey || data.title,
+  message: 'Either titleKey or title must be provided',
+} as const
+
+export const createNotificationSchema = baseNotificationFieldsSchema
+  .extend({ recipientUserId: z.string().uuid() })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createBatchNotificationSchema = baseNotificationFieldsSchema
+  .extend({ recipientUserIds: z.array(z.string().uuid()).min(1).max(1000) })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createRoleNotificationSchema = baseNotificationFieldsSchema
+  .extend({ roleId: z.string().uuid() })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createFeatureNotificationSchema = baseNotificationFieldsSchema
+  .extend({ requiredFeature: z.string().min(1).max(100) })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const listNotificationsSchema = z.object({
+  status: z.union([notificationStatusSchema, z.array(notificationStatusSchema)]).optional(),
+  type: z.string().optional(),
+  severity: notificationSeveritySchema.optional(),
+  sourceEntityType: z.string().optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  since: z.string().datetime().optional(),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+})
+
+export const executeActionSchema = z.object({
+  actionId: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()).optional(),
+})
+
+export const restoreNotificationSchema = z.object({
+  status: z.enum(['read', 'unread']).optional(),
+})
+
+const notificationDeliveryStrategySchema = z.object({
+  enabled: z.boolean().optional(),
+})
+
+const notificationDeliveryEmailSchema = notificationDeliveryStrategySchema.extend({
+  from: z.string().trim().min(1).optional(),
+  replyTo: z.string().trim().min(1).optional(),
+  subjectPrefix: z.string().trim().min(1).optional(),
+})
+
+const notificationDeliveryCustomSchema = notificationDeliveryStrategySchema.extend({
+  config: z.unknown().optional(),
+})
+
+export const notificationDeliveryConfigSchema = z.object({
+  appUrl: z.string().url().optional(),
+  panelPath: safeRelativeHrefSchema.optional(),
+  strategies: z.object({
+    database: notificationDeliveryStrategySchema.optional(),
+    email: notificationDeliveryEmailSchema.optional(),
+    custom: z.record(z.string(), notificationDeliveryCustomSchema).optional(),
+  }).optional(),
+})
+
+export type CreateNotificationInput = z.infer<typeof createNotificationSchema>
+export type CreateBatchNotificationInput = z.infer<typeof createBatchNotificationSchema>
+export type CreateRoleNotificationInput = z.infer<typeof createRoleNotificationSchema>
+export type CreateFeatureNotificationInput = z.infer<typeof createFeatureNotificationSchema>
+export type ListNotificationsInput = z.infer<typeof listNotificationsSchema>
+export type ExecuteActionInput = z.infer<typeof executeActionSchema>
+export type NotificationDeliveryConfigInput = z.infer<typeof notificationDeliveryConfigSchema>

package/src/modules/notifications/di.ts

@@ -0,0 +1,11 @@
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import { asFunction } from 'awilix'
+import { createNotificationService } from './lib/notificationService'
+
+export function register(container: AppContainer): void {
+  container.register({
+    notificationService: asFunction(({ em, eventBus, commandBus }) =>
+      createNotificationService({ em, eventBus, commandBus })
+    ).scoped(),
+  })
+}

package/src/modules/notifications/emails/NotificationEmail.tsx

@@ -0,0 +1,98 @@
+import React from 'react'
+import { Html, Head, Preview, Body, Container, Heading, Text, Section, Button, Hr } from '@react-email/components'
+
+export type NotificationEmailAction = {
+  id: string
+  label: string
+  href: string
+}
+
+export type NotificationEmailCopy = {
+  preview: string
+  heading: string
+  bodyIntro: string
+  actionNotice: string
+  openCta: string
+  footer: string
+}
+
+type NotificationEmailProps = {
+  title: string
+  body?: string | null
+  actions: NotificationEmailAction[]
+  panelUrl: string
+  copy: NotificationEmailCopy
+}
+
+export function NotificationEmail({ title, body, actions, panelUrl, copy }: NotificationEmailProps) {
+  return (
+    <Html>
+      <Head />
+      <Preview>{copy.preview}</Preview>
+      <Body style={{ backgroundColor: '#f5f5f5', fontFamily: 'Arial, sans-serif', margin: 0, padding: 0 }}>
+        <Container style={{ maxWidth: 560, margin: '0 auto', padding: '24px' }}>
+          <Section style={{ backgroundColor: '#ffffff', padding: '24px', borderRadius: 12 }}>
+            <Heading as="h1" style={{ fontSize: '22px', margin: '0 0 8px', color: '#111827' }}>
+              {copy.heading}
+            </Heading>
+            <Text style={{ margin: '0 0 16px', color: '#4b5563' }}>{title}</Text>
+            {body && (
+              <Text style={{ margin: '0 0 16px', color: '#111827', fontSize: '15px' }}>
+                {body}
+              </Text>
+            )}
+            <Text style={{ margin: '0 0 16px', color: '#6b7280', fontSize: '13px' }}>
+              {copy.bodyIntro}
+            </Text>
+            {actions.length > 0 && (
+              <Section style={{ marginBottom: 16 }}>
+                {actions.map((action) => (
+                  <Button
+                    key={action.id}
+                    href={action.href}
+                    style={{
+                      backgroundColor: '#111827',
+                      color: '#ffffff',
+                      padding: '10px 16px',
+                      borderRadius: 8,
+                      textDecoration: 'none',
+                      display: 'inline-block',
+                      marginRight: 8,
+                      marginBottom: 8,
+                      fontSize: '13px',
+                    }}
+                  >
+                    {action.label}
+                  </Button>
+                ))}
+              </Section>
+            )}
+            <Text style={{ margin: '0 0 16px', color: '#6b7280', fontSize: '12px' }}>
+              {copy.actionNotice}
+            </Text>
+            <Button
+              href={panelUrl}
+              style={{
+                backgroundColor: '#2563eb',
+                color: '#ffffff',
+                padding: '12px 18px',
+                borderRadius: 8,
+                textDecoration: 'none',
+                display: 'inline-block',
+                fontSize: '14px',
+              }}
+            >
+              {copy.openCta}
+            </Button>
+            <Hr style={{ margin: '24px 0', borderColor: '#e5e7eb' }} />
+            <Text style={{ margin: 0, color: '#9ca3af', fontSize: '12px' }}>
+              {copy.footer}
+            </Text>
+          </Section>
+        </Container>
+      </Body>
+    </Html>
+  )
+}
+
+export default NotificationEmail

package/src/modules/notifications/frontend/NotificationInboxPageClient.tsx

@@ -0,0 +1,42 @@
+'use client'
+
+import * as React from 'react'
+import { useRouter } from 'next/navigation'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { NotificationPanel } from '@open-mercato/ui/backend/notifications'
+import { useNotificationsPoll } from '@open-mercato/ui/backend/notifications'
+
+export function NotificationInboxPageClient() {
+  const t = useT()
+  const router = useRouter()
+  const {
+    notifications,
+    unreadCount,
+    markAsRead,
+    executeAction,
+    dismiss,
+    dismissUndo,
+    undoDismiss,
+    markAllRead,
+  } = useNotificationsPoll()
+
+  return (
+    <NotificationPanel
+      open
+      onOpenChange={(open) => {
+        if (!open) router.push('/backend')
+      }}
+      notifications={notifications}
+      unreadCount={unreadCount}
+      onMarkAsRead={markAsRead}
+      onExecuteAction={executeAction}
+      onDismiss={dismiss}
+      dismissUndo={dismissUndo}
+      onUndoDismiss={undoDismiss}
+      onMarkAllRead={markAllRead}
+      t={t}
+    />
+  )
+}
+
+export default NotificationInboxPageClient

package/src/modules/notifications/frontend/NotificationSettingsPageClient.tsx

@@ -0,0 +1,233 @@
+"use client"
+
+import * as React from 'react'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { apiCall, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { Switch } from '@open-mercato/ui/primitives/switch'
+import { Spinner } from '@open-mercato/ui/primitives/spinner'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@open-mercato/ui/primitives/card'
+
+type NotificationDeliveryConfig = {
+  appUrl?: string
+  panelPath: string
+  strategies: {
+    database: { enabled: boolean }
+    email: { enabled: boolean; from?: string; replyTo?: string; subjectPrefix?: string }
+    custom?: Record<string, { enabled?: boolean; config?: unknown }>
+  }
+}
+
+type SettingsResponse = {
+  settings?: NotificationDeliveryConfig
+  error?: string
+}
+
+const emptySettings: NotificationDeliveryConfig = {
+  panelPath: '/backend/notifications',
+  strategies: {
+    database: { enabled: true },
+    email: { enabled: true },
+    custom: {},
+  },
+}
+
+export function NotificationSettingsPageClient() {
+  const t = useT()
+  const [settings, setSettings] = React.useState<NotificationDeliveryConfig | null>(null)
+  const [loading, setLoading] = React.useState(true)
+  const [saving, setSaving] = React.useState(false)
+  const [error, setError] = React.useState<string | null>(null)
+
+  const fetchSettings = React.useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const body = await readApiResultOrThrow<SettingsResponse>(
+        '/api/notifications/settings',
+        undefined,
+        { errorMessage: t('notifications.settings.loadError', 'Failed to load notification settings'), allowNullResult: true },
+      )
+      if (body?.settings) {
+        setSettings(body.settings)
+      } else {
+        setSettings(emptySettings)
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : t('notifications.settings.loadError', 'Failed to load notification settings')
+      setError(message)
+      flash(message, 'error')
+    } finally {
+      setLoading(false)
+    }
+  }, [t])
+
+  React.useEffect(() => {
+    fetchSettings()
+  }, [fetchSettings])
+
+  const updateSettings = (patch: Partial<NotificationDeliveryConfig>) => {
+    setSettings((prev) => (prev ? { ...prev, ...patch } : prev))
+  }
+
+  const updateStrategy = (
+    strategy: keyof NotificationDeliveryConfig['strategies'],
+    patch: Partial<NotificationDeliveryConfig['strategies'][keyof NotificationDeliveryConfig['strategies']]>,
+  ) => {
+    setSettings((prev) => {
+      if (!prev) return prev
+      return {
+        ...prev,
+        strategies: {
+          ...prev.strategies,
+          [strategy]: {
+            ...prev.strategies[strategy],
+            ...patch,
+          },
+        },
+      }
+    })
+  }
+
+  const handleSave = async () => {
+    if (!settings) return
+    setSaving(true)
+    try {
+      const response = await apiCall<SettingsResponse>('/api/notifications/settings', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(settings),
+      })
+      if (!response.ok) {
+        const message = response.result?.error || t('notifications.settings.saveError', 'Failed to save notification settings')
+        throw new Error(message)
+      }
+      if (response.result?.settings) {
+        setSettings(response.result.settings)
+      }
+      flash(t('notifications.settings.saveSuccess', 'Notification settings saved'), 'success')
+    } catch (err) {
+      const message = err instanceof Error ? err.message : t('notifications.settings.saveError', 'Failed to save notification settings')
+      flash(message, 'error')
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  if (loading || !settings) {
+    return (
+      <div className="flex items-center gap-2 text-sm text-muted-foreground">
+        <Spinner size="sm" />
+        {t('notifications.settings.loading', 'Loading notification settings...')}
+      </div>
+    )
+  }
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-semibold">{t('notifications.settings.pageTitle', 'Notification Delivery')}</h1>
+        <p className="text-muted-foreground text-sm">
+          {t('notifications.settings.pageDescription', 'Configure delivery strategies for in-app notifications.')}
+        </p>
+      </div>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('notifications.settings.core.title', 'Core delivery')}</CardTitle>
+          <CardDescription>{t('notifications.settings.core.description', 'Control the default notification center and panel link used by external channels.')}</CardDescription>
+        </CardHeader>
+        <CardContent className="grid gap-4 md:grid-cols-2">
+          <div className="space-y-2">
+            <Label htmlFor="notifications-app-url">{t('notifications.settings.core.appUrl', 'Application URL')}</Label>
+            <Input
+              id="notifications-app-url"
+              value={settings.appUrl ?? ''}
+              placeholder="https://app.open-mercato.com"
+              onChange={(event) => updateSettings({ appUrl: event.target.value || undefined })}
+            />
+            <p className="text-xs text-muted-foreground">{t('notifications.settings.core.appUrlHint', 'Used to build absolute links in email notifications.')}</p>
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="notifications-panel-path">{t('notifications.settings.core.panelPath', 'Notification panel path')}</Label>
+            <Input
+              id="notifications-panel-path"
+              value={settings.panelPath}
+              onChange={(event) => updateSettings({ panelPath: event.target.value })}
+            />
+            <p className="text-xs text-muted-foreground">{t('notifications.settings.core.panelPathHint', 'Relative path for the read-only notification panel.')}</p>
+          </div>
+          <div className="flex items-center justify-between rounded-lg border p-3">
+            <div>
+              <p className="text-sm font-medium">{t('notifications.settings.core.databaseLabel', 'In-app notifications')}</p>
+              <p className="text-xs text-muted-foreground">{t('notifications.settings.core.databaseHint', 'Store notifications in the database for the panel and bell.')}</p>
+            </div>
+            <Switch
+              checked={settings.strategies.database.enabled}
+              disabled
+              onCheckedChange={(checked) => updateStrategy('database', { enabled: checked })}
+            />
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('notifications.settings.email.title', 'Email strategy')}</CardTitle>
+          <CardDescription>{t('notifications.settings.email.description', 'Send notification copies via Resend using React templates.')}</CardDescription>
+        </CardHeader>
+        <CardContent className="grid gap-4 md:grid-cols-2">
+          <div className="flex items-center justify-between rounded-lg border p-3 md:col-span-2">
+            <div>
+              <p className="text-sm font-medium">{t('notifications.settings.email.enabledLabel', 'Enable email delivery')}</p>
+              <p className="text-xs text-muted-foreground">{t('notifications.settings.email.enabledHint', 'Email actions are read-only and link back to the notification center.')}</p>
+            </div>
+            <Switch
+              checked={settings.strategies.email.enabled}
+              onCheckedChange={(checked) => updateStrategy('email', { enabled: checked })}
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="notifications-email-from">{t('notifications.settings.email.from', 'From address')}</Label>
+            <Input
+              id="notifications-email-from"
+              value={settings.strategies.email.from ?? ''}
+              placeholder="notifications@open-mercato.com"
+              onChange={(event) => updateStrategy('email', { from: event.target.value || undefined })}
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="notifications-email-reply">{t('notifications.settings.email.replyTo', 'Reply-to')}</Label>
+            <Input
+              id="notifications-email-reply"
+              value={settings.strategies.email.replyTo ?? ''}
+              placeholder="support@open-mercato.com"
+              onChange={(event) => updateStrategy('email', { replyTo: event.target.value || undefined })}
+            />
+          </div>
+          <div className="space-y-2 md:col-span-2">
+            <Label htmlFor="notifications-email-subject-prefix">{t('notifications.settings.email.subjectPrefix', 'Subject prefix')}</Label>
+            <Input
+              id="notifications-email-subject-prefix"
+              value={settings.strategies.email.subjectPrefix ?? ''}
+              placeholder="[Open Mercato]"
+              onChange={(event) => updateStrategy('email', { subjectPrefix: event.target.value || undefined })}
+            />
+          </div>
+        </CardContent>
+      </Card>
+
+      <div className="flex items-center gap-3">
+        <Button type="button" onClick={handleSave} disabled={saving}>
+          {saving ? t('notifications.settings.saving', 'Saving...') : t('notifications.settings.save', 'Save settings')}
+        </Button>
+        {error && <span className="text-sm text-destructive">{error}</span>}
+      </div>
+    </div>
+  )
+}
+
+export default NotificationSettingsPageClient

package/src/modules/notifications/i18n/de.json

@@ -0,0 +1,50 @@
+{
+  "notifications.nav.title": "Benachrichtigungen",
+  "notifications.title": "Benachrichtigungen",
+  "notifications.empty": "Keine Benachrichtigungen",
+  "notifications.markAllRead": "Alle als gelesen markieren",
+  "notifications.actionTaken": "Ausgeführte Aktion: {action}",
+  "notifications.filters.all": "Alle",
+  "notifications.filters.unread": "Ungelesen",
+  "notifications.filters.actionRequired": "Aktion erforderlich",
+  "notifications.actions.dismiss": "Verwerfen",
+  "notifications.actions.undo": "Rückgängig",
+  "notifications.actions.markRead": "Als gelesen markieren",
+  "notifications.toast.new": "Neue Benachrichtigung",
+  "notifications.toast.dismissed": "Benachrichtigung verworfen",
+  "notifications.toast.actionSuccess": "Aktion erfolgreich ausgeführt",
+  "notifications.toast.actionError": "Aktion konnte nicht ausgeführt werden",
+  "notifications.error.load": "Benachrichtigungen konnten nicht geladen werden",
+  "notifications.error.action": "Aktion konnte nicht ausgeführt werden",
+  "notifications.badge.unread": "{count} ungelesene Benachrichtigungen",
+  "notifications.delivery.email.preview": "Neue Benachrichtigung",
+  "notifications.delivery.email.heading": "Sie haben eine neue Benachrichtigung",
+  "notifications.delivery.email.bodyIntro": "Prüfen Sie die Benachrichtigung und führen Sie bei Bedarf Aktionen aus.",
+  "notifications.delivery.email.actionNotice": "Aktionen sind in Open Mercato verfügbar und in dieser E-Mail schreibgeschützt.",
+  "notifications.delivery.email.openCta": "Benachrichtigungszentrum öffnen",
+  "notifications.delivery.email.footer": "Open Mercato Benachrichtigungen",
+  "notifications.delivery.settings.invalid": "Ungültige Zustelleinstellungen",
+  "notifications.settings.pageTitle": "Benachrichtigungszustellung",
+  "notifications.settings.pageDescription": "Zustellstrategien für In-App-Benachrichtigungen konfigurieren.",
+  "notifications.settings.loadError": "Benachrichtigungseinstellungen konnten nicht geladen werden",
+  "notifications.settings.saveError": "Benachrichtigungseinstellungen konnten nicht gespeichert werden",
+  "notifications.settings.saveSuccess": "Benachrichtigungseinstellungen gespeichert",
+  "notifications.settings.loading": "Benachrichtigungseinstellungen werden geladen...",
+  "notifications.settings.saving": "Speichern...",
+  "notifications.settings.save": "Einstellungen speichern",
+  "notifications.settings.core.title": "Kernzustellung",
+  "notifications.settings.core.description": "Standard-Benachrichtigungszentrum und Panel-Link für externe Kanäle steuern.",
+  "notifications.settings.core.appUrl": "Anwendungs-URL",
+  "notifications.settings.core.appUrlHint": "Wird verwendet, um absolute Links in E-Mail-Benachrichtigungen zu erstellen.",
+  "notifications.settings.core.panelPath": "Pfad des Benachrichtigungspanels",
+  "notifications.settings.core.panelPathHint": "Relativer Pfad für das schreibgeschützte Benachrichtigungspanel.",
+  "notifications.settings.core.databaseLabel": "In-App-Benachrichtigungen",
+  "notifications.settings.core.databaseHint": "Speichert Benachrichtigungen in der Datenbank für Panel und Glocke.",
+  "notifications.settings.email.title": "E-Mail-Strategie",
+  "notifications.settings.email.description": "Benachrichtigungskopien per Resend mit React-Templates senden.",
+  "notifications.settings.email.enabledLabel": "E-Mail-Zustellung aktivieren",
+  "notifications.settings.email.enabledHint": "E-Mail-Aktionen sind schreibgeschützt und verlinken zurück zum Benachrichtigungszentrum.",
+  "notifications.settings.email.from": "Absenderadresse",
+  "notifications.settings.email.replyTo": "Antwortadresse",
+  "notifications.settings.email.subjectPrefix": "Betreffpräfix"
+}