@open-mercato/core 0.6.6-develop.6529.1.e1de4b3f27 → 0.6.6-develop.6531.1.87e9d31db6

package/src/modules/dictionaries/fields/dictionary.tsx

@@ -90,9 +90,12 @@ function DictionaryFieldDefEditor({ def, onChange }: { def: { configJson?: Dicti
   const [error, setError] = React.useState<string | null>(null)
   const multiId = React.useId()
   const inlineCreateId = React.useId()
+  const inlineCreateHintId = React.useId()
+  const defaultValueHintId = React.useId()
   const selectedId = typeof def?.configJson?.dictionaryId === 'string' ? def?.configJson?.dictionaryId : ''
   const inlineCreate = def?.configJson?.dictionaryInlineCreate !== false
   const isMulti = def?.configJson?.multi === true
+  const inlineCreateDisabled = !selectedId || isMulti
   const errorLoadLabel = t('dictionaries.customFields.errorLoad', 'Failed to load dictionaries.')
 
   React.useEffect(() => {
@@ -181,45 +184,65 @@ function DictionaryFieldDefEditor({ def, onChange }: { def: { configJson?: Dicti
           </a>
         </div>
       ) : null}
-      <div className="inline-flex items-center gap-2 text-xs">
-        <Checkbox
-          id={multiId}
-          checked={isMulti}
-          onCheckedChange={(checked) => {
-            const enabled = checked === true
-            onChange({ multi: enabled, defaultValue: enabled ? undefined : def?.configJson?.defaultValue })
-          }}
-          disabled={!selectedId}
-        />
-        <label
-          htmlFor={multiId}
-          className={selectedId ? 'cursor-pointer select-none' : 'cursor-not-allowed opacity-60'}
-        >
-          {t('dictionaries.customFields.allowMultiple', 'Allow selecting multiple entries')}
-        </label>
-      </div>
-      {!isMulti ? (
-        <div className="inline-flex items-center gap-2 text-xs">
-          <Checkbox
-            id={inlineCreateId}
-            checked={inlineCreate}
-            onCheckedChange={(checked) => onChange({ dictionaryInlineCreate: checked === true })}
-            disabled={!selectedId}
-          />
-          <label
-            htmlFor={inlineCreateId}
-            className={selectedId ? 'cursor-pointer select-none' : 'cursor-not-allowed opacity-60'}
-          >
-            {t('dictionaries.customFields.allowInlineCreate', 'Allow inline creation inside forms')}
-          </label>
+      <div className="space-y-2">
+        <div className="flex flex-col gap-2 sm:flex-row sm:flex-wrap sm:items-center sm:gap-x-4">
+          <div className="inline-flex items-center gap-2 text-xs">
+            <Checkbox
+              id={multiId}
+              checked={isMulti}
+              onCheckedChange={(checked) => {
+                const enabled = checked === true
+                onChange({ multi: enabled, defaultValue: enabled ? undefined : def?.configJson?.defaultValue })
+              }}
+              disabled={!selectedId}
+            />
+            <label
+              htmlFor={multiId}
+              className={selectedId ? 'cursor-pointer select-none' : 'cursor-not-allowed opacity-60'}
+            >
+              {t('dictionaries.customFields.allowMultiple', 'Allow selecting multiple entries')}
+            </label>
+          </div>
+          <div className="inline-flex items-center gap-2 text-xs">
+            <Checkbox
+              id={inlineCreateId}
+              checked={!isMulti && inlineCreate}
+              onCheckedChange={(checked) => onChange({ dictionaryInlineCreate: checked === true })}
+              disabled={inlineCreateDisabled}
+              aria-describedby={isMulti ? inlineCreateHintId : undefined}
+            />
+            <label
+              htmlFor={inlineCreateId}
+              className={!inlineCreateDisabled ? 'cursor-pointer select-none' : 'cursor-not-allowed opacity-60'}
+            >
+              {t('dictionaries.customFields.allowInlineCreate', 'Allow inline creation inside forms')}
+            </label>
+          </div>
         </div>
-      ) : null}
+        {isMulti ? (
+          <p id={inlineCreateHintId} className="text-xs text-muted-foreground">
+            {t(
+              'dictionaries.customFields.inlineCreateSingleOnly',
+              'Inline creation is available for single-entry dictionary fields only.',
+            )}
+          </p>
+        ) : null}
+      </div>
       {selectedId && !isMulti ? (
         <DictionaryDefaultSelector
           dictionaryId={selectedId}
           defaultValue={typeof def?.configJson?.defaultValue === 'string' ? def.configJson.defaultValue : ''}
           onChange={(value) => onChange({ defaultValue: value || undefined })}
         />
+      ) : selectedId && isMulti ? (
+        <div className="inline-flex items-center gap-2 text-xs">
+          <p id={defaultValueHintId} className="text-xs text-muted-foreground">
+            {t(
+              'dictionaries.customFields.defaultValueMultiUnavailable',
+              'Default values are not available for multi-select dictionary fields.',
+            )}
+          </p>
+        </div>
       ) : null}
     </div>
   )

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

@@ -82,6 +82,7 @@
   "dictionaries.customFields.allowInlineCreate": "Inline-Erstellung in Formularen erlauben",
   "dictionaries.customFields.allowMultiple": "Mehrere Einträge auswählen erlauben",
   "dictionaries.customFields.defaultValue": "Standardwert",
+  "dictionaries.customFields.defaultValueMultiUnavailable": "Standardwerte sind für Wörterbuchfelder mit Mehrfachauswahl nicht verfügbar.",
   "dictionaries.customFields.defaultValueNone": "Kein Standardwert",
   "dictionaries.customFields.defaultValueStale": "Standardeintrag nicht gefunden — er wurde möglicherweise gelöscht oder umbenannt.",
   "dictionaries.customFields.dictionaryLabel": "Quelle des Wörterbuchs",
@@ -89,6 +90,7 @@
   "dictionaries.customFields.empty": "Noch keine Wörterbücher verfügbar. Erstellen Sie zuerst eines.",
   "dictionaries.customFields.errorLoad": "Wörterbücher konnten nicht geladen werden.",
   "dictionaries.customFields.inactive": "inaktiv",
+  "dictionaries.customFields.inlineCreateSingleOnly": "Inline-Erstellung ist nur für Wörterbuchfelder mit Einzelauswahl verfügbar.",
   "dictionaries.customFields.loading": "Wörterbücher werden geladen…",
   "dictionaries.customFields.manageLink": "Wörterbücher verwalten",
   "dictionaries.customFields.selectedHint": "Einträge aus diesem Wörterbuch füllen das Feld.",

package/src/modules/dictionaries/i18n/en.json

@@ -82,6 +82,7 @@
   "dictionaries.customFields.allowInlineCreate": "Allow inline creation inside forms",
   "dictionaries.customFields.allowMultiple": "Allow selecting multiple entries",
   "dictionaries.customFields.defaultValue": "Default value",
+  "dictionaries.customFields.defaultValueMultiUnavailable": "Default values are not available for multi-select dictionary fields.",
   "dictionaries.customFields.defaultValueNone": "No default",
   "dictionaries.customFields.defaultValueStale": "Default entry not found — it may have been deleted or renamed.",
   "dictionaries.customFields.dictionaryLabel": "Dictionary source",
@@ -89,6 +90,7 @@
   "dictionaries.customFields.empty": "No dictionaries available yet. Create one first.",
   "dictionaries.customFields.errorLoad": "Failed to load dictionaries.",
   "dictionaries.customFields.inactive": "inactive",
+  "dictionaries.customFields.inlineCreateSingleOnly": "Inline creation is available for single-entry dictionary fields only.",
   "dictionaries.customFields.loading": "Loading dictionaries…",
   "dictionaries.customFields.manageLink": "Manage dictionaries",
   "dictionaries.customFields.selectedHint": "Entries from this dictionary populate the field.",

package/src/modules/dictionaries/i18n/es.json

@@ -82,6 +82,7 @@
   "dictionaries.customFields.allowInlineCreate": "Permitir creación en línea dentro de los formularios",
   "dictionaries.customFields.allowMultiple": "Permitir seleccionar varias entradas",
   "dictionaries.customFields.defaultValue": "Valor predeterminado",
+  "dictionaries.customFields.defaultValueMultiUnavailable": "Los valores predeterminados no están disponibles para campos de diccionario con selección múltiple.",
   "dictionaries.customFields.defaultValueNone": "Sin valor predeterminado",
   "dictionaries.customFields.defaultValueStale": "No se encontró la entrada predeterminada; puede haber sido eliminada o renombrada.",
   "dictionaries.customFields.dictionaryLabel": "Fuente del diccionario",
@@ -89,6 +90,7 @@
   "dictionaries.customFields.empty": "Aún no hay diccionarios disponibles. Crea uno primero.",
   "dictionaries.customFields.errorLoad": "No se pudieron cargar los diccionarios.",
   "dictionaries.customFields.inactive": "inactivo",
+  "dictionaries.customFields.inlineCreateSingleOnly": "La creación en línea solo está disponible para campos de diccionario de una sola entrada.",
   "dictionaries.customFields.loading": "Cargando diccionarios…",
   "dictionaries.customFields.manageLink": "Administrar diccionarios",
   "dictionaries.customFields.selectedHint": "Las entradas de este diccionario rellenarán el campo.",

package/src/modules/dictionaries/i18n/pl.json

@@ -82,6 +82,7 @@
   "dictionaries.customFields.allowInlineCreate": "Zezwól na tworzenie w formularzach",
   "dictionaries.customFields.allowMultiple": "Zezwól na wybór wielu wpisów",
   "dictionaries.customFields.defaultValue": "Wartość domyślna",
+  "dictionaries.customFields.defaultValueMultiUnavailable": "Wartości domyślne nie są dostępne dla wielokrotnego wyboru wpisów słownika.",
   "dictionaries.customFields.defaultValueNone": "Brak wartości domyślnej",
   "dictionaries.customFields.defaultValueStale": "Nie znaleziono domyślnego wpisu — mógł zostać usunięty albo przemianowany.",
   "dictionaries.customFields.dictionaryLabel": "Źródło słownika",
@@ -89,6 +90,7 @@
   "dictionaries.customFields.empty": "Brak dostępnych słowników. Najpierw utwórz jeden.",
   "dictionaries.customFields.errorLoad": "Nie udało się wczytać słowników.",
   "dictionaries.customFields.inactive": "nieaktywne",
+  "dictionaries.customFields.inlineCreateSingleOnly": "Tworzenie wpisów w formularzu jest dostępne tylko dla pól z pojedynczym wyborem.",
   "dictionaries.customFields.loading": "Ładowanie słowników…",
   "dictionaries.customFields.manageLink": "Zarządzaj słownikami",
   "dictionaries.customFields.selectedHint": "Wpisy z tego słownika uzupełnią pole.",

package/src/modules/entities/backend/entities/system/[entityId]/page.meta.ts

@@ -2,6 +2,7 @@ export const metadata = {
   requireAuth: true,
   requireFeatures: ['entities.definitions.manage'],
   pageTitle: 'Edit Definitions',
+  pageTitleKey: 'entities.userEntities.edit.pageTitle',
   pageGroup: 'Data designer',
   navHidden: true,
 }

package/src/modules/entities/backend/entities/user/[entityId]/page.meta.ts

@@ -2,6 +2,7 @@ export const metadata = {
   requireAuth: true,
   requireFeatures: ['entities.definitions.manage'],
   pageTitle: 'Edit Definitions',
+  pageTitleKey: 'entities.userEntities.edit.pageTitle',
   pageGroup: 'Data designer',
   navHidden: true,
 }

package/src/modules/entities/backend/entities/user/[entityId]/page.tsx

@@ -167,7 +167,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         const entJson = await readApiResultOrThrow<EntitiesListResponse>(
           '/api/entities/entities',
           undefined,
-          { errorMessage: 'Failed to load entity metadata', fallback: { items: [] } },
+          { errorMessage: t('entities.userEntities.edit.errors.loadMetadataFailed', 'Failed to load entity metadata'), fallback: { items: [] } },
         )
         const ent = (entJson.items || []).find((x: any) => x.entityId === entityId)
         if (mounted) {
@@ -197,7 +197,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         const json = await readApiResultOrThrow<DefinitionsManageResponse>(
           `/api/entities/definitions.manage?entityId=${encodeURIComponent(entityId)}`,
           undefined,
-          { errorMessage: 'Failed to load entity definitions', fallback: { items: [], deletedKeys: [] } },
+          { errorMessage: t('entities.userEntities.edit.errors.loadDefinitionsFailed', 'Failed to load entity definitions'), fallback: { items: [], deletedKeys: [] } },
         )
         if (mounted) {
           const loaded: Def[] = (json.items || []).map((d: any) => ({ key: d.key, kind: d.kind, configJson: d.configJson || {}, isActive: d.isActive !== false }))
@@ -220,14 +220,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           setSingleFieldsetPerRecord(json.settings?.singleFieldsetPerRecord !== false)
         }
       } catch (e: any) {
-        if (mounted) setError(e.message || 'Failed to load')
+        if (mounted) setError(e.message || t('entities.userEntities.edit.errors.loadFailed', 'Failed to load'))
       } finally {
         if (mounted) setLoading(false)
       }
     }
     if (entityId) load()
     return () => { mounted = false }
-  }, [entityId])
+  }, [entityId, t])
 
   function addField() {
     setDefs((arr) => [
@@ -249,13 +249,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         body: JSON.stringify({ entityId, key }),
       })
       if (!call.ok) {
-        await raiseCrudError(call.response, 'Failed to restore field')
+        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'))
       }
       // Reload definitions & deleted keys
       const j2 = await readApiResultOrThrow<DefinitionsManageResponse>(
         `/api/entities/definitions.manage?entityId=${encodeURIComponent(entityId)}`,
         undefined,
-        { errorMessage: 'Failed to reload field definitions', fallback: { items: [], deletedKeys: [] } },
+        { errorMessage: t('entities.userEntities.edit.errors.reloadDefinitionsFailed', 'Failed to reload field definitions'), fallback: { items: [], deletedKeys: [] } },
       )
       const loaded: Def[] = (j2.items || []).map((d: any) => ({ key: d.key, kind: d.kind, configJson: d.configJson || {}, isActive: d.isActive !== false }))
       loaded.sort(
@@ -264,10 +264,10 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       setDefs(loaded)
       setDefsVersion(readVersionToken(j2.version))
       setDeletedKeys(Array.isArray(j2.deletedKeys) ? j2.deletedKeys : [])
-      flash(`Restored ${key}`, 'success')
+      flash(t('entities.userEntities.edit.flash.restoredField', 'Restored {{key}}', { key }), 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || 'Failed to restore field', 'error')
+      flash(e?.message || t('entities.userEntities.edit.errors.restoreFieldFailed', 'Failed to restore field'), 'error')
     }
   }
 
