@dev.smartpricing/message-composer-layer 4.5.1-next.2 → 5.0.0-automations.0

package/app/utils/filters/rows.ts

@@ -0,0 +1,367 @@
+import { CONDITION_OPERATORS_BY_FIELD_TYPE } from '@dev.smartpricing/message-composer-utils/types'
+import type {
+  Condition,
+  ConditionFieldType,
+  ConditionOperator,
+  FilterField,
+  FilterOptionValue,
+  FilterUnavailableReason,
+  FiltersReport,
+} from '@dev.smartpricing/message-composer-utils/types'
+
+/**
+ * The filter components' own model (ADR 0018): a list of Conditions seen as
+ * rows, one per field. Internal: "between" as one row, prices in units and
+ * the rows themselves never leave the components.
+ */
+
+/**
+ * The operators of a row: the engine's, plus "between", a pair of Conditions.
+ * There is no "not between": the engine holds all the Conditions of a list
+ * together, and no pair of them says "outside this range".
+ */
+export type FilterRowOperator = ConditionOperator | 'between'
+
+/** Select: one option. Multiselect: a list. Number, price: a number. Date: `YYYY-MM-DD`. Text: a string. */
+export type FilterRowValue = FilterOptionValue | FilterOptionValue[] | undefined
+
+/** A row with no field picked yet. Never emitted, and not half-filled either. */
+export interface FilterBlankRow {
+  kind: 'blank'
+  id: number
+}
+
+export interface FilterEditableRow {
+  kind: 'editable'
+  id: number
+  field: string
+  type: ConditionFieldType
+  operator: FilterRowOperator
+  /** The value, or the lower bound of "between". A price is in units, not cents. */
+  value: FilterRowValue
+  /** The upper bound of "between". */
+  to: FilterRowValue
+  /**
+   * The Conditions the row was read from, until the user edits it: an
+   * untouched row is emitted exactly as it came in.
+   */
+  original?: Condition[]
+}
+
+/** A Condition the editor cannot edit: shown locked, emitted as it is. */
+export interface FilterUnavailableRow {
+  kind: 'unavailable'
+  id: number
+  reason: FilterUnavailableReason
+  condition: Condition
+}
+
+export type FilterRow = FilterBlankRow | FilterEditableRow | FilterUnavailableRow
+
+const ORDERED_TYPES: readonly ConditionFieldType[] = ['number', 'price', 'date']
+
+function isOrdered(type: ConditionFieldType): boolean {
+  return ORDERED_TYPES.includes(type)
+}
+
+/** The operators a row on a field of this type offers, in display order. */
+export function filterRowOperators(type: ConditionFieldType): FilterRowOperator[] {
+  const operators: FilterRowOperator[] = [...CONDITION_OPERATORS_BY_FIELD_TYPE[type]]
+  if (!isOrdered(type)) return operators
+  // "Is set" stays last.
+  operators.splice(operators.indexOf('exists'), 0, 'between')
+  return operators
+}
+
+export function isFilterRange(operator: FilterRowOperator): boolean {
+  return operator === 'between'
+}
+
+function isOptionValue(value: unknown): value is FilterOptionValue {
+  return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value))
+}
+
+function isIsoDate(value: unknown): value is string {
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false
+  const date = new Date(`${value}T00:00:00Z`)
+  // "2026-02-31" parses, as the 3rd of March.
+  return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)
+}
+
+/** The row value of a stored one, or `undefined` when it does not fit the type. */
+function readValue(type: ConditionFieldType, value: unknown): FilterRowValue {
+  switch (type) {
+    case 'select':
+      return isOptionValue(value) ? value : undefined
+    case 'multiselect':
+      return Array.isArray(value) && value.every(isOptionValue) ? [...value] : undefined
+    case 'number':
+      return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+    case 'price':
+      return typeof value === 'number' && Number.isFinite(value) ? value / 100 : undefined
+    case 'date':
+      return isIsoDate(value) ? value : undefined
+    case 'text':
+      return typeof value === 'string' ? value : undefined
+  }
+}
+
+function writeValue(type: ConditionFieldType, value: FilterRowValue): unknown {
+  return type === 'price' ? Math.round((value as number) * 100) : value
+}
+
+function isComplete(type: ConditionFieldType, value: FilterRowValue): boolean {
+  switch (type) {
+    case 'select':
+      return isOptionValue(value) && value !== ''
+    case 'multiselect':
+      return Array.isArray(value) && value.length > 0
+    case 'number':
+    case 'price':
+      return typeof value === 'number' && Number.isFinite(value)
+    case 'date':
+      return isIsoDate(value)
+    case 'text':
+      return typeof value === 'string' && value !== ''
+  }
+}
+
+/** Numbers compare as numbers, ISO dates as strings. */
+function isAtMost(a: FilterRowValue, b: FilterRowValue): boolean {
+  return (a as number) <= (b as number)
+}
+
+type RowContent = Pick<FilterEditableRow, 'operator' | 'value' | 'to'>
+
+function readSingle(field: FilterField, condition: Condition): RowContent | undefined {
+  const operators: readonly ConditionOperator[] = CONDITION_OPERATORS_BY_FIELD_TYPE[field.type]
+  if (!operators.includes(condition.operator)) return undefined
+  if (condition.operator === 'exists') {
+    return { operator: 'exists', value: undefined, to: undefined }
+  }
+
+  const value = readValue(field.type, condition.value)
+  if (value === undefined) return undefined
+  return { operator: condition.operator, value, to: undefined }
+}
+
+/**
+ * "Between" is `gte` the lower bound and `lte` the upper one. A `gte` above
+ * its `lte` is no range: the two are read one by one.
+ */
+function readPair(
+  field: FilterField,
+  first: Condition | undefined,
+  second: Condition | undefined,
+): RowContent | undefined {
+  if (!first || !second || !isOrdered(field.type)) return undefined
+
+  const gte = [first, second].find((condition) => condition.operator === 'gte')
+  const lte = [first, second].find((condition) => condition.operator === 'lte')
+  if (!gte || !lte) return undefined
+
+  const from = readValue(field.type, gte.value)
+  const until = readValue(field.type, lte.value)
+  if (from === undefined || until === undefined) return undefined
+
+  return isAtMost(from, until) ? { operator: 'between', value: from, to: until } : undefined
+}
+
+/**
+ * The rows of a list of Conditions, in the order the Conditions are in. No
+ * Condition is left out: one the editor cannot edit is an unavailable row.
+ * A field gets one editable row, from its first two Conditions when they are
+ * a "between", else from the first one that can be edited.
+ */
+export function conditionsToFilterRows(
+  conditions: readonly Condition[],
+  fields: readonly FilterField[],
+  nextId: () => number,
+): FilterRow[] {
+  const fieldsByKey = new Map(fields.map((field) => [field.key, field]))
+
+  const indexesByField = new Map<string, number[]>()
+  conditions.forEach((condition, index) => {
+    const indexes = indexesByField.get(condition.field) ?? []
+    indexes.push(index)
+    indexesByField.set(condition.field, indexes)
+  })
+
+  // By the index of the Condition a row starts at; `null` for the second of a pair.
+  const editable = new Map<number, (RowContent & { original: Condition[] }) | null>()
+  for (const [key, indexes] of indexesByField) {
+    const field = fieldsByKey.get(key)
+    if (!field) continue
+
+    const [first, second] = indexes as [number, number | undefined]
+    const pair = readPair(
+      field,
+      conditions[first],
+      second === undefined ? undefined : conditions[second],
+    )
+    if (pair && second !== undefined) {
+      editable.set(first, { ...pair, original: [conditions[first]!, conditions[second]!] })
+      editable.set(second, null)
+      continue
+    }
+
+    for (const index of indexes) {
+      const single = readSingle(field, conditions[index]!)
+      if (!single) continue
+      editable.set(index, { ...single, original: [conditions[index]!] })
+      break
+    }
+  }
+
+  const rows: FilterRow[] = []
+  conditions.forEach((condition, index) => {
+    const content = editable.get(index)
+    if (content === null) return
+
+    const field = fieldsByKey.get(condition.field)
+    if (content && field) {
+      rows.push({ kind: 'editable', id: nextId(), field: field.key, type: field.type, ...content })
+      return
+    }
+    rows.push({
+      kind: 'unavailable',
+      id: nextId(),
+      reason: field ? 'not_editable' : 'unknown_field',
+      condition,
+    })
+  })
+  return rows
+}
+
+/** The Conditions of an editable row; `null` while it is half-filled. */
+export function filterRowToConditions(row: FilterEditableRow): Condition[] | null {
+  if (row.original) return row.original
+
+  const { field, type, operator } = row
+  if (operator === 'exists') return [{ field, operator }]
+
+  if (!isFilterRange(operator)) {
+    if (!isComplete(type, row.value)) return null
+    return [{ field, operator: operator as ConditionOperator, value: writeValue(type, row.value) }]
+  }
+
+  if (!isComplete(type, row.value) || !isComplete(type, row.to)) return null
+  // Whichever way round the user typed them.
+  const [lower, upper] = isAtMost(row.value, row.to) ? [row.value, row.to] : [row.to, row.value]
+  return [
+    { field, operator: 'gte', value: writeValue(type, lower) },
+    { field, operator: 'lte', value: writeValue(type, upper) },
+  ]
+}
+
+/** What the rows are worth as Conditions. Blank and half-filled rows are left out. */
+export function filterRowsToConditions(rows: readonly FilterRow[]): Condition[] {
+  return rows.flatMap((row) => {
+    if (row.kind === 'unavailable') return [row.condition]
+    if (row.kind === 'editable') return filterRowToConditions(row) ?? []
+    return []
+  })
+}
+
+/** The option values a row holds that its field's `options` do not list. */
+export function missingFilterOptions(
+  row: FilterEditableRow,
+  field: FilterField | undefined,
+): FilterOptionValue[] {
+  if (row.operator === 'exists') return []
+  if (row.type !== 'select' && row.type !== 'multiselect') return []
+
+  const known = new Set((field?.options ?? []).map((option) => option.value))
+  const selected = Array.isArray(row.value) ? row.value : [row.value]
+  return selected.filter(
+    (value): value is FilterOptionValue => value !== undefined && value !== '' && !known.has(value),
+  )
+}
+
+export function reportFilterRows(
+  rows: readonly FilterRow[],
+  fields: readonly FilterField[],
+): FiltersReport {
+  const fieldsByKey = new Map(fields.map((field) => [field.key, field]))
+  const report: FiltersReport = {
+    unknownFields: [],
+    unavailable: [],
+    unavailableOptions: [],
+    halfFilled: 0,
+  }
+
+  for (const row of rows) {
+    if (row.kind === 'unavailable') {
+      report.unavailable.push({ condition: row.condition, reason: row.reason })
+      const { field } = row.condition
+      if (row.reason === 'unknown_field' && !report.unknownFields.includes(field)) {
+        report.unknownFields.push(field)
+      }
+    } else if (row.kind === 'editable') {
+      if (filterRowToConditions(row) === null) report.halfFilled += 1
+      for (const value of missingFilterOptions(row, fieldsByKey.get(row.field))) {
+        report.unavailableOptions.push({ field: row.field, value })
+      }
+    }
+  }
+  return report
+}
+
+/** A row on a field the user just picked: its first operator, no value. */
+export function newFilterRow(id: number, field: FilterField): FilterEditableRow {
+  return {
+    kind: 'editable',
+    id,
+    field: field.key,
+    type: field.type,
+    operator: filterRowOperators(field.type)[0]!,
+    value: field.type === 'multiselect' ? [] : undefined,
+    to: undefined,
+  }
+}
+
+/** The row under another operator: a value is kept wherever it still means something. */
+export function withFilterOperator(
+  row: FilterEditableRow,
+  operator: FilterRowOperator,
+): FilterEditableRow {
+  return {
+    ...row,
+    operator,
+    to: isFilterRange(operator) ? row.to : undefined,
+    original: undefined,
+  }
+}
+
+/** The locale key of an operator's label, under `filters.operators`. */
+export const FILTER_OPERATOR_LABEL_KEYS: Record<FilterRowOperator, string> = {
+  eq: 'is',
+  neq: 'is_not',
+  gt: 'is_more',
+  gte: 'is_at_least',
+  lt: 'is_less',
+  lte: 'is_at_most',
+  between: 'is_between',
+  in: 'in',
+  not_in: 'not_in',
+  contains: 'contains',
+  exclude: 'does_not_contain',
+  exists: 'is_set',
+}
+
+/** A stored value the components cannot label, as it is. */
+export function rawConditionValue(value: unknown): string {
+  if (value === undefined) return ''
+  return typeof value === 'string' ? value : JSON.stringify(value)
+}
+
+/** The currency to show prices in: the caller's, or EUR when `Intl` does not take it. */
+export function filterCurrency(currency: string | undefined): string {
+  if (!currency) return 'EUR'
+  try {
+    new Intl.NumberFormat('en', { style: 'currency', currency })
+    return currency
+  } catch {
+    return 'EUR'
+  }
+}