@@ -276,8 +276,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     setError(null)
     try {
       if (!validateAll()) {
-        flash('Please fix validation errors in field definitions', 'error')
-        throw new Error('Validation failed')
+        flash(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'), 'error')
+        throw new Error(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
       }
       const payload = {
         entityId,
@@ -298,13 +298,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       )
       if (!call.ok) {
         if (surfaceRecordConflict({ status: call.status, body: call.result }, t)) return
-        await raiseCrudError(call.response, 'Failed to save definitions')
+        await raiseCrudError(call.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
       }
       setDefsVersion(readVersionToken(call.result?.version))
       await invalidateCustomFieldDefs(queryClient, entityId)
-      router.push(`/backend/entities/user?flash=Definitions%20saved&type=success`)
+      router.push(`/backend/entities/user?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`)
     } catch (e: any) {
-      setError(e.message || 'Failed to save')
+      setError(e.message || t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
     } finally {
       setSaving(false)
     }
@@ -321,13 +321,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           body: JSON.stringify({ entityId, key: def.key }),
         })
         if (!call.ok) {
-          await raiseCrudError(call.response, 'Failed to delete field')
+          await raiseCrudError(call.response, t('entities.customFields.errors.deleteFailed', 'Failed to delete field.'))
         }
         // Keep the optimistic-lock token in sync after an out-of-band delete so a
         // later Save does not falsely 409 against our own change (issue #3152).
         setDefsVersion(readVersionToken(call.result?.version))
       } catch (error) {
-        const message = error instanceof Error ? error.message : 'Failed to delete field'
+        const message = error instanceof Error ? error.message : t('entities.customFields.errors.deleteFailed', 'Failed to delete field.')
         flash(message, 'error')
         return
       }
@@ -372,7 +372,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     setOrderSaving(true)
     try {
       // Do not save order when there are invalid keys/kinds
-      if (!validateAll()) throw new Error('Validation failed')
+      if (!validateAll()) throw new Error(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
       const payload = {
         entityId,
         definitions: defs.filter(d => !!d.key).map((d) => ({
@@ -396,14 +396,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           setOrderDirty(false)
           return
         }
-        await raiseCrudError(call.response, 'Failed to save order')
+        await raiseCrudError(call.response, t('entities.userEntities.edit.errors.saveOrderFailed', 'Failed to save order'))
       }
       setDefsVersion(readVersionToken(call.result?.version))
       setOrderDirty(false)
-      flash('Order saved', 'success')
+      flash(t('entities.userEntities.edit.flash.orderSaved', 'Order saved'), 'success')
       await invalidateCustomFieldDefs(queryClient, entityId)
     } catch (e: any) {
-      flash(e?.message || 'Failed to save order', 'error')
+      flash(e?.message || t('entities.userEntities.edit.errors.saveOrderFailed', 'Failed to save order'), 'error')
     } finally {
       setOrderSaving(false)
     }
@@ -423,21 +423,21 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
 
   const metadataFieldsReadOnly = entitySource === 'code'
   const fields: CrudField[] = [
-    { id: 'label', label: 'Label', type: 'text', required: true, readOnly: metadataFieldsReadOnly },
-    { id: 'description', label: 'Description', type: 'textarea', readOnly: metadataFieldsReadOnly },
+    { id: 'label', label: t('entities.userEntities.form.label.label', 'Label'), type: 'text', required: true, readOnly: metadataFieldsReadOnly },
+    { id: 'description', label: t('entities.userEntities.form.description.label', 'Description'), type: 'textarea', readOnly: metadataFieldsReadOnly },
     {
       id: 'defaultEditor',
-      label: 'Default Editor (multiline)',
+      label: t('entities.userEntities.form.defaultEditor.label', 'Default Editor (multiline)'),
       type: 'select',
       readOnly: metadataFieldsReadOnly,
       options: [
-        { value: '', label: 'Default (Markdown)' },
-        { value: 'markdown', label: 'Markdown (UIW)' },
-        { value: 'simpleMarkdown', label: 'Simple Markdown' },
-        { value: 'htmlRichText', label: 'HTML Rich Text' },
+        { value: '', label: t('entities.userEntities.form.defaultEditor.options.default', 'Default (Markdown)') },
+        { value: 'markdown', label: t('entities.userEntities.form.defaultEditor.options.markdown', 'Markdown (UIW)') },
+        { value: 'simpleMarkdown', label: t('entities.userEntities.form.defaultEditor.options.simpleMarkdown', 'Simple Markdown') },
+        { value: 'htmlRichText', label: t('entities.userEntities.form.defaultEditor.options.htmlRichText', 'HTML Rich Text') },
       ],
     } as any,
-    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: 'Show in sidebar', type: 'checkbox' }] : []),
+    ...(entitySource === 'custom' ? [{ id: 'showInSidebar', label: t('entities.userEntities.form.showInSidebar.label', 'Show in sidebar'), type: 'checkbox' }] : []),
   ]
   const renderFieldDefinitions = React.useCallback(() => (
       <FieldDefinitionsEditor
@@ -474,7 +474,7 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
           })
           setOrderDirty(true)
         }}
-        orderNotice={orderDirty ? { dirty: true, saving: orderSaving, message: 'Reordered — will auto-save on blur' } : undefined}
+        orderNotice={orderDirty ? { dirty: true, saving: orderSaving, message: t('entities.userEntities.edit.orderNotice', 'Reordered - will auto-save on blur') } : undefined}
         addButtonLabel={t('entities.customFields.editor.addField', 'Add Field')}
         translate={t}
         listRef={listRef}
@@ -491,22 +491,22 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         }}
       />
     ),
-  [defs, defErrors, deletedKeys, fieldsets, activeFieldset, singleFieldsetPerRecord, orderDirty, orderSaving, addField, removeField, restoreField, saveOrderIfDirty])
+  [defs, defErrors, deletedKeys, fieldsets, activeFieldset, singleFieldsetPerRecord, orderDirty, orderSaving, addField, removeField, restoreField, saveOrderIfDirty, t])
 
-  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: 'Field Definitions', column: 1, component: renderFieldDefinitions }
+  const definitionsGroup: CrudFormGroup = { id: 'definitions', title: t('entities.userEntities.edit.groups.definitions', 'Field Definitions'), column: 1, component: renderFieldDefinitions }
 
   const groups: CrudFormGroup[] = [
-    { id: 'settings', title: 'Entity Settings', column: 1, fields: entitySource === 'custom' ? ['label','description','defaultEditor','showInSidebar'] : ['label','description','defaultEditor'] },
+    { id: 'settings', title: t('entities.userEntities.edit.groups.settings', 'Entity Settings'), column: 1, fields: entitySource === 'custom' ? ['label','description','defaultEditor','showInSidebar'] : ['label','description','defaultEditor'] },
     definitionsGroup,
   ]
 
   const handleCrudFormSubmit = React.useCallback(async (vals: Record<string, unknown>) => {
     if (!entityId) {
-      throw createCrudFormError('Invalid entity ID')
+      throw createCrudFormError(t('entities.userEntities.edit.errors.invalidEntityId', 'Invalid entity ID'))
     }
     if (!validateAll()) {
-      flash('Please fix validation errors in field definitions', 'error')
-      throw createCrudFormError('Please fix validation errors in field definitions')
+      flash(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'), 'error')
+      throw createCrudFormError(t('entities.customFields.errors.validation', 'Please fix validation errors in field definitions.'))
     }
     // Code-declared system entities are not registered as custom entities — their
     // metadata is owned by code and `POST /api/entities/entities` is fail-closed for
@@ -514,14 +514,14 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
     // skip the registration call and persist definitions below.
     if (shouldRegisterEntityMetadata(entitySource)) {
       const entityPayload = buildEntityMetadataPayload(entitySource, vals)
-      if (!entityPayload) throw createCrudFormError('Validation failed')
+      if (!entityPayload) throw createCrudFormError(t('entities.userEntities.edit.errors.validationFailed', 'Validation failed'))
       const callEntity = await apiCall('/api/entities/entities', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({ entityId, ...entityPayload }),
       })
       if (!callEntity.ok) {
-        await raiseCrudError(callEntity.response, 'Failed to save entity')
+        await raiseCrudError(callEntity.response, t('entities.userEntities.edit.errors.saveEntityFailed', 'Failed to save entity'))
       }
       try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
     }
@@ -543,13 +543,13 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       }),
     )
     if (!callDefs.ok) {
-      await raiseCrudError(callDefs.response, 'Failed to save definitions')
+      await raiseCrudError(callDefs.response, t('entities.customFields.errors.saveFailed', 'Failed to save field definitions.'))
     }
     setDefsVersion(readVersionToken(callDefs.result?.version))
     try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
     await invalidateCustomFieldDefs(queryClient, entityId)