package/app/utils/testIds.const.ts

@@ -519,7 +519,6 @@ export const templateListTableTestIds = {
   paginationSummary: 'template-list-table-pagination-summary',
   card: 'template-list-table-card',
   table: 'template-list-table-table',
-  loading: 'template-list-table-loading',
   rowName: 'template-list-table-row-name',
   rowInternalBadge: 'template-list-table-row-internal-badge',
   rowCategoryBadge: 'template-list-table-row-category-badge',

package/i18n/locales/de.ts

@@ -1,4 +1,226 @@
 export default {
+  automations: {
+    action: {
+      at: 'Um',
+      itIsSent: 'Wird gesendet',
+    },
+    actions: {
+      addChannel: 'Nachricht hinzufügen',
+    },
+    advanced: 'Erweitert',
+    audienceAll: 'Alle Gäste',
+    audienceSpecific: 'Spezifisch',
+    channel: {
+      addTitle: 'Neue Nachricht',
+      cannotFindMessage: 'Brauchen Sie eine andere Nachricht?',
+      category: 'Nachrichten',
+      channelType: 'Nachrichtentyp',
+      chooseDays: 'Tage',
+      createNew: 'Neu erstellen',
+      editTitle: 'Nachricht bearbeiten',
+      no_message: {
+        description:
+          'Wählen Sie eine Nachricht aus oder erstellen Sie eine neue, um hier die Vorschau zu sehen',
+        title: 'Keine Vorschau',
+      },
+      preview: 'Vorschau',
+      searchMessagePlaceholder: 'Nach einer Nachricht suchen',
+      selectMessage: 'Nachricht',
+      selectMessageHint:
+        'Nachrichten im Status „Entwurf“ sind in der Liste nicht sichtbar und können nicht ausgewählt werden.',
+      selectMessagePlaceholder: 'Wählen Sie eine Nachricht',
+      sendingTime: 'Sendezeit',
+      when: 'Geplantes Senden',
+      whenHint:
+        'Diese Planung ist nicht an den Check-out-Aktion in Ihrem Property Management System (PMS) gebunden.',
+    },
+    channels: {
+      email: 'E-Mail',
+      whatsapp: 'WhatsApp',
+    },
+    clone: {
+      namePlaceholder: 'Name der Automatisierung',
+      title: 'Automatisierung duplizieren',
+    },
+    delete: {
+      confirm:
+        'Möchtest du diese Automatisierung löschen? Nach dem Löschen kann sie nicht wiederhergestellt werden.',
+      messages: 'Auch ihre Nachrichten löschen',
+      title: 'Automatisierung löschen',
+      warning:
+        'Eine Nachricht kann von anderen Automatisierungen verwendet werden: Beim Löschen wird sie auch dort entfernt.',
+    },
+    editTitle: 'Automatisierung bearbeiten',
+    form: {
+      actions: {
+        deleteConfirm: 'Nachricht löschen',
+        deleteConfirmDescription:
+          'Sind Sie sicher, dass Sie die Nachricht löschen möchten? Sie können sie jederzeit wieder hinzufügen.',
+        empty:
+          'Es wurde noch keine Nachricht hinzugefügt. Klicken Sie auf die Schaltfläche, um eine zu erstellen.',
+        emptyHint:
+          'Wählen Sie, wie Sie mit Ihrer Zielgruppe kommunizieren, indem Sie die richtigen Nachrichten hinzufügen.',
+      },
+      addFilters: 'Filter hinzufügen',
+      changeTrigger: {
+        confirm: 'Ändern',
+        message:
+          'Wenn Sie den Auslöser ändern, werden Ihre Nachrichten und Zielgruppe zurückgesetzt.',
+        title: 'Auslöser ändern?',
+      },
+      create: 'Erstellen',
+      create_specific_audience: 'Eine bestimmte Zielgruppe erstellen',
+      create_specific_audience_hint:
+        'Nutzen Sie Filter, um die Nachricht an eine zielgerichtete Zielgruppe zu senden.',
+      data: {
+        requiredBadge: 'Pflichtdaten',
+        title: 'Daten',
+      },
+      error_banner: 'Bitte füllen Sie alle Pflichtfelder aus',
+      includeIf: 'Gäste einschließen, wenn...',
+      messages: 'Nachrichten',
+      name: 'Name',
+      namePlaceholder: 'Marketplace bewerben',
+      required: 'Erforderlich',
+      sendToHint:
+        'Nutzen Sie Filter, um die Nachricht an eine zielgerichtete Zielgruppe zu senden.',
+      sendTo_all: 'Alle Gäste',
+      sendTotitle: 'Zielgruppe',
+      title: 'Details',
+      trigger: 'Auslöser',
+    },
+    gate: {
+      catalog_failed_description:
+        'Beim Laden der für diese Seite benötigten Daten ist ein Fehler aufgetreten. Versuche es erneut.',
+      catalog_failed_title: 'Die Automatisierungen konnten nicht geladen werden',
+      load_failed_description:
+        'Beim Laden dieser Automatisierung ist ein Fehler aufgetreten. Versuche es erneut.',
+      load_failed_title: 'Die Automatisierung konnte nicht geladen werden',
+      no_catalog_description:
+        'In diesem Produkt gibt es noch nichts, woraus eine Automatisierung erstellt werden kann. Wende dich an den Support, wenn du sie hier erwartet hast.',
+      no_catalog_title: 'Automatisierungen sind hier nicht verfügbar',
+      no_context_description:
+        'Diese Seite hat nicht erhalten, was sie zum Funktionieren braucht. Lade die Seite neu; wenn es erneut passiert, wende dich an den Support.',
+      no_context_title: 'Automatisierungen können nicht angezeigt werden',
+      no_organization_description:
+        'Automatisierungen gehören zu einer Organisation, und es ist keine ausgewählt.',
+      no_organization_title: 'Keine Organisation zum Arbeiten',
+      not_found_description:
+        'Sie wurde möglicherweise gelöscht oder gehört zu einer anderen Organisation oder einem anderen Produkt.',
+      not_found_title: 'Automatisierung nicht gefunden',
+    },
+    immediately: 'Sofort {moment}',
+    list: {
+      active: 'Aktiv',
+      allChannels: 'Alle Nachrichten',
+      allStatuses: 'Alle Status',
+      allTriggers: 'Alle Auslöser',
+      empty: 'Keine Automatisierungen gefunden',
+      headers: {
+        audience: 'Zielgruppe',
+        channels: 'Nachrichten',
+        createdAt: 'Erstellt am',
+        name: 'Name',
+        status: 'Status',
+        trigger: 'Auslöser',
+      },
+      inactive: 'Inaktiv',
+      search: 'Nach Namen suchen',
+    },
+    nDays: '{count} Tage {moment}',
+    new: 'Neue Automatisierung',
+    newTitle: 'Automatisierung erstellen',
+    oneDay: '1 Tag {moment}',
+    preventDuplicates: {
+      hint: 'Senden überspringen, wenn diese Nachricht bereits an denselben Empfänger zur selben Zeit gesendet oder geplant wurde',
+      label: 'Doppelte Nachrichten verhindern',
+    },
+    problems: {
+      action_channel_not_in_catalog:
+        '"{name}": Dieser Nachrichtentyp kann mit diesem Auslöser nicht verwendet werden.',
+      action_date_reference_not_in_catalog:
+        '"{name}": Der Zeitpunkt, zu dem diese Nachricht geplant ist, ist nicht mehr verfügbar. Wählen Sie einen anderen.',
+      action_invalid:
+        '"{name}": Diese Nachricht ist aktiv, aber nicht in jeder Sprache genehmigt. Deaktivieren Sie sie oder wählen Sie eine genehmigte Nachricht, um zu speichern.',
+      action_not_found: '"{name}": Diese Nachricht existiert nicht mehr. Wählen Sie eine andere.',
+      action_other_organization:
+        '"{name}": Diese Nachricht gehört zu einer anderen Organisation. Wählen Sie eine andere.',
+      condition_field_not_in_catalog:
+        'Ein Filter bezieht sich auf "{field}", das nicht mehr verfügbar ist. Entfernen Sie ihn, um zu speichern.',
+      condition_operator_not_allowed:
+        'Der Filter auf "{field}" verwendet einen Vergleich, der hier nicht möglich ist. Ändern oder entfernen Sie ihn, um zu speichern.',
+      show: 'Anzeigen',
+      title: 'Diese Automatisierung kann noch nicht gespeichert werden',
+      trigger_not_in_catalog: 'Der Auslöser ist nicht mehr verfügbar. Wählen Sie einen anderen.',
+      unknown:
+        'Etwas in dieser Automatisierung kann nicht gespeichert werden. Bitte prüfen und erneut versuchen.',
+    },
+    recurrence: {
+      daily: 'Täglich',
+      label: 'Wiederholung',
+      monthly: 'Monatlich',
+      none: 'Keine',
+      yearly: 'Jährlich',
+    },
+    strictDelay: {
+      hint: 'Nachrichten überspringen, wenn die geplante Zeit bereits verstrichen ist',
+      label: 'Strikte Verzögerung',
+    },
+    system: {
+      alert:
+        'Dies ist eine Systemautomatisierung. Sie können nur ihre Nachrichten aktivieren oder deaktivieren und die angeforderten Daten ausfüllen. Duplizieren Sie sie, um eine vollständig bearbeitbare Kopie zu erstellen.',
+      badge: 'Systemautomatisierung',
+      tooltip: 'Nur die Nachrichtenaktivierung und die angeforderten Daten können geändert werden',
+    },
+    title: 'Automatisierungen',
+    toast: {
+      cloned: 'Automatisierung erfolgreich dupliziert',
+      created: 'Automatisierung erfolgreich erstellt',
+      deleted: 'Automatisierung erfolgreich gelöscht',
+      deleted_messages: 'Mit ihr gelöschte Nachrichten: {names}',
+      kept_messages: 'Nachrichten, die nicht gelöscht werden konnten und erhalten bleiben: {names}',
+      partly_saved: 'Die Automatisierung wurde nur teilweise gespeichert',
+      partly_saved_description:
+        'Deine Änderungen sind noch da. Speichere erneut, um sie abzuschließen.',
+      updated: 'Automatisierung erfolgreich aktualisiert',
+    },
+    trip: {
+      back: 'Zurück zur Automatisierung',
+      kept: 'Deine nicht gespeicherten Änderungen wurden beibehalten',
+    },
+    unavailable: {
+      badges: {
+        not_approved: 'Nicht genehmigt',
+        not_set_up: 'Nicht eingerichtet',
+        unavailable: 'Nicht verfügbar',
+      },
+      channel:
+        '{channel} ist für diese Organisation nicht eingerichtet. Diese Nachricht bleibt erhalten, wird aber nicht gesendet.',
+      channel_option: '{channel} (nicht eingerichtet)',
+      condition_not_editable:
+        'Dieser Filter kann hier nicht bearbeitet werden. Er gilt weiterhin: Behalte ihn oder entferne ihn.',
+      condition_unknown_field:
+        'Dieser Filter ist nicht mehr verfügbar. Entferne ihn, um zu speichern.',
+      date_reference:
+        'Das Datum, auf das diese Nachricht geplant ist, ist nicht mehr verfügbar. Wähle ein anderes, um zu speichern.',
+      kept: 'Bleiben unverändert erhalten',
+      message_group_active:
+        'Diese Nachricht ist aktiv, aber nicht in jeder Sprache genehmigt. Deaktiviere sie oder wähle eine genehmigte Nachricht, um zu speichern.',
+      message_group_inactive:
+        'Diese Nachricht ist noch nicht in jeder Sprache genehmigt. Sie kann aktiviert werden, sobald sie es ist.',
+      option:
+        'Eine ausgewählte Option ist nicht mehr verfügbar. Sie gilt weiterhin und bleibt erhalten, bis du sie entfernst.',
+      title_blocked: 'Diese Automatisierung kann noch nicht gespeichert werden',
+      title_kept: 'Einige Teile dieser Automatisierung sind nicht verfügbar',
+      to_fix: 'Vor dem Speichern zu beheben',
+      trigger:
+        'Dieser Auslöser ist nicht mehr verfügbar. Wähle einen anderen, um zu speichern; deine Nachrichten und deine Zielgruppe werden zurückgesetzt.',
+      where: {
+        filter: 'Filter "{field}"',
+        message: 'Nachricht "{name}"',
+      },
+    },
+  },
   categories: {
     marketing: 'Marketing',
     utility: 'Service',
@@ -642,6 +864,52 @@ export default {
     no_preview: 'Keine Vorschau verfügbar',
     subject: 'Betreff',
   },
+  filters: {
+    actions: {
+      add_filter: 'Filter hinzufügen',
+      open_calendar: 'Kalender öffnen',
+      remove_filter: 'Filter entfernen',
+      remove_option: 'Option entfernen',
+    },
+    and: 'und',
+    applied: '{count} Filter angewendet',
+    field_placeholder: 'Feld auswählen',
+    operators: {
+      contains: 'Enthält',
+      does_not_contain: 'Enthält nicht',
+      in: 'In',
+      is: 'Ist',
+      is_at_least: 'Ist mindestens',
+      is_at_most: 'Ist höchstens',
+      is_between: 'Ist zwischen',
+      is_empty: 'Ist leer',
+      is_less: 'Ist kleiner als',
+      is_more: 'Ist größer als',
+      is_not: 'Ist nicht',
+      is_not_between: 'Ist nicht zwischen',
+      is_not_empty: 'Ist nicht leer',
+      is_set: 'Ist gesetzt',
+      not_in: 'Nicht in',
+    },
+    selected: '{count} ausgewählt',
+    types: {
+      date: 'Datum',
+      multiselect: 'Mehrfachauswahl',
+      number: 'Zahl',
+      price: 'Preis',
+      select: 'Einfachauswahl',
+      text: 'Text',
+    },
+    unavailable: {
+      badge: 'Nicht verfügbar',
+      not_editable:
+        'Dieser Filter kann hier nicht bearbeitet werden. Er gilt weiterhin: Behalte ihn oder entferne ihn.',
+      option: 'Option nicht verfügbar',
+      option_description:
+        'Eine ausgewählte Option ist nicht mehr verfügbar. Sie gilt weiterhin und bleibt erhalten, bis du sie entfernst.',
+      unknown_field: 'Dieser Filter ist nicht mehr verfügbar.',
+    },
+  },
   language: {
     de: 'Deutsch',
     en: 'Englisch',
@@ -825,7 +1093,6 @@ export default {
         status: 'Status',
         updated_at: 'Aktualisiert am',
       },
-      loading: 'Nachrichten werden geladen...',
       pagination_summary: '{from}–{to} von {total}',
       product_placeholder: 'Produkt auswählen',
       render_type_placeholder: 'Render-Typ auswählen',