-    flash('Definitions saved', 'success')
-  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, validateAll])
+    flash(t('entities.customFields.flash.saved', 'Definitions saved'), 'success')
+  }, [buildFieldsetPayload, defs, defsVersion, entityId, entitySource, queryClient, singleFieldsetPerRecord, t, validateAll])
 
   if (!entityId) {
     return (
@@ -557,8 +557,8 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
         <PageBody>
           <div className="p-6">
             <Alert variant="destructive">
-              <AlertTitle>Invalid entity</AlertTitle>
-              <AlertDescription>The requested entity ID is missing or invalid.</AlertDescription>
+              <AlertTitle>{t('entities.userEntities.edit.errors.invalidEntityTitle', 'Invalid entity')}</AlertTitle>
+              <AlertDescription>{t('entities.userEntities.edit.errors.invalidEntityDescription', 'The requested entity ID is missing or invalid.')}</AlertDescription>
             </Alert>
           </div>
         </PageBody>
@@ -571,12 +571,12 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <div className="p-4">
         <CrudForm
           schema={entityFormSchema}
-          title={`Edit fieldset: ${requestedFieldset ?? entityId}`}
+          title={t('entities.userEntities.edit.fieldsetTitle', 'Edit fieldset: {{name}}', { name: requestedFieldset ?? entityId })}
           fields={[]}
           groups={[definitionsGroup]}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel="Save"
+          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
           deleteVisible={false}
           backHref={undefined}
           cancelHref={undefined}
@@ -592,30 +592,32 @@ export default function EditDefinitionsPage({ params }: { params?: { entityId?:
       <PageBody>
         <CrudForm
           schema={entityFormSchema}
-          title={`Edit Entity: ${entityId}`}
+          title={t('entities.userEntities.edit.title', 'Edit Entity: {{entityId}}', { entityId })}
           backHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
           fields={fields}
           groups={groups}
           initialValues={entityInitial as any}
           isLoading={entityFormLoading || loading}
-          submitLabel="Save"
+          submitLabel={t('entities.userEntities.records.form.submitSave', 'Save')}
           deleteVisible={entitySource === 'custom'}
           extraActions={entitySource === 'custom' ? (
             <Button variant="outline" asChild>
               <Link href={`/backend/entities/user/${encodeURIComponent(entityId)}/records`}>
-                Show Records
+                {t('entities.userEntities.edit.showRecords', 'Show Records')}
               </Link>
             </Button>
           ) : null}
           cancelHref={entitySource === 'code' ? "/backend/entities/system" : "/backend/entities/user"}
-          successRedirect={entitySource === 'code' ? "/backend/entities/system?flash=Definitions%20saved&type=success" : "/backend/entities/user?flash=Definitions%20saved&type=success"}
+          successRedirect={entitySource === 'code'
+            ? `/backend/entities/system?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`
+            : `/backend/entities/user?flash=${encodeURIComponent(t('entities.customFields.flash.saved', 'Definitions saved'))}&type=success`}
           onSubmit={handleCrudFormSubmit}
         onDelete={entitySource === 'custom' ? async () => {
           const callDelete = await apiCall('/api/entities/entities', { method: 'DELETE', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ entityId }) })
           if (!callDelete.ok) {
-            await raiseCrudError(callDelete.response, 'Failed to delete entity')
+            await raiseCrudError(callDelete.response, t('entities.userEntities.edit.errors.deleteEntityFailed', 'Failed to delete entity'))
           }
-          flash('Entity deleted', 'success')
+          flash(t('entities.userEntities.edit.flash.entityDeleted', 'Entity deleted'), 'success')
           try { window.dispatchEvent(new Event('om:refresh-sidebar')) } catch {}
         } : undefined}
       />

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

@@ -93,6 +93,7 @@
   "entities.customFields.editor.noFieldsets": "Noch keine Feldgruppen definiert. Mit Feldgruppen lassen sich benutzerdefinierte Felder für verschiedene Varianten derselben Entität gruppieren (z. B. Mode- vs. Sportprodukte).",
   "entities.customFields.editor.noGroup": "Keine Gruppe",
   "entities.customFields.editor.noOptionsDefined": "Keine Optionen definiert.",
+  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "Keine Validierungsregeln definiert.",
   "entities.customFields.editor.optionLabelPlaceholder": "Für Benutzer sichtbare Beschriftung (optional)",
   "entities.customFields.editor.options": "Optionen",
@@ -118,6 +119,17 @@
   "entities.customFields.editor.unassignedFields": "Nicht zugewiesene Felder",
   "entities.customFields.editor.unitsOptional": "Einheiten (optional)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm usw.",
+  "entities.customFields.editor.validation.date": "Datum",
+  "entities.customFields.editor.validation.eq": "gleich",
+  "entities.customFields.editor.validation.float": "Gleitkommazahl",
+  "entities.customFields.editor.validation.gt": "größer als",
+  "entities.customFields.editor.validation.gte": "größer oder gleich",
+  "entities.customFields.editor.validation.integer": "Ganzzahl",
+  "entities.customFields.editor.validation.lt": "kleiner als",
+  "entities.customFields.editor.validation.lte": "kleiner oder gleich",
+  "entities.customFields.editor.validation.ne": "ungleich",
+  "entities.customFields.editor.validation.regex": "Regex",
+  "entities.customFields.editor.validation.required": "erforderlich",
   "entities.customFields.editor.validationRules": "Validierungsregeln",
   "entities.customFields.editor.value": "Wert",
   "entities.customFields.editor.valueRequired": "Der Wert ist erforderlich",
@@ -183,6 +195,28 @@
   "entities.nav.systemEntities": "Systementitäten",
   "entities.nav.userEntities": "Benutzerentitäten",
   "entities.nav.userEntities.create": "Entität erstellen",
+  "entities.userEntities.edit.errors.deleteEntityFailed": "Entität konnte nicht gelöscht werden",
+  "entities.userEntities.edit.errors.invalidEntityDescription": "Die angeforderte Entitäts-ID fehlt oder ist ungültig.",
+  "entities.userEntities.edit.errors.invalidEntityId": "Ungültige Entitäts-ID",
+  "entities.userEntities.edit.errors.invalidEntityTitle": "Ungültige Entität",
+  "entities.userEntities.edit.errors.loadDefinitionsFailed": "Entitätsdefinitionen konnten nicht geladen werden",
+  "entities.userEntities.edit.errors.loadFailed": "Laden fehlgeschlagen",
+  "entities.userEntities.edit.errors.loadMetadataFailed": "Entitätsmetadaten konnten nicht geladen werden",
+  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "Felddefinitionen konnten nicht neu geladen werden",
+  "entities.userEntities.edit.errors.restoreFieldFailed": "Feld konnte nicht wiederhergestellt werden",
+  "entities.userEntities.edit.errors.saveEntityFailed": "Entität konnte nicht gespeichert werden",
+  "entities.userEntities.edit.errors.saveOrderFailed": "Reihenfolge konnte nicht gespeichert werden",
+  "entities.userEntities.edit.errors.validationFailed": "Validierung fehlgeschlagen",
+  "entities.userEntities.edit.fieldsetTitle": "Feldgruppe bearbeiten: {{name}}",
+  "entities.userEntities.edit.flash.entityDeleted": "Entität gelöscht",
+  "entities.userEntities.edit.flash.orderSaved": "Reihenfolge gespeichert",
+  "entities.userEntities.edit.flash.restoredField": "{{key}} wiederhergestellt",
+  "entities.userEntities.edit.groups.definitions": "Felddefinitionen",
+  "entities.userEntities.edit.groups.settings": "Entitätseinstellungen",
+  "entities.userEntities.edit.orderNotice": "Neu angeordnet - wird beim Verlassen gespeichert",
+  "entities.userEntities.edit.pageTitle": "Definitionen bearbeiten",
+  "entities.userEntities.edit.showRecords": "Datensätze anzeigen",
+  "entities.userEntities.edit.title": "Entität bearbeiten: {{entityId}}",
   "entities.userEntities.errors.entityIdExists": "Entitäts-ID ist bereits vorhanden",
   "entities.userEntities.errors.entityIdRequired": "Entitäts-ID ist erforderlich",
   "entities.userEntities.errors.loadFailed": "Entitäten konnten nicht geladen werden",

package/src/modules/entities/i18n/en.json

@@ -93,6 +93,7 @@
   "entities.customFields.editor.noFieldsets": "No fieldsets defined yet. Fieldsets let you group custom fields for different variants of the same entity (e.g., Fashion vs. Sport products).",
   "entities.customFields.editor.noGroup": "No group",
   "entities.customFields.editor.noOptionsDefined": "No options defined.",
+  "entities.customFields.editor.noParameterPlaceholder": "-",
   "entities.customFields.editor.noValidationRules": "No validation rules defined.",
   "entities.customFields.editor.optionLabelPlaceholder": "Label shown to users (optional)",
   "entities.customFields.editor.options": "Options",
@@ -118,6 +119,17 @@
   "entities.customFields.editor.unassignedFields": "Unassigned fields",
   "entities.customFields.editor.unitsOptional": "Units (optional)",
   "entities.customFields.editor.unitsPlaceholder": "kg, cm, etc.",
+  "entities.customFields.editor.validation.date": "date",
+  "entities.customFields.editor.validation.eq": "eq",
+  "entities.customFields.editor.validation.float": "float",
+  "entities.customFields.editor.validation.gt": "gt",
+  "entities.customFields.editor.validation.gte": "gte",
+  "entities.customFields.editor.validation.integer": "integer",
+  "entities.customFields.editor.validation.lt": "lt",
+  "entities.customFields.editor.validation.lte": "lte",
+  "entities.customFields.editor.validation.ne": "ne",
+  "entities.customFields.editor.validation.regex": "regex",
+  "entities.customFields.editor.validation.required": "required",
   "entities.customFields.editor.validationRules": "Validation rules",
   "entities.customFields.editor.value": "Value",
   "entities.customFields.editor.valueRequired": "Value is required",
@@ -183,6 +195,28 @@
   "entities.nav.systemEntities": "System Entities",
   "entities.nav.userEntities": "User Entities",
   "entities.nav.userEntities.create": "Create Entity",
+  "entities.userEntities.edit.errors.deleteEntityFailed": "Failed to delete entity",
+  "entities.userEntities.edit.errors.invalidEntityDescription": "The requested entity ID is missing or invalid.",
+  "entities.userEntities.edit.errors.invalidEntityId": "Invalid entity ID",
+  "entities.userEntities.edit.errors.invalidEntityTitle": "Invalid entity",
+  "entities.userEntities.edit.errors.loadDefinitionsFailed": "Failed to load entity definitions",
+  "entities.userEntities.edit.errors.loadFailed": "Failed to load",
+  "entities.userEntities.edit.errors.loadMetadataFailed": "Failed to load entity metadata",
+  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "Failed to reload field definitions",
+  "entities.userEntities.edit.errors.restoreFieldFailed": "Failed to restore field",
+  "entities.userEntities.edit.errors.saveEntityFailed": "Failed to save entity",
+  "entities.userEntities.edit.errors.saveOrderFailed": "Failed to save order",
+  "entities.userEntities.edit.errors.validationFailed": "Validation failed",
+  "entities.userEntities.edit.fieldsetTitle": "Edit fieldset: {{name}}",
+  "entities.userEntities.edit.flash.entityDeleted": "Entity deleted",
+  "entities.userEntities.edit.flash.orderSaved": "Order saved",
+  "entities.userEntities.edit.flash.restoredField": "Restored {{key}}",
+  "entities.userEntities.edit.groups.definitions": "Field Definitions",
+  "entities.userEntities.edit.groups.settings": "Entity Settings",
+  "entities.userEntities.edit.orderNotice": "Reordered - will auto-save on blur",
+  "entities.userEntities.edit.pageTitle": "Edit definitions",
+  "entities.userEntities.edit.showRecords": "Show Records",
+  "entities.userEntities.edit.title": "Edit Entity: {{entityId}}",
   "entities.userEntities.errors.entityIdExists": "Entity ID already exists",
   "entities.userEntities.errors.entityIdRequired": "Entity ID is required",
   "entities.userEntities.errors.loadFailed": "Failed to load entities